16 ms·

Why MIT switched from Scheme to Python (2009)

284 points by borski 1y ago

anthk 1y ago
Scheme it's far easier to grasp. With SICP you basically rewrite a Scheme within a Scheme. And you teach Calculus to the interpreter to solve further problems. Online SICP: http://sarabander.github.io/sicp/ http://sarabander.github.io/sicp/
- glimshe 1y ago
  To do that with Scheme/SICP, you actually have to understand the CS principles behind it. Not as much with Python, which is likely why it became a more popular choice.
  - postepowanieadm 1y ago
    Shouldn't that be the point?
    - zdragnar 1y ago
      I remember when universities wouldn't teach languages higher level than C/++ because "the languages changed too quickly and the 4 year degree would be obsolete by the time the students graduate". Instead, they focused purely on the low level engineering aspects of the software meeting the hardware, with only advanced classes focusing on things like AI research (pre-LLM days) or modelling fluid dynamics on specialized hardware. Of course, this is also why most companies worth working at didn't care if you had a CS college degree or not to build a wordpress website or a SOAP/REST API. Aside from some very basic lessons learned from experience (generally understanding computational complexity and maths) most software jobs didn't need any knowledge of assembly at all, or how to write an interpreter or a garbage collector.
      - JackFr 1y ago
        I spent years knowing nothing but C and I’d say it handicapped me in many ways. (I recall insisting that it would be impossible to do anything without assignment.) After getting my eyes opened a little bit, I read SICP and it was mind blowing. I read a little Haskell, wrote a little Clojure and a lot of Scala. And even though the day job now is Java and Python, I’m much better off for having bothered to learn it.
    - glimshe 1y ago
      That's what I'm trying to say. SICP teaches you to think differently and "grok" the CS concepts. This isn't always the case with other approaches, which can be much more reliant on blind copy-and-paste and library functionality.
  - anthk 1y ago
    The point of Scheme SICP is that it will teach you these CS principles.
- morkalork 1y ago
  I fondly remember doing a course in my CS degree that was basically working through SICP as a class, taught my an ancient but very fun and enthusiastic tenured professor. When he retired I think the curriculum was updated to JavaScript (??) or as the new professor called it "scheme in drag". I'm glad to have taken the original course..
  - jerrycruncher 1y ago
    Honestly, the new professor wasn't too far off. I've often referred to "The Little Schemer" as "the best javascript book that isn't about javascript."
- terminalbraid 1y ago
  The official SICP site is here, including the text. https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/index.html https://mitp-content-server.mit.edu/books/content/sectbyfn/b... pdf https://web.mit.edu/6.001/6.037/sicp.pdf https://web.mit.edu/6.001/6.037/sicp.pdf
  - anthk 1y ago
    Yep, and there's a Texinfo version too. With Chicken, 'sudo chicken-install srfi-203 ; sudo chicken-install srfi-216; Emacs, Geiser and this ~/.csirc, you can run SICP exercises on really constrained environments. ~/.csirc (import scheme) (import (srfi 203)) (import (srfi 216)) Texinfo version: https://zv.github.io/sicp-in-texinfo https://zv.github.io/sicp-in-texinfo Run Emacs. Press Ctrl-u Ctrl-h i and choose the sicp.info.gz file. Then, run: Alt-x package-refresh-contents Alt-x package-install geiser-chicken wait. Run Alt-x geiser, and if it ask you which Scheme interpreter to run, choose 'chicken'. Later, press Ctrl-x f to choose a file, create a new one called "hello.scm". Write in that file: (display "Hello world"). Run Ctrl-c Ctrl-c and then the Scheme code in that file will be evaluated. To choose the running Chicken interpreter, press Ctrl-x b and choose the Geiser buffer. Run Ctrl-h t for the Emacs tutorial, it will be handy. If you want the same tutorial in Spanish, Japanese, French... press Ctrl-u Ctrl-h t and just input your language, press [TAB] to autocomplete. Happy Hacking.
Steelkiwer 1y ago
[dead]
ltbarcly3 1y ago
When I read this I just feel like Sussman is getting out of touch and maybe a little disillusioned. From the wording he seems annoyed about the change, isn't even sure why it was made "probably because there's some library for robots", has gone from someone who would have a complete understanding of complex systems to someone who sounds more like a frustrated beginner. "Doing basic science on libraries to see how they behave" instead of grabbing the source and looking at it - he is expressing the view of someone who wants to complete their ticket in Jira without too much effort and go home for the night rather than someone with an actual curiosity and enjoyment of what they are doing.
- monkeyelite 1y ago
  Can you not see that there is a philosophical difference between these two approaches and why someone might have a preference for one or the other?
  - ltbarcly3 1y ago
    There isn't a philosophical difference. Both are problem solving strategies. You would choose one or the other depending on goals and constraints. There isn't a 'philosophical' reason to choose one or the other. In the end the choice wasn't made for philosophical reasons. It was made because the robot library was in Python, or so he thinks. I think this actually shows there was a strong reason to never use Scheme: it's a failed language family. Outside of academic life support and very niche uses (which are usually directly caused by the academic uses, such as Emacs lisp) scheme just doesn't exist out in the world, despite a dozen very competent and complete implementations that are still supported. This is not an invitation for lisp fan boys to stomp their feet, TIOBE doesn't have any (()())()(()) language in the top 20. Debate rankings all you want, but lisp type languages are extremely rarely used because people don't find them productive when given a choice.
    - monkeyelite 1y ago
      > There isn't a philosophical difference. I think that’s key to understanding the issue, so I guess the conversation is over.
ferguess_k 1y ago
Considering the target students of MIT CS department, I'd argue that they could simple start from an interpreter class in Python.
- programjames 1y ago
  As in, write a Scheme interpreter in Python?
mrexroad 1y ago
Ga Tech used to teach Scheme as an intro to CS course. I vividly remember sitting in lecture and being struck w/ the implications of functional programming as the professor said you could pass functions into functions and modify them. It was as formative of a moment as my 2nd Grade teacher showing us a really complex looking (at the time) rainbow flower in LOGO (she had one of few color Mac classic), and showing us it was simply the work of drawing the path of one petal, then repeating same “work” after changing two values (starting angle and color).
- cs_throwaway 1y ago
  It is possible that this doesn't work anymore. I distinctly recall the following episode when I last taught intro CS in Scheme: I revealed first-class functions. After lecture, the brightest kid in class came up to me and said something to the effect of, "What's the big deal? You can do this in Python."
  - zahlman 1y ago
    That should be the beginning of the formative experience for that kid rather than the end. Yes, you can. How often do you? What are you missing by not thinking about problems in that way more often? What idioms could be unlocked that way? (How many Python programmers out there are aping wholly unnecessary "design patterns" created for C++ or Java? Or rather: shouldn't a design pattern be about the design rather than the implementation? What is a design, in the pure abstract, really?)
    - cs_throwaway 1y ago
      Don’t worry, aforementioned kid is doing just fine, machine learning PhD IIRC. There is a lot of other remarkable stuff in modern computing.
      - zahlman 1y ago
        Oh, I don't doubt that. Smart kids usually land on their feet just fine (and even when they don't, they cope and mask their problems better). But when I get the opportunity to teach things, I strive to allow smart students to rise to their own level.
_aleph2c_ 1y ago
https://archive.is/20150709075141/http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-to-python https://archive.is/20150709075141/http://www.wisdomandwonder...
mhh__ 1y ago
Decline.
varenc 1y ago
I was one of the last batches of students on the old Scheme curriculum. I absolutely loved it! Understanding that all loops could be done via recursion, and what a side effect is, is what fundamentally made me fall in love with CS. I've heard good things about the new, and now newer, curriculum but I know I wouldn't have had the awakening I did if it weren't for scheme. RIP SICP --- ps another fun story: we had some test where we were allowed to bring in 1 page of reference notes. And turns out the entire scheme specification is short enough to fit on a double sided page if condensed. So my friend, mostly in jest, brought the whole Scheme specification to the test with him and figured every possible question could be answered that way!
- chuckadams 1y ago
  > turns out the entire scheme specification is short enough to fit on a double sided page if condensed I think this only held for R4RS and earlier. You can fit War and Peace on one page if you condense it enough.
  - TMWNN 1y ago
    >You can fit War and Peace on one page if you condense it enough. "I took a course in speed reading, learning to read straight down the middle of the page, and I was able to go through War and Peace in 20 minutes. It's about Russia." —Woody Allen
