Let me start off by saying that I have the uttermost respect for all the faculty members of the fantastic Cornell Computer Science Department. I have been enjoying the education ever since I came here and I've become a much better budding software engineer / computer scientist than I was only half a year ago, thanks to all the amazing professors, TAs, and classmates from and with whom I have been learning.
However, I've noticed a trend that is making me quite uneasy. The CS curriculum, for some reason, is becoming easier. The hard courses are still pretty hard, but the easier courses, in particular CS1110 and CS2110, which traditionally together make up an introductory sequel which a student has to complete before he can affiliate with the computer science major, have been made easier.
As most CS majors probably know, CS1110 has undergone a major redesign over the last summer. Before the 2012-13 academic year, CS1110 was "Introduction to Computing Using Java", but since then it has become "Introduction to Computing Using Python". Both being "Introduction to Computing", the two courses nevertheless differ significantly. I'm not going to pretend that I know more about programming languages than the professors who made this decision, but I think I'm doing a justice to claim that Python is a less "hardcore" programming language. Among other things, new programmers starting with Python seldom develop an awareness of type-checking and often find it hard to believe that you can't just "run" your program ("WTF, what do these red lines in Eclipse mean?").
As a natural consequence of changing 1110, the new 2110, which started in this spring, assumes no prior experience in Java. Before, students taking 2110 were required to know basic Java syntax, so they could focus more on things that actually matter: data structures, algorithms, software engineering practices, etc. But now since students are coming from a Python background, the course staff have to spend a significant amount of time to help students transition from a dynamic-type language to a static-type language. This isn't a trivial transition. Some of the 2110 TAs that I know of have commented on how hard it can be to explain to some students why, for example, a class can probably be useful.
The reader at this point may start asking: OK, so the classes are becoming easier, but isn't that a good thing? The two courses, being introductory, are meant to be easy, aren't they?
Maybe not. Last semester I wondered if I could potentially be a musician so I took a semi-music class. I tried to learn the most basic music concepts like staff and beat, but I failed miserably. I left the class relieved, knowing that music is indeed not for me and glad that I'm pursuing a CS career which seems so much more fun. That's exactly what I wanted to get out of an introductory course.
In the same way, while I appreciate anyone who gives computer science a try, it just isn't for everyone. Some people can think like a computer scientist and others cannot, and that's perfectly OK. The point of an introductory course, in my opinion, is about separating the students who will enjoy and do well in this particular subject from those who won't. In this sense, 1110 and 2110 are failing. They just aren't hard enough. I mentioned this at the very beginning of the essay but I want to emphasize it again: 1110 and 2110 are the only two CS courses you need to complete before you can become a CS major. Right now, what's happening is that everyone is getting As in these two classes and everyone seems to be a promising computer scientist, and that just isn't the reality. What if my music class was really easy? What if I was deceived into the illusion that I MIGHT be able to pursue a career in music? What if I ended up taking more music classes, only to find out in my fifth music class that, hell, I'd still be better off writing code? I would be really, really mad and upset.
The peril of easy computer science courses, therefore, is that they aren't hard enough to convince some students that they will be better off doing other things. By making 1110 and 2110 easier, the CS department is essentially saying "we welcome every sane Cornell student to become a CS major," and many of them will. But then they will start taking 3110, 3410, 4820, and while many of them will do well, some of them won't. And they will be frustrated, and they will doubt, and they will find out maybe CS isn't for them after all, but they have already invested so much time in it. Now, you tell them what to do.
This scenario is bad for everyone: the students who waste time on things they won't enjoy, the course staff who spends so much time explaining basic concepts, the true CS guys who have to slow down in class to wait for others to catch up, the industry who expects Cornell CS graduates to be amazing but finds out, disappointedly, that not all of them are.
Let's not be afraid of making our introductory classes hard. Let's not be afraid of telling students, directly, that they aren't likely to enjoy a particular subject. After all, we want to help everyone discover his or her true passion. We are making something seem easier than it really is, and this isn't the way to go.