Why MIT now uses python instead of scheme for its undergraduate CS program

This week, I find myself lucky enough to be at the International Lisp Conferenceat MIT in Cambridge, MA.  I won’t get into why I’m here right now, for those of you who might be surprised.  The purpose of this post is simply to paraphrase what Gerald Jay Sussman, one of the original creators of Scheme, said yesterday in an a brief impromptu talk about why the computer science department at MIT had recently switched to using python in its undergraduate program.  This change is something that was widely panned when it was announced by many people all across the programming and computing world from various disciplines, so it seems worthwhile to try to document what Prof. Sussman said.

(The impromptu talk happened much after Monday’s formal talks and presentations, and I don’t think that anyone was recording Prof. Sussman’s remarks.  If anyone does have a recording, by all means, post it, and I’ll link to it here — and probably just drop my paraphrasing.)

This is all from memory, so I’ll just apologize ahead of time for any errors or misinterpretations I propagate. If anyone has any corrections, by all means, leave a comment (try to keep your debate reflex in check, though).  In a couple of places, I’ve added notes in italics.  Just to keep things simple and concise, the following is written in first-person perspective:

When we conceived of scheme in the 1970’s, programming was a very different exercise than it is now.  Then, what generaly happened was a programmer would think for a really long time, and then write just a little bit of code, and in practical terms, programming involved assembling many very small pieces into a larger whole that had aggregate (did he say ‘emergent’?) behaviour.  It was a much simpler time.

Critically, this is the world for which scheme was originally designed.  Building larger programs out of a group of very small, understandable pieces is what things like recursion and functional programming are built for.

The world isn’t like that anymore.  At some point along the way (he may have referred to the 1990’s specifically), the systems that were being built and the libraries and components that one had available to build systems were so large, that it was impossible for any one programmer to be aware of all of the individual pieces, never mind understand them.  For example, the engineer that designs a chip, which now have hundreds of pins generally doesn’t talk to the fellow who’s building a mobile phone user interface.

The fundamental difference is that programming today is all about doing science on the parts you have to work with.  That means looking at reams and reams of man pages and determining that POSIX does this thing, but Windows does this other thing, and patching together the disparate parts to make a usable whole.

Beyond that, the world is messier in general.  There’s massive amounts of data floating around, and the kinds of problems that we’re trying to solve are much sloppier, and the solutions a lot less discrete than they used to be.

Robotics is a primary example of the combination of these two factors.  Robots are magnificently complicated and messy, with physical parts in the physical world.  It doesn’t just move forward along the ground linearly and without interruption: the wheels will slip on the ground, the thing will get knocked over, etc.

This is a very different world, and we decided that we should adjust our curriculum to account for that.  So, a committee (here, Prof. Sussman peaked his hands over his head, which I interpreted to indicated pointy-headedness) got together and decided that python was the most appropriate choice for future undergraduate education.  Why did they choose python?  Who knows, it’s probably because python has a good standard library for interacting with the robot.

That is my best paraphrasing of Prof. Sussman’s remarks.  I spoke with him briefly earlier today, primarily to ask his permission for me to post this sort of first-person paraphrasing; he replied: “Sure, as long as you paraphrase me accurately.”  Hopefully I succeeded; I’ll mention again my solicitation for corrections in the comments.

As a short addendum, while I had Prof. Sussman’s ear, I asked him whether he thought that the shift in the nature of a typical programmer’s world minimizes the relevancy of the themes and principles embodied in scheme.  His response was an emphatic ‘no’; in the general case, those core ideas and principles that scheme and SICP have helped to spread for so many years are just as important as they ever were.  However, he did say that starting off with python makes an undergraduate’s initial experiences maximally productive in the current environment.  To that, I suggested that that dynamic makes it far easier to “hook” undergrads on “computer science” and programming, and retaining people’s interest and attracting people to the field(s) is a good thing in general; Prof. Sussman agreed with that tangential point.

About these ads
This entry was posted in lisp. Bookmark the permalink.