- cactusfrog 1y ago
  I worked an MIT programmer who bragged about the Scheme curriculum. He was also the worst programmer that I’ve worked with. He really liked clojure and would constantly complain about Python syntax, and ended up quitting abruptly when his hand spun Datomic based system was rejected. I think there is a trap in thinking that a strange way of being taught puts one at an advantage. It is really annoying to work with people who believe they are more enlightened than others.
  - agordhandas 1y ago
    That kinda defeats the purpose of why scheme was the language of choice in the first place! The goal was for us to fall in love with programming, not a programming language.
djtriptych 1y ago
build a scheme interpreter in python = best of both worlds?? I love SICP - easily in my top ten most influential CS books. But I've basically never seen a real Scheme job. I do think it's reasonable to at least try to instill both foundational and marketable skills early.
MontyCarloHall 1y ago
Isn't this just part of the broader trend of CS departments switching away from teaching computer science to teaching computer engineering, which in turn is part of the more general trend of colleges becoming more vocational? LISP dialects like Scheme are excellent for teaching pure computer science because they are the closest thing to executing lambda calculus expressions. Whereas Python is excellent for teaching applied computer engineering, because it's essentially executable pseudocode for imperative languages, and imperative languages are the most common language a computer engineer encounters in the real world.
- SoftTalker 1y ago
  Yes. One of the biggest complaints that computer science departments used to get from students is that they weren't learning any languages that employers are using.
  - cess11 1y ago
    I'm not so sure someone who's good with Scheme will be bad with Python or Java. On the contrary, I suspect that such a person is likely to be better suited to build software in either of the latter two. I also suspect that Python is not a particularly good first language for someone who aims for a professional career building software.
    - masklinn 1y ago
      > I'm not so sure someone who's good with Scheme will be bad with Python or Java. The problem likely has always been the companies / HR rather than the students. > I also suspect that Python is not a particularly good first language for someone who aims for a professional career building software. It's not a particularly bad one either, certainly better than Java. IIRC a secondary benefit is that it allows overlap between some of the basic CS, and the CS/CE courses for non CS track students
    - Jtsummers 1y ago
      > I'm not so sure someone who's good with Scheme will be bad with Python or Java. They won't be. But students don't understand that, they want to learn marketable skills and are 18 years old. They haven't figured out that if your skills transcend language choice you will be more marketable even if it means you have to spend a few weeks learning a new language for a new job. They lack maturity, which isn't surprising given their age and experience, and so they complain.
AlanYx 1y ago
There's probably a middle ground somewhere. IMHO, SICP leans a little too heavily on the homoiconicity of Scheme for its choice of exercises. Which is intellectually nifty but it could also include exercises from something like Crafting Interpreters (Nystrom) where you would build up step-by-step to an interpreter of a non-Scheme-like language, using Scheme.
- shawn_w 1y ago
  Eh, being able to skip parsing allows a fairly short book to spend more time on its real focus than it otherwise would.
ted_dunning 1y ago
The last sentence was the key: And why Python, then? Well, said Sussman, it probably just had a library already implemented for the robotics interface, that was all. That is the essence of Python's strength ... the eco-system. And the comment about engineering becoming the art of trying to reason about half-documented toys from the huge grab bag of packages is exactly on point relative to the risk and challenge of this transition.
ayhanfuat 1y ago
I think it was also one of the first freely available courses for learning Python. It’s been more than 10 years since I took that course on edX and I still appreciate it. Robot vacuum exercises were a lot of fun.
KenSF 1y ago
The move away from Scheme has always saddened me. The first thing we learned in 6.001 was abstraction and invariance. These are still the core of writing good software. I still use these principles every day. There is a purity to Scheme. It is a beautiful light-weight language anyone can learn over a weekend. It does nothing magical for you which means you get to / have to build everything you want and you must understand how it fits together.
- eggdaft 1y ago
  I agree. I was taught Scheme and I later taught it. It was a much cleaner and suitable language for teaching computer science than Python. Students could completely understand the language and how it worked by the end of a semester. Scheme is much closer to mathematics, which made it much more suitable for teaching strong mathematicians arriving without coding experience. It also made the hackers more rigorous and broadened their minds from the imperative "do this then that" mindset. There's a notable difference between those first taught scheme and those first taught Python. Of course, both can go on to learning Python or FP or whatever. But that foundation needs to be there to teach truly great coding for most mortals.
jbanes 1y ago
Did anyone notice this announcement was from 16 years ago? I very much doubt this is the current state of the MIT coursework.
temporallobe 1y ago
This is just an introductory language and if you’re in a CS program, you’ll definitely move on to more advanced ones. It actually makes sense to switch to Python since it’s far more ubiquitous and accessible than Scheme. Scheme is not widely used in commercial software development, but still enjoys a presence in academia. Python has strong presence in both. On the other hand, Pascal was my “introductory” programming language (I already knew BASIC pretty well at that point), but it certainly wasn’t the only one in my program - we did Perl, Prologue, C, C++, etc. In a professional software development career, it certainly won’t be the last language you’ll learn.
- lokar 1y ago
  This is one of many divides in the field that makes many general discussions hard. There are many people who think of themselves as a “X programmer” (and perhaps Y and Z), and managers/companies looking for them. Then there are people who think of themselves as software engineers, and the language does not really matter (and companies that hire for that). If often see the two camps talking past each other.
  - temporallobe 1y ago
    I certainly consider myself a software engineer first and programmer second, and you’re right, the language doesn’t matter. I recently got a position developing in Python having never really used it professionally, but it’s so similar to other interpreted languages I knew so I was able to jump right in and start making meaningful contributions. Often we are expected to learn new languages, which is exactly how I picked up the 10ish languages I can confidently say I’m good in, despite never having been formally trained in those. Most common languages don’t stray from certain basic principles anyway.
- materielle 1y ago
  But this is the problem. Our premier academic institutions shouldn’t merely exist as job training programs for big tech. If anything, tech is still one of the better off fields in the university. Look at history or literature programs for where this is heading. I’d imagine that most literature majors don’t even read at all these days. As recent as 50 years ago, the requirement involved hundreds of pages of reading per week, over a sustained 4 year period. Honestly, just close down the university at this point, if all it wants to do is print out degree certificates for social signaling in the job market.
dang 1y ago
Related. Others? Ask HN: How has MIT's switch from Scheme to Python worked out? - https://news.ycombinator.com/item?id=24960481 https://news.ycombinator.com/item?id=24960481 - Nov 2020 (1 comment) Why MIT uses Python instead of Scheme for its undergraduate CS program (2009) - https://news.ycombinator.com/item?id=18782101 https://news.ycombinator.com/item?id=18782101 - Dec 2018 (136 comments) Why MIT Switched from Scheme to Python (2009) - https://news.ycombinator.com/item?id=14167453 https://news.ycombinator.com/item?id=14167453 - April 2017 (97 comments) Ask HN: Python or Scheme? - https://news.ycombinator.com/item?id=2523432 https://news.ycombinator.com/item?id=2523432 - May 2011 (11 comments) Videos for MIT 6.00 - Python Version - https://news.ycombinator.com/item?id=1045114 https://news.ycombinator.com/item?id=1045114 - Jan 2010 (1 comment) Why MIT now uses python instead of scheme for its undergraduate CS program - https://news.ycombinator.com/item?id=842333 https://news.ycombinator.com/item?id=842333 - Sept 2009 (38 comments) Python based MIT 6.00 | Intro to Computer Science and Programming - https://news.ycombinator.com/item?id=819734 https://news.ycombinator.com/item?id=819734 - Sept 2009 (6 comments) Chiming in on the MIT Scheme to Python Switch - https://news.ycombinator.com/item?id=622261 https://news.ycombinator.com/item?id=622261 - May 2009 (7 comments) Why Did M.I.T. Switch from Scheme to Python? - https://news.ycombinator.com/item?id=602307 https://news.ycombinator.com/item?id=602307 - May 2009 (65 comments) Why MIT switched from Scheme to Python - https://news.ycombinator.com/item?id=530605 https://news.ycombinator.com/item?id=530605 - March 2009 (128 comments) MIT replacing Scheme with Python for Intro CS class - https://news.ycombinator.com/item?id=75401 https://news.ycombinator.com/item?id=75401 - Nov 2007 (16 comments) --- Berkeley version: Scheme vs. Python (2011) - https://news.ycombinator.com/item?id=9973156 https://news.ycombinator.com/item?id=9973156 - July 2015 (118 comments) SICP (Python Version) - https://news.ycombinator.com/item?id=3718364 https://news.ycombinator.com/item?id=3718364 - March 2012 (18 comments) SICP taught in Python 3 - UC Berkeley online - https://news.ycombinator.com/item?id=3491142 https://news.ycombinator.com/item?id=3491142 - Jan 2012 (25 comments) SICP in Python - https://news.ycombinator.com/item?id=3141996 https://news.ycombinator.com/item?id=3141996 - Oct 2011 (49 comments)
- deleted 1y ago
  [deleted]
