SICP Distilled: An idiosyncratic tour of SICP in Clojure

I am with you, and also a backer. The original goal was exceeded by a wide margin (£12,927 pledged of £3,500 goal). 12K GBP is a non-trivial amount of money. There are no videos (if you exclude a low quality recording of a talk on the project https://www.youtube.com/watch?v=LVM8N0eH9Qk), no screencasts and the text only covers a few of the topics outlined in the campaign.

The math should probably be way understated, for a general non-MIT/CS audience:

"Abelson: There’s a tremendous amount [of math] in this 6.001 book. That’s partly because we were writing it for MIT. You want to talk about higher-order procedures, so the obvious thing you can do is you can express the idea of an integral. So that’s an obstacle for lots of places. Remember, at MIT the context we were writing in is every person who took the course had just had a semester of calculus."

"We actually did some versions for the Humanities faculty, where we didn’t do that at all, and we effectively started with the data structure chapter and then talked about the ideas for how do you structure and manipulate data, and then do abstractions over that." http://codequarterly.com/2011/hal-abelson/

I haven't read this new book yet, so I can't address your contingent criticisms of it, but some of your criticisms are not contingent on the contents of the book, and those I think I can refute.

We've actually learned a lot about how to program since SICP was written; Clojure embodies some of that knowledge.

To take one example, Scheme was built around the state-of-the-art FP-persistent data structure of the 1950s, the singly-linked list, which was still state-of-the-art in the 1980s. Clojure's standard library includes state-of-the-art production-quality data structures of the 2000s, which can support many more operations persistently than singly-linked lists can.

To take another example, miniKanren, which is also in Clojure's standard library, is a dramatically more powerful logic programming system than anything that was available in the 1980s. Basic miniKanren is small enough that you could in fact present it, starting with mu-Kanren, in a book chapter. This may be a better way to introduce people to nondeterministic programming than the simple temporal backtracking approach in SICP.

Of course, we've learned a great deal about formal semantics, types, and proving properties of programs since then, some of which could be presented productively even in dynamically-typed languages like Clojure.

Perhaps most importantly, we've learned an enormous amount about building distributed systems since then.

SICP is, to my mind, largely about different relationships between time, memory, and programming. It begins with a timeless, memoryless reduction semantics, and expands from there, exploring different relationships with time: mutating, backtracking, lazy, and so on. Since SICP was published, some new approaches to time in programming have become important: transactional stores, although those were already in use in niche applications like transaction processing and business data processing in general; incremental computing, where parts of your program are re-executed by need, while leaving other parts alone, although that was already in use in niche applications like compilation of large software systems; and partial evaluation, which, again, existed but was not yet popular.

A SICP for 2015 would surely incorporate some of these things, though I'm not sure which. And surely there were lessons the authors themselves learned in writing SICM that could be deployed to good effect in a new SICP, as well.

> SICP is a classic text, and although it is old, it has not aged. I wonder if this is a sign of a stagnation in the field of computing, that as the machines we use become exponentially more powerful, we still know very little about how to use them. In any case, SICP is still an excellent introduction to computing and does not need to be updated just yet.

The more I research into Xerox PARC papers, the more is clear to me how long we have taken to reach a developer experience that they had already available to them in the early 80's.

The interest in the work developed by Bret Victor, Evan Czaplicki, Chris Granger among many others, shows how far we still are from catching up with those systems.

Sometimes looks like Romans looking at the state of technology available to the the common guy, after the fall of the empire.

I can't speak to locomotive or aerospace, but I found The Reluctant Motor Mechanic by John Fordham a great introduction to how cars work. It was written in 1979 and you can pick up a used copy from Amazon for approximately $0.01+shipping.

It's a thorough introduction to how the whole car works, written to be understood by actual humans who don't have experience with engineering. He goes through each system, starting with the engine, until he has covered every piece of equipment inside your car. It doesn't take as long as you'd think, either - he's pretty concise.

It was written in 1979, so it only covers technology up to that point, but since the car is basically the textbook case of what you can achieve through incremental improvements, it's still pretty relevant. Plus, it's got a lot of good illustrations!

I always thought of it as being a kindred spirit to Zen and the art of motorcycle maintenance.

You can use recur for tail call optimization in Clojure, though it's messier than Scheme.

> Note that recur is the only non-stack-consuming looping construct in Clojure.

http://clojure.org/special_forms#Special%20Forms--%28recur%2...

Thanks! (you might need to shift-refresh to see it yourself as I set cache headers your browser should also honour)