
Why Did M.I.T. Switch from Scheme to Python? - l0stman
http://danweinreb.org/blog/why-did-mit-switch-from-scheme-to-python
======
lincolnq
This issue is a fundamental one that everybody teaching programming or
computer science must answer. Is it better to teach CS from the ground up or
top down?

The ground up approach is something like SICP, with fundamentals in lambda
calculus or Turing machines. Students learn rules such as how a Lisp evaluates
an expression and write programs which apply the rules. It's not necessary
that this be taught using Lisp, but it seems to be popular, because it greatly
reduces distractions when understanding and writing actual programs. In any
case, the ground-up approach generally teaches first a system of rules, and
only once the rules are understood does it move on to programs.

The top-down approach, on the other hand, starts with programs. Often the
students are given a partially written program and are asked to improve it.
The curriculum doesn't focus on rules because they all have exceptions. It's
much more like engineering and less like mathematics. As the article says,
nowadays "a real engineer is given a big software library, with a 300-page
manual that’s full of errors. He’s also given a robot, whose exact behavior is
extremely hard to characterize...."

What's better? Some schools (such as my alma mater, Brown) have two intro
classes, one for each method of teaching. I chose the rules-based bottom-up
approach when I was an undergrad, and it was very good, and I was convinced it
was the better way to go.

But I'm losing my conviction, partially because MIT is changing it and they
must know what they're doing (heh), and partially because I'm coming to the
understanding that everybody uses libraries and this is not going to change.
The top-down approach doesn't really provide any sense that there should be
libraries, that code should be organized, that you can write to an interface
and document your code. People can learn these sorts of things later, though.

~~~
silentOpen
Unfortunately, when MIT moved from 6.001 in Scheme to 6.01 in Python, they
also changed later courses to Python because now students wouldn't have Scheme
experience.

This results in: 6.005 ("software engineering") in Java 6.006 (intro to
algorithms) in Python 6.034 (intro to AI) in Python 6.035 (compilers) in Java