omnicognate 1y ago
> 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. Probably the best way, and maybe the only way, to learn this is by doing it. That's how I learned it, with no formal training in programming. What I learned from SICP and Sussman's other books I would never have figured out any other way. I don't think the world is really as different as Sussman says it is here, and I think the programming world lost something special with this change. The book lives on anyway, and he'll always be one of my heroes.
- zahlman 1y ago
  Absolutely agreed. This situation reminds me of discourse on learning natural languages, where people are constantly told that there is no substitute for time spent deliberately on immersion. But you won't accurately figure out grammatical structures that way; you'll get distracted by the parts you understand and fail to assemble them into a whole. University (and earlier!) courses ought to focus on the kinds of things that actually require direction to learn.
dvrp 1y ago
Because Worse Is Better!
keithwinstein 1y ago
This story has been reposted many times, and I think GJS's remarks (as recorded by Andy Wingo) are super-interesting as always, but this is really not a great account of "why MIT switched from Scheme to Python." Source: I worked with GJS (I also know Alexey and have met Andy Wingo), and I took 6.001, my current research still has us referring to SICP on a regular basis, and in 2006 Kaijen Hsiao and I were the TAs for what was basically the first offering of the class that quasi-replaced it (6.01) taught by Leslie Kaelbling, Hal Abelson, and Jacob White. I would defer to lots of people who know the story better than me, but here's my understanding of the history. When the MIT EECS intro curriculum was redesigned in the 1980s, there was a theory that an EECS education should start with four "deep dives" into the four "languages of engineering." There were four 15-unit courses, each about one of these "languages": - 6.001: Structure and Interpretation of Computer Programs (the "procedural" language, led by Abelson and Sussman) - 6.002: Circuits and Electronics ("structural" language) - 6.003: Signals and Systems ("functional" language) - 6.004: Computation Structures ("architectural" language) These were intellectually deep classes, although there was pain in them, and they weren't universally beloved. 6.001 wasn't really about Scheme; I think a lot of the point of using Scheme (as I understood it) is that the language is so minimalist and so beautiful that even this first intro course can be about fundamental concepts of computer science without getting distracted by the language. This intro sequence lasted until the mid-2000s, when enrollment in EECS ("Course 6") declined after the dot-com crash, and (as would be expected, and I think particularly worrisome) the enrollment drop was greater among demographic groups that EECS was eager to retain. My understanding circa 2005 is that there was a view that EECS had broadened in its applications, and that beginning the curriculum with four "deep dives" was offputting to students who might not be as sure that they wanted to pursue EECS and might not be aware of all the cool places they could go with that education (e.g. to robotics, graphics, biomedical applications, genomics, computer vision, NLP, systems, databases, visualization, networking, HCI, ...). I wasn't in the room where these decisions were made, and I bet there were multiple motivations for these changes, but I understood that was part of the thinking. As a result, the EECS curriculum was redesigned circa 2005-7 to de-emphasize the four 15-unit "deep dives" and replace them with two 12-unit survey courses, each one a survey of a bunch of cool places that EECS could go. The "6.01" course (led by Kaelbling, Abelson, and White) was about robots, control, sensing, statistics, probabilistic inference, etc., and students did projects where the robot drove around a maze (starting from an unknown position) and sensed the walls with little sonar sensors and did Bayesian inference to figure out its structure and where it was. The "6.02" course was about communication, information, compression, networking, etc., and eventually the students were supposed to each get a software radio and build a Wi-Fi-like system (the software radios proved difficult and, much later, I helped make this an acoustic modem project). The goal of these classes (as I understood) was to expose students to a broad range of all the cool stuff that EECS could do and to let them get there sooner (e.g. two classes instead of four) -- keep in mind this was in the wake of the dot-com crash when a lot of people were telling students that if they majored in computer science, they were going to end up programming for an insurance company at a cubicle farm before their job was inevitably outsourced to a low-cost-of-living country. 6.01 used Python, but in a very different way than 6.001 "used" Scheme -- my recollection is that the programming work in 6.01 (at least circa 2006) was minimal and was only to, e.g., implement short programs that drove the robot and averaged readings from its sonar sensors and made steering decisions or inferred the robot location. It was nothing like the big programming projects in 6.001 (the OOP virtual world, the metacircular evaluator, etc.). So I don't think it really captures it to say that MIT "switched from Scheme to Python" -- I think the MIT EECS intro sequence switched from four deep-dive classes to two survey ones, and while the first "deep dive" course (6.001) had included a lot of programming, the first of the new survey courses only had students write pretty small programs (e.g. "drive the robot and maintain equal distance between the two walls") where the simplest thing was to use a scripting language where the small amount of necessary information can be taught by example. But it's not like the students learned Python in that class. My (less present) understanding is that >a decade after this 2006-era curricular change, the department has largely deprecated the idea of an EECS core curriculum, and MIT CS undergrads now go through something closer to a conventional CS0/CS1 sequence, similar to other CS departments around the country (https://www.eecs.mit.edu/changes-to-6-100a-b-l/ https://www.eecs.mit.edu/changes-to-6-100a-b-l/). But all of that is long after the change that Sussman and Wingo are talking about here.
CalChris 1y ago
Berkeley seems to want to slice the baby in half. cs61a teaches in Python but then retains the implementation of a Scheme interpreter. They don't use SICP anymore. They use John DeNero's online text, Composing Programs. https://cs61a.org/ https://cs61a.org/ https://www.composingprograms.com https://www.composingprograms.com BTW, my complaint about Scheme in 61a was that after the class, the department never used it again. They didn't even have the decency to use Guile or some standard Scheme. Instructional Computing had some hacked up something Scheme.
davideg 1y ago
Brown CS (back in 2004) gave you a choice: you could either take a 2-class intro sequence that started with Scheme and eventually OCaml before moving into OOP with Java, or you could start with Java from the get-go and make cool/flashy projects like Tetris by the end. Both course sequences were supposed to bring you to roughly the same place by the end. I took the Scheme path and feel great about having a deep theoretical foundation in CS, but I know plenty of folks who started with the fun/shiny stuff and became amazing software engineers. So all in all I'm really glad they gave us a choice. I will admit that there were people in my classes who didn't really understand what they were getting themselves into and possibly would have benefited from starting with Python or Java and getting more inspired about building cool projects. It really was a YMMV ¯\_(ツ)_/¯
deleted 1y ago
[deleted]
subtextminer 1y ago
Related: when UT Austin computer science dropped Haskell for Java for it's first course in 2001. Dijkstra on Haskell and Java https://chrisdone.com/posts/dijkstra-haskell-java/ https://chrisdone.com/posts/dijkstra-haskell-java/ "A fundamental reason for the preference is that functional programs are much more readily appreciated as mathematical objects than imperative ones, so that you can teach what rigorous reasoning about programs amounts to."
warbaker 1y ago
16 years later, I'm still disappointed about this decision. The justification for it is just awful: "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." This is just false. Engineering is still about taking small parts you understand entirely and using simple techniques to compose them into larger things you want. Sussman's justification is an abject surrender to shitty complexity. Engineers need to develop a taste for simplicity and elegance, especially at the beginning of their education. Incidentally, an overlooked advantage of teaching in Scheme is that it levels the playing field, as pre-undergrad programming classes almost never use functional languages.
- pledess 1y ago
  His top students were capable of entirely understanding Scheme within a day or so (but not capable of entirely understanding all of Python and all of PyPI). He wanted students to be even better than that. He wanted them to lead productive and resilient collaborations even when they didn't or couldn't entirely understand the small parts.
  - zahlman 1y ago
    Given a day, top students can understand enough of Python to write enough code to get the point about how programs rely on abstraction and composition. (Of course, the latter part of the course, describing the implementation of the runtime, would need considerable rethinking.)
