
SICP Distilled: An idiosyncratic tour of SICP in Clojure - jboynyc
http://www.sicpdistilled.com/
======
fu86
This was a Kickstarter a year ago (i baked too):
[https://www.kickstarter.com/projects/1751759988/sicp-
distill...](https://www.kickstarter.com/projects/1751759988/sicp-distilled)

Unfortunately the author still not be able to fullfill the goals :/ So,
bookmark this and visit it in a year or two again.

~~~
macmac
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](https://www.youtube.com/watch?v=LVM8N0eH9Qk)),
no screencasts and the text only covers a few of the topics outlined in the
campaign.

~~~
thattommyhall2
Either of you please email me with your backer number and I can refund you or
turn what you paid into a donation to Médecins Sans Frontières if you are not
happy.

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.

Best wishes, Tom

~~~
agumonkey
It seems like a communication problem. If you're still going forward but don't
push sub-par content out in the public due to pressure, this is acceptable;
but if people don't know (I can't read the KS status updates, but there's not
many of them) they'll be angry just because of that.

------
throwaway76411
I feel very uneasy about this project.

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"[1] 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."[2]

[1]
[http://www.amazon.com/review/R403HR4VL71K8/](http://www.amazon.com/review/R403HR4VL71K8/)
[2] [https://mitpress.mit.edu/sicp/full-text/book/book-
Z-H-3.html](https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-3.html)

~~~
kragen
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.

~~~
abecedarius
The backtracking in sicp's logic language is more like minikanren than Prolog.
What minikanren offers in addition is better integration with Scheme (and more
painful syntax).

Upvoting; just had a well-actually to add.

~~~
kragen
Hmm, that's an interesting point. I didn't realize that.

------
k_bx
I think this is awesome! One thing – would be really awesome if examples would
be editable and you could evaluate them via ClojureScript somehow, that would
make a huge advantage I think.

------
keyan
"To use an analogy, if SICP were about automobiles, it would be for the person
who wants to know how cars work, how they are built, and how one might design
fuel-efficient, safe, reliable vehicles for the 21st century."

On that note can anyone recommend SICP-equivalents for automotive, locomotive
and aerospace engineering?

~~~
robto
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!

------
kephra
What is the sense in teaching SICP in a language that has no tail
optimization? McEval would run straight into the wall.

~~~
joonoro
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...](http://clojure.org/special_forms#Special%20Forms--%28recur%20exprs*%29)

~~~
hga
I personally think there's something to be said for making tail recursion
explicit, as Clojure on the JVM requires, although the greater mess is not
good, especially for introducing the concepts, and Clojure on the JVM can't do
all types of desirable tail recursion.

------
lgrapenthin
Excercise 1.5 needs fix, def form is is invalid

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

