CS1 and CS2 are the traditional names given to the first and second courses of programming. Even if that’s not the name your university or college use, it’s a shorthand name.
It was once thought that two semesters were all that’s required to master the basics of programming. CS1 would cover the basics of the language: if statements, loops, functions, structures. CS2 would cover basic data structures: linked lists, stacks, queues, binary search trees.
Although this was a perfectly good way to teach programming when the language was Pascal, it’s increasingly obvious that it’s not enough for any object-oriented programming language. Indeed, I’d argue that we need four semesters of programming, rather than two. Object oriented programming is that tough.
This is just another indication of CS faculty not properly paying attention to what they’re teaching. Of course, there was a pragmatic reason to keep to two semesters instead of four. That’s two additional courses that don’t need staffing. And believe me, staffing is a big issue.
There’s many an academic professor who don’t want to teach introductory courses. Too many students sign up for programming that don’t really have a head for programming, and the teachers often lack the patience when students don’t understand basic concepts like array indexing. When professors want students to use continuations and lambda expressions, the thought that simple loops can confound a student is scary.
So imagine the horror if they had to teach not just one, not just two, but four courses.
Of course, you’re now waiting with bated breath, wondering what four courses I think are important to teach. It’s not terribly surprising. First course is OO programming one. This covers basics objects, loops, functions, etc. Basically, object-based programming. Not so much inheritance. Second course is OO programming two. This would include inheritance. It would also discuss some basic design patterns. Course three would be data structures, and some basic software engineering. Course four would be design and software engineering.
When I taught at Maryland, we had three courses. First course was C. Second course was C++. Third course was C++. Even with three courses, the drop/fail rate was pretty high. Since then, they’ve changed the curriculum to two courses in Java, and a third course in C. The C course was set up to teach systems level programming (low-level programming). My four courses admittedly misses that.
I found it interesting that Maryland would teach three semesters of introductory programming taking fifteen weeks per semester (or 45 weeks total), while the University of Washington, on a quarter system, would take two quarters (or about 20 weeks total) to cover traditional CS 1 and CS 2. Maryland spent more than twice as long to cover intro programming.
How did UW manage to avoid awful programmers in their system? Simple. They have a selective major that removes more than half the eligible computer science majors. When you’re willing to teach 200, but only want 70-80 majors, those who survive the cut are likely to be good, no matter what you did in the first courses. It would be seriously scary if 140 students were allowed through, as it is in Maryland.
Imagine if every major did that. Many students would simply not graduate. Of course, computer science professors (and companies recruiting top students/programmers) love this because it means you don’t have people struggling with the basics of the language when you want to address math or some higher level concepts in operating systems.
Ultimately, where we’re failing students is our ability to give appropriate feedback, and large universities are worse than small ones. English departments, for example, value feedback so much that they force small sizes when they teach. At one point, I had to teach a course where each grader had to grade nearly 100 students. Clearly, they had no time to look at their projects to see if it was any good. They had to check the basics, and move on. Our resources were that limited, and the department did not see it as a travesty. English professors and graduate students would have been up in arms. We were not.
We need to adopt a model that’s closer to what the English department (and similar majors) do when it comes to teaching coding. It’s amazing that good coders develop, even in a system that doesn’t necessarily evaluate good vs. bad coding.
One reason I decided to be a software developer was to see coding in a real environment, and see how development was done (at least, someplace). It’s been an eye-opener, especially during code reviews, and it’s something that computer science departments need to adopt.