- zahlman 1y ago
  > Engineering is still about taking small parts you understand entirely and using simple techniques to compose them into larger things you want. Engineering fundamentally is still about that. But what people seem to do with computers nowadays mainly involves composing already-large parts that they absolutely do not understand. Often with disastrous results.
unixhero 1y ago
I hated learning Scheme on their free open courseware. Yet I loved that it was free :)
bastawhiz 1y ago
One of the less obvious benefits of teaching a mainstream language (or a "hobby" language—the kind you might pick up on the weekend for some hacking) is all the folks who don't go on to graduate with a CS degree. Will Scheme teach interesting ideas? Of course. Will someone who doesn't code for a living download a scheme compiler and write a script five years after graduating? Not a chance. Ten years? There's no universe. Front-loading the mainstream language means you're not just teaching CS fundamentals, you're giving someone a tool that they can readily pick up and use in their real life for real tasks. It's the same as having home maintenance as a component of your basic high school shop class instead of how to rebuild a carburetor: unless you're working with carburetors for a living, that's an unlikely skill that you'd reach for. But knowing how to correctly hang a picture, replace an electrical outlet, or patch drywall is something almost anyone can put to good use ten, twenty, thirty years on.
- em-bee 1y ago
  Front-loading the mainstream language means you're not just teaching CS fundamentals, you're giving someone a tool that they can readily pick up and use in their real life for real tasks. It's the same as having home maintenance as a component of your basic high school shop class basic programming should be taught in high school too.
cs_throwaway 1y ago
A lot of this boils down to what you can convince the prof to teach. For most professors, teaching CS1 is a service and does not advance their research. Fewer faculty today are willing to learn Scheme just because it may be marginally better for students, according to some people.
jhancock 1y ago
Good writeup...it's two answers in one ;) I've come full circle from the first answer given. I wanted to get into neural nets a couple years ago. I chose Clojure because I knew I would be interfacing with components I didn't understand and wanted a system that helped me explore.
bytefish 1y ago
I know, that I am just a single data point, but Scheme took the fun out of programming in my computer science studies. Of course I do understand, that it makes teaching lambda calculus obviously a lot easier and is a better vehicle for teaching theoretical computer science concepts, than say, Python. But at the same time Scheme is limited to academia and has near zero practitioners outside academia. So the Scheme ecosystem is tiny compared to Python or Java. Yes, you could argue, that "Computer Science" is not mere "Software Development" and academia shouldn't bow down to industry and shouldn't be a tool to provide "programmers". But again it's also important for motivation to apply the language, algorithms and concepts in other fields. Learning also has to do a lot with motivation and experimentation. And this is a "hot take", but I always had the feeling back then, that courses are often bound to the professors curriculum and sometimes their books, so I am not surprised about resistance to changing the language. That said, I was glad, when the Scheme lectures were over. Now I am a Software developer for more than a decade and have to admit, that learning Scheme didn't make me a better programmer at all. If I'd stayed in academia I might have a different opinion.
jillesvangurp 1y ago
A good computer science program should expose students to lots of different languages and teach them that they are all different for valid reasons. There are many different paradigms and there is a rich history of languages at this point. The issue with Scheme is that it has very little relevance outside of academia. It's fine for making students learn that as an exercise to teach them that there are different ways of doing things and some of those ways can be wonderful. But you need to learn more than just that to become a proper computer scientist or software engineer. Python is a useful language to know just because of how useful it is. But it's not a great language to teach functional or object oriented programming. I would actually use different languages for teaching those concepts. Back when I studied, those languages where Gofer and Smalltalk. Gofer is a Haskell dialect/predecessor. Haskell already existed but wasn't that common yet. Scheme was already old news in the early nineties. I actually learned Java during the summer of 1995 as a second year student as a preparation to teach it to first year students. My university was progressive like that. I learned C in my first year. They switched to C++ the next year. By the fourth year I had been exposed to Prolog, Java, Delphi, C, C++, Gofer, Smalltalk, Modula, Pascal, Lisp (in various variants) and probably a few other things that I've since forgotten. One of the wonderful courses we got taught us all about the UNIX command line (mostly HP UNIX at the time, and a little bit of Solaris). Things like pipes & filters, regexes, AWK, etc. Different courses would expose you to different tools and languages. I followed a few courses on expert systems and bayesian belief networks. That just required you to deal with the lisp dialects used for that. The people giving these courses were proper researchers too. And they just used what they would use themselves. I did not fully appreciate it at the time, but Utrecht university had a wonderful computer science faculty with some amazing people. I learned functional programming from a young enthusiastic Erik Meijer who later joined Microsoft, Facebook etc. and built things like F#, LINQ and a few other things.
proverbialbunny 1y ago
>In 1980, good programmers spent a lot of time thinking, and then produced spare code that they thought should work. ... 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. Is that how people read code these days? I've always been weaker at reading code, but great at writing it. Iama Data Scientist, which explains why; I haven't had to read tons of code throughout my career. The topic kind of scares me. His description scares me even more.
deleted 1y ago
[deleted]
yodsanklai 1y ago
I feel some people are way too passionate on the topic of which languages should be taught first. It doesn't really matter.
deleted 1y ago
[deleted]
Vaslo 1y ago
It will never make sense to me to teach one language (Scheme) to learn one thing (how to program) when you can use a different language (Python) to teach two things (how to program, actual specific syntax you’ll use forever)
user94wjwuid 1y ago
Epstein preferred python and persuaded MIT to make the switch
deleted 1y ago
[deleted]
deleted 1y ago
[deleted]
so-cal-schemer 1y ago
Parens, parens, every where, And all the conses link; Parens, parens, every where, Nor infix op to think.
- deleted 1y ago
  [deleted]
so-cal-schemer 1y ago
Hal Abelson InfiniteHistoryProject MIT (2011) https://youtu.be/r8k8o7zkA1o?t=2689 https://youtu.be/r8k8o7zkA1o?t=2689 INTERVIEWER: How has introductory curriculum in EECS changed since that time? I mean clearly it's-- ABELSON: Oh, it's changed a lot. INTERVIEWER: Yeah. ABELSON: I don't know. People keep using the phrase bittersweet. It's changed in style. So what happened in the department is the department kind of decided that the way students get introduced into the department should become more horizontal and less vertical, by which I mean when you go into the department before the new curriculum, there were a bunch of very intellectually deep courses. So 6.001 really is a deep course in software engineering. And then the idea was well, you shouldn't actually do that because if students want to think about what they want to major in, they ought to get an experience that's a lot more broad. So they should learn not only about software, but something about circuits and something about signal processing and all that. So 6.001 sort of didn't fit into that world. I sort was on the committee. I had this funny feeling. I sort of loved the course. But I also had this feeling that the course needed to change. And both Gerry and I felt that as long as we were part of it, it wasn't going to change. And in fact we consciously got out of it. We had an official, what you call passing of the baton ceremony in one of the lectures where Bob Fano was there as the originator of this, who let us do 6.001. And then Eric Grimson and Duane Boning were there. They were going to take it over. And we kind of officially passed the baton. And we said we now did this in front of 350 student witnesses. We are never going to teach this course again. The department can't ask us. But then what happened is even after we got out of it, the course didn't change as much. And we can flatter ourselves and say well, the ideas were just really great. But sometimes you just need a kick in the pants to go someplace else. So this new department curriculum structure turned out to be the kick in the pants. And so I was part of the group, along with Leslie Kaelbling and Jacob White and Tomas Lozano-Perez, who sort of designed sort of the new course, which consciously was not about 6.001. But a lot of the biggest themes of 6.001 about extraction and modularity and the way you express things, they carry over into the new course. But the new course is also doing robotics. And it's thinking that signal processing. And there's even some stuff about circuits. So it's not a deep course in that sense. And there's a lot of people who have come through MIT--I don't want to take credit for 6.001 and that, but I want to say it was a very deep experience in how you think of software--who criticized what we did. And they say they really miss it. They talk about their own intellectual development as programmers. It was just profoundly influenced by that kind of very--we would sit in that class and talk about the philosophy sometimes. The new course does not do that in the same way. On the other hand, you have to sort of ask what's the population you're serving? And the fact that you talk to the minority of students who really, really glommed on to our way of thinking and they say, gee, we really wish MIT were still doing that. I don't know what the right way of serving the most students are. But in any case we're just doing something rather different in motivation now. INTERVIEWER: So it's broader, but less deep. ABELSON: And very consciously less deep.
deleted 1y ago
[deleted]

284 points by borski 1y ago

Scheme it's far easier to grasp. With SICP you basically rewrite a Scheme within a Scheme. And you teach Calculus to the interpreter to solve further problems. Online SICP: http://sarabander.github.io/sicp/ http://sarabander.github.io/sicp/

glimshe 1y ago
To do that with Scheme/SICP, you actually have to understand the CS principles behind it. Not as much with Python, which is likely why it became a more popular choice.
- postepowanieadm 1y ago
  Shouldn't that be the point?
  - zdragnar 1y ago
    I remember when universities wouldn't teach languages higher level than C/++ because "the languages changed too quickly and the 4 year degree would be obsolete by the time the students graduate". Instead, they focused purely on the low level engineering aspects of the software meeting the hardware, with only advanced classes focusing on things like AI research (pre-LLM days) or modelling fluid dynamics on specialized hardware. Of course, this is also why most companies worth working at didn't care if you had a CS college degree or not to build a wordpress website or a SOAP/REST API. Aside from some very basic lessons learned from experience (generally understanding computational complexity and maths) most software jobs didn't need any knowledge of assembly at all, or how to write an interpreter or a garbage collector.
    - JackFr 1y ago
      I spent years knowing nothing but C and I’d say it handicapped me in many ways. (I recall insisting that it would be impossible to do anything without assignment.) After getting my eyes opened a little bit, I read SICP and it was mind blowing. I read a little Haskell, wrote a little Clojure and a lot of Scala. And even though the day job now is Java and Python, I’m much better off for having bothered to learn it.
  - glimshe 1y ago
    That's what I'm trying to say. SICP teaches you to think differently and "grok" the CS concepts. This isn't always the case with other approaches, which can be much more reliant on blind copy-and-paste and library functionality.
- anthk 1y ago
  The point of Scheme SICP is that it will teach you these CS principles.
morkalork 1y ago
I fondly remember doing a course in my CS degree that was basically working through SICP as a class, taught my an ancient but very fun and enthusiastic tenured professor. When he retired I think the curriculum was updated to JavaScript (??) or as the new professor called it "scheme in drag". I'm glad to have taken the original course..
- jerrycruncher 1y ago
  Honestly, the new professor wasn't too far off. I've often referred to "The Little Schemer" as "the best javascript book that isn't about javascript."
terminalbraid 1y ago
The official SICP site is here, including the text. https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/index.html https://mitp-content-server.mit.edu/books/content/sectbyfn/b... pdf https://web.mit.edu/6.001/6.037/sicp.pdf https://web.mit.edu/6.001/6.037/sicp.pdf
- anthk 1y ago
  Yep, and there's a Texinfo version too. With Chicken, 'sudo chicken-install srfi-203 ; sudo chicken-install srfi-216; Emacs, Geiser and this ~/.csirc, you can run SICP exercises on really constrained environments. ~/.csirc (import scheme) (import (srfi 203)) (import (srfi 216)) Texinfo version: https://zv.github.io/sicp-in-texinfo https://zv.github.io/sicp-in-texinfo Run Emacs. Press Ctrl-u Ctrl-h i and choose the sicp.info.gz file. Then, run: Alt-x package-refresh-contents Alt-x package-install geiser-chicken wait. Run Alt-x geiser, and if it ask you which Scheme interpreter to run, choose 'chicken'. Later, press Ctrl-x f to choose a file, create a new one called "hello.scm". Write in that file: (display "Hello world"). Run Ctrl-c Ctrl-c and then the Scheme code in that file will be evaluated. To choose the running Chicken interpreter, press Ctrl-x b and choose the Geiser buffer. Run Ctrl-h t for the Emacs tutorial, it will be handy. If you want the same tutorial in Spanish, Japanese, French... press Ctrl-u Ctrl-h t and just input your language, press [TAB] to autocomplete. Happy Hacking.

Steelkiwer 1y ago

[dead]

ltbarcly3 1y ago

When I read this I just feel like Sussman is getting out of touch and maybe a little disillusioned. From the wording he seems annoyed about the change, isn't even sure why it was made "probably because there's some library for robots", has gone from someone who would have a complete understanding of complex systems to someone who sounds more like a frustrated beginner. "Doing basic science on libraries to see how they behave" instead of grabbing the source and looking at it - he is expressing the view of someone who wants to complete their ticket in Jira without too much effort and go home for the night rather than someone with an actual curiosity and enjoyment of what they are doing.

monkeyelite 1y ago
Can you not see that there is a philosophical difference between these two approaches and why someone might have a preference for one or the other?
- ltbarcly3 1y ago
  There isn't a philosophical difference. Both are problem solving strategies. You would choose one or the other depending on goals and constraints. There isn't a 'philosophical' reason to choose one or the other. In the end the choice wasn't made for philosophical reasons. It was made because the robot library was in Python, or so he thinks. I think this actually shows there was a strong reason to never use Scheme: it's a failed language family. Outside of academic life support and very niche uses (which are usually directly caused by the academic uses, such as Emacs lisp) scheme just doesn't exist out in the world, despite a dozen very competent and complete implementations that are still supported. This is not an invitation for lisp fan boys to stomp their feet, TIOBE doesn't have any (()())()(()) language in the top 20. Debate rankings all you want, but lisp type languages are extremely rarely used because people don't find them productive when given a choice.
  - monkeyelite 1y ago
    > There isn't a philosophical difference. I think that’s key to understanding the issue, so I guess the conversation is over.

ferguess_k 1y ago

Considering the target students of MIT CS department, I'd argue that they could simple start from an interpreter class in Python.

programjames 1y ago
As in, write a Scheme interpreter in Python?

mrexroad 1y ago

Ga Tech used to teach Scheme as an intro to CS course. I vividly remember sitting in lecture and being struck w/ the implications of functional programming as the professor said you could pass functions into functions and modify them. It was as formative of a moment as my 2nd Grade teacher showing us a really complex looking (at the time) rainbow flower in LOGO (she had one of few color Mac classic), and showing us it was simply the work of drawing the path of one petal, then repeating same “work” after changing two values (starting angle and color).

cs_throwaway 1y ago
It is possible that this doesn't work anymore. I distinctly recall the following episode when I last taught intro CS in Scheme: I revealed first-class functions. After lecture, the brightest kid in class came up to me and said something to the effect of, "What's the big deal? You can do this in Python."
- zahlman 1y ago
  That should be the beginning of the formative experience for that kid rather than the end. Yes, you can. How often do you? What are you missing by not thinking about problems in that way more often? What idioms could be unlocked that way? (How many Python programmers out there are aping wholly unnecessary "design patterns" created for C++ or Java? Or rather: shouldn't a design pattern be about the design rather than the implementation? What is a design, in the pure abstract, really?)
  - cs_throwaway 1y ago
    Don’t worry, aforementioned kid is doing just fine, machine learning PhD IIRC. There is a lot of other remarkable stuff in modern computing.
    - zahlman 1y ago
      Oh, I don't doubt that. Smart kids usually land on their feet just fine (and even when they don't, they cope and mask their problems better). But when I get the opportunity to teach things, I strive to allow smart students to rise to their own level.

_aleph2c_ 1y ago

https://archive.is/20150709075141/http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-to-python https://archive.is/20150709075141/http://www.wisdomandwonder...

mhh__ 1y ago

Decline.

varenc 1y ago

I was one of the last batches of students on the old Scheme curriculum. I absolutely loved it! Understanding that all loops could be done via recursion, and what a side effect is, is what fundamentally made me fall in love with CS. I've heard good things about the new, and now newer, curriculum but I know I wouldn't have had the awakening I did if it weren't for scheme. RIP SICP --- ps another fun story: we had some test where we were allowed to bring in 1 page of reference notes. And turns out the entire scheme specification is short enough to fit on a double sided page if condensed. So my friend, mostly in jest, brought the whole Scheme specification to the test with him and figured every possible question could be answered that way!

chuckadams 1y ago
> turns out the entire scheme specification is short enough to fit on a double sided page if condensed I think this only held for R4RS and earlier. You can fit War and Peace on one page if you condense it enough.
- TMWNN 1y ago
  >You can fit War and Peace on one page if you condense it enough. "I took a course in speed reading, learning to read straight down the middle of the page, and I was able to go through War and Peace in 20 minutes. It's about Russia." —Woody Allen
