Sarabander's edition is definitely a huge credit to it's author: It isn't just a reprint of SICP; The text and it's font has been updated, many of the diagrams have been redone for clarity and the document and footnotes are hyperlinked.
If it's your ambition to follow in the footsteps of others or otherwise just prefer the classic Lisp-haqr experience, you can use a TexInfo version of SICP and have both the text and your REPL in Emacs: http://zv.github.io/note/sicp-in-texinfo
Also, just to pimp my own ride: I put together a SICP guide for new explorers of this great text: https://github.com/zv/SICP-guile
It contains both meta-information about which dialects of Lisps and languages are most suited to SICP, overviews of subchapters, helpful hints for those who are following along at home as well as answers to the exercises in Elisp, Guile scheme & Racket.
Woah, yeah I think this is a solid approach. You can remove all distractions and just work on the one page and focus on only the task at hand rather than worrying about dealing with your own setup and can be accessed anywhere.
SICP is the one text I wish I'd known about when studying computer science at uni. When I finally discovered and read it, it was a truly eye-opening experience and revolutionised the way I thought about tackling problems and designing software. It may have been around for a while, but the ideas presented still hold water today.
As others have mentioned, the linked version has some definite improvements over the web version provided by MIT Press [0], which doesn't have particularly clear diagrams.
In fact, MIT Press does have an alternative version with larger diagrams [1], but the footnote links don't work.
Do also check out the 1986 Abelson and Sussman lectures [2] that accompany the text. Those two present the course in such an interesting and (dare I say it) fun way.
And for those who have already watched that and are curious, I've recently uploaded a 2004 version of the lectures to YouTube [3]. They're sourced from the SICP iCampus site [4], which is another fantastic resource, though I find the way that site presents the lectures to be a bit annoying. Completing the problem sets is a good way to check your understanding, though!
For example, I previously tended to use a bottom-up approach to development. However, SICP showed me the benefits of what it calls "wishful thinking" with a more top-down approach.
It also helped me finally 'get' functional programming. Even in situations where other programming paradigms make more sense, I'll still opt for a functional style a lot of the time and avoid state.
I'm also a lot more confident with higher-order functions and closures after SICP help me understand them better. Seeing how cons pairs can be implemented as functions was simply mind-blowing. I think being able to use some of these techniques have improved the way I code.
There are a lot of other topics, such as the meta-circular evaluator, that I haven't had the opportunity to put into practice, but are nonetheless absolutely fascinating.
Unpopular opinion but having read this book, I think it's a "good" text that is a bit blown out of proportion in terms of how good it is. I'm curious for people that endorse to such a magnanimous degree what other literature they've read and what aspects of SICP in particular they find so superior.
First of all, it's an introductory text that provides a practical whirlwind tour of introductory computer science. Second starts from a straightforward place (when the first edition was written it was quite reasonable to assume that a student arriving at university, even MIT, might never have programmed a computer before) and after one lecture on the scheme language, dives in to practical details. Third, unlike, say, your average introductory programming class it doesn't get hung up on syntax; unlike an average introductory algorithm class the algorithm examples are typically on stuff a student would already know (numerical methods, etc) rather than super-abstract "consider a graph..." Finally it's an engineering text: if you do the problems you end up writing an interpreter for the thing that seemed so amazing on the first day and you discover you know how all the bits fit together.
Right I always wondered if my opinion of it stemmed from the fact that I read it relatively late in my career. Never having fresh eyes on it, I suppose it's easy to take things like syntax and such for granted. That said, is Scheme really a good language for "not getting hung up on syntax?" It has an admittedly simple grammar but I can't help but feel that with the prevalence of ALGOL style languages, an intro student is better off just just biting the bullet and learning something more traditional.
If I was going to teach things like type systems and such and was ok with exotic syntax, I might teach Haskell or something.
It's funny you contrast it with ALGOL since ALGOL was explicitly cited as one of the predecessor languages used when designing Scheme (the other being Lisp) as Scheme is a block-structured language with lexical scope. And the programming style of SICP is procedural, not a functional or logic approach.
Remember the kids for whom this course was designed were going to be doing circuit design concurrently or the following semester. So the point was to learn composition, abstraction, modularity, algorithms etc, not syntax.
And Sussman was not the only one who used scheme to do a lot of engineering computation as well.
I have never considered Lisp syntax exotic. In any case, remember SICP was the text for a fundamental CS and Engineering class, not a programming class.
I used Scheme a lot in the past and currently help people get up to speed on JavaScript. I definitely think the IIFE syntax makes more sense in Scheme, and higher order functions are a lot easier when you end a block with ))) instead of )}; }) )};
At my university the introductory programming was taught using scheme and I found it weird at first as I knew the more traditional approaches (personally I have taught myself programming first in Basic and Pascal).
Later I have been assisting a professor during python classes and I have come to appreciate the benefits of a purely functional language for introductions (our teachers have strategically chosen not to talk about the `begin` keyword in Scheme). Many students have had really hard time grasping the idea of variables and scopes.
Because so many of us learn imperative programming first, then find functional a big shift, I think we forget that everyone learns maths, which has no mutable state in the traditional maths classroom written style, and so functional actually resonates pretty well with people who have never touched programming at all, provided they've been exposed to enough maths.
The weakness to this approach is that learning the functional approach is all well and good but you can't learn this at the expense of learning what the machine does. Learning a traditional ALGOL like C exposes you to memory access, the stack pointer, and other such concepts. You're also a small hop away from assembly where you learn about RISC/CISC architectures, CPU caches, etc. I wish there was a book as popular as SICP that people would read so that the understanding of what the hardware is doing is better across the industry.
I think the book shown with nand2tetris (maybe called the elements of computing) is pretty good going from logic gates to building Tetris. Also "CODE" and "Computer Architecture with the Raspberry Pi" are great.
All of that comes in but I think it is better to introduce an overview of what a computer can do and later explain how it is done. Motivation has a great influence of how well you can learn something. Swamping people with technicalities is a great way to lose them.
Chapter 5 of SICP actually goes into the details of how to implement a register machine to execute Scheme, including a simulator, assembler and compiler.
It is particularly good for an introductory programming course to use something 'exotic', because that levels the field. Students who did some Basic/Pascal/PHP/Ruby/... in high school, who often think they already know what programming is, are forced to take a fresh look. So the steeper start pays off.
Reading the book isn't really good enough. The lessons are tucked into the well thought-out exercises, which is a feature that isn't found an many other texts.
The book was written a long time ago, yet they described MapReduce, and the industry took over 30 years to finally see the light. They described functional programming, and similarly, the industry took forever to catch up, though sadly FP is mostly being done very wrong.
In this day and age of "get a job at CompanyX with 2 months of study," I'd argue that this book is even more valuable. It is an introductory text (where nearly every intro text is water-down; online isn't worth speaking on) that teaches the implementation details of common data structures, along with many clever approaches and tricks, all written and explained without being overly abstruse. Sure current resources may teach you to set up RoR and plug in flavor-of-the-day javascript, but those who built the meta-circular evaluator rightfully roll their eyes at yet another JS... evaluator.
Oh I should say, I did the exercises too. My background is in math and I'm very accustomed to the meat of the book being in the exercises (I'm looking at you Springer).
I read the book for the first time later in my career and for me the chapter 4 about metacircular evaluator combined with the video lectures was and still is mind blowing. When I was a freshman I was learning to do for loops with Java when SICP teaches how to create your own programming language...
The insight that "code is data" and should be viewed as such is very well treated by lots of literature/languages. Tons of languages support "eval" and building an AST is really not that difficult. I think SICP might be a popular entrypoint to interpreters but probably not the best.
Perl supports eval like lots of languages because data CAN be code. It's only in homoiconic languages like Common Lisp, Scheme, Racket, Clojure, and Rebol/Red that code IS data. Just because you have EVAL doesn't make it a 1:1 relationship and that makes a big difference. If your code/data is just a big AST, then macros are trivial and that prompts you to write DSLs...etc.
Right, I'm not even just talking about code as data in a homoiconic sense but literally just, code is a bag of instructions (jumps, load, store, add, etc) regardless of if your language is homoiconic or not. Maybe the point that can be made is that exposure to a homoiconic language earlier helps bridge this gap faster?
"Third Addendum: Things go in spirals. We explored the powers of Texinfo and LaTeX at typesetting the PDF book. Now it’s time to come back to HTML. This turn it shall be HTML5. “It can be a dangerous place, but it’s our last, best hope for peace.” (Sinclair, Babylon 5.)"
Another online version of SICP that is (slightly) less good looking, but interactive (CTRL-Enter to run any code block) by a LISP interpreter that runs in your browser.
Looks really nice. Maybe I'll finally get around to reading SICP, given how often it seems to come up in discussions here. :)
That said, it seems that the font in this version is insanely large. I know large fonts are trendy right now, but 27pt text is just too much for long-form content like a book. (Compare with printed material at 10-12pt.) If the author's trying to improve readability, I'd recommend a higher-contrast font color instead.
On the other hand, the PDF version looks fantastic and addresses both concerns.
However, the fact that they're not tiny and pixelated is definitely an improvement.
As for the content of SICP itself, it's extremely interesting and enlightening but perhaps encourages a little too much "abstraction-worship" --- not surprising given that computers were still getting faster exponentially when the book was first written.
Does anyone know of a better way to navigate the document structure here?
I see this on the GNU website and in the HTML versions of their manuals, so am assuming it's from a design choice made there ...
Making the empty side margins Clickable to indicate "next page" / "continue" or binding the arrow keys, or spacebar-if-scrolled-to-bottom would make this much more tolerable to navigate, I surmise that the emacs / info readers must have more usable controls. Are there nav controls I'm missing?
This is incredibly beautiful. I wish all technical writing online could be so well presented - I'm tired of trying to read two-column journal-formatted PDFs on my phone.
My biggest issue with SICP was the lack of available unit tests for the exercises. I'd often "get it wrong" and have no recourse but to read a solution to see that I'd failed to account for some aspect of the problem.
Without an easily verifiable way to test your solutions as you go I think these kinds of books really do themselves a disservice as you lose the ability to struggle and think hard about the problem if you can't immediately solve it.
I worked through a couple chapters of SICP using Racket and the SICP package in DrRacket before moving on to Emacs and Geiser.
DrRacket is a great starting point if you don't want to bother with setting up Emacs and the SICP package even supports the image elements that are covered in the course.
perhaps only tangentially related but recently I began noting down beautiful typefaces I come across, the two used here are Inconsolata LGC and Linux Libertine O. do you guys have favorites?
Inconsolata has been my favorite monospace font for working in terminals and editors for a couple years now. It's pretty subtly-serifed for a monospace, punctuation doesn't seem to distract me like it can in other fonts, and I find it easy to distinguish close characters like "1" "l" "I".
awesome. I'd also do Cormen & Leiserson's book as well as Aho's dragon book if I had the copyrights :). True epics in CS. Maybe even add Don Knuth's multi-volumes.
Try reading SICP not for the sake of becoming a better programmer or learning some applicable skills. Do it for the sake of having fun. You'll get everything else as a bonus.
you all with your fancy pants "reading". Nothing beats the movie, not only showing the height of computing power, but the awesome fashion of uber geeks.
Any advice from the community on what environment is best for SICP/Scheme? I'm currently using Dr.Racket as I've heard to avoid Emacs at this point, any other suggestions/thoughts?
this must have been so much work. SICP is an intricate masterpiece. So many projects like this fail mid-way. Even if all you do is change the CSS style, that's an accomplishment in itself.
> Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman with Julie Sussman is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License by the MIT Press. [1]
That's not an "ND" (no derivative works) license, and this version also says it's licensed under CC-BY-SA 4.0 International, which should cover the "ShareAlike" part.
If it's your ambition to follow in the footsteps of others or otherwise just prefer the classic Lisp-haqr experience, you can use a TexInfo version of SICP and have both the text and your REPL in Emacs: http://zv.github.io/note/sicp-in-texinfo
Also, just to pimp my own ride: I put together a SICP guide for new explorers of this great text: https://github.com/zv/SICP-guile
It contains both meta-information about which dialects of Lisps and languages are most suited to SICP, overviews of subchapters, helpful hints for those who are following along at home as well as answers to the exercises in Elisp, Guile scheme & Racket.