Do most CS graduates lose interest in CS after they become programmers?

My opinion is that most CS graduates end up in a position of software engineering, which is a subset of computer science. That's just what companies are willing to pay for. On top of that, companies are driven by profit (often short-term), which does not require to make good software (on the contrary).

For many companies, it is deemed more valuable to quickly come up with a mediocre solution than to actually study the problem and engineer a good solution. Quickly assemble some libraries into a prototype that will go in production, then either get a promotion or change company. That is how I feel it works most of the time. Therefore developers don't really get/need to study how the system works: they won't be judged on how good they are in computer science, but rather on how fast they build the next prototype that will be shipped to customers.

Those who want to keep learning about actual computer science have to do it in their free time. Which is fine for a while, but at some point they grow older and have other priorities in their free time, which probably makes it look like they lose interest in CS.

I don't think it means that libraries replace computer scientists in making good software. Libraries enable developers to quickly assemble mediocre software, and they get paid for that. One still needs computer scientists to make good software, but most companies don't want that (because that is not what will increase their short-term profit).

Again, just my opinion :-).

    Libraries take care of so much

Are these libraries written by magical code gnomes?

I would be surprised to learn that more than 20% of people in CS cared at all about computer science as more than just writing code.

I studied computer engineering to learn to build stuff. Any theory I learn about today is mostly for interview prep.

I think most university students are not actually interested in research. They are interested in computing, and they do find some of the experimental nature in the field interesting, but I think (and this exposes my personal bias) most people are more interested in telling a computer to do something than understanding how to make it do it efficiently.

I think folks get degrees in CS because university degrees are a path to a decent salary, and it’s a subject they like.

CS is more of a precursor to people getting MS or PhD in it but the tech industry uses it as a barometer to assess candidates. I actually like solving business problems with software so advanced topics where core CS is crucial (writing RDBMS software or OSes) aren’t of interest to me other than foundational knowledge. CS is sorta useful in writing business systems but really for CS level problems, you’re mostly using installed software, not writing your own RDBMS, or your own sorting algorithm. The foundational knowledge is helpful, makes picking up new tech somewhat easier but I’m using libraries and installed software that provides proven solutions. There is still complex software involved but it’s complexity is business complexity.

If your path is to write business software, a CS degree can be a good entry point but day to day work isn’t typically writing advanced CS stuff.

All analogies are bad, so here’s one comparing software to healthcare: a software engineer is more like your primary care doc (there are lots and they use proven solutions) and a CS PhD writing code for an OS on how to use CPU cores is more like a brain surgeon (there are few and they may have to find/create solutions).

opposite for me.

the libraries lets me do more, it saves me time, it lets me avoid repeating and doing what other people can do better than me.

it opens me up to intersections of cs across other industries too.

Most CS graduates probably didn't understand what they were getting into and never had an interest in CS.

I'll read a bit here and there but CS was always more of the traditional pathway to software engineering for me. I do still love to read language theory (what I can understand, at least). It's a very neat glimpse at what we can hope to see in our compilers in the upcoming decades.