cactusfrog 1y ago
I worked an MIT programmer who bragged about the Scheme curriculum. He was also the worst programmer that I’ve worked with. He really liked clojure and would constantly complain about Python syntax, and ended up quitting abruptly when his hand spun Datomic based system was rejected. I think there is a trap in thinking that a strange way of being taught puts one at an advantage. It is really annoying to work with people who believe they are more enlightened than others.
- agordhandas 1y ago
  That kinda defeats the purpose of why scheme was the language of choice in the first place! The goal was for us to fall in love with programming, not a programming language.

djtriptych 1y ago

build a scheme interpreter in python = best of both worlds?? I love SICP - easily in my top ten most influential CS books. But I've basically never seen a real Scheme job. I do think it's reasonable to at least try to instill both foundational and marketable skills early.

MontyCarloHall 1y ago

Isn't this just part of the broader trend of CS departments switching away from teaching computer science to teaching computer engineering, which in turn is part of the more general trend of colleges becoming more vocational? LISP dialects like Scheme are excellent for teaching pure computer science because they are the closest thing to executing lambda calculus expressions. Whereas Python is excellent for teaching applied computer engineering, because it's essentially executable pseudocode for imperative languages, and imperative languages are the most common language a computer engineer encounters in the real world.

SoftTalker 1y ago
Yes. One of the biggest complaints that computer science departments used to get from students is that they weren't learning any languages that employers are using.
- cess11 1y ago
  I'm not so sure someone who's good with Scheme will be bad with Python or Java. On the contrary, I suspect that such a person is likely to be better suited to build software in either of the latter two. I also suspect that Python is not a particularly good first language for someone who aims for a professional career building software.
  - masklinn 1y ago
    > I'm not so sure someone who's good with Scheme will be bad with Python or Java. The problem likely has always been the companies / HR rather than the students. > I also suspect that Python is not a particularly good first language for someone who aims for a professional career building software. It's not a particularly bad one either, certainly better than Java. IIRC a secondary benefit is that it allows overlap between some of the basic CS, and the CS/CE courses for non CS track students
  - Jtsummers 1y ago
    > I'm not so sure someone who's good with Scheme will be bad with Python or Java. They won't be. But students don't understand that, they want to learn marketable skills and are 18 years old. They haven't figured out that if your skills transcend language choice you will be more marketable even if it means you have to spend a few weeks learning a new language for a new job. They lack maturity, which isn't surprising given their age and experience, and so they complain.

AlanYx 1y ago

There's probably a middle ground somewhere. IMHO, SICP leans a little too heavily on the homoiconicity of Scheme for its choice of exercises. Which is intellectually nifty but it could also include exercises from something like Crafting Interpreters (Nystrom) where you would build up step-by-step to an interpreter of a non-Scheme-like language, using Scheme.

shawn_w 1y ago
Eh, being able to skip parsing allows a fairly short book to spend more time on its real focus than it otherwise would.

ted_dunning 1y ago

The last sentence was the key: And why Python, then? Well, said Sussman, it probably just had a library already implemented for the robotics interface, that was all. That is the essence of Python's strength ... the eco-system. And the comment about engineering becoming the art of trying to reason about half-documented toys from the huge grab bag of packages is exactly on point relative to the risk and challenge of this transition.

ayhanfuat 1y ago

I think it was also one of the first freely available courses for learning Python. It’s been more than 10 years since I took that course on edX and I still appreciate it. Robot vacuum exercises were a lot of fun.

KenSF 1y ago

The move away from Scheme has always saddened me. The first thing we learned in 6.001 was abstraction and invariance. These are still the core of writing good software. I still use these principles every day. There is a purity to Scheme. It is a beautiful light-weight language anyone can learn over a weekend. It does nothing magical for you which means you get to / have to build everything you want and you must understand how it fits together.

eggdaft 1y ago
I agree. I was taught Scheme and I later taught it. It was a much cleaner and suitable language for teaching computer science than Python. Students could completely understand the language and how it worked by the end of a semester. Scheme is much closer to mathematics, which made it much more suitable for teaching strong mathematicians arriving without coding experience. It also made the hackers more rigorous and broadened their minds from the imperative "do this then that" mindset. There's a notable difference between those first taught scheme and those first taught Python. Of course, both can go on to learning Python or FP or whatever. But that foundation needs to be there to teach truly great coding for most mortals.

jbanes 1y ago

Did anyone notice this announcement was from 16 years ago? I very much doubt this is the current state of the MIT coursework.

temporallobe 1y ago

This is just an introductory language and if you’re in a CS program, you’ll definitely move on to more advanced ones. It actually makes sense to switch to Python since it’s far more ubiquitous and accessible than Scheme. Scheme is not widely used in commercial software development, but still enjoys a presence in academia. Python has strong presence in both. On the other hand, Pascal was my “introductory” programming language (I already knew BASIC pretty well at that point), but it certainly wasn’t the only one in my program - we did Perl, Prologue, C, C++, etc. In a professional software development career, it certainly won’t be the last language you’ll learn.

lokar 1y ago
This is one of many divides in the field that makes many general discussions hard. There are many people who think of themselves as a “X programmer” (and perhaps Y and Z), and managers/companies looking for them. Then there are people who think of themselves as software engineers, and the language does not really matter (and companies that hire for that). If often see the two camps talking past each other.
- temporallobe 1y ago
  I certainly consider myself a software engineer first and programmer second, and you’re right, the language doesn’t matter. I recently got a position developing in Python having never really used it professionally, but it’s so similar to other interpreted languages I knew so I was able to jump right in and start making meaningful contributions. Often we are expected to learn new languages, which is exactly how I picked up the 10ish languages I can confidently say I’m good in, despite never having been formally trained in those. Most common languages don’t stray from certain basic principles anyway.
materielle 1y ago
But this is the problem. Our premier academic institutions shouldn’t merely exist as job training programs for big tech. If anything, tech is still one of the better off fields in the university. Look at history or literature programs for where this is heading. I’d imagine that most literature majors don’t even read at all these days. As recent as 50 years ago, the requirement involved hundreds of pages of reading per week, over a sustained 4 year period. Honestly, just close down the university at this point, if all it wants to do is print out degree certificates for social signaling in the job market.

dang 1y ago

Related. Others? Ask HN: How has MIT's switch from Scheme to Python worked out? - https://news.ycombinator.com/item?id=24960481 https://news.ycombinator.com/item?id=24960481 - Nov 2020 (1 comment) Why MIT uses Python instead of Scheme for its undergraduate CS program (2009) - https://news.ycombinator.com/item?id=18782101 https://news.ycombinator.com/item?id=18782101 - Dec 2018 (136 comments) Why MIT Switched from Scheme to Python (2009) - https://news.ycombinator.com/item?id=14167453 https://news.ycombinator.com/item?id=14167453 - April 2017 (97 comments) Ask HN: Python or Scheme? - https://news.ycombinator.com/item?id=2523432 https://news.ycombinator.com/item?id=2523432 - May 2011 (11 comments) Videos for MIT 6.00 - Python Version - https://news.ycombinator.com/item?id=1045114 https://news.ycombinator.com/item?id=1045114 - Jan 2010 (1 comment) Why MIT now uses python instead of scheme for its undergraduate CS program - https://news.ycombinator.com/item?id=842333 https://news.ycombinator.com/item?id=842333 - Sept 2009 (38 comments) Python based MIT 6.00 | Intro to Computer Science and Programming - https://news.ycombinator.com/item?id=819734 https://news.ycombinator.com/item?id=819734 - Sept 2009 (6 comments) Chiming in on the MIT Scheme to Python Switch - https://news.ycombinator.com/item?id=622261 https://news.ycombinator.com/item?id=622261 - May 2009 (7 comments) Why Did M.I.T. Switch from Scheme to Python? - https://news.ycombinator.com/item?id=602307 https://news.ycombinator.com/item?id=602307 - May 2009 (65 comments) Why MIT switched from Scheme to Python - https://news.ycombinator.com/item?id=530605 https://news.ycombinator.com/item?id=530605 - March 2009 (128 comments) MIT replacing Scheme with Python for Intro CS class - https://news.ycombinator.com/item?id=75401 https://news.ycombinator.com/item?id=75401 - Nov 2007 (16 comments) --- Berkeley version: Scheme vs. Python (2011) - https://news.ycombinator.com/item?id=9973156 https://news.ycombinator.com/item?id=9973156 - July 2015 (118 comments) SICP (Python Version) - https://news.ycombinator.com/item?id=3718364 https://news.ycombinator.com/item?id=3718364 - March 2012 (18 comments) SICP taught in Python 3 - UC Berkeley online - https://news.ycombinator.com/item?id=3491142 https://news.ycombinator.com/item?id=3491142 - Jan 2012 (25 comments) SICP in Python - https://news.ycombinator.com/item?id=3141996 https://news.ycombinator.com/item?id=3141996 - Oct 2011 (49 comments)

