They do interpreters for Logo instead, and wow... not even 6.001 at MIT did the register and bytecode stuff.

Yeah, the interpreters were really cool. Being able to write a program, have it run and do stuff, and know that you're the one who made it run is really a great feeling which I'm probably failing to describe properly.

The lazy interpreter was also brilliant--realizing that you can change a language's behavior drastically with a small change in the interpreter is very empowering. Coincidentally, that's what pushed me over the edge to learning Haskell, so I'm extra grateful there.

Overall, the amount of magic that class showed me definitely made it worthy of the wizard on the cover.

(also a TA for the course)

I took this class while it was still taught in Scheme, and I loved it. Now I'm teaching it in Python. I am also sad to see Scheme go, but I think we gained as much as we have lost in our switch to Python. For example, I argue that Python dictionaries are more intuitive to use than the old "association lists" implementation in Scheme (we still taught the implementation). Concepts like MapReduce and concurrency that we cover later on in the course are also cleaner and more elegant than the Scheme implementation. The above-the-line OO syntax is also much, much easier to use.

We are still covering interpreters as our last unit. It will be for a "calculator" language, with conditionals and assignments. We are hoping to cover a lot of the same concepts, but we decided that a metacircular interpreter is obviously too difficult. We are keeping project 4 the same (Logo interpreter) but we have ported it to Python and wrote some new questions. Personally, I think the OO-centric interpreter is an improvement over the old Logo interpreter in Scheme (we can have Environment objects that now contain Frame objects, for example. Before, environments were just a list of association lists).