Unfortunately the author still not be able to fullfill the goals :/ So, bookmark this and visit it in a year or two again.
I am very pleased with what is there so far, think it genuinely captures all the best bits in an accessible way. I am most proud of the Escher and Evaluator bits and associated projects.
I have lots more partially complete, feel I have a fair bit of momentum now and do still intend to make videos as I said in the update to backers, backers will see them first. I am genuinely sorry it has taken so long to get this out.
I think I was quite fair minded re: pricing etc during the kickstarter. I changed it from a sliding scale to allowing unlimited people taking the lowest amount (£20), then created a 'pay what you can' tier and invited people to switch to it if they wished.
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 name "SICP Distilled" feels very misleading. The programming language has been changed, in what I assume was an attempt to be more trendy, and the content has been changed to the point that it only superficially resembles the original text. There is no better language to explain the concepts of SICP than Scheme, and it appears the author understands this, as he had to remove sections of the text to compensate for Clojure's unsuitability. It appears that he changed or removed a large portion of the text, in fact, and added in their place new ideas which are arguably unrelated to the spirit of the original book. Perhaps it is merely the name "SICP Distilled" that makes me apprehensive, and I would be happy if it was marketed as something completely unrelated, with only a nod to SICP as its inspiration. However, it feels wrong as it is.
Peter Norvig wrote that SICP "is a very personal message that works only if the reader is at heart a computer scientist" It is entirely possible that this project will bring some of the most important ideas of SICP to those who do not fit that description. But is that a goal we should be striving to achieve? This question makes me think back to a portion of the quote, on the very first page of SICP, by Alan Perlis: "Above all, I hope we don't become missionaries. Don't feel as if you're Bible salesmen. The world has too many of those already. What you know about computing other people will learn. Don't feel as if the key to successful computing is only in your hands."
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.
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.
Upvoting; just had a well-actually to add.
"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/
On that note can anyone recommend SICP-equivalents for automotive, locomotive and aerospace engineering?
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!
> Note that recur is the only non-stack-consuming looping construct in Clojure.