deleted 1y ago
[deleted]

omnicognate 1y ago

> 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. Probably the best way, and maybe the only way, to learn this is by doing it. That's how I learned it, with no formal training in programming. What I learned from SICP and Sussman's other books I would never have figured out any other way. I don't think the world is really as different as Sussman says it is here, and I think the programming world lost something special with this change. The book lives on anyway, and he'll always be one of my heroes.

zahlman 1y ago
Absolutely agreed. This situation reminds me of discourse on learning natural languages, where people are constantly told that there is no substitute for time spent deliberately on immersion. But you won't accurately figure out grammatical structures that way; you'll get distracted by the parts you understand and fail to assemble them into a whole. University (and earlier!) courses ought to focus on the kinds of things that actually require direction to learn.

dvrp 1y ago

Because Worse Is Better!

keithwinstein 1y ago

This story has been reposted many times, and I think GJS's remarks (as recorded by Andy Wingo) are super-interesting as always, but this is really not a great account of "why MIT switched from Scheme to Python." Source: I worked with GJS (I also know Alexey and have met Andy Wingo), and I took 6.001, my current research still has us referring to SICP on a regular basis, and in 2006 Kaijen Hsiao and I were the TAs for what was basically the first offering of the class that quasi-replaced it (6.01) taught by Leslie Kaelbling, Hal Abelson, and Jacob White. I would defer to lots of people who know the story better than me, but here's my understanding of the history. When the MIT EECS intro curriculum was redesigned in the 1980s, there was a theory that an EECS education should start with four "deep dives" into the four "languages of engineering." There were four 15-unit courses, each about one of these "languages": - 6.001: Structure and Interpretation of Computer Programs (the "procedural" language, led by Abelson and Sussman) - 6.002: Circuits and Electronics ("structural" language) - 6.003: Signals and Systems ("functional" language) - 6.004: Computation Structures ("architectural" language) These were intellectually deep classes, although there was pain in them, and they weren't universally beloved. 6.001 wasn't really about Scheme; I think a lot of the point of using Scheme (as I understood it) is that the language is so minimalist and so beautiful that even this first intro course can be about fundamental concepts of computer science without getting distracted by the language. This intro sequence lasted until the mid-2000s, when enrollment in EECS ("Course 6") declined after the dot-com crash, and (as would be expected, and I think particularly worrisome) the enrollment drop was greater among demographic groups that EECS was eager to retain. My understanding circa 2005 is that there was a view that EECS had broadened in its applications, and that beginning the curriculum with four "deep dives" was offputting to students who might not be as sure that they wanted to pursue EECS and might not be aware of all the cool places they could go with that education (e.g. to robotics, graphics, biomedical applications, genomics, computer vision, NLP, systems, databases, visualization, networking, HCI, ...). I wasn't in the room where these decisions were made, and I bet there were multiple motivations for these changes, but I understood that was part of the thinking. As a result, the EECS curriculum was redesigned circa 2005-7 to de-emphasize the four 15-unit "deep dives" and replace them with two 12-unit survey courses, each one a survey of a bunch of cool places that EECS could go. The "6.01" course (led by Kaelbling, Abelson, and White) was about robots, control, sensing, statistics, probabilistic inference, etc., and students did projects where the robot drove around a maze (starting from an unknown position) and sensed the walls with little sonar sensors and did Bayesian inference to figure out its structure and where it was. The "6.02" course was about communication, information, compression, networking, etc., and eventually the students were supposed to each get a software radio and build a Wi-Fi-like system (the software radios proved difficult and, much later, I helped make this an acoustic modem project). The goal of these classes (as I understood) was to expose students to a broad range of all the cool stuff that EECS could do and to let them get there sooner (e.g. two classes instead of four) -- keep in mind this was in the wake of the dot-com crash when a lot of people were telling students that if they majored in computer science, they were going to end up programming for an insurance company at a cubicle farm before their job was inevitably outsourced to a low-cost-of-living country. 6.01 used Python, but in a very different way than 6.001 "used" Scheme -- my recollection is that the programming work in 6.01 (at least circa 2006) was minimal and was only to, e.g., implement short programs that drove the robot and averaged readings from its sonar sensors and made steering decisions or inferred the robot location. It was nothing like the big programming projects in 6.001 (the OOP virtual world, the metacircular evaluator, etc.). So I don't think it really captures it to say that MIT "switched from Scheme to Python" -- I think the MIT EECS intro sequence switched from four deep-dive classes to two survey ones, and while the first "deep dive" course (6.001) had included a lot of programming, the first of the new survey courses only had students write pretty small programs (e.g. "drive the robot and maintain equal distance between the two walls") where the simplest thing was to use a scripting language where the small amount of necessary information can be taught by example. But it's not like the students learned Python in that class. My (less present) understanding is that >a decade after this 2006-era curricular change, the department has largely deprecated the idea of an EECS core curriculum, and MIT CS undergrads now go through something closer to a conventional CS0/CS1 sequence, similar to other CS departments around the country (https://www.eecs.mit.edu/changes-to-6-100a-b-l/ https://www.eecs.mit.edu/changes-to-6-100a-b-l/). But all of that is long after the change that Sussman and Wingo are talking about here.

CalChris 1y ago

Berkeley seems to want to slice the baby in half. cs61a teaches in Python but then retains the implementation of a Scheme interpreter. They don't use SICP anymore. They use John DeNero's online text, Composing Programs. https://cs61a.org/ https://cs61a.org/ https://www.composingprograms.com https://www.composingprograms.com BTW, my complaint about Scheme in 61a was that after the class, the department never used it again. They didn't even have the decency to use Guile or some standard Scheme. Instructional Computing had some hacked up something Scheme.

davideg 1y ago

Brown CS (back in 2004) gave you a choice: you could either take a 2-class intro sequence that started with Scheme and eventually OCaml before moving into OOP with Java, or you could start with Java from the get-go and make cool/flashy projects like Tetris by the end. Both course sequences were supposed to bring you to roughly the same place by the end. I took the Scheme path and feel great about having a deep theoretical foundation in CS, but I know plenty of folks who started with the fun/shiny stuff and became amazing software engineers. So all in all I'm really glad they gave us a choice. I will admit that there were people in my classes who didn't really understand what they were getting themselves into and possibly would have benefited from starting with Python or Java and getting more inspired about building cool projects. It really was a YMMV ¯\_(ツ)_/¯

deleted 1y ago

[deleted]

subtextminer 1y ago

Related: when UT Austin computer science dropped Haskell for Java for it's first course in 2001. Dijkstra on Haskell and Java https://chrisdone.com/posts/dijkstra-haskell-java/ https://chrisdone.com/posts/dijkstra-haskell-java/ "A fundamental reason for the preference is that functional programs are much more readily appreciated as mathematical objects than imperative ones, so that you can teach what rigorous reasoning about programs amounts to."

warbaker 1y ago

16 years later, I'm still disappointed about this decision. The justification for it is just awful: "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." This is just false. Engineering is still about taking small parts you understand entirely and using simple techniques to compose them into larger things you want. Sussman's justification is an abject surrender to shitty complexity. Engineers need to develop a taste for simplicity and elegance, especially at the beginning of their education. Incidentally, an overlooked advantage of teaching in Scheme is that it levels the playing field, as pre-undergrad programming classes almost never use functional languages.

pledess 1y ago
His top students were capable of entirely understanding Scheme within a day or so (but not capable of entirely understanding all of Python and all of PyPI). He wanted students to be even better than that. He wanted them to lead productive and resilient collaborations even when they didn't or couldn't entirely understand the small parts.
- zahlman 1y ago
  Given a day, top students can understand enough of Python to write enough code to get the point about how programs rely on abstraction and composition. (Of course, the latter part of the course, describing the implementation of the runtime, would need considerable rethinking.)
