Why are most CS programs so bad at teaching programming as a skill in itself?

Ah! This question which offends as many people as it pleases (because it is a correct question).

Some people in academia are actually trying to solve this issue. You may look at:

1. How to Design Programs : https://htdp.org/

2. Data-Centric Introduction to Computing: https://dcic-world.org/

3. A course based on the above book: https://learnaifromscratch.github.io/software.html

As someone who is "self-taught" and comes from an EE background rather than CS, I appreciate you sharing these!

Knowledge should be open to all. Thank the people who made such resources publicly available to all.

The people teaching in CS departments aren't interested in nor are knowledgeable in practical programming.

They'd need to hire people with experience in software engineering, but those people are busy making $200k a year.

My college had a couple night classes taught by people who worked in the industry and were semi-retired — I learned a lot of practical advice from them!

This strikes me as the best answer right now. It’s the classic “Those who can, do; those who can't, teach”

When I was in community college the professors were far more practical because they were often industry professionals teaching out of passion.

After I transferred to a state university I noticed that the vast majority of my professors had zero industry experience. They had finished graduate degrees and went straight to teaching. The content was impractical and often just factually incorrect.

Maybe the problem is that it's called "Computer Science"? I've always imagined that Computer Science and Software Engineering should be distinct programs at the university level.

I'd rather it be a certificate or a community college series. Basically a vetted and accredited bootcamp.

It's nice that software engineering is one of the very few middle class careers that doesn't require the elitism of higher ed. Let's not make it that way...

No, you would need a history of computing, which could also be called 'all the shit we tried before and abandoned, and why we laugh at that guy on reddit who thinks he just invented it'

I doubt bootcamps or certificate courses go over anything like that. half of a software engineering degree needs to be stuff like that. also soft skills like writing documentation.

Focus on documentation (and readability, and comments, etc.) would definitely be nice.

As for "history of computing", I don't know, is it really that helpful to know that all the algorithms were invented by really smart people a few decades ago and then reinvented again and again in modern frameworks? I just assume that whatever I learn this year is going to obsolete by next year lol (web dev, sigh).

On the other hand, a "how to decide if you should reinvent the wheel" course would be super helpful.

How do you feel about the other types of engineering. Do they "require the elitism of higher ed?"

I don't know enough about other types of engineering to comment on that?

Programming can be engineering but isn't always. Web dev for example, especially frontend, mostly seems like a mountain of hacks... :shrug:

In this instance, I think skills-based certifications & testing would be far more accurate, useful, and fair than requiring a college degree.

At my current workplace, some of the software "engineers" there get paid less than me, even though they're better programmers, just because I have a 4-year college degree (in a completely unrelated field). It's a stupid requirement.

I think some of the old-guard companies still equate "college" with "intellectual capacity & ability to follow instructions for four years". The former is better measured in other ways now and the latter isn't really a key trait of good programmers, unless you're a code mill hiring silent code monkeys.

And yet without any kind of rigorous scholastic requirements any Tom Dick and Harry can take a six week code camp course, and more and more companies have to do leet code style interviews because they can't trust the competency of their applicants.

Worse, 95% of those who graduate with CS degrees are going to work as software engineers, not computer scientists. And I suspect that most CS degrees aren't actually aimed at preparing them for that.

> By that I don't mean only syntax of popular languages. I mean the art of solving problems using programming languages.

Out of curiosity, what school's don't include this in their CS degree programs? Not as in: "I can major in CS here and stick to almost exclusively theory and math courses." But as in: "I can major in CS here and don't even have the option of taking project based courses and courses that are mostly dependent on writing programs to demonstrate understanding?"

Has something changed that caused CS programs to drop most of their courses in the past 20+ years? Or did I get lucky with the schools I went to?

> There are schools where a typical undergrad Algorithms class has no coding assignments.

Again, 20+ years ago, but the first algorithms class (and data structures) had us demonstrating our knowledge via programs, or writing programs to benchmark different things, and so on. That was for first years, not advanced students just the preliminaries, coding from day one (or near it). Even the 3xxx courses that didn't require programming still encouraged it.

> Ofcourse there are schools where there are courses with extensive programming requirements. I am not talking about those. Those are exceptions.

I cannot believe that the random CS programs in GA were exceptions to some rule. So again, where is this happening and why the regression if this is actually happening en masse?

I'd be interested in learning more of what you mean about "good programming". If you mean the standard practices around software engineering - code reviews, unit testing, integration testing, automated testing, archiving and version control, and so forth, then yes, I would agree that CS programs don't teach "good programming." However, speaking as a math major who has had to continually study to remediate gaps in my understanding of CS fundamental, my impression is that CS majors do a lot of programming, especially around algorithms and data structures, operating systems, and compiler design, and were way ahead of math majors like me at the end of college. And I actually had a somewhat CS oriented math degree, since my classes in number theory, numerical analysis, linear and non-linear optimization, and graph theory all had programming labs.

