That's definitely cool, but as I mentioned in another comment, check out what they're missing:
metacircular Scheme interpreter
lazily-evaluated Scheme interpreter
non-deterministic Scheme interpreter
pseudo-Prolog in Scheme
register machine simulator
compiler to bytecode for the same machine
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).
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.
The interpreter for Logo is actually extremely similar to an interpreter for Scheme; additionally, we went over several variations on the Scheme interpreter in lecture.
We didn't do the registers and bytecode, which was too bad although fair to students taking the class with less programming experience. One happy side-effect of the switch to Python is that there is now a self-paced version that allows the students to do all that if they want.
Comments
That's definitely cool, but as I mentioned in another comment, check out what they're missing:
edited for formatting(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).
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.
They do interpreters for Logo instead, and wow... not even 6.001 at MIT did the register and bytecode stuff.
The interpreter for Logo is actually extremely similar to an interpreter for Scheme; additionally, we went over several variations on the Scheme interpreter in lecture.
We didn't do the registers and bytecode, which was too bad although fair to students taking the class with less programming experience. One happy side-effect of the switch to Python is that there is now a self-paced version that allows the students to do all that if they want.