zahlman 1y ago
> Engineering is still about taking small parts you understand entirely and using simple techniques to compose them into larger things you want. Engineering fundamentally is still about that. But what people seem to do with computers nowadays mainly involves composing already-large parts that they absolutely do not understand. Often with disastrous results.

unixhero 1y ago

I hated learning Scheme on their free open courseware. Yet I loved that it was free :)

bastawhiz 1y ago

One of the less obvious benefits of teaching a mainstream language (or a "hobby" language—the kind you might pick up on the weekend for some hacking) is all the folks who don't go on to graduate with a CS degree. Will Scheme teach interesting ideas? Of course. Will someone who doesn't code for a living download a scheme compiler and write a script five years after graduating? Not a chance. Ten years? There's no universe. Front-loading the mainstream language means you're not just teaching CS fundamentals, you're giving someone a tool that they can readily pick up and use in their real life for real tasks. It's the same as having home maintenance as a component of your basic high school shop class instead of how to rebuild a carburetor: unless you're working with carburetors for a living, that's an unlikely skill that you'd reach for. But knowing how to correctly hang a picture, replace an electrical outlet, or patch drywall is something almost anyone can put to good use ten, twenty, thirty years on.

em-bee 1y ago
Front-loading the mainstream language means you're not just teaching CS fundamentals, you're giving someone a tool that they can readily pick up and use in their real life for real tasks. It's the same as having home maintenance as a component of your basic high school shop class basic programming should be taught in high school too.

cs_throwaway 1y ago

A lot of this boils down to what you can convince the prof to teach. For most professors, teaching CS1 is a service and does not advance their research. Fewer faculty today are willing to learn Scheme just because it may be marginally better for students, according to some people.

jhancock 1y ago

Good writeup...it's two answers in one ;) I've come full circle from the first answer given. I wanted to get into neural nets a couple years ago. I chose Clojure because I knew I would be interfacing with components I didn't understand and wanted a system that helped me explore.

bytefish 1y ago

I know, that I am just a single data point, but Scheme took the fun out of programming in my computer science studies. Of course I do understand, that it makes teaching lambda calculus obviously a lot easier and is a better vehicle for teaching theoretical computer science concepts, than say, Python. But at the same time Scheme is limited to academia and has near zero practitioners outside academia. So the Scheme ecosystem is tiny compared to Python or Java. Yes, you could argue, that "Computer Science" is not mere "Software Development" and academia shouldn't bow down to industry and shouldn't be a tool to provide "programmers". But again it's also important for motivation to apply the language, algorithms and concepts in other fields. Learning also has to do a lot with motivation and experimentation. And this is a "hot take", but I always had the feeling back then, that courses are often bound to the professors curriculum and sometimes their books, so I am not surprised about resistance to changing the language. That said, I was glad, when the Scheme lectures were over. Now I am a Software developer for more than a decade and have to admit, that learning Scheme didn't make me a better programmer at all. If I'd stayed in academia I might have a different opinion.

jillesvangurp 1y ago

A good computer science program should expose students to lots of different languages and teach them that they are all different for valid reasons. There are many different paradigms and there is a rich history of languages at this point. The issue with Scheme is that it has very little relevance outside of academia. It's fine for making students learn that as an exercise to teach them that there are different ways of doing things and some of those ways can be wonderful. But you need to learn more than just that to become a proper computer scientist or software engineer. Python is a useful language to know just because of how useful it is. But it's not a great language to teach functional or object oriented programming. I would actually use different languages for teaching those concepts. Back when I studied, those languages where Gofer and Smalltalk. Gofer is a Haskell dialect/predecessor. Haskell already existed but wasn't that common yet. Scheme was already old news in the early nineties. I actually learned Java during the summer of 1995 as a second year student as a preparation to teach it to first year students. My university was progressive like that. I learned C in my first year. They switched to C++ the next year. By the fourth year I had been exposed to Prolog, Java, Delphi, C, C++, Gofer, Smalltalk, Modula, Pascal, Lisp (in various variants) and probably a few other things that I've since forgotten. One of the wonderful courses we got taught us all about the UNIX command line (mostly HP UNIX at the time, and a little bit of Solaris). Things like pipes & filters, regexes, AWK, etc. Different courses would expose you to different tools and languages. I followed a few courses on expert systems and bayesian belief networks. That just required you to deal with the lisp dialects used for that. The people giving these courses were proper researchers too. And they just used what they would use themselves. I did not fully appreciate it at the time, but Utrecht university had a wonderful computer science faculty with some amazing people. I learned functional programming from a young enthusiastic Erik Meijer who later joined Microsoft, Facebook etc. and built things like F#, LINQ and a few other things.

proverbialbunny 1y ago

>In 1980, good programmers spent a lot of time thinking, and then produced spare code that they thought should work. ... 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. Is that how people read code these days? I've always been weaker at reading code, but great at writing it. Iama Data Scientist, which explains why; I haven't had to read tons of code throughout my career. The topic kind of scares me. His description scares me even more.

deleted 1y ago

[deleted]

yodsanklai 1y ago

I feel some people are way too passionate on the topic of which languages should be taught first. It doesn't really matter.

deleted 1y ago

[deleted]

Vaslo 1y ago

It will never make sense to me to teach one language (Scheme) to learn one thing (how to program) when you can use a different language (Python) to teach two things (how to program, actual specific syntax you’ll use forever)

user94wjwuid 1y ago

Epstein preferred python and persuaded MIT to make the switch

deleted 1y ago

[deleted]

deleted 1y ago

[deleted]

so-cal-schemer 1y ago

Parens, parens, every where, And all the conses link; Parens, parens, every where, Nor infix op to think.

deleted 1y ago
[deleted]

so-cal-schemer 1y ago

Hal Abelson InfiniteHistoryProject MIT (2011) https://youtu.be/r8k8o7zkA1o?t=2689 https://youtu.be/r8k8o7zkA1o?t=2689 INTERVIEWER: How has introductory curriculum in EECS changed since that time? I mean clearly it's-- ABELSON: Oh, it's changed a lot. INTERVIEWER: Yeah. ABELSON: I don't know. People keep using the phrase bittersweet. It's changed in style. So what happened in the department is the department kind of decided that the way students get introduced into the department should become more horizontal and less vertical, by which I mean when you go into the department before the new curriculum, there were a bunch of very intellectually deep courses. So 6.001 really is a deep course in software engineering. And then the idea was well, you shouldn't actually do that because if students want to think about what they want to major in, they ought to get an experience that's a lot more broad. So they should learn not only about software, but something about circuits and something about signal processing and all that. So 6.001 sort of didn't fit into that world. I sort was on the committee. I had this funny feeling. I sort of loved the course. But I also had this feeling that the course needed to change. And both Gerry and I felt that as long as we were part of it, it wasn't going to change. And in fact we consciously got out of it. We had an official, what you call passing of the baton ceremony in one of the lectures where Bob Fano was there as the originator of this, who let us do 6.001. And then Eric Grimson and Duane Boning were there. They were going to take it over. And we kind of officially passed the baton. And we said we now did this in front of 350 student witnesses. We are never going to teach this course again. The department can't ask us. But then what happened is even after we got out of it, the course didn't change as much. And we can flatter ourselves and say well, the ideas were just really great. But sometimes you just need a kick in the pants to go someplace else. So this new department curriculum structure turned out to be the kick in the pants. And so I was part of the group, along with Leslie Kaelbling and Jacob White and Tomas Lozano-Perez, who sort of designed sort of the new course, which consciously was not about 6.001. But a lot of the biggest themes of 6.001 about extraction and modularity and the way you express things, they carry over into the new course. But the new course is also doing robotics. And it's thinking that signal processing. And there's even some stuff about circuits. So it's not a deep course in that sense. And there's a lot of people who have come through MIT--I don't want to take credit for 6.001 and that, but I want to say it was a very deep experience in how you think of software--who criticized what we did. And they say they really miss it. They talk about their own intellectual development as programmers. It was just profoundly influenced by that kind of very--we would sit in that class and talk about the philosophy sometimes. The new course does not do that in the same way. On the other hand, you have to sort of ask what's the population you're serving? And the fact that you talk to the minority of students who really, really glommed on to our way of thinking and they say, gee, we really wish MIT were still doing that. I don't know what the right way of serving the most students are. But in any case we're just doing something rather different in motivation now. INTERVIEWER: So it's broader, but less deep. ABELSON: And very consciously less deep.

deleted 1y ago

[deleted]