(6.005 was 6.170 which used Java and 6.035 has always used Java afaik so this
list isn't all the new curriculum's fault... but it does give a good overview
of MIT's undergrad CS decline)

Frankly, this is unacceptable. I'm not sure I would hire an MIT CS grad that
did the new curriculum. It is absolutely absurd that MIT (which purports to
have one of the best CS programs in the world) is teaching Java and Python in
their undergrad CS curriculum even in places where Java and Python are not the
best suited (compilers!? algorithms!? AI!?). For instance, one 6.005 pset is
to build a Sudoku solver... in Java. Every MIT undergrad should have the
ability to learn a new programming language. 6-3 students (CS majors) should
especially be able to do this. MIT is getting watered down.

Students don't learn other programming paradigms and they learn to accept the
bloat and poor design decisions of the required languages. Where once students
would build a text adventure and a metacircular evaluator in Scheme for 6.001,
they now build what amount to Lego Mindstorms kits. Seriously?

~~~
amalcon
The program I was in didn't even try to do things like this. Web course? Use
perl. OS course? Use C. Soft Eng? Use Java (people demanded at least one Java
course). If you can't learn the appropriate language within the first week of
the course, you probably should have a different major.

Naturally some people were very upset about this, but it definitely made for a
better program all in all.

~~~
strlen
This was the same at my university (Santa Clara University,
<http://www.scu.edu/engineering/cse/>): introductory courses used C++ (for
"intro to computing" and data structures), assembly (for a computer
organization course) and Haskell (for the SICP equivalent -- not sure if it's
still a requirement).

Upper level courses would then expect students to pick up Verilog/VHDL,
regular C, assembly, lex/yacc, Scheme/Lisp, Java and Perl/Python as needed.

------
silentOpen
I'm graduating from MIT (hopefully) in under a month with a degree in CS. The
new curriculum is an abomination. If you are teaching some of the (supposedly)
brightest students in the world, you shouldn't worry about teaching marketable
skills or using popular languages. Your students should be able to pick up a
new language easily.

Luckily, I took all old-curriculum classes. If I were a student entering
college for CS now, I would not choose MIT. I don't know other schools'
curricula in depth but some place has got to be more rigorous (Berkeley?
Stanford? CMU?).

~~~
endtime
I didn't do my undergrad at Stanford, but I'm here as a grad student, and I
believe they use Java for the intro classes. They do teach Python and C
eventually, but no Lisp AFAIK.

I did my undergrad at Georgetown, where nearly every class used C++ (or C, for
classes in things like OS and security).

~~~
andrewparker
I did my undergrad at Stanford, and after taking two simple intro courses, we
had the first real intro to paradigms course (CS107). In that course, three
languages were used: C++ (for a data structures project), Java (for an OOP and
Concurrency project), and Lisp (for a context-free grammar project). I don't
know if the course is still taught this way, but I thought it was great.

~~~
endtime
There's a new CS107 this year (along with a few other classes; they just redid
the undergrad curriculum). One of my friends is a 107 TA and he is actually
sitting next to me right now. Apparently 107 no longer includes anything on
Lisp. :(

------
cia_plant
I find this justification downright weird. Yes, a class like 6.001 is an
extremely purified and unrealistic view of modern software engineering. But
the same could be said of any theoretical subject. The people at the Large
Hadron Collider are probably spending a lot more time reading 300-page
technical manuals than they are reading Feynman.

A lot of the charm of academia, to me, is that it gives you some breathing
room to step back from the mess, and look for unifying principles. There might
be a bit of a shock when the student first graduates, but in the long term
they're often better off with the kind of knowledge that they couldn't easily
pick up through osmosis.

~~~
Confusion
From what I've been reading about this issue, I think many people are missing
one important point: 6.001 was an _introductory_ course, the contents of which
would be rehashed and expanded in several later courses. That the contents of
this course has changed does not mean that MIT students do not learn about
these concepts anymore.

~~~
silentOpen
Sort of... I don't think MIT has any required undergrad CS courses that use
~(Python || Java). I'd call that a problem.

~~~
cyen
Before 6.01 was introduced, MIT didn't have any required undergrad CS courses
that required anything besides Scheme and Java! Is that much better? Frankly -
I think if you're starting to argue simply based on language, you'll find few
supporters.

The strengths of the old curriculum were the concepts you learned through
6.001 and using Scheme, not the Scheme skills themselves. Do I think 6.034
would be significantly different if I had to use Python versus Scheme? Not at
all - and frankly using Scheme added nothing to my experience in that class.

~~~
silentOpen
It's not the language that is important, it's the programming style(s) the
language supports. With Scheme and Java, you get a functional language (and
one in which other paradigms can easily be implemented) and an OO-ish
language. Pedagogically, I think that's superior to a sorta-functional-and-
sorta-OO language and a OO-ish language.

I had a different experience in 6.034 than you did, I suppose. I think Scheme
suited the class well and offered a nice way to express searches,
minimizations, and decision systems. I'm sure you can do everything you can do
in Scheme in Python but you could also do it in Java. Functional languages are
particularly well-suited to these tasks. I wouldn't necessarily pick Scheme,
though. Why not use the most appropriate tool for the job? If students have to
learn a new language, OK. If you really do think Python is the best tool, OK.

------
Mongoose
I'm in the middle of taking the undergrad PL class at the University of
Washington and I've come to the conclusion that classes of this sort can be
whatever you make them. We spent the first five weeks learning/using ML,
recently switched to Scheme, and will dive into Ruby for a few weeks before
the quarter ends. While I'm sure many of my peers will leave the course
thinking of functional languages as a quirky set of under-developed relatives
to the tried-and-true OO family, I've spent the last 6 weeks breathing
functional programming, both in my coursework and in places like this thread.
I feel that I'm taking more away from the class and that much of introductory
computer science works this way. The burden of learning is on the student to
become engaged in the subject matter and make use of the resources the school
and professor provides.

At the end of the day, the department won't make the student great. To a
degree, a driven and talented student can succeed anywhere, regardless of how
many ooh's and aah's a name-dropping of their school will produce.

------
mkramlich
An intelligent person, particularly one with natural aptitude for programming
will end up fine regardless of which language they start with. Also, anybody
that truly starts programming in college is a rather sad candidate to begin
with.

Also, Python is a much more practical choice than Scheme, and has technical
merits which are at least as attractive as Scheme, and arguably more so.
Scheme is elegant. But Python is also elegant, yet more practical. From that
angle, looks like a net change for the better.

MIT also strikes me as a school oriented more towards producing engineers
rather than programmers. And if you're going to school at MIT just to get into
a career in programming, that sounds like a terrible waste of money. Robotics
or electrical engineering? Probably a good choice. But programming? Come on.

Then there's the whole argument of why anybody needs to go to MIT, or even get
a college education in CS. We live in a world with the Internet and scads of
free books in libraries and documentation online. Follow that line of thinking
and the whole controversy over this tweak in some random school's class
content seems silly. It is as if nobody can learn anything outside of a class,
so if it is not taught in that particular class at MIT, it will never be
learned, and the world will end. Hilarious. :)

