
Beautiful Online SICP - Dangeranger
http://sarabander.github.io/sicp/
======
ZephyrP
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](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](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.

~~~
cies
> you can use a TexInfo version of SICP and have both the text and your REPL
> in Emacs

Or have it all in your browser (every code block is a REPL; CTRL-Enter to
run):

[https://xuanji.appspot.com/isicp](https://xuanji.appspot.com/isicp)

~~~
znpy
Info is an awesome format but sadly is very well underappreciated.

------
ldjb
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!

[0] [http://mitpress.mit.edu/sicp/full-
text/book/book.html](http://mitpress.mit.edu/sicp/full-text/book/book.html)

[1] [https://mitpress.mit.edu/sicp/full-
text/sicp/book/](https://mitpress.mit.edu/sicp/full-text/sicp/book/)

[2]
[http://www.youtube.com/playlist?list=PLE18841CABEA24090](http://www.youtube.com/playlist?list=PLE18841CABEA24090)

[3]
[http://www.youtube.com/playlist?list=PL7BcsI5ueSNFPCEisbaoQ0...](http://www.youtube.com/playlist?list=PL7BcsI5ueSNFPCEisbaoQ0kXIDX9rR5FF)

[4]
[http://icampustutor.csail.mit.edu/6.001-public/](http://icampustutor.csail.mit.edu/6.001-public/)

~~~
babyrainbow
>it was a truly eye-opening experience and revolutionised the way I thought
about tackling problems and designing software.

Really curious. Can you share a bit more details about this. Like specific
instances of how it changed your thinking..

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

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

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

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

~~~
yoz-y
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.

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

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

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

------
Dangeranger
Downloadable PDF version here:

[https://github.com/sarabander/sicp-
pdf/raw/master/sicp.pdf](https://github.com/sarabander/sicp-
pdf/raw/master/sicp.pdf)

------
rcarmo
Loved the Third Addendum bit:

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

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

[https://xuanji.appspot.com/isicp](https://xuanji.appspot.com/isicp)

------
xiaq
Now that we're seeing WASM being supported, it would be awesome if code in the
textbook runs in the browser.

~~~
rjeli
See
[https://news.ycombinator.com/item?id=4860370](https://news.ycombinator.com/item?id=4860370)
from 4 years ago, it's fantastic

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

------
userbinator
I actually prefer the square corners of the original link-structure diagrams
to the rounded ones in this version; compare:

[https://mitpress.mit.edu/sicp/full-text/book/book-
Z-H-15.htm...](https://mitpress.mit.edu/sicp/full-text/book/book-
Z-H-15.html#%_sec_2.2.2)

[http://sarabander.github.io/sicp/html/2_002e2.xhtml#g_t2_002...](http://sarabander.github.io/sicp/html/2_002e2.xhtml#g_t2_002e2_002e2)

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.

------
jankoprowski
Nice interactive, online explanation of SICP is under
[http://www.composingprograms.com/](http://www.composingprograms.com/).
Examples are in Python3

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

~~~
ldjb
There are access keys set that are supposed to work as follows:

    
    
      t: top of page
      b: bottom of page
      n: next page
      p: previous page
      u: up one level
      c: table of contents
    

Unfortunately, they seem to be a bit iffy (partly because some of them are set
on multiple elements).

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

~~~
Dangeranger
There is an excellent 'pocket' format for compact E-readers in the parent's
Github repo as well, which should be nice for smaller screen sizes.

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

~~~
afarrell
Ideally, it would actually include guidance on a good way to write the
automated tests yourself after the first few.

------
40acres
I just started SICP today and am using this source. I have no idea what I'm
getting myself into but am looking forward to it.

~~~
Dangeranger
It's one of those books you will come back to every three to four years and
appreciate with new eyes each time.

------
laxentasken
I've just skimmed through the first couple of pages, but didnt find anything
about which lisp to use/howto. Any ideas?

~~~
rhizome31
There is a package that you can use with Racket: [http://docs.racket-
lang.org/sicp-manual/index.html](http://docs.racket-lang.org/sicp-
manual/index.html)

In order to use this, you will need to install Racket first: [http://racket-
lang.org/](http://racket-lang.org/)

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

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

~~~
alxndr
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".

------
git-pull
It would be beautiful if there was a Sphinx Theme for that book layout /
structure. It looks positively fantastic.

Imagine reading through SQLAlchemy's documentation [1] in that format.

Quick link to the repo:
[https://github.com/sarabander/sicp](https://github.com/sarabander/sicp)

The format this book is made out of seems to be Texinfo:
[https://en.wikipedia.org/wiki/Texinfo](https://en.wikipedia.org/wiki/Texinfo)

[1]
[http://docs.sqlalchemy.org/en/latest/](http://docs.sqlalchemy.org/en/latest/)

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

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

------
mike986
absolutely beautiful. i have the dead tree version and i've grown tired of the
times new roman font.

anyone know how `Figure 1.5: The tree-recursive process' is generated? it's
not an image.

[http://sarabander.github.io/sicp/html/1_002e2.xhtml#g_t1_002...](http://sarabander.github.io/sicp/html/1_002e2.xhtml#g_t1_002e2_002e2)

~~~
zellyn
It appears to be an svg. It could have been drawn using any number of tools,
or by hand: svg is remarkably understandable. In this case, it was drawn with
Inkscape: view source on
[http://sarabander.github.io/sicp/html/fig/chap1/Fig1.5d.std....](http://sarabander.github.io/sicp/html/fig/chap1/Fig1.5d.std.svg)

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

[https://www.youtube.com/watch?v=2Op3QLzMgSY](https://www.youtube.com/watch?v=2Op3QLzMgSY)

------
westurner
Thanks!

[https://en.wikipedia.org/wiki/Structure_and_Interpretation_o...](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)

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

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

------
gravypod
How would one compile this with higher contrast text? This is a wonderful
refresh to an eternal programming classic.

------
die2code
Was reading the Neil Van Dyke version yesterday.. And now this gift. Thanks
Sarabender & Neil Van Dyke..

------
throwaway7645
Very pretty...is it just a nicer version of the one MIT's SICP page links to?

------
guhsnamih
A lot more readable on the computer. I hope MIT Press doesn't complain.

~~~
0xcde4c3db
I'm not sure why they would, considering:

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

[1] [https://mitpress.mit.edu/sicp/](https://mitpress.mit.edu/sicp/)

------
hitlin37
is there a beautiful epub version?

~~~
hitlin37
found it.

~~~
provemewrong
Here's a direct link, if anyone else is looking for it.

[https://github.com/sarabander/sicp-
epub/blob/master/sicp.epu...](https://github.com/sarabander/sicp-
epub/blob/master/sicp.epub?raw=true)

------
torrent-of-ions
It is more beautiful (IMO) with "text-align: justify" on the paragraphs.

