This semester Prof. Hilfinger is teaching it in Python 3. It isn't a formal online course, but it looks like everything is available including lectures, slides, book & homework.
Oh, I see, just give them trivially small data sets: http://www-inst.eecs.berkeley.edu/~cs61a/sp12/labs/lab8/lab8...
The question I had is how are they going to code a metacircular interpreter? Apparently they make a Scheme interpreter instead.
Just one possibility: http://code.activestate.com/recipes/474088/
Focus is naturally put on how a language looks on paper, more than how it executes on the machine.
My 2c.
Also, it's the Structure and Interpretation of Computer Programs; naturally, the first bit talks about how programs look (structure), but the second bit (mainly chapters 4 and 5, if I remember correctly) talks about exactly that: how to execute code on the machine. The last chapter, in fact, introduces a register-based language not unlike assembly.
It's the self-paced, Scheme-based version of the course. The website is currently for last semester; I have some friends working on it and they promise the next iteration (should be up soon) is going to be really awesome. I believe them.
Also, since it's a self-paced course, it's probably a much better option if you want to work along on your own in your free time. I think some other institutions might be using the materials from this class as well, but am not sure about that.
Here are the rather insightful thoughts about using Scheme vs Python for this course from its old professor (who was really awesome): http://www.cs.berkeley.edu/~bh/proglang.html
It sounds really interesting and useful though, thank you (and your friends for working on it)
I'll keep an eye on it and check it out when it's up ...
The book touches so many fields in computing and does it in a profound, deep, yet entertaining way. Part of its ability to do so is its use of scheme, a language that doesn't give you a whole lot in conventional terms, but which also puts very few restrictions on your ability to build those things up, so you can get an understanding of them as you create them. Polymorphic method dispatch can seem magical if it has always "just worked" for you in Java, but when the text discusses a system for implementing this (several systems in fact) suddenly it all clicks, and the magic you use every day is a little bit more comprehensible.
And so I feel like attempts to teach SICP but in whatever the more practical language of the day is are misguided, and ultimately a little bit of a cop-out. Before you read the next few sentences let me preface them by saying that I have respect for everyone involved with these decisions even if I don't agree with them, and I don't want to come off as supposing malicious motives on their part.
But the overwhelming feeling I get from reading about these initiatives is that people have looked at SICP and said "Wow that is really a great book, shame about how it uses this fringe language. I know, I'll use language-x which is much more practical, and if there are areas in the text that language-x can't really handle, I'll limit the size of the recursion, or not use higher-order functions as much, etc, etc". And that misses the point. If you want to use language-x then you should probably step back and write a text using language-x that is just as amazing as SICP, and that really utilizes the strength of language-x in the same way SICP utilizes the strengths of scheme. But of course that is really, really hard work and so no one does it. Instead we get initiatives like this that dispense with the magic of using scheme and tail-recursion and lambda, and shoe-horn it into lisp, while also constraining Python to a weird lispy style doing basic things like defining your own functional binary search on a list, which is entirely against the whole reason you use python which is BATTERIES INCLUDED.
And thus you end up with a lazy compromise that doesn't really do justice to either the tremendous original material, or the strengths of a current language. I really think that before you decide to use SICP but with a "modern" language you should ask yourself why you are using SICP and not the amazing course material you have put together yourself to really leverage the strengths of language-x in a way that also teaches computer science. And if your answer is "Because that would be a lot of hard work, and I can just have students do list recursion in python, on small lists, and without doing too much higher-order stuff" then I submit you should abandon your plan and head back to the drawing board, with better goals, and higher standards.
MIT is doing something similar, with the support of the authors.
The same material is being taught, just in a different language.
Python has a wealth of syntax and data structures that make it great for real programs but is perhaps not as good at building abstractions from the ground up.
From Lab 4 [0]: Exercise 2: Data Herp Derping
The same lab -- possibly others -- has mixed whitespace usage (ex. str_rat method), which may be worrisome for introducing students to languages that hinge upon proper whitespace. The examples will work, as expected, but beginners may be confused by usage of or burdened by not understanding the implications of using 4 spaces here, 6 spaces there, etc.
[0] http://www-inst.eecs.berkeley.edu/~cs61a/sp12/labs/lab4/lab4...
Python can be a problem and get in the way; scheme was beautiful because it's so simple that all that rest to understand is the really big ideas described in SICP.
I die a little every time I see $ cat file | grep word
- correct definition of 'cat'
- what is wrong with '$ cat file | grep word"
edit: formatting
what is wrong with... -- "grep word file" takes fewer keys to type and uses fewer resources (important on a heavily loaded server with tons of processes which may well prove compromised and you're trying to peruse the logs for evidence. Been there, done that, got the t-shirt, and donated it to the local shelter).