------
Tritis
Every time this story comes up I'm shocked at the number of CS MIT grads there
are on the internets. MIT must be graduating something like 50% of the total
internet.

Also the comments on this story are always of the type "Well when I was in
school things were taught right. The day I graduated it all started going
downhill and now I wouldn't hire someone graduating from that school."

------
gengstrand
The title is a bit misleading. The gist of TFA is that MIT is switching from
Scheme to Python in its INTRODUCTION TO PROGRAMMING course. That would seem to
me to be a bit of a no brainer. I find python to be a much more acceptable
alternative than BASIC in introducing people new to coder in a way that is
more in line with sound computer engineering practices.

~~~
jobeirne
Why is this guy being voted down for a decently formed comment?

~~~
krschultz
because SICP was a great introduction, personally I think that Scheme (at
least at first) is easier to pick up than Python. Our professor taught us
basic Scheme in 40 minutes no problem. Python takes longer than that because
there is more syntax. Basically all you need in scheme are some () and define,
lambda, cons, car, cdr, and cond for the first 4 or 5 weeks.

------
wingo
See also, <http://news.ycombinator.com/item?id=530605>.

------
asciilifeform
It it just me who is seeing a cowardly surrender to cultural decay here? From
the renowned Sussman, no less. The glorious MIT of the 1980s and prior appears
to be dead. Erased, in fact, without a trace. Consider the following:

<http://mitpress.mit.edu/catalog/browse/browse.asp?btype=2>

These are the latest releases from MIT press. Among them you will find nothing
remotely like SICP, but plenty of postmodernist/related pablum.

"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 this not an atrocity,
to be fought to the last bullet? Is this not an argument for declaring all
existing software obsolete and starting from scratch? Why are we - even
luminaries like Sussman - so willing to give up on the future without a fight?

As argued in some of PG's essays, in order for creativity to bear fruit it is
not enough for a given individual to possess a creative mind. The culture has
to be hospitable to creativity. And there are processes which come close to
stamping out creativity without any overt or deliberate suppression involved.
Specifically, a transition to a medium where one cannot get reliable,
understandable "small parts" having predictable behavior.

Take note: <http://xkcd.com/298/>

Programmers have indeed created a universe where "science doesn't work."
Learning where the permanent bugs and workarounds are inside a phonebook-
length API teaches you nothing. It is anti-knowledge. Where your mind could
have instead held something lastingly useful or truly beautiful, there is now
garbage.

There is no longer a "what you see is all there is" Commodore 64 for kids to
play with:

<http://www.loper-os.org/?p=16>

