Hacker News new | past | comments | ask | show | jobs | submit login
Easing into SICP
299 points by thinkingeric on Jan 18, 2011 | hide | past | favorite | 46 comments
"The Structure and Interpretation of Computer Programs" by Abelson and Sussman (http://mitpress.mit.edu/sicp/full-text/book/book.html) is often recommended reading on HN and elsewhere. However, you may find it to be much denser than the breezy computer books that are typically published. To help you acclimate to the concepts in SICP, I recommend the following steps:

First, read "Concrete Abstractions" by Max Heilparin (http://gustavus.edu/+max/concrete-abstractions-pdfs/index.html) and "Simply Scheme" by Brian Harvey (http://www.cs.berkeley.edu/~bh/ss-toc2.html). Neither of these books assume much programming knowledge, and should be accessible to anyone.

Next, listen to or watch Brian Harvey's lectures for "The Structure and Interpretation of Computer Programs" (http://webcast.berkeley.edu/course_details.php?seriesid=1906978502). This course uses SICP as a text book, but takes a less mathematical approach. The lecture notes are also available (http://www-inst.eecs.berkeley.edu/~cs61a/reader/vol2.html). This is a full semester course, so it will take you a while to get through it, but Harvey's lectures are easy to listen to.

Third, watch the lectures by Holly Yanko (http://www.aduni.org/courses/sicp/index.php?view=cw) for a SICP course. These follow the book very closely, but Yanko covers the material at relaxed pace. Unfortunately, these videos are Real Player, so you may have difficulty playing them. There are notes for the first few lectures.

Finally, watch the videos of Abelson and Sussman (http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures/). At this point, you will certainly be able to understand the more subtle and/or complex points that they make.

Overall, this is a big commitment of time, but it will certainly shake you out of any rut that your current languages have put you in regarding how to solve problems with computers.

I did SICP at the start of high school without any of these preparations and I'm not a genius. Some of the math was hard, but not too hard: just hard enough to learn a lot from it. You won't be able to read it like you read a novel, but I'd advise diving right into SICP and only using these additional materials if you really get stuck. I think you'll learn more per invested time.

If you "did" this book at the age of 14 and came away with the idea that it was about "hard" math, your learning/time ratio might not have been as high as you imagined.

I know the book is not about math (in fact I'm a math major now so I think I know what math is about ;), it was just that the mathy things were the hardest for me. For example understanding the O(log n) algorithm for fibonacci, the square root algorithm, series, exponentiation algorithm, newton's method, etc (especially since I had no idea what a derivative or exponentiation was). I suspect programmers with little math training will have similar difficulties.

I think one of the wonderful qualities of SICP is that a determined 14 year old and an experienced programmer can both get a lot out of it. I also think the difficulty of the text is generally overstated.

How do you infer that "[SICP] was about 'hard' math" from "some of the math [in SICP] was hard," by the way?

You qualified your inference with a conditional (to be fair); but I still find the implication irritating.

The downvotes to my response to his self-proclaimed precociousness indicate that others find my implication to be 'irritating' as well. However, anyone who is bogged down in the math would most certainly benefit from the sources in this list, many of which are explicitly prepared to avoid the math difficulties. SICP is not the place to learn basic mathematics, and it seems to me that it would be distracting from their message.

This is probably a good list but I really hope no one is intimidated and decides not to read SICP at all. I have to add another voice saying that it's really not that hard. I'm into chapter 5 and I found it not nearly as difficult as I thought it would be, challenging but not insurmountable. The writing is extremely clear and it really builds up the material at a good (not too fast, or too slow) pace. It's a terrific book and well worth the effort.

I don't know about the other lectures listed but the 1986 lectures are worth a watch, they are quite motivating since both authors exhibit an infectious enthusiasm.

Also recommended mostly as a prerequisite to SICP is "How to Design Programs" by Matthias Felleisen http://www.htdp.org/2003-09-26/Book/

I would advise anyone who is already at the point of considering reading SICP (so probably some familiarity with programming) to skip How to Design Programs. I tried working through it and found the pace excruciatingly slow to the point that I lost interest and stopped.

I've read the authors' presentations and thinking behind the program's design and I was impressed, but I think the end product they came up with just lacks anything special to recommend it. It's dry, slow, and not particularly fun.

I haven't done SICP so I don't know what a good prereq would be, but I remember The Little Schemer being entertaining and covering the same sort of ground as HTDP at a better pace.

It's true that HTDP is a little slow, but Felleisen is a master of CS pedagogy, and it shows in the book. The "design recipe" system that the book presents is actually extremely helpful in designing software once internalized. HTDP and SICP are in my opinion rather complimentary--I worked through HTDP in a couple weeks and am still working through SICP when possible. I consider the background that HTDP has given me valuable, not only as a Scheme programmer, but as a programmer in general.

You may want to work on your self-discipline. If you quit anything that is not entertaining enough you are limiting yourself a great deal.

I assume you haven't read HTDP and that you don't know me apart from a single online comment, so I don't appreciate you telling me I lack self discipline.

I didn't quit after one chapter. I explained my experience in hopes of saving someone else from wasting time.

Edit: I didn't downvote you.

OTOH, I read SICP first, and later checked out HTDP. It didn't seem very interesting to me. Not sure what I would have thought about it first.

Other potential prerequisites to SICP, all of which use Scheme: The Little Schemer (http://www.ccs.neu.edu/home/matthias/BTLS/; a quick read, but a bit overly cute), EoPL (http://www.cs.indiana.edu/eip/eopl.html; a great book in its own right; I recommend the _first_ edition), PLAI (http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/).

I'd also add The Schemer's Guide to that list: http://www.schemers.com/tsg.html

Good story about it here: http://www.trollope.org/scheme.html

EoPL seems like an interesting read. But why is the 1st edition better?

There's a REALLY cool chapter in the first edition, Chapter 12 ("Compiler Derivation") about using continuation-passing style to incrementally convert an interpreter to a (bytecode) compiler. I had never seen that approach before, and it completely blew my mind. Steele's _RABBIT_ (http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AITR...), Krantz's _ORBIT_ (http://repository.readscheme.org/ftp/papers/orbit-thesis.pdf), and Appel's _Compiling with Continuations_ develop the approach further.

It was cut from later editions, for some reason. Too advanced? Too tangential to the rest of the book? Too bad.

The first edition is also really cheap. FWIW.

I've had success using HTDP with students, and can recommend it - especially for the type of student that has interest/potential but that might otherwise struggle with a more standardized teaching approach.

I've also used Picturing Programs (http://picturingprograms.com/philosophy.html) and "How to Design Worlds" (http://world.cs.brown.edu/) with a few students that had a great deal of math anxiety and wanted a more graphics-intensive approach. I myself had/have a great deal of math anxiety, so I appreciate all of their efforts on this front. All of these materials help student's get their feet wet before they get too scared of the waves.

BTW, Does anyone know if someone has worked out the kinks so that you can use SICP examples directly in DrScheme/Racket to make the transition from HTDP to SICP easier for students? The last time I tried it, there were too many little gotchas and I gave up due to (volunteer work) time constraints.

I'm using this:


Hope it helps.

Thank you pointing this out. The audio is nice to listen to with the slides.

I'd like to add that there are also people working through SICP on Curious Reef (my social learning website): http://curiousreef.com/class/structure-and-interpretation-of...

It's an easy way to keep track of your work and collaborate with other people.

The OCW page for 6.001/SICP has complete lecture notes, which are useful supplements to the book, especially with additional diagrams: http://ocw.mit.edu/courses/electrical-engineering-and-comput...

There is also a public tutor [1] based on the course - basically a set of slides and audio (I think taken from an actual course) plus sets of questions to test your understanding of the material. It's interactive though - so you can submit your answers in scheme and they're tested on the server. I think this it's a discontinued experiment as there are only 2 tutors. For me, this approach works very, very well; you can read the material, listen to it and self-test your understanding with basic yes/no answers.

[1] http://icampustutor.csail.mit.edu/

I finally made it to the eval/apply video of the SICP series... so many hours in then you get that gift. A crazy, 70s synth-filled, wizard induced gift.

I'm determined to learn Lisp now just so I can buy myself a cape and a fez.

'Concrete Abstractions' looks interesting.

Can anyone here who's read it/is familiar to it comment on it?

I enjoyed reading 'Concrete Abstractions', and it's usually very cheap if you buy it used on Amazon (I think I paid about $5.00 for a copy that was like new.)

I disagree with the recommendation for 'Simply Scheme', though. I didn't learn much from it, and I was disappointed with the amount of code in it that was non-standard stuff created by the authors purely for pedagogical purposes. I would personally recommend spending more time on HTDP or SICP instead of reading 'Simply Scheme.'

This is a noteworthy objection, and applies to much of Harvey's course at Berkeley as well. I think the rationale for his approach is so that student's don't get tripped up by using only math examples.

Several people have brought up HTDP, which is very much in the same SICP-inspired vein as these other books in the list. I personally find it to be different enough from SICP as to not be considered a precursor to SICP. YMMV.

HTDP (How To Design Programs) and the Schemer series I highly recommend. The Schemers are really easy to read and HTDP goes into greater detail on many of the topics.

This was my order of execution in learning Scheme: Schemer series -> HTDP -> SICP

You can also find assignments, tests, lecture notes, lab notes, example and other course material to compliment Brian Harvey's course here:


(This is just one semester, you can find materials for almost every semester for the past few years with-some Google-fu)

Awesome, thanks for these tips. I'm going to start working through SICP in about two weeks.

I love what Eli Bendersky did here to track his progess as he was going through the book: http://eli.thegreenplace.net/category/programming/lisp/sicp/

One of the really cool things about Eli's story is the fact that he received a copy of SICP signed by Abelson and Sussman after completing his project (because of the actions of someone who knows the authors). That had to be a fun thing to receive in the mail.


If anyone is interested, someone out there was nice enough to turn the SICP content into Kindle/.mobi format: https://github.com/twcamper/sicp-kindle

All these are great resources. I am going through this process right now. So far I am just using the book with Racket and occasionally watch Prof. Harvey's lectures. I also recommend reading "The little Schemer". It had a great influence in me and I really learnt how to think in terms of recursion from that book.

One suggestion I have is to never skip any of exercises. They extend the discussions and are often very thought provoking.

If there are like minded people in your city, it is a good idea to meet regularly and discuss solutions after working through them.

Never say never. From the last exercise in ch 4: "This problem is open-ended. A good answer is probably worth a Ph.D."

I admit that I indeed skipped over that one.

:-) I am yet to reach chapter 4.

This is obviously not a universal formula, but I started out with "Practical Common LISP"; and then went on to SICP, translating the Scheme code into CL code as I went along. I then followed this by "On LISP".

For someone who does not know programming at all, I'd recommend SICP first. The text is dense, no doubt there; but, IMHO, not dense enough to deter reading.

Of course, I'm more of a "learn-it-the-hard-way" person; mileage may differ for more easygoing people.

Well it's good to know I'm not the only one that found SICP difficult. I started it recently and many of the exercises are tough.

Nice amalgamation of resources for SCIP related stuff. I wish there was a way to mark this as a sticky of some sort.

If you up vote the post it gets saved in your profile under saved stories. (Click on your username up top then saved stories is towards the bottom.)

You could just bookmark it.

Marking something as a sticky is like noting something as an FAQ -- usually for the benefit of those that come along later, as opposed to oneself.

The protocol around here seems to be re-submission every few months. At least that's the treatment popular links get.

I had no problems doing SICP. Yes, it was somewhat hard, but only in a few areas.

SICP really isn't that hard. It's just different. Just stick with it and you'll realize that you actually understand it.

I agree it isn't hard but I think that if you read the companion texts and read the "prerequisites" you will internalize the lessons better.

I found that reading SCIP while stoned helps understanding. Give it a shot! I finally understood big-theta!

I consider this comment unlikely to be part of the front page, and am commenting so that I might find this later.

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