16 Responses to Why MIT now uses python instead of scheme for its undergraduate CS program

  1. Jason Birchoff says:

    Given this shift at MIT, I wonder if we can look forward to a python reimagination of SICP.

  2. Tom says:

    Thank the heavens! I took the Berkeley Intro the Computer Science course, based off of MIT’s, which also uses Scheme and SICP, and while I eventually learned to have a great respect for Scheme and that book in particular, it is a terrible way to teach people how to program in this day and age. I already had an AA in computer science coming in to the class, and was familiar with imperative programming procedures in a few languages, but Scheme so utterly confused me that I missed out on most of the theory they were trying to teach because I was so held up in the language. Many of my fellow classmates were even worse off, and many ended up dropping the class entirely or just barely scraping by. Functional programming is an amazing tool, but I am convinced it is just not the best language for an introductory class.

    • Sergio says:

      It’s a sad decision. They really needed to change the way of teaching it. Any programming language is artificial so every concept from it would be strange, specially when new concepts are thrown, in a unfamiliar syntax, all mixed up. That was creating a chasm between everything known and the new ideas of the SICP making it a steep learning curve. This would happend to any language, even Python.

      A better idea for an introductory course is to create a bridge from what a newbie to computation already knows, and gradually crossing the bridge, just like http://www.htdp.org/ does, and it’s also from The MIT Press.

      The problem was the strategy for teaching, not the language neither the concepts.

  3. dherring says:

    I heard it a bit differently.

    “Critically, this is the world for which scheme was originally designed.”
    =~s/scheme/SICP/

    Sussman also made a point that he tried killing the SICP course ~10 years ago, but the department tradition wouldn’t let it die (and others taught it in the intervening years).

    Another of his points was that the modern programmer “does science on libraries” since the API is under/mis-documented, we poke at things until we become comfortable with what’s needed and hope we didn’t miss anything subtle.

    Other than those points, your account rings quite true to my memory (unfortunately I generally remember concepts, not words). Its a shame if this 5-minute speech wasn’t recorded. It was given during “the great macro debate”, so there is a chance the normal cameraman got it. Also, I noticed a few of the Japanese participants using personal recorders, maybe one of them has it?

    • Chas Emerick says:

      I’ll make that s/scheme/SICP edit shortly. The camera that had been recording all of the proceedings throughout the day was not in place for the macro debate. I remember looking for it before Prof. Sussman began his remarks. Hopefully some recording will emerge eventually.

  4. fu says:

    Will it take 10x longer now to get your degree from MIT? :-)

  5. Noah Friedman says:

    Since python doesn’t have tail recursion, anonymous procedures, or continuations, I don’t see how it is a replacement for scheme at all. I appreciate the pragmatics of using a language that has some “real world” application, but the concepts in SICP will not carry over easily.

    • Chas Emerick says:

      Prof. Sussman said nothing about the new curriculum fully encompassing the old. It’s different, and different for a set of distinct reasons. He underlined the continuing utility of lisps when I spoke to him later, as I described at the end of the post.

  6. Sam Griffin says:

    Thanks for the paraphrased speech, Chas. I’d read it before in another blog, but it was less detailed.

    If I’m distilling correctly the argument for python, it’s that it is easy, fun and accessible. This is a good argument in most cases, but it seems a terrible argument within MIT.

  7. Matt Domsch says:

    python has lambdas now, an incredibly useful addition. Nearly 20 years later, I had a dream just last week that I was back in class with Dr. Sussman and a copy of SIPC in my hand. Eval / Apply anyone? :-)

  8. Dan Weinreb says:

    The point is that the change in the curriculum has almost nothing to do with Scheme or with Python! It wasn’t a big change based on the programming language. Rather, there was a huge change in the entire goal of the courses and the freshman curriculum. They aren’t trying to teach the same thing they used to teach. They are now teaching the engineering of the 21st century instead of the engineering of the 20th century. The use of Python is largely incidental; the software for the hardware platforms that they’re uisng just happen use Python. If they used Scheme or Ruby, then they’d teach the course in Scheme or Ruby, but they just happen to use Python, and Python is an acceptable language for the curriculum.

    You may get different answers from other faculty members; it’s a big faculty and different people vote based on different criteria. But the original post only claimed to be what Gerry Sussman believes, and it’s right.
    (Sorry, no, this part of the conference did not get videotaped.)

  9. Stephen Ferg says:

    To guess that Python was chosen because it has good standard-library support for robotics strikes me as odd. First, because Python has little if any support for robotics in the standard library. Second, because citing this as the first reason for choosing Python is like saying that you chose GM cars for your 1000-car corporate fleet because you like the trunk latches.

    If I read Professor Sussman’s remarks correctly, he’s talking from personal knowledge about why MIT abandoned Scheme. But he’s not talking from personal knowledge about why it chose Python. He says “we” decided that we should adjust our curriculum, but uses “they” to refer to the committee that chose Python, and indicates that he doesn’t know (although he can hazard a guess) about why “they” choose python.

    In short, the title of this blog is a bit misleading. It has virtually nothing to do with choosing Python. It really should be titled “Why MIT no longer uses Scheme for its undergraduate program”.

    I would love to see an endorsement of Python from Professor Sussman. And he may have given such an endorsement – but not here.

  10. Rick says:

    I applaud the decision. Probably the best reason: Python better reflects the implementation tools a software developer is likely to encounter ‘in the wild’. Mo’ better real-life!

  11. Chas Emerick says:

    I wouldn’t say there was any sarcasm there. I might speculate that python doesn’t have any particular features on its own to recommend it as the language of choice of an undergrad CS course, except perhaps its massive libraries and applicability to subject matter (like robotics). Given that, any other language with the same characteristics would do, and it could be very different from python (e.g. if Lua had a larger community, it probably would have been a contender).

  12. Anon says:

    ridiculous notion. i am a huge fan of python, and use it on a daily basis. this decision makes sense if you’re teaching programming,

    but i thought MIT had a computer science curriculum. my bad.

  13. queuerious says:

    Pathetic. Python … a language one can learn in 3 days on his/her own … for 6.001? Wow.

    The whole push for LISP/Scheme in the late 70’s and early 80’s (when I was there) was to realize A.I.

    MIT (and the greater computing community) failed with A.I. (aka fifth generation computing). MIT has fallen way behind in robotics. And now MIT is going with Python??!!! What a joke! Watering down of MIT continues. We had to solve problem sets recursively. I heard that became an “option” in the 90’s and 00’s. Now … Python?!?! What is there to teach on Python for 14 weeks? MIT = Harvard now?

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s