The Deep End of the Pool

After having taught introductory programming (CS 1) for the past six years, and having watched many students struggle through this course and the subsequent course (CS 2), I have come to the conclusion that it is absurd to expect students who don’t have any prior programming experience to be well prepared to study Computer Science after a single 15-week course (i.e., CS 1).

In particular, I believe that expecting a student to learn to program well enough to study Computer Science in a single 15-week course is almost as absurd as expecting a student with no instrumental musical experience to be ready to join the university orchestra after 15 weeks. There are, of course, musical prodigies that can handle this challenge. Likewise, there are many “natural born programmers” who learn how to program with very little apparent effort. However, these individuals are the exception, not the rule.

Read my reasoning then please leave a comment and tell me what you think.

Why the 15-week expectation is absurd

Almost every college program of study sits firmly upon the standard high school college-prep curriculum. Some majors, such as Math, Chemistry, Physics, English, Literature, and Writing, follow almost directly from the high school curriculum: The college courses for these majors are the logical, direct successors to high school courses. Other majors, such as Psychology, History, Engineering, Accounting, and Business, are strongly based upon standard high school math, writing, and scientific reasoning skills.

Music is one of the few college programs that does not sit firmly on the standard high school curriculum. Nobody expects a student who has never played an instrument to be able to enter college and be ready to enter an instrumental music program within a year.

Although programming has very strong mathematical foundations, it requires a style of thinking that is not emphasized anywhere in the standard high school curriculum. (I can think of only one standard college-prep topic that comes anywhere close to the “algorithmic thinking” needed to write computer programs: proving trigonometric identities.) Consequently, for many students, learning to program is almost as far from their academic experience as learning to play an instrument. Therefore, I believe that expecting the typical student to learning to program at a “college level” in 15 weeks is almost as absurd as expecting the typical student to learn to play an instrument well enough to join a college orchestra after 15 weeks.

Consequences of the current system

The “almost” in the previous paragraph is important because it allows many CS programs to survive in spite of a “sink-or-swim” entry point that drives away talented students.

The number of students with the innate musical talent to be ready to join a college orchestra 15 weeks after picking up an instrument for the first time is so small that college music programs simply assume that all of their students have been playing for years before entering college.

In contrast, most Computer Science programs assume that a student with no programming experience can be successful. This assumption appears reasonable because there are enough “natural-born” programmers and students with programming experience to populate CS programs. However, in my experience, this assumption causes a lot of “collateral damage.”

Almost every student who has taken my CS 1 course without the benefit of either programming experience or a strong natural aptitude for programming either (1) did not succeed in CS 1, or (2) went on to struggle even more in CS 2. It is possible, through a lot of hard work and sheer tenacity, for these “normal” students to earn a ‘C’ or better in CS 1. The problem is that, while these “survivors” have demonstrated a minimal amount of proficiency with the basics of programming, they cannot yet program “fluently”: Writing code requires a deliberate, focused effort.

This lack of fluency greatly hinders these students in CS 2. CS 2 covers topics such as inheritance, polymorphism, object-oriented design, and basic data structures. However, while I’m presenting these higher-level concepts, the “non-fluent” students are still thinking about the code. It takes most of their mental energy to process the sample code I’ve put on the whiteboard, leaving almost none to actually process the topic at hand. Likewise, when working on assignments, it takes so much time and effort just to get the code work, they have neither the time to complete the assignment, nor the mental energy to focus on the higher-level concepts the code is supposed to illustrate.

As a result, many, many, talented students get frustrated and quit before successfully completing CS 2. It is very frustrating as an instructor to see so many intelligent students struggle and fail—- especially at a subject I love. Worse yet, this failure is bad for the profession. Computer Science is so much bigger than programming, yet we are filtering out most of the students who are not naturally talented programmers.

What is the solution?

Ideally, people would learn to program the same way “normal” people learn to play instruments: Slowly over several years, with lots of practice. However, this is not practical at the university level.

The foreign language model is closer to being practical. At Grand Valley, students study a foreign language for four semesters before beginning a serious study of literature and composition in that language. In theory, I think a similar model would for programming would be much more effective. As with foreign language, students could test into the appropriate place in the four-semester sequence. However, I see two problems. First, it would be difficult to fit a such a program into a four-year program. Students who don’t begin the programming sequence during their first semester would have almost no hope of graduating in four years. Second, I don’t know if I could make four semesters of programming sufficiently challenging and interesting. Whereas there is a huge set of interestingly different practice music for students of any level, and a huge set of literature in any language at any level, there are not a lot of interestingly different programming problems to solve at the very basic level. It is not until one has covered conditionals, loops, methods, and arrays that the variety of interesting programming problems becomes very large. (I would expect a set of 100 practice programming problems utilizing expressions and conditionals only to feel more like a sheet of arithmetic problems than a set of programming challenges. Such a set may help students learn a langage’s syntax, but doesn’t do much for developing “deep” programming skills.)

I simply do not have a good answer. I really don’t see what we can do (practically) at the college level to make Computer Science more accessible to the majority of students who don’t already have either programming experience or a strong aptitude. (Choosing a non-programming course as an entry point may help, although I see that as a better solution for other computing majors like IS and IT.)

Recent progress

There has been a lot of excellent work in the past few years that promises to help more students succeed in CS 1:

  • BlueJ and Greenfoot provide development environments that are designed to support learning Java. These environments have a much lower learning curve than professional IDEs, thereby allowing students to focus more on programming and less on managing their environment.
  • Mark Guzdial and Barb Erickson have shown that introducing students to programming by teaching them Python and writing programs that manipulate images and sound (an approach they call Media Computation) clearly improves overall success rates for students in CS 1 and CS 2. (The use of Pyton lowers the learning curve, and the user of muti-media based assignments improves interest and motivation.)
  • Laurie Williams has shown that most students learn to program better when they work in pairs.

I am confident that this and other research will reduce the number of students who quit CS out of frustration; however, my gut still tells me that 15 weeks is not enough for most students to truly become “fluent” enough programmers to learn advanced CS concepts to the best of their ability. My guess is that, even if we were to somehow begin teaching CS 1 perfectly, we would still loose a disappointingly large percentage of students simply because 15 weeks isn’t enough time to develop the algorithmic thinking skills programmers need.

h2(#whatThink). What do you think?

What does your gut tell you? I get a lot of feedback from students who are “natural-born” programmers and excelled in my course, and from students who did not make through CS 1; but, I rarely hear from the students in the middle: Those who entered college without the benefit of previous experience or an unusually strong aptitude for programming and survived.

  • Am I right? Are our expectations absurd?
  • Am I wrong? Are the people who are not prepared for CS 2 simply those that didn’t try hard enough?
  • Should Computer Science programs focus on those who enter college ready to program and advise the rest to consider less programming-intensive areas of study (e.g., IS, IT)? (In other words, should we use CS 1 as a “sink-or-swim” filter?)
  • Am I just not well-suited to teaching CS 1 and CS 2? As a “natural-born”, but not prodigious, programmer, the answer may very well be “yes”. I personally don’t understand why programming is so difficult. I’m sure that affects my effectiveness in the classroom.
  • What could your university done to improve your experience at the beginning of your CS program?

Please leave a comment. Your observations may spark the next big innovation in teaching programming.