What are these schools where an algorithms class has no coding assignments? At my college, you could take graph theory in the math department and not take the optional programming lab, but in CS? Really? Not saying this doesn't exist but... weird.

I think it's really hard to think up of curriculum for a "programming" class. It'd be hard to standardize across different professors. Also while I do think that more programming experience would benefit most new grads, it's hard for me to say that it would be more beneficial than say better interpersonal working skills or even specialized knowledge.

FWIW at the uni I attended, projects were a huge part of some classes (usually ~50%) and there were some SWE specific classes where you learn best practices / tooling. You would need to be able to program in order to graduate. I feel like this is the norm and not the exception, but I may be wrong.

There were a lot of CS clubs at my school that hosted workshops and tried to teach people some of this stuff. Maybe you can find a club (or start one) at your school.

FWIW, "regular" engineering courses aren't that great at teaching the skill of engineering either. You learn tons of theory, but little that is actually practical (outside of labs and capstone projects).

Traditionally graduates learn actual engineering on the job by being given simple projects and asking for help when they get stuck. Better companies will have a standardized way of doing this, but I haven't seen a lot of variation on this theme.

In fact, come to think of it, that's pretty much what I did with the intern I had last summer. "Here's a task in Jira to add this feature. This is the area of the code you'll need to understand in order to do it. Contact me if you need help or let me know when you're done and I'll review it." He did very well!

Such life... But there are many reasons.

There is a lot to teach ! hw knowledge, asm, C and scripting languages at minimum. Then Lisp and functional languages and rest. And that just a syntax that takes years to be proficient with. Then you discover that all of them are full of if's and loops (or recursions) and you start to smile from language flame wars. But still you need to concentrate on syntax of one or two languages. So, years.

Then there are algorithms - for all kind of things. Years.

And then there is domain of the problem ! Totally not related to languages syntax. Simply - programmers are in much worse position then journalists :) And domains are not part of uni program. Except some like eg. databases.

Also: on first year in uni we had fellow who learned good programming skills before, in a mid school. And he asked: I know how to program, why I need all that math ?? And dropped. And on the other hand - few years into uni one of professors said: there is no point to be a programmer without somekindof algebra. So what actually "skill of programming" is ?

So 5 years of learning programming is just not enough. Maybe joining some existing long term project could help - like kernel or some game. That is, without dropping CS :)

At least a few reasons I can think of:

- Career academics don't necessarily have the level of experience in building large-scale software systems that need to exist and be maintained for a long time to teach that as a skill.

- University programs in general focus on time-tested fundamentals that aren't going to change much over the decades, and practical programming skills involve a whole lot of toolset bikeshedding minutiae that is inherently ephemeral and not suited for curriculum.

- Semesters are too short to allow students to go through much in the way of a full development lifecycle on a project of any notable scale (exception for TAs and grad students working on libraries and tools maintained by the schools).

Not speaking for all schools, but I'll say for Georgia Tech that I felt courses with significant project components were actually great for practicing programming as a practical, vocational thing, but at the same time, there was very much an attitude among the faculty that they weren't going to teach you to program or anything about the specifics of languages and toolchains. You either needed to know that already or figure it out. Maybe that was elitist, but they were explicitly and intentionally selecting for the kind of people who can figure it out on their own. If nothing else, it is a lot easier to teach yourself programming than it is to teach yourself computer science and mathematics.

I never really experienced this kind of thing with other subjects. Physics and biology labs definitely taught you how to use the lab equipment, but in fairness, it isn't feasible to set up your own lab, whereas any 10 year-old can get a sufficient programming lab out of a $50 R Pi with Internet access.

But in all fairness, the ability to figure out shit on your own is essential to becoming a good engineer. So if GA forces their students to learn this skill more power to them.

> Ofcourse there are schools where there are courses with extensive programming requirements. I am not talking about those. Those are exceptions.

Are you talking about American institutions now? Because in my university classes larger and smaller programming projects were part of almost every course. Even the first year's courses assumed the students had working knowledge of git.

Just as an analogy, can a person majoring in architecture not do drawing or designing?

Of course drawing and designing is most of architectural education.

The problem is that unlike CS, architecture is a studio practice and a principal pedagogical premise is the only way to demonstrate design ability is by executing a design against constraints.

Another principle premise is that while there are objectively better and worse executions, there is no objectively correct solution. So no multiple choice tests in the design studio.

Finally, soft skills are part of the curriculum. Students have to present their work and stand there while others talk about it. Basically a long series of whiteboard interviews where the whiteboard contains weeks of work.

Sure programming could be taught in a studio environment. But probably not CS because the studio is not part of science pedagogy.

