What's Going On with 61A?

(Update 8/11/2013)

(Introduction for non-Berkeley-CS people: CS 61A is our first course for computer science majors. The course title and curriculum come from its former textbook, Structure and Interpretation of Computer Programs, the best computer science book ever written.)

In fall 2011 the department decided to switch 61A away from its longstanding textbook, SICP, to a new version using lecture notes partly based on SICP but rearranged and with some sections replaced by new material. The purported goal is to make the course "more modern."

I've been teaching and championing 61A (and its predecessor 60A) for 25 years. During that time, 61B (our data structures course) has gone through three programming languages and even more textbook changes; 61C (our machine organization course) has moved from the Vax architecture (CISC) to the MIPS architecture (RISC) and then had three major redesigns, most recently to put parallelism at the heart of the curriculum. That's no surprise in a fast-moving field like computer science. So how come 61A is still using, with fairly minor changes, a 27-year-old curriculum?

Well, there are two possible answers to that: (1) Certain old fogies on the faculty just aren't keeping up with the times. (2) Even though the details have changed, in very dramatic ways, the central ideas of computer science, as highlighted in SICP, remain unchanged.

To be honest, there's definitely some truth to the first one. I could never in a million years program the slick web apps that our undergraduates put together overnight at the CSUA Hackathons. But I also believe the second one. Before SICP, introductory CS courses were an unending sequence of programming language details. Instructors tried to invent entertaining program examples to illustrate these fundamentally boring details. SICP highlights the idea of abstraction as the fundamental principle of computer science, and brilliantly illustrates this principle with a series of mind-blowing examples from the functional, object-oriented, and declarative programming paradigms. Each abstraction is presented both from the user's point of view and from the implementor's, so that nothing feels like magic beyond the student's abilities.

Every six or seven years, this question has come up at a faculty meeting. The young turks propose to replace 61A with something more modern. Until now, after each discussion, the faculty has voted to keep SICP. But now I'm retiring, and there has to be a plan for how 61A will continue after that.

In fact there are two such plans, mine and the other one.

Starting with the latter, in 2011-12, 61A was taught by John DeNero (fall) and Paul Hilfinger (spring) using lecture notes based on SICP (since its text is now available on the web with a Creative Commons license that permits such use) but with the program examples recoded in Python. This is, on its face, a strange idea; Scheme and SICP build on each other's strengths and programming in Python as if it were Scheme will surely result in some of the examples looking unlike the way a native Python speaker would code them. But the long-term plan is that over time, the 61A curriculum will gradually change to include "more modern" ideas, leaving out some of the SICP ones to make room; because of its huge collection of application libraries, the new ideas will be more easily expressed in Python than in Scheme. Also, there is currently a vibrant open-source project community using Python, and 61A students can be introduced into that community.

Another reason why some EECS faculty favored changing the programming language to a more widely used one is that many students who come to Berkeley satisfying the 61A prerequisite of experience programming recursive functions have nevertheless felt the need to take CS 3L or 3S, the "zeroth" CS course recently replaced by CS 10, leading to a de facto four-course lower division CS sequence. This has been especially problematic for EECS students more interested in EE than in CS.

John and Paul assure me that they value SICP and that changes will be slow, incremental, and small enough so that the spirit of SICP will remain. Earlier in the planning process, there was a proposal to dump the 61A curriculum altogether and start from scratch, but that was rejected by the lower division task force organized by the CS Chair. So this is not an epic battle between good and evil. And the reason the Python version of the course was introduced at scale in fall 2011, rather than as a small pilot section as in past reforms, is my own decision not to teach in 2011-12.

Nevertheless, I prefer my own proposal for how to preserve 61A after my retirement: a self-paced version, CS 61AS, using SICP.

For one thing, I'm skeptical about the "more modern ideas" claim. The various faculty members who take that view don't agree about what the new ideas should be; among the more popular ones are web programming and querying large online databases. Those are important applications, but central ideas in computer science? Hardly. (This business about undergraduates coding web apps overnight cuts both ways!) They're application libraries (and, by the way, such libraries exist in Scheme, too). Also, among trendy languages, Python isn't the best choice, I think, because its version of lambda is deficient in various ways. I'd have chosen Javascript, a decent language apart from its horrible name.

But, as I keep saying, the choice of programming language isn't the main point. I get upset when students, even the students who like 61A, refer to it as "the Scheme course." It's not a course about Scheme! It's a course about programming paradigms. MIT, where SICP was written, no longer includes that course in its lower division core sequence, not because they wanted to change programming languages, but because they changed the entire sequence from courses organized around big groups of ideas to courses organized around application areas: first "let's build and program a robot" and then "let's build and program a cell phone." That's a brave and thoroughgoing attempt to, among other things, attract non-nerds to computer science. To say, as some people do here, "MIT switched from Scheme to Python" completely misses the point of what MIT did; nobody is proposing any change half as profound at Berkeley.

But also, I wish I'd invented the self-paced structure of the course years ago, before the issue of changing 61A came up. We've always had a pretty high 61A dropout rate because students can't keep up. It turns out, from our 61AS experience, that many of those students are perfectly capable of learning the ideas if they're given more time, and a self-paced structure lets you spread the course over two semesters if necessary. Conversely, there are always a few students who find SICP pretty easy, and they can race ahead to Chapter 5, on compilers, and also do some of the example sections that we omitted from lecture-based 61A.

As I designed 61AS, we could figure out at the end of the semester how far each student had progressed, and give him or her credit for that many units (one unit per SICP chapter). But the campus administrators didn't go for that, so you now have to commit yourself to some number of units by the add/drop deadline in week 5. Also, a big administrative stumbling block has been how to deal with "Unit 0," a collection of starting-from-scratch material on recursion and on Scheme taken from my book Simply Scheme (written with Matt Wright), which was designed as an easier "prequel" to SICP. My idea was that this unit would carry no credit (since it's not the real course curriculum), but to make up for the time needed to learn it, students doing Unit 0 would be allowed to satisfy the 61A requirement with only three units. All this was supposed to be a concession to non-CS engineering faculty, to handle the complaints about the four-course de-facto CS sequence. This was adamantly rejected by College of Engineering administrators on the grounds that if some students have to take four 61A units, then all students must have to take four units. Their solution was giving a unit of 61A credit for Unit 0, so students could take either Units 0-3 or Units 1-4. Apparently it doesn't matter what you learn, just how many hours you spend warming a seat. I counterproposed giving a unit of CS 3S credit (the course, replaced by CS 10, that used Simply Scheme), but no, it has to be 61A(S) units. And I can't give anyone a fifth unit of 61AS, even an optional one, for Chapter 5.

There is a plan afoot to eliminate some of these problems by recasting 61AS as a two-semester course, for a constant four units (namely, Chapters 1-4 of SICP). Students who finish in one semester will get their final grade that semester. Students who require two semesters will get a grade of IP (In Progress) for the first semester, and a final grade in the second semester, based on all four units. Unit 0 will be offered as a separate one-unit CS 3S. Chapter 5 will be offered as a one-unit CS H61AS. All four units of 61AS will be required for all students who wish to continue in computer science, but Unit 4 can be taken in parallel with CS 61B. But it takes a long time to make administrative changes of this sort, so don't expect it until fall 2014 at the earliest.

But, despite a lot of administrative hassle, 61AS still exists and will still be offered at least in the near-term future, as part of the self-paced structure. And a bunch of students who wouldn't have succeeded at traditional 61A (or the new lecture version, which is just as fast-paced) have completed the course, including many women and members of other groups underrepresented in computer science.