No one is working on, or sees the need for a replacement. This is just as
well, considering as one would have to start from bare silicon - and avoid the
use of design tools built on the decaying crud of the past. Only a raving
lunatic would dare contemplate it... Outside of programming: Linus Pauling
developed an interest in chemistry by experimenting incessantly throughout his
childhood. Today, he would have been imprisoned:

[http://memepunks.blogspot.com/2006/06/americas-war-on-
scienc...](http://memepunks.blogspot.com/2006/06/americas-war-on-scienc..).

The new generation will have no Linus Pauling, unless the Third World - where
one might still purchase a beaker without a license - supplies us with one.
Likewise, we will see very few truly creative programmers. What creativity can
there be when your medium is shit mixed with sawdust?

~~~
hc
wow, this is just ridiculously over the top.

------
drawkbox
I think this is a technology evolution natural move. This will probably happen
every few decades to the most capable new language or platform.

There is a strong religious backing to Scheme being the only way to teach core
CS fundamentals at MIT. I think that is an emotional almost fanboy reaction at
times probably filled with heavy bias.

Python is a great balance of showing many sides of programming, it can be as
eye opening as Lisp. Python is functional and object-oriented. Python is a
simplifying tool and culture. All platforms used here should be simplifying.

Python can get you building market ready desktop applications, web
applications, building robotics, scientific computing, game development,
algorithms and AI and nearly anything out there Python is at the tip of the
spear. Python is rapid iterations and prototype friendly. The frameworks of
Python are more capable to wrap nearly anything, that is what software
engineering is about now. It is the same evolution software process has taken
from the CMM, to CMMI (supporting modular and libraries), to Agile and a more
natural iterative process rather than top down design everything from the
bottom up approach. You can still do that, it is just not the majority of
software engineering today, and it will continue to simplify.

Are Scheme and Lisp programmers who are biased because they had that more
hardcore bottom up technique really thinking this degrades the experience or
is this more of a bias that is being attacked. Or has software engineering
fundamentally changed?

Scheme will not go away. This does not mean that people will stop making
compilers or REPL. It simply means the starting place is different. It might
even drive some better compilers and multi-platform tools because of the
quirkiness of many compiler systems out there will drive good engineeers to
simplify that process.

That is what we do, we simplify problems.

I would argue Python makes for more marketable and capable graduates to be
successful almost immediately after school, but I don't think it harms the
fundamentals much. Good developers and engineers still take time to get
better. No one is the best programmer in college, it takes time and
experiences after the academics to be highly skilled. Python fits closely with
computer science and is very capable of taking the torch.

I do think that there is a benefit to learning from a more difficult and core
understanding because it is more downhill from there but Python is hardly the
worst case scenario here.

I think that Python is perfect for teaching CS because of the flexibility,
libraries, open source but support by Google (they are big on CS and like
Python) and many other reasons.

What can you make in Scheme that you can't make in Python, very little.

Would you rather it be Java or C# they are teaching?

~~~
asciilifeform
> Scheme and Lisp programmers who are biased

Because we know what it is like to work in a medium that can be _understood_ ,
behaves _correctly_ , isn't peppered with inconsistencies, and does not force
you to clutter your brain with pointless trivia. Call that bias if you will.

> the quirkiness of many compiler systems out there will drive good engineeers
> to simplify that process

There is no evidence that this is happening or will ever happen. Almost
everyone shuts up, bends over, and spreads wide to accept whatever level of
pointless complexity the system they are forced to work with has. Programming
systems are continuously growing more Byzantine and idiotically laden with
accidental complexity as feature is piled on top of feature. _This is how we
got_ Python, C++, Java, C#, et al.

------
polos
Teaching has always to do with bringing something really new and perfect to a
still quite fresh mind.

So, when teaching, you always need to bring the simple and perfect theory.

Practice is what your students will make out of your 'perfect' theory --
slumming down quite a bit -- but if you start with bringing a 'practical'
theory to begin with, your students will never learn to fly high (bringing in
some really fresh new ideas).

