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)

105 thoughts on “Why MIT switched from Scheme to Python”

  1. 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.

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

  3. 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.

  4. 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.

  5. 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.

  6. “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.

  7. 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.

  8. 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)
    >>> 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
    >>> a + (7,9)
    >>> a + (7)
    TypeError: can only concatenate tuple (not “int”) to tuple
    # Because that’s arithmetic parens, not tuple parens
    >>> a + (7,)
    Is it any wonder people who learn python first come to be afraid of parentheses?

  9. 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.

    1. You need a language or how do you create and manipulate these? How do you learn how to make them actually work?

  10. 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”

  11. 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.

  12. 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.

  13. 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.

  14. 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.

  15. 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.

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

  17. 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++.

  18. 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.

  19. 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.

  20. > 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.
    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
    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.

  21. 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
    ~~~~~~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.

  22. 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.

  23. 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.

  24. 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:
    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)
    def __call__(self,too_low):
    if too_low:
    self.low = self.mid
    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)

  25. 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.

  26. 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.

  27. 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…

  28. 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

  29. 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.

  30. 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.

  31. “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.

  32. 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.

  33. 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.

  34. 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.

  35. 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 🙂

  36. 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.

  37. 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.

  38. 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.

  39. 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.

  40. @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.)

  41. 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.

  42. 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.

  43. “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.

  44. 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.

  45. 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.

  46. 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?)

  47. 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.

  48. 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”
    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.

  49. 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.

  50. 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.

  51. 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.

  52. 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.

  53. 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!

  54. 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

  55. Thanks for the auspicious writeup. It in reality
    was once a enjoyment account it. Glance complex to more introduced agreeable from you!
    By the way, how can we communicate?

  56. SICP is back at MIT in the form of 6.037 which teaches a “condensed” version. http://web.mit.edu/alexmv/6.037/
    You can actually develop professional programs in Scheme using Lambda Native. You write out the guts in Scheme then can automatically port to iOS, Blackberry, Android, OSX, Windows, BSD, Linux ect. Write one program, export many times.
    More and more industry languages are becoming Lisp like, such as Julia. I think in the end all of us will just be using some kind of optimized Lisp.
    I’m glad Knuth didn’t take MIXAL/MMIX out of The Art of Programming books. He uses the same defense claiming what would be the point of including the low level flavor of the day when he’d have to go back and constantly rewrite his books to update the language. He also once had to learn a half dozen different low level languages to build compilers back in the 60s/70s so if he can be fluent in a number of different languages any computer scientist can. You learn the fundamentals in one, then just pickup a “learn Python (or Assembler)” book and translate what you know already in a weekend, learning new syntax and libraries.

    1. @SchemeHax, SICP isn’t really “back” at MIT — note that course is during IAP (January winter vacation during which offbeat and experimental courses are offered, some led by fellow students, and aren’t part of any degree program or necessarily overseen by academic departments).
      Source: am MIT Alumnus

  57. To start, python has 0 value for CS. For intro to programming python/java/csharp/etc. are all equally horrific but can do the job.
    However, there are two languages every CS must have at least rudimentary knowledge of: schema/lisp and c/c++.
    Lisp was just few weeks as part of intro to AI. Wonder how my thinking&approach about programming could have been different granted I was introduced to scheme instead of C first !!!

  58. My 10 year old wants to learn Programming. Scheme or Python – which is it?
    Simple English please.

  59. I should probably write my own blog post on the topic, but, in short —
    When I took computer science courses, in a school to the south of MIT not known traditionally for engineering, the core two courses were “programming” (taught in M68000 assembler) and “algorithms and data structures” (taught in pascal). That’s where you were supposed to learn “all the way down”.
    Interestingly, most students “didn’t get it”, especially algorithms and data structures, because they could copy from the book. They didn’t re-think the problem. I asked for – and was allowed – to submit all my problem sets in C, which means I had to re-code everything and use only the ideas in the book, not the code itself. Thus, I submit, that while the old world of understanding “all the way down” has greatly vanished, the idea of skating over the top of unknown libraries has been with us since the beginning.
    I didn’t get an A in that course, and I did become my TA’s worst nightmare because I quickly knew more C than they did, but I came out with an extraordinary knowledge of data structures that form the core of my professional practice to this day.
    There were no other programming courses. I remember the first day in Operating Systems. Tom said “the course is taught in C. Anyone not know C? If you don’t know C, go to (some particular) TA, they will help you get up to speed and be your resource, but if you know programming you can program in any language. Let’s begin Operating Systems.”

    1. It’s funny you mention Data Structures and Algorithms, because in High School I took a summer class at Harvard (it’s a school a little northwest of MIT) that was also taught in Pascal, then I went on to get a CS degree from MIT, but I always felt most of my day-to-day programming knowledge came from that one Data Structures class. Arrays, pointers, structures, sorting and searching, binary trees, heaps and stacks were never really taught in the MIT comp sci program, which was mostly about theory and handling complexity, but it’s the stuff you use every day as a programmer.

Leave a Reply to David Marshall Cancel reply
