Highlights
# 1A Overview and Introduction to Lisp
The real problems come when we try to build very, very large systems … nobody can really hold them in their heads all at once … the only reason that that’s possible is because there are techniques for controlling the complexity of these large systems. And these techniques that are controlling complexity are what this course is really about. And in some sense, that’s really what computer science is about. —Abelson
So in that sense, computer science is like an abstract form of engineering. It’s the kind of engineering where you ignore the constraints that are imposed by reality. —Abelson
# 1B Procedures and Processes; Substitution Model
But one of the things we have to learn how to do is ignore details. The key to understanding complicated things is to know what not to look at, and what not compute, and what not to think. —Sussman
The way in which you would construct a recursive process is by wishful thinking. You have to believe. —Sussman
# 2B Compound Data
See, in general, as systems designers, you’re forced with the necessity to make decisions about how you’re going to do things, and in general, the way you’d like to retain flexibility is to never make up your mind about anything until you’re forced to do it. The problem is, there’s a very, very narrow line between deferring decisions and outright procrastination. So you’d like to make progress, but also at the same time, never be bound by the consequences of your decisions. —Abelson
I said that computer science is a lot like magic, and it’s sort of good that it’s like magic. There’s a bad part of computer science that’s a lot like religion. And in general, I think people who really believe that you design everything before you implement it basically are people who haven’t designed very many things.
The real power is that you can pretend that you’ve made the decision and then later on figure out which one is right, which decision you ought to have made. And when you can do that, you have the best of both worlds. —Abelson
# 3A Henderson Escher Example
Lisp is a lousy language for doing any particular problem. What it’s good for is figuring out the right language that you want and embedding that in Lisp. That’s the real power of this approach to design. —Abelson
The design process is not so much implementing programs as implementing languages. And that’s really the powerful idea of Lisp. —Abelson
# 3B Symbolic Differentiation; Quotation
In order to make a system that’s robust, it has to be insensitive to small changes, that is, a small change in the problem should lead to only a small change in the solution. There ought to be a continuity. The space of solutions ought to be continuous in this space of problems. —Sussman
# 4A Pattern Matching and Rule-Based Substitution
The key to this—very good programming and very good design—is to know what not to think about. —Sussman
# 5A Assignment, State, and Side-Effects
For example, here I am, I am a particular person, a particular object. Now, I can take out my knife, and cut my fingernail. A piece of my fingernail has fallen off onto the table. I believe I am the same person I was a second ago, but I’m not physically the same in the slightest. I have changed. Why am I the same? What is the identity of me? I don’t know. Except for the fact that I have some sort of identity. And so, I think by introducing assignment and objects, we have opened ourselves up to all the horrible questions of philosophy that have been plaguing philosophers for some thousands of years about this sort of thing. It’s why mathematics is a lot cleaner. —Sussman
# 5B Computational Objects
But inadvertent sharing, unanticipated interactions between objects, is the source of most of the bugs that occur in complicated programs. So by introducing this possibility of things having identity and sharing and having multiple names for the same thing, we get a lot of power. But we’re going to pay for it with lots of complexity and bugs. —Sussman