Programming by poking: why MIT stopped teaching SICP

In this talk at the NYC Lisp meetup, Gerry Sussman was asked why MIT stopped teaching the legendary 6.001 course, which was based on Sussman and Abelson’s classic text The Structure and Interpretation of Computer Programs (SICP). Sussman’s answer was that: (1) he and Hal Abelson got tired of teaching it (having done it since the 1980s). So in 1997, they walked into the department head’s office and said: “We quit. Figure out what to do.” And more importantly, (2) that they felt that the SICP curriculum no longer prepared engineers for what engineering is like today. Sussman said that in the 80s and 90s, engineers built complex systems by combining simple and well-understood parts. The goal of SICP was to provide the abstraction language for reasoning about such systems.

Today, this is no longer the case. Sussman pointed out that engineers now routinely write code for complicated hardware that they don’t fully understand (and often can’t understand because of trade secrecy.) The same is true at the software level, since programming environments consist of gigantic libraries with enormous functionality. According to Sussman, his students spend most of their time reading manuals for these libraries to figure out how to stitch them together to get a job done. He said that programming today is “More like science. You grab this piece of library and you poke at it. You write programs that poke it and see what it does. And you say, ‘Can I tweak it to do the thing I want?'”. The “analysis-by-synthesis” view of SICP — where you build a larger system out of smaller, simple parts — became irrelevant. Nowadays, we do programming by poking.

As to why they chose Python as an alternative, Sussman joked that it was “late binding” decision. Python has a ton of libraries that make it applicable to many types of projects that instructors might want to assign (like writing software to control a robot.)

Sussman admitted that the SICP curriculum was “more coherent” than what they have now and that they still don’t know what the right curriculum should be.

The full text of SICP is available online. The SICP video lectures by Sussman and Abelson from 1986 (given to HP) are also available.

Yarden Katz is a fellow in the Dept. of Systems Biology at Harvard Medical School.


  1. I cannot overstate how greatly Sussman and Abelson’s 6.001 course (which I had as a freshman the very first semester it was offered, fall 1980, using MacLisp and Algol, before it switched to Scheme in the spring semester) affected my future career. The things I learned in the course are still useful to me, over 35 years later. (Barbara Liskov’s course, 6.170, using CLU, that I took spring ’81, was also hugely influential).
    I would still recommend going through SICP and watching the 6.001 lectures to anybody who really cares about their craft as a software engineer.

  2. This is bewildering … The problem with this “poke at it until it work” approach to programming is that it produces programmers that known only how to poke things and stitch libraries together. The moment the library doesn’t do what is needed or, God forbid, they have to actually design something, the house of cards collapses.

    I agree that the course perhaps needed modernization (students hate to learn stuff they perceive as out of touch with reality – like Lisp), but dropping the content completely? Whoa …

    1. …like Lisp? Or maybe like Clojure, a modern JVM language, and a lot of fun to build big system with!

      There have been a couple of community projects to convert SICP’s code to Clojure so you can follow along in a REPL easily enough.

      Things have changed a lot since ’97 when Sussman and Abelson stopped teaching SICP — but Sussman turns up in Clojure circles and I have often wondered if he would have persisted with SICP if he’d have known how Functional Programming would start to go mainstream a decade or two latter? 🙂

  3. I wonder if this is why there’s a reinvigoration into functional languages such as Haskell. We wrote a book for complete beginners on Haskell that aims at having people understand the pieces of their software as they build them. Haskell provides such a lovely abstraction mechanism. More advanced than Scheme in many ways, it’s a really beautiful way to build software.

  4. I appreciate the principals behind SICP, but “programming by poking” really resonates with how I self-taught and holds a lot of merit. However I don’t think it makes SICP irrelevant at all, it just moves it to a more mature point in the education of an engineer. Rather than starting out with the principals, you start out by making things work, and then apply the principals to make it work *better*.

  5. This is the operative phrase (he most important word in a phrase, which explains the truth of a situation) —
    “… Sussman pointed out that engineers now routinely write code for complicated hardware that they don’t fully understand (and often can’t understand because of trade secrecy.) …”

  6. I self-taught myself, using “programming by poking”. and I wrote garbage code.

    Then I got a CS degree, and learned proper structure and organization of code.
    It’s bad enough now, when a large contingent of code is produced by non-educated “pokers”.

    I weep for the future where ALL code is produced by “pokers”.

Leave a Reply

Your email address will not be published. Required fields are marked *