Skip to content

Why MIT switched from Scheme to Python

Costanza asked Sussman why MIT had switched away from Scheme for their introductory programming course, 6.001. This was a gem. He said that the reason that happened was because engineering in 1980 was not what it was in the mid-90s or in 2000. In 1980, good programmers spent a lot of time thinking, and then produced spare code that they thought should work. Code ran close to the metal, even Scheme — it was understandable all the way down. Like a resistor, where you could read the bands and know the power rating and the tolerance and the resistance and V=IR and that’s all there was to know. 6.001 had been conceived to teach engineers how to take small parts that they understood entirely and use simple techniques to compose them into larger things that do what you want.

But programming now isn’t so much like that, said Sussman. Nowadays you muck around with incomprehensible or nonexistent man pages for software you don’t know who wrote. You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts. This is a fundamentally different job, and it needed a different course.

So the good thing about the new 6.001 was that it was robot-centered — you had to program a little robot to move around. And robots are not like resistors, behaving according to ideal functions. Wheels slip, the environment changes, etc — you have to build in robustness to the system, in a different way than the one SICP discusses.

And why Python, then? Well, said Sussman, it probably just had a library already implemented for the robotics interface, that was all.

(via wingolog)

64 Comments

  1. Andy Hefner wrote:

    So the reason, basically, is that software today is a train wreck, and you might as well embrace helplessness and random tinkering from the start? Horrifying.

    Tuesday, March 24, 2009 at 15:25 | Permalink
  2. JLR wrote:

    Unbelievable.

    Tuesday, March 24, 2009 at 15:36 | Permalink
  3. Gabriel C wrote:

    I don’t know about 6.001, but if is a introductory course for non software engineers / CSers, I totally agree: practical reasons…

    Tuesday, March 24, 2009 at 16:27 | Permalink
  4. Walkingbeard wrote:

    This is a shame. I’ve been reading their introductory programming course, because I felt that using C or something higher (mostly VB in my case) is quick, but does not teach you how to be what I call a ‘real programmer’, and it doesn’t.

    Reading their Scheme-based course is an eye-opener.

    I see the reasoning behind their move to Python, which may have more immediate application and even make more sense to someone who does not have a background in CS, but really, it will only further the financial interests of MIT. I can’t help but feel someone Higher Up (duh duh duuuhhhhh) has pushed this on them. MIT will now churn out countless applications programmers. Half decent ones I am sure, but not the kind of full-on nerds that make the *very best* programmers.

    There seems to be such a divorce between systems and hard mathematical programmers on one hand, and applications programmers on the other. But regardless, programmers who have been raised on really, really geeky stuff are the best ones. EOF. ;-)

    I started with Pascal and BASIC, moved on to 80×86 assembly and *then* went to C and C++. I spent my school years breaking the school systems and finding out how they worked. These days I would say that I am a very bad programmer (though lack of practice), but I am still a million times better than someone who has been taught using only Java or Python, because I have a basic but functional knowledge of PCs and a feel for the workings of hardware and limitations of systems.

    Going back to Scheme and Python:

    When I started reading their course using Scheme, and I saw the way it worked, it was like I had come to the top of a mountainous pass and suddenly saw the blue-green vista of endless, verdant fields stretching away before me. That is a feeling I have not had in the last 10 years with regards programming and it is a crying shame that forthcoming MIT first-years will not have the same degree of understanding.

    It’s not about doing things, it’s about being able to do them. Anyone who knows how can write a brilliant programme, but if you are not apprised of The Way, then you will *have* to settle for mediocrity.

    Tuesday, March 24, 2009 at 18:05 | Permalink
  5. Ryan wrote:

    Python is better at teaching introductory and deeper knowledge. Scheme is a must know but Python is practical, but attracts many smart programmers because of the ability to prototype quickly and understand the problem at hand not the mountain of ramp up that scheme can do. I agree with this and look at it this way, it could have been worse, it could have been Java.

    Python is by far my favorite language I can use to prototype and developer real world applications from desktop, web, system admin, services, game development and many other things.

    Plus CS grads will be familiar still with lambdas, tuples, lists as they are used in CS, dictionaries and they will start out with a clean dictated style. Python I believe will continue to win out over Java definitely but more and more scientific and academic support.

    Tuesday, March 24, 2009 at 18:34 | Permalink
  6. Michael Lang wrote:

    Pathetic. Now even MIT is pandering to the “But I won’t ever use language X on a REAL job crowd”. This is ridiculous and I expect better from an institution like MIT. Seriously, our programs need to be teaching students concepts first (Data structures, Information Architecture, Systems Thinking, How to judge code quality based on merits – like ease to produce, maintain, understand, performance, etc) and how to express those concepts using the various families of languages out there later. Choose the language that expresses the concepts you’re going to teach with the least noise. Since I’m partial to starting with data and data structures, Scheme & the elegance through which it expresses the concept of recursion is my pick.

    Tuesday, March 24, 2009 at 19:25 | Permalink
  7. Kip P. Mailer wrote:

    “You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts”

    This is a bizarre argument. Empirical “science” testing of your libraries is more or less required in a dynamic scripting language like Python, where the type system is extremely poorly defined, no compiler is available, and the closest substitute is vast unit test coverage.

    Tuesday, March 24, 2009 at 20:11 | Permalink
  8. Paul Prescod wrote:

    Michael Lang: did you read the blognpost that you are responding to? Your claim of why MIT switched language is at odds with the professor’s claim. Do you intend to call him a liar?

    Kip Mailer: standard Scheme also has a dynamic type system.

    Tuesday, March 24, 2009 at 20:21 | Permalink
  9. The trouble with python as the first language people see is that it is inherently confusing.

    There are three different kinds of things that “do stuff”, not just functions, but also operators and statements (and lambdas, but that’s not taught at first).

    Parentheses are badly confusing to beginners. Consider:
    >>> max(3,5)
    5
    >>> print(3,5)
    (3, 5)
    >>> print 3,5
    3 5
    >>> max 3,5
    Syntax error: invalid syntax
    # because print is a statement, whereas max is a builtin function. Huh?

    >>> a = ()
    >>> print a
    ()
    >>> a = (3,5)
    >>> print a
    (3,5)
    >>> a + (7,9)
    (3,5,7,9)
    >>> a + (7)
    TypeError: can only concatenate tuple (not “int”) to tuple
    # Because that’s arithmetic parens, not tuple parens
    >>> a + (7,)
    (3,5,7)

    Is it any wonder people who learn python first come to be afraid of parentheses?

    Tuesday, March 24, 2009 at 22:27 | Permalink
  10. uhh wrote:

    get over yourself Walkingbeard.

    Tuesday, March 24, 2009 at 22:38 | Permalink
  11. Kumar Mettu wrote:

    Programming languages should never be taught in class. There is no engineering in programming languages. Familiarity with a Programming Languages can be achieved by reading online manual or a book.
    Concepts like Data Structures, System’s thinking are ideal for class room teaching.

    Tuesday, March 24, 2009 at 22:52 | Permalink
  12. poslathian wrote:

    I took 6.001 at MIT. I also took 6.099, the experimental python-version of 6.001 when they needed guinea pigs to fool around with their new robots. The politics behind the switch were nasty, you wont ever get good answers from a faculty member about this ( observe sussman’s dark wit above). That said, the new course was slaved over by folks like Ableson and Kaebling who did their best to produce an adequate successor to scheme – 6.001.

    the mostly likely one liner explanation for the switch:
    authority insists a change from scheme ; python supports anonymous lambda functions – sussman appeased; python is well supported; python is interpreted…which means a lesser mind might confuse it with scheme; teaching c as an introductory language would destroy that special moment every MIT student gets to experience when his first boss reviews those first 1000 lines of c he committed and starts to say: “let me show you something they didnt teach you in your C course” … and the newbie responds … “hah, they dont teach that at MIT. Im just really fucking hardcore”

    Tuesday, March 24, 2009 at 23:17 | Permalink
  13. Ryan wrote:

    Gregory, no offence but…

    “Parentheses are badly confusing to beginners. Consider:”

    exhibit a: )))))))))))))

    The thing about Python tuples is that simply having a , makes it a tuple. Same with unicode just u’. It takes away much of the verboseness of Java. It also is much more simple than C. Again, allowing the user to focus on the problem at hand making the language a tool not another obstacle.

    Tuesday, March 24, 2009 at 23:34 | Permalink
  14. JLR wrote:

    The beauty of encountering Scheme in 6.001 was that it broadened your mind and changed your thinking, like it or not. This is the hallmark of great education, no matter what the field.

    Not everyone realized or appreciated it at the time; it took years for me to have my epiphany. I doubt it would ever have happened without my experiences with Scheme.

    I’m sure that Abelson and co. are trying their hardest to do with Python what they did easily with Scheme. I have serious doubts that they can provide the same kind of educational experiences that they used to. The students are probably bright enough to overcome it eventually, but something of real value has been lost.

    Tuesday, March 24, 2009 at 23:48 | Permalink
  15. poslathian wrote:

    JLR,
    While I agree whole heartedly, I think it is worth mentioning that the fundamental ideas behind lisp based programming are preserved in Sussman’s two classes, Computational Mechanics and Adventures in Symbolic Programming (6.945). Most course 6ers are proactive enough to seek out classes like these to delve deeper into worthy topics. Thrusting SICP material onto uninterested students is all weve really lost with python-6.001. Weve gained a pretty comprehensive and practical introduction to systems engineering. Kids who care can still get to the original material in other courses.

    Tuesday, March 24, 2009 at 23:53 | Permalink
  16. JLR wrote:

    Please excuse the “get off my lawn” moment, but in my day, Course 6-3 (CS) was all about computer science, and 6.001 provided the groundwork for that. Software engineering was relegated to one class, 6.170. “Engineering” was something that course 6-1 (EE) did, and if we had to sit through 6.002 and God help us 6.003, then they could suck it up and deal with 6.001. Computer science was the whole idea, and I don’t think people should have to be in the position of having to seek it out.

    That being said, I am actually fairly ignorant of the current state of affairs, so I could be overstating things.

    Wednesday, March 25, 2009 at 00:06 | Permalink
  17. poslathian wrote:

    hah…alright I concede! Of course I was (am?) one of those cop out 6-2ers, which makes me something of a not-a-real computer scientist and not-a-real hardware engineer. I tool on fpgas now….go figure.

    for the record, I liked 6.099 when I took it. Although the original version devoted about 1/3 of the course to 6.003 material.

    Wednesday, March 25, 2009 at 00:17 | Permalink
  18. JLR wrote:

    I’ll admit that programming robots does sound like fun. Of course, if I were to do it now, I’d use Haskell :)

    Wednesday, March 25, 2009 at 00:49 | Permalink
  19. Conrad wrote:

    One thing I loved about learning 6.001 in Scheme was that it easily and unconsciously twisted my mind into a purely functional way of thinking. We went six weeks without being taught the “set” command, so it was impossible to change the value of a variable. It’s amazing how much we could do with purely functional programming, and 6.001 taught us to think of the cleaner, functional approach *first*.

    Today I code mostly in C++, and it’s sad that without unnamed lambda expressions and closures, I program by constantly manipulating state. But in reality, most modern programming languages focus on manipulating state, so perhaps the 6.001 approach was quaint but outdated? Python has generators, lambdas, closures, and purely run-time types, so despite the enormous syntax difference, it actually has a lot in common with Scheme. It’s surely a better choice than Java or C++.

    Wednesday, March 25, 2009 at 02:04 | Permalink
  20. Joshua Griffith wrote:

    When Sussman talks about robustness, I think this is what he means: http://groups.csail.mit.edu/ma.....ystems.pdf

    Wednesday, March 25, 2009 at 04:08 | Permalink
  21. Someguy wrote:

    Maybe when Clojure is more mature, they’ll switch back to a Lisp.

    Wednesday, March 25, 2009 at 05:47 | Permalink
  22. Bryan wrote:

    Scheme was great for folks who had programmed before. When I took 6.001, it was the first language I’d ever seen. Bad times. Took me years to learn to actually do anything.

    I had to laugh out loud at the “Python parentheses are confusing” comment. If that’s not Lisp=based satire, it’s damn close.

    Wednesday, March 25, 2009 at 06:01 | Permalink
  23. Snappy wrote:

    Between learning CS or programming concepts/skills and a practical language, universities always have to strike a balance.

    Too much conceptual stuff, and you get research material, but not good for the industry; too much practical stuffs, and you become a vocational institute where your grads are one-trick ponies.

    Wednesday, March 25, 2009 at 06:59 | Permalink
  24. > Parentheses are badly confusing to beginners. Consider:?)))))))))))))”

    Yes, this seems to be what non-lispers have trouble with until they realize just how helpful those parens are. Good tool support, e.g. paredit, is enough to overcome this.

    > The thing about Python tuples is that simply having a , makes it a tuple.

    It would be a might easier to teach if that were true, i.e. if this weren’t the case:

    >>> a = (,)
    SyntaxError: invalid syntax

    > The thing about Python tuples is that simply having a , makes it a tuple. Same with unicode just u?. It takes away much of the verboseness of Java. It also is much more simple than C. Again, allowing the user to focus on the problem at hand making the language a tool not another obstacle.

    Yes, this is what makes python worth criticizing.

    > Python has generators, lambdas, closures, and purely run-time types, so despite the enormous syntax difference, it actually has a lot in common with Scheme.

    I’m curious, could someone show me how to write (with-timeout 10 (lambda () foo) (lambda () timeout-handler)) using generators? They seem closer to iterators, but I’m a python newbie myself and may not have understood generators well enough.

    lambdas are one-liners only, are not very clearly delimited from their surroundings, and if I understand correctly will be getting removed from the language.

    closures are problematic:

    def make_bisector(initial_low,initial_high):
    low = initial_low
    high = initial_high
    mid = mean(low,high)
    def bisector(too_low):
    if too_low:
    low = mid
    else:
    high = mid
    mid = mean(low,high)
    return mid
    return bisector

    The = operator is used for both let and set!, so python here makes the decision that the = in the if implies a let at the level of the bisector function, rather than at the level of make_bisector. What one does in python is to use either a hash or an object to store low, mid, and high, but I think it’s hard for python to claim that it has useful closures here.

    The enormous syntax difference makes a difference. I’m currently teaching computing to students who have never programmed, and of necessity one must have some language to do it in, and MIT 6.00 uses python too, despite no robots. One of the biggest confusions is about return values vs. side effects (like printing), of course, but another was just between different kinds of things returning, and the order that things happen. I mentioned this before, but the syntax really gets in your way here. Operators take arguments to either side and return a value. Functions are on the left, and they use parens. Statements are on the left and they abhor parens (or rather, treat them as tuple parens, as in my print example). I have watched over and over my students’ eyes light up in understanding when I take the python syntax for
    a = 3 + max(5,8)
    and transform it to =(a, +(3, max(5,8))).
    They are not bothered by the “)))”.

    > I had to laugh out loud at the ?Python parentheses are confusing? comment. If that?s not Lisp=based satire, it?s damn close.

    I’m delighted to entertain.

    Grem

    Wednesday, March 25, 2009 at 07:07 | Permalink
  25. Sorry, meaningful whitespace doesn’t always do well with indentation:

    def make_bisector(initial_low,initial_high):
    ~~low = initial_low
    ~~high = initial_high
    ~~mid = mean(low,high)
    ~~def bisector(too_low):
    ~~~~if too_low:
    ~~~~~~low = mid
    ~~~~else:
    ~~~~~~high = mid
    ~~~~mid = mean(low,high)
    ~~~~return mid
    ~~return bisector
    b = make_bisector(0,32)
    print b(True)
    print b(False)
    print b(True)

    Gives a syntax error: mid used before it is assigned.

    Wednesday, March 25, 2009 at 07:10 | Permalink
  26. Harold wrote:

    Ryan: “… it could have been worse, it could have been Java.”

    It is worse. 6.01 and 6.02 don’t teach all that much of what was in 6.001. The remainder of that has in theory been put in 6.005, “Principles of Software Development” … which uses Java. To paraphrase Wolfgang Pauli, for this purpose Java is not even wrong.

    I’ll note that this removes a “service subject” from the EECS department. A lot of people outside the department who had no interest in EE and who only wanted to learn computer science (as opposed to just programming) used to take 6.001, and now there is nothing for them in the department’s offerings (e.g. 6.005 has 6.01 as a prerequisite and 6.042J Mathematics for Computer Science as a corequisite).

    As for Sussman’s comment “…it probably just had a library already implemented for the robotics interface…”, well, no probably about it, it indeed uses just such a library.

    The politics behind all this are perhaps illustrated by the fact they have finished the purge of Scheme/LISP from the basic curriculum by switching the AI course (6.034) to Python. (I knew they were going to do this and a quick look at the course’s web site indicates it’s done; BTW, does anyone (good) in the real world do AI in Python???).

    Ah well.

    Wednesday, March 25, 2009 at 07:51 | Permalink
  27. Gregory: Python 3.0 introduces the ‘nonlocal’ keyword to solve that problem. See here for more information:

    http://www.python.org/dev/peps/pep-3104/

    You can also change the definition of bisector to the following to have it work:

    def bisector(too_low, mid=mid, low=low, high=high):

    Wednesday, March 25, 2009 at 08:03 | Permalink
  28. Impatient wrote:

    I had several MIT grads in the developer training course I used to teach for a large software development company. They were bright, but the practicality (or lack thereof) of their programming education often left them far behind their classmates. I congratulate them for the soaring vistas they enjoyed when they first groked Scheme. So did I, when I learned it. But back here on planet Earth, we have software to develop to make the world a better place, and it’s not being done in Scheme.

    Wednesday, March 25, 2009 at 09:59 | Permalink
  29. subhan wrote:

    i appricate MITs dicision

    Wednesday, March 25, 2009 at 10:24 | Permalink
  30. Schuyler wrote:

    Gregory: I don’t think this issue is related to whitespace. Steven’s solution will remove the error, but will not give you what you want. You’re fighting Python’s object-oriented style. I think you’d want something like:
    http://pastebin.com/m2a457acf

    class Bisector:
    def mean(self,a,b):
    return (a+b)/2

    def __init__(self,initial_low,initial_high):
    self.low = initial_low
    self.high = initial_high
    self.mid = self.mean(self.low,self.high)
    return

    def __call__(self,too_low):
    if too_low:
    self.low = self.mid
    else:
    self.high = self.mid
    self.mid = self.mean(self.low,self.high)
    return self.mid

    b = Bisector(0,32)
    print b(True)
    print b(False)
    print b(True)

    Wednesday, March 25, 2009 at 12:51 | Permalink
  31. WulfCry wrote:

    The only computer language ever giving me an hard on where SuperBasic on a Sinclair QL.

    Normal basic never had that appeal to me peek , poke whatever but it was much easier to do without looking through an LIBRARY to add some functionality to your code.

    Python ? well it works for today the learning curve is easy for beginners the fact of knowing what you want to import like any other language with the need of including something is annoying making the learn curve steep again. Going up a mountain could be hard , Decent from it even harder but the trip could be worthwhile.

    Wednesday, March 25, 2009 at 13:38 | Permalink
  32. Adam Olsen wrote:

    I second Schuyler’s Bisect class, except for the use of __call__. Not only are you pretending to be a simple function, you’re also returning a result (implying you have no side effect).

    As this particular case seems to need the side effect and the result, the next best thing is to find a method name that implies them both.

    Wednesday, March 25, 2009 at 14:11 | Permalink
  33. Trainer Inukuma wrote:

    Very good decision!

    Monday, May 18, 2009 at 08:19 | Permalink
  34. NedHorvath wrote:

    All the difficulty this thread is having getting the bisector defined suggests that we still have a wee way to go. Who’d have imagined it more than 50 years after the invention of Fortran and Lisp…

    Monday, May 25, 2009 at 20:59 | Permalink
  35. Ian wrote:

    RIP 6.001

    Monday, October 26, 2009 at 21:20 | Permalink
  36. Laurence wrote:

    i’m from National University of Singapore, my lecturer was from MIT scheme class. And the teaching staff actually used scheme to create a library for us to program robots. We didn’t have to change to python

    Tuesday, October 27, 2009 at 01:27 | Permalink
  37. If you don’t learn C, how in the H#ll can you be a CS magor? C is the mother tongue of all modern application languages, and YES you will learn how to use pointers.

    Tuesday, October 27, 2009 at 05:49 | Permalink
  38. Harold wrote:

    Dale Wilbanks: Yes, well, that’s the point of Joel Spolsky’s essay “The Perils of JavaSchools”, which says among other things that you really need to grok pointers and recursion.

    Tuesday, October 27, 2009 at 10:49 | Permalink
  39. Mortimer Snerd wrote:

    “If you don’t learn C, how in the H#ll can you be a CS magor?” — I was a 6-3/CS major at MIT and they never taught us C and I’ve done just fine. Languages you can pick up yourself by reading a manual. It’s the fundamental concepts behind all languages that they’re better off teaching.

    Tuesday, October 27, 2009 at 18:46 | Permalink
  40. edencraze wrote:

    Unbelievable. I think software is now more of a crash site, not of our aircraft but of alien origin. You have so many things lying around but not quite really sure how to use them effectively until you dedicate your lifetime.

    Wednesday, October 28, 2009 at 15:24 | Permalink
  41. Having actually taken, and aced, the now departed 6.001, I can say something meaningful about the course. It wasn’t about scheme, it was about what you could do with it.

    The more advanced software engineering course, 6.034 used something called CLU. I doubt anybody’s ever heard of it, but who cares. Computer science courses should teach fundamentals, and they probably should vary the language every few years if only to emphasize that it is primarily the approach to solving problems that really matters.

    Of course, that does NOT mean I want to go back to F77. But I could if I had to.

    Nobody ever accused MIT of producing bad programmers, even if they used languages that were not commercially prevalent. It’s a real shame that “.001″ is gone.

    Sunday, November 1, 2009 at 12:15 | Permalink
  42. Actually, what I wrote isn’t strictly true. There was this whole debate about the “MIT approach” vs. the “NJ approach”, but those who know this also know there are merits to both.

    Sunday, November 1, 2009 at 12:16 | Permalink
  43. BTW, even when they taught 6.001, there were still courses available in Fortran and C. It is an error to say that C is not taught at MIT. I believe it was part of the Civil Engineering Dept at the time.

    I’m not going to look it up. I’m too lazy :-)

    Sunday, November 1, 2009 at 12:19 | Permalink
  44. Ubu Walker wrote:

    This debate is silly. It is the “should we offer Latin since it is a dead language” debate. Fact of the matter is that you can learn about programming using any language. It’s the teaching and problem solving that’s important.

    Sunday, November 15, 2009 at 08:54 | Permalink
  45. Harold wrote:

    Ubu Walker: I don’t think you understand what MIT is trying to accomplish with its EECS majors or the time constraints in a university course (13 weeks of instruction in a semester for MIT).

    In those contexts the choice of a language is very important. If you want to teach some functional programming you’d best not choose something like Java.

    You don’t want to spend a lot of time teaching syntax and solving syntax problems, so languages like Scheme and Python are good.

    Sunday, November 15, 2009 at 11:52 | Permalink
  46. Peter Szilagyi wrote:

    I was saddened at first, as a Lisp hacker. But even in “my day”, most students complained about using Scheme the whole time. Only a fraction “got it”.

    Anyway, the 6.001 crew will be inspirational in Python. I doubt the students will lose much. The ones that get Lisp will still learn it. Many will be inspired to do so by the course.

    It is too bad to not be able to use SICP, as that was a truly great book. But times change.

    Monday, November 23, 2009 at 09:01 | Permalink
  47. Michael Tuchman wrote:

    Well, students complained about every other course as well. I’m not sure where you get the idea that only a few people got it. The drop rate would have been a great deal higher were that true. Yet by the time of the eighth lab or so, most people were still in the course and attending lectures and recitations, so I would dispute the claim that \most people didn’t get it\ based on simple survival analysis.

    Monday, November 23, 2009 at 09:53 | Permalink
  48. Rowan Davies wrote:

    @Ubu: I disagree about “any language”. The language can get in the way – and I doubt machine code is a good language for this.

    A functional language has the most fundamentally rich concepts, and is appropriate at somewhere like MIT.

    Python is better than some, but it obscures some fundamental concerns. (And both obscure some fundamental concerns by being dynamically typed – concepts have important static structure in the real world.)

    Wednesday, December 2, 2009 at 08:52 | Permalink
  49. Peter Szilagyi wrote:

    Michael, sorry, I didn’t mean that students didn’t get 6.001, they did. I mean most students didn’t get the Lisp bug. But the purpose of the course isn’t to give us the Lisp bug, but to teach us programming, which most students got.

    Thursday, July 22, 2010 at 21:26 | Permalink
  50. Michael Tuchman wrote:

    Talk about a time lag – picking up a conversation seven months later. I still think that most got it – even the lisp side.

    Changing sides for a second, I think there were two places where people “got off the bus”. The first was at the mention of lambda. A fair # of People really were confused about how to properly employ anonymous functions.
    But based on % of people asking at recitation sections, maybe only 25% had this issue, and they had sorted it out.

    A larger number left (in spirit) during the metacircular evaluator assignment. Why take the time to write lisp in lisp? We already have it!

    It was a fairly long assignment that came at a time when all the other courses were getting tough as well.

    All said though, I still think dropping Scheme was a loss and a mistake. I really felt it served our goals well to think about programming rather than syntax. And the syntax was simple – it was just functions, and we “understand” functions well from our math classes.

    Thursday, July 22, 2010 at 23:11 | Permalink
  51. Michael Tuchman wrote:

    “Times” don’t change. People make decisions. there aren’t bad “times”, just bad cultures or bad institutions, or bad groupthink.

    “Times” didn’t change; we as a society decided to abandon an approach to programming where scheme/lisp would have excelled.

    I don’t like blaming “times” because it is a very bad figure of speech; it lets us blame circumstance instead of investigating the causes of group decision making.

    Thursday, July 22, 2010 at 23:18 | Permalink
  52. jobbly wrote:

    Ridiculous.

    Reading this, you’d think that scheme was a prerequisite to good programming. Come off it.

    The world is full of examples of excellent software, written by excellent programmers, with a myriad of backgrounds, many who’ve never written a line of scheme.

    Changing from scheme to python will make little or no difference to the outcomes of this course. The talented will be just as taltented regardless of the playground.

    Tuesday, October 26, 2010 at 03:05 | Permalink
  53. Michael Tuchman wrote:

    If talent were the only issue, I’d have no problem with what jobbly is saying. First of all, Python came along well after scheme and absorbed some of its good ideas. So, it would not be surprising that we can obtain the same results.

    However, it is not simply identification of programming talent that is the objectives of this course. Scheme met the needs of a computer course well because one could get to the computer science ideas quickly without being mired down in programming details.

    It’s not simply a matter of “getting the job done” or “identifying talent”. A first year computer science course needs to meet the intellectual needs of the class, too. In other words, it needs to have a certain amount of elegance too.

    Now, I have not seen python so I cannot comment if this is elegant, but I reject your notion that all languages are equivalent for a first year computer science course. They could still do it in Fortran, and your logic would hold just fine. But they don’t, and for a good reason.

    Tuesday, October 26, 2010 at 07:58 | Permalink
  54. Kanishka Ray wrote:

    Scheme was my first programming language in my Intro to CompSci class at the U. of Chicago in 1993. I was a second year undergrad at the time, and I had 0 experience with programming prior to that, and had learned to use email and Word a few months before. Our text was Abelson and Sussman.

    Needless to say…despite being pretty mathematically inclined, it kicked my ass. And the use of Scheme as the learning medium/tool did not help matters.

    The class was tough enough, the problem sets grueling and in some cases mind blowingly hard, but Scheme with its’ bare bones interface and joke level debugging did not help matters. I often spent more time being a good code technician than actually trying to solve the core problems being posed (8 queens problem anyone?)

    Saturday, December 11, 2010 at 12:51 | Permalink
  55. Python is an excellent teaching language. The interactive prompt is a nice tool for the students to use for experimentation and for me to demonstrate programming constructs in class.

    Python teaches good formatting habits. When my students use a free-format language and I tell them to observe good formatting conventions, they are trained to expect good formatting and they just do it.

    Python’s syntax is simple. It allows my students to focus on semantics instead of syntax.

    Python offers the additional benefit that is it a powerful tool and an excellent general-purpose programming language.

    I applaud MIT’s decision. We have been using Python since 2004 at NCSSM. It is interesting to see lots of others climbing aboard.

    Sunday, February 6, 2011 at 09:47 | Permalink
  56. Bianca wrote:

    What book does M.I.T use to teach python to their first year’s?

    Thursday, March 10, 2011 at 08:07 | Permalink
  57. We began using Python as a first programming language at the North Carolina School of Science and Mathematics in 2004. Our first course is a course in procedural programming, which uses Python objects as smart data types. Here are some benefits we have seen

    1. Python’s grammar is simple. Hello world is

    print “Hello, World”

    or

    print (“Hello, World”)

    in Python 3. The students are not left bewildered by traffic jams of arcane keyworks.

    Python’s whitespace delimitation causes beginners to develop good formatting habits that last.

    There are not great piles of parentheses to wade through

    There are powerful libraries that do hosts of useful stuff.

    It supports the functional, imperative and OO paradigms but forces none of them on you. We like it a great deal.

    Wednesday, December 28, 2011 at 09:29 | Permalink
  58. Michael Tuchman wrote:

    All introductory languages are intuitive at the start and have their nice features. It’s how easily you put the elements together that determines the true sense of a language.

    Syntactic sugar is sweet but fattening. I worry about non-issues like how to space things or matching parentheses. That’s my text editor’s job.

    I think succumbing to popular fads was a bad idea. I think a great deal of the assignments were made easier because we could start by solving problems without having to spend time on the syntax of the language. That said, Python was probably the best choice, given the regrettable decision to leave Scheme.

    Wednesday, December 28, 2011 at 10:38 | Permalink
  59. Nihat K wrote:

    I don’t agree. Coming with heavy assembly, C, C++ background Scheme was a train crash for me. I think Scheme is a beautiful tiny language with 1 page language spec, yet powerful enough to do even OOP. If you teach it right it is the best language you can teach to an average Joe and makes him a “very good” programmer in any language he might encounter in the future. Within a few weeks your average Joe starts developing his own algorithms within 2 months he shuffles objects around, in 6 months starts writing his own compiler. This is way faster learning curve than C/C++. Yet once you master it you become a very good programmer, the rest is just about learning the sytax rules of any language they propose you. I still do C/C++ for living (mostly on realtime) but even now for mocking up a small algorithm I use Scheme. Python inherits a lot from Scheme except “the consistent” but a bit hard-on-the-eyes syntax of Scheme.
    Consistency is important for a starter because with his one page spec knowledge he can decode any expression he might encounter, without diving deep in to the thick language manual (e.g. ANSI C spec and any later C/C++ specs). One good thing on Python’s account perhaps is that it has lots of open source support libraries so for anything which requires interaction with the “real world” (including GUI, Web, custom hardware) is easier. I think I would teach Scheme first to teach about programming, then switch to Python (which is relatively easy), for real world then C/C++/Java is just something you pickup when you need it.

    Thursday, November 22, 2012 at 05:03 | Permalink
  60. Reinhard Neuwirth wrote:

    MIT’s switch from Scheme/Lisp to Python was a surprising move, agreed, but it and the discussion above demonstrates that computer science and the programming languages that implement them (and are of course themselves manifestations of the latest in CS, or at least attempt to be) are a alive and well, and, half a century on, are growing rather than slowing their pace towards maturity. So let professionals and amateurs alike rejoice and enjoy working or dabbling in the field, in spite of the mess. In fact, challenges and opportunities arise from the mess. Or would anyone rather be an expert designer of steam locomotives or build analog electronic circuits around pentodes? The physics of steam and vacuum tubes and the engineering disciplines of of their machines and circuits are well settled, no surprises there. In other words, all maturity and no mess.

    Thursday, January 17, 2013 at 16:51 | Permalink
  61. Martin wrote:

    What a shame they did not pick Ruby, but as someone here already pointed out, this is pushed by someone higher up.

    Sunday, April 7, 2013 at 23:42 | Permalink
  62. David Marshall wrote:

    So many people in their ivory towers looking down on the world in idealistic bliss, drowning in the depth of their pool of ego. None have ever strayed near the real world with it’s deadlines and profit margins. Oh no. They make their own toys to play with.

    Thursday, April 25, 2013 at 10:09 | Permalink
  63. David Marshall wrote:

    The other thing people forget about 6.001 is that it’s a course for engineers, taught by engineers. They simply used the best tool for the job. Now, 20 odd years later, new tools have been made and they are better than the old tools. It’s called progress!

    Monday, April 29, 2013 at 06:58 | Permalink
  64. derpsec wrote:

    And now ‘industry’ is moving towards functional programming, which is exactly what you learn in SICP. You can also write apps in Racket/Scheme and deploy directly to Yandex cloud. 6.001 is still the best intro to comp science

    Tuesday, January 7, 2014 at 19:41 | Permalink