And to be clear, the studio dominates architectural education. All nighters are normal and expected because more work is how better is achieved and projects are only done because time has run out. None of which is part of science education.

In my personal opinion:

The reason is that there exist so many ways of programming. Programming is not a single skill, but a multitude of different approaches to get the computer do what it should.

To give an example: what an ABAP (SAP) developer does is very different from an embedded developer which is again very different from a frontend web developer, database developer, ...

So, learning programming is rather like learning to write great belletristic literature. What is the "best"/"correct" way to write a belletristic book? Read a lot of of great literature and find your own style. The same holds for programming.

Also, the problem is that actually quite employers value good programming; they value people who can put together some application based on the current in-fashion library fast. Understanding the current in-fashion library from ground up leads to the situation that in most cases, when you come a little bit nearer towards understanding it from ground up, the library has become horribly obsolete.

Your school should be requiring extensive programming projects for algorithms, compilers, OS, distributed systems, AI, etc. If not then your school sucks. Change schools if you can.

Because there doesn't exist a trade school for programming quite yet. There are degree programs and bootcamps that are trying to fill this demand in specific applications of programming, but this skill is much more nuanced than your average trade. Who knows if that will change in the next decade given the advancement of AGI.

I think a large part of being a good engineer is similar to becoming a good writer with the key difference of being a good writer on a paper that 10 other people are also helping to write.

So the challenge isn't just in developing the skill individually, but also collectively. No engineer is ever working alone on a project at work (and if they are its likely temporary).

Like prose and literature there are various styles, personal likes and dislikes, ways of problem solving etc.

Schools are concerned with imbuing in their students the skills to get a job. No fresh out of college employee is going to be the best of the group they join. It's impossible because the group they are joining will already have those same people but who also have more experience. School has to teach enough to make their graduates employable - often in the context of being at least on par with other schools curriculums so their students aren't at a disadvantage in the hiring pool.

I'd be surprised too with your assumption that schools don't have practical programming assignments that give students time to write code and develop their own style.

Unlike reading and writing, which we start learning extremely young, software is only exposed often at the beginning of college with just 4 short to learn and practice. It may also not be the sole focus.

Being a great writer requires the perspective of a reader, which is also difficult to map for teaching software - learning to read other people's code and write your own code in a way that is easy for others to read let alone modify and maintain is hard.

There really is just so much to learn and 4 years isn't enough to do it all. Schools have to balance the breadth and depth of different subjects so students can understand what's out there and also be on par with students from other schools.

That's why there is so much room to grow in this industry (like many others) from associate to mid, to senior, to lead, to staff and then principal/architecht/etc. Plus all the specializations.

Edit: I decided to leave this as is, but with misgivings. The tone may seem off, as it does to me too on re-reading it in context as a reply. I think I'm echoing very similar sentiment...

I also think writing good code is a skill or craft like writing prose. But there are also drastic differences. The analogy falls apart in many ways. While it has a textual or symbolic aspect, in other ways programming is more like other crafts where the novice starts at zero, rather than with decades of relevant listening, speaking, reading, and writing.

Good code get consumed and maintained by others in a way that most prose does not. Sure, there are editors and published revisions, but not nearly the amount of modular reuse and refactoring. Natural language reuse happens in other indirect ways that benefit from the mental plasticity of the audience. You invoke ideas or idioms from your influences, but not as literal embedding and reuse. A good writer does not need to engineer their prose to be easily lifted and reused by a different author and an unanticipated audience.

Another thing is that code is mostly consumed by an audience who do not even see or read the code. They only use the resulting program. Whereas prose consumption is in the same essential form as it was authored. You don't naturally encounter code examples even if you spend your early life using programs. I think this is perhaps the biggest problem. Many may have internalized many examples of natural language utterances by the time they reach college-level classes. Few, if any, have similar exposure to code. Most exposure is at the level of kindergarten reading exercises. See factorial run. Run, factorial! Run!

So even if college classes are similarly structured and staffed, all the participants have far different depth of exposure at the beginning. Your term projects are too short to experience programming in the large and to gain experience. Most of your teachers are grad students with only a few years extra exposure than you have, and most of that similarly shallow. Even after decades as a professional practitioner, one is still learning interesting and hard lessons about what it means to program well. And these lessons are often personal and idiosyncratic, as we cannot usually separate our coding outcomes from other economic concerns which may not care for or reward "good programming".

I've had mixed experiences in master's level programming-oriented classes. Some of the professors just kind of expect us to Google our ways through while some are fantastic at explaining languages, coding practices, etc.

Programming is REALLY to teach.

Unless you worked on some complex problems from start to finish, you can't really understand why things are where they are right now.

The premise is not true. Many universities in Europe teach proper classes with programming assignments.