Beautiful Online SICP | Hacker News Reader

Beautiful Online SICP

sarabander.github.io

762 pointsDangeranger80 comments

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.

Yes, I love this idea as well.

Did a little research and found the TextInfo format from Neil Van Dyke here:

http://www.neilvandyke.org/sicp-texi/

> 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

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

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.

Someone put it on Melpa. `M-x package-install sicp`, then open the info directory node (with `C-h i`) and search for "SICP".

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

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

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

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

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

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

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.

I have no idea why I started a lisp quest in my final uni year, but I felt the same when I found SICP.

ps: beside the very bad quality images, I'm still in love with the old layout.

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.

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.

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 )}; }) )};

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.

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.

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.

It's also the concept of the reader which differentiates lisps from languages which attempt the same thing with eval.

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?

Aight we're on the same page now. Yea it's all the same instructions under the hood anyway at some point.

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

Downloadable PDF version here:

https://github.com/sarabander/sicp-pdf/raw/master/sicp.pdf

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

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

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

See https://news.ycombinator.com/item?id=4860370 from 4 years ago, it's fantastic

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.

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

http://sarabander.github.io/sicp/html/2_002e2.xhtml#g_t2_002...

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.

Nice interactive, online explanation of SICP is under http://www.composingprograms.com/. Examples are in Python3

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?

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

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.

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.

You would like the "beautifulracket" site.

Anxiously awaiting an iPad Pro (the big 'un) refresh and a bit of time to save up so I can use it for reading PDFs.

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.

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

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.

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

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

It's a lisp dialect form the MIT called scheme. You can find more information here: https://www.gnu.org/software/mit-scheme/

I guess racket is where the development continues for the scheme language.

http://racket-lang.org/

There are a few: Gambit, Chicken-Scheme, Chez-Scheme, and Racket. Racket is starting to purposely diverge though like Pharo is to Smalltalk.

Racket has official support for R5RS and R6RS, and unofficial support for R7RS-S. So you can program in scheme in with the Racket environment too.

You also have GNU Guile, if you for whatever reason prefer the GNU stack.

https://www.gnu.org/software/guile/

You're in for a treat. Keep digging.

There is a package that you can use with Racket: 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/

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.

This is perfect, thanks. mit-scheme appears to be broken and unsupported on Windows.

Or run all from your browser (any code block is editable, CTRL-Enter to run):

https://xuanji.appspot.com/isicp

You can use Racket, they recently introduced a new language pragma (#lang sicp) that includes all necessary functions.

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

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

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

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

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.

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

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

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

Thanks!

https://en.wikipedia.org/wiki/Structure_and_Interpretation_o...

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.

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

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

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

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

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/

is there a beautiful epub version?

found it.

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

https://github.com/sarabander/sicp-epub/blob/master/sicp.epu...

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

Reply on news.ycombinator.com