22 Trackbacks/Pingbacks

  1. Why I Find Software Depressing on Tuesday, March 24, 2009 at 15:49

    [...] today I read this and it only makes me more depressed about the whole of computerdom. God help us if this is where [...]

  2. A n00b g33k blog - Meta Programming and Catacombs on Wednesday, March 25, 2009 at 08:59

    [...] Why MIT switched from Scheme to Python | Wisdom and Wonder Why MIT switched from Scheme to Python [...]

  3. WebDevGeekly » Blog Archive » Episode 8 on Wednesday, March 25, 2009 at 21:54

    [...] I fought learning scheme in college, but we did it because that’s what MIT used, http://www.wisdomandwonder.com.....-to-python [...]

  4. [...] It’s the end of an era, for the Knights of the Lambda Calculus. Why MIT switched from Scheme to Python [...]

  5. Alex Miller - Weekly twitter links (March 30th) on Monday, March 30, 2009 at 02:13

    [...] this boggles my mind on so many levels that I don’t even know where to start (re MIT going fro… [...]

  6. Twitted by EdgarSanchez on Wednesday, July 22, 2009 at 21:45

    [...] This post was Twitted by EdgarSanchez [...]

  7. Capstone projects and time management | dv8-designs on Monday, October 26, 2009 at 18:41

    [...] At least they’re replacing Java with Scheme, if only because “that’s what MIT does.” (Too late!) And they are teaching students to think a certain way. And given how much the average CS professor [...]

  8. [...] At least they’re replacing Java with Scheme, if only because “that’s what MIT does.” (Too late!) And they are teaching students to think a certain way. And given how much the average CS professor [...]

  9. [...] http://www.wisdomandwonder.com.....-to-python a few seconds ago from choqoK [...]

  10. [...] http://www.wisdomandwonder.com.....-to-python a few seconds ago from xmpp [...]

  11. Capstone projects and time management « ThisGlobe.com on Thursday, November 5, 2009 at 20:55

    [...] At least they’re replacing Java with Scheme, if only because “that’s what MIT does.” (Too late!) And they are teaching students to think a certain way. And given how much the average CS professor [...]

  12. [...] At least they’re replacing Java with Scheme, if only because “that’s what MIT does.” (Too late!) And they are teaching students to think a certain way. And given how much the average CS professor [...]

  13. Loper OS » You have made your bedrock, now lie in it. on Monday, December 7, 2009 at 16:29

    [...] Software, on the other hand, routinely ships broken.  And software cannot be meaningfully repaired or replaced, only re-designed.  Yet witness the cries of righteous outrage among software vendors whenever hardware deviates ever so slightly from its advertised function.  What software company could honestly lay claim to even the lowliest silicon pusher’s levels of bug-free operation and architectural soundness?  I cannot help but picture a stereotypically slick and unrepentant con artist, frothing with rage after having been duped into purchasing a costly full page ad in what turned out to be a Skeptic society’s periodical.  It appears that Microsoft (and now Apple) is entitled to comfortable and stable bedrock abstractions, while you and I are not. [...]

  14. [...] основанный на Scheme на 3 курса основанные на Python. Вот почему MIT решили сменить свой курс: Costanza asked Sussman why MIT had switched away [...]

  15. Daily links for 11/07/2010 | Blog | Bob Sutor on Sunday, November 7, 2010 at 07:30

    [...] Why MIT switched from Scheme to Python | Wisdom and Wonder [...]

  16. Zasoby dla deweloperów | Wiadomości o technologiach IT on Sunday, December 12, 2010 at 13:27

    [...] MIT wybrał zamiast Schema język Python  – http://www.wisdomandwonder.com.....-to-python [...]

  17. 1-555-CONFIDE - 教育片面觀察 on Thursday, April 7, 2011 at 22:22

    [...] SICP 教學語言是 COBOL ,會教 COBOL 。 [↩]據說 MIT 的 6.001 SICP 已由 Scheme 轉為 Python 。 [↩]順帶一提, UCB 用的 Scheme 是 STK , MIT 用的是 MIT/GNU Scheme 。 [...]

  18. [...] itself had changed since the ’80s; developers no longer built whole systems from nothing; now they merely plugged together existing libraries to get something that worked. This is true for much of the programming work out there — but I am gloomily reminded of [...]

  19. SICP Under Attack? | Irreal on Tuesday, December 27, 2011 at 11:42

    [...] but they, at least, had a reasonable, if not ultimately convincing, rationale for doing so. Sussman explained that software engineering today is all about gluing together huge libraries that hardly anyone [...]

  20. syawLa » SICP – Preparation on Tuesday, January 24, 2012 at 01:54

    [...] Why MIT switched from Scheme to Python [...]

  21. Tackling Clojure | Spencer Rogers on Sunday, May 6, 2012 at 13:10

    [...] AI friendly programming language is notable for many things such as being MIT’s one-time introductory language, Paul Graham’s secret sauce, and the Emacs extension [...]

  22. 7 Quick Takes (10/19/12) on Thursday, October 18, 2012 at 23:11

    [...] itself had changed since the ’80s; developers no longer built whole systems from nothing; now they merely plugged together existing libraries to get something that worked. This is true for much of the programming work out there — but I am gloomily reminded [...]

Post a Comment

Your email is never published nor shared. Required fields are marked *
*
*