There is a post on Lambda the Ultimate about MIT’s recent switch from Scheme to Python for the first-year computer science course. I read about this change when it was proposed, has anybody taken these new courses?

I remember when I took 6.001 (seven years ago). At the time I knew it was cool but I wouldn’t have been able to explain why its particular approach to computer science was so useful. But now with several years of experience evolving software systems, I can.

It really does come down to abstraction. Say I have to do a series of mundane tasks (like sorting things or doing paperwork). Being a lazy person, as I start I make a judgement: would it be faster for me to just brute force my way through this or take a step back and make a system so that I can go through it more efficiently.

This same judgement applies to coding. Is it faster to solve a series of problems by barreling through, one after another, or would it be faster to take a step back, figure out the commonalities among the problems and abstract those commonalities away.

With simple things, the judgement can go either way. This is sometimes why I’ll quickly hack something in PHP, for example.

But it turns out with large systems where there are multiple people working over long periods of time, unless there is a deadline, it is always better to go with the latter, abstraction approach. The reason is that the system will be around for a while and constantly changing. So you want each piece of functionality in only one place in the source code (to avoid introducing bugs when making changes). Further, the fact that there are multiple team members and the system is larger than a person can think about at one time puts constraints on the humans’ collective working memory. Thus you want to have the smallest amount of code possible.

Only by being lazy, and refusing to behave mechanically like a computer, can humans make computers behave intelligently. Don’t meet a computer on its level, make it meet you on your level. This laziness (aversion to performing mechanical activity) is what separates good computer scientists from everyone else.

6.001 was good because Scheme introduced strongly (at the time) this idea of abstraction.

But Scheme is surely out of date at this point. I recently attended a Guy Steele lecture at Sussman’s advanced class where he had several slides in Scheme. Haskell would have been clearer. The LISP idea that one should abstract the syntax of the code so that one writes code to write code is currently being beaten by the Haskell idea that one should just use abstracter abstractions (monads, etc.). In other words, if MIT wants to keep a class in the spirit of 6.001, it should teach Haskell.

Further, it seems that this new curriculum has completely different goals than 6.001. It is now a hardware/software engineering course, not computer science. This is fine, there’s a lot of interesting stuff going on in this arena (feedback systems, for example).

But if you want to become a good computer scientist, you’ll need to supplement with theoretical math courses, to exercise your brain in using (and forcing yourself to use) higher abstractions. Category theory is a fun way to do this, but any higher math will do.