Hacker News new | past | comments | ask | show | jobs | submit login
SICP Distilled: An idiosyncratic tour of SICP in Clojure (sicpdistilled.com)
243 points by jboynyc on Sept 6, 2015 | hide | past | web | favorite | 20 comments

This was a Kickstarter a year ago (i baked too): https://www.kickstarter.com/projects/1751759988/sicp-distill...

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

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

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.

I think you are off to a great start, and appreciate the effort.

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/ [2] https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-3.html

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

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.

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

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

"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?

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.

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

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.


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.

Excercise 1.5 needs fix, def form is is invalid

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

Registration is open for Startup School 2019. Classes start July 22nd.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact