Structure and Interpretation of Computer Programs (1996) [pdf]

Alternatively, install MIT Scheme (*nix/macOS): https://www.gnu.org/software/mit-scheme/

Not a lot, given that Clojure semantics are very different from Lisp semantics.

I actually knew Clojure going into the course and it helped make Scheme easier to pick up, but I think to make the code exercises more straightforward, it's better to use Racket and #lang sicp as someone suggested.

Yes and no. Maybe use http://www.sicpdistilled.com/ as a guide.

I started with Clojure but ultimately ended up using scheme. Clojure has built in solutions to some of the things that you’re asked in exercises which I think takes away from the experience.

I’d suggest going with a scheme such as racket.

I think it makes sense to use whatever language you want, and the ideas in the book don't only apply to Scheme.

I've been working through the book in Javascript - https://github.com/ahuth/sicp/. Maybe I'm losing something by doing it in JS instead of Scheme, but I'm still learning a lot and having a ton of fun.

Wrote a little bit about SICP here: https://ahuth.github.io/articles/the-first-time-sicp-blew-my....

There's a case to be made for alternatives to MIT Scheme. A good example of this is the exercises where you might employ the OOP system that SICP describes like the constraint-solver or metacircular evaluator but realize that you could be much more productive if you had some kind of controlled method for generating similar piles of code from some base implementation, something which is found in the object systems like CLOS like GOOPS or ChrisH's SOS or even Emacs's EIEIO here [2].

There's no impediment to completing Chapters 1 & 2 in Clojure, but the first chapters are not what is called to mind by "Structure and Interpretation of Computer Programs" [1].

- Function redefinition is extremely useful required if you want to write your code in a linear fashion as intended. Clojure automatically sets up a major hindrance here.

- A few subchapters explore parallel computation, Clojure is likely to lead you astray here as you try to find directly corresponding functions and why exactly the authors are suggesting.

- Several chapters explore mutable lists in detail. Serious complaints have been made about the suitability of Racket here, where there exists no more of a barrier than that methods which operate on mutable lists are prefixed with a specially named qualifier. Clojure would be functionally impossible here.

- On the plus side, the "JIT" meta-evaluator will be a much more interesting challenge!

You'll notice that all of these issues can be worked around. However, SICP with exercises will take you about a year if you're a serious student.

[1] Huffman trees exercises excluded.

[2] Doing the whole thing in Emacs Lisp is potentially fantastic. I don't know if I can wholeheartedly recommend it, but I would be really pleased if someone wrote tests and built the metaevaluator, compiler and really went the whole nine yards here.

I listened to that episode recently. Really dig your podcast; always looking forward to new episodes. I really appreciate the semi-esoteric topics while staying lucid and engaging (I think I found the podcast while I was mucking about with idris). Keep it up!

Oh yes. Grad school is all reading. I recall reading these books in their entirety.

Security Engineering. Ross Anderson

The Formal Semantics of Programming Languages. Glynn Wynskell.

Communicating Sequential Processes. Tony Hoare. This book is surprising in its compactness and lucidity.

Pi Calculus. Robin Milner.

Semantics With Applications. Hanne Riis Nielson

On Concurrent Programming. Fred Schneider.

Specifying Systems with TLA+. Leslie Lamport.

Distributed Algorithms. Nancy Lynch.

Reliable Distributed Computing. Ken Birman and Robert Van Renesse.

I'm sure I'll recall more as soon as I hit "reply".

Thank you much. Sorry for the wall of text, but you got me going!

I had been living and working in California, and found myself at the crest of the dot-com wave of the late 90's and early '00s. But post-SICP, I _had_ to dig deeper.

I didn't feel prepared for the schools I wanted to apply to: Berkeley & Stanford. I am totally self-taught, and not having taken an exam in any CS subjects, the subject GRE was a huge mental barrier. So I applied to the Univ. of Cambridge in the UK.

That was a miscalculation. I was expecting to sit through a number of courses before figuring out what I wanted -- the US model -- but no, I was thrown into the deep-end right away, as an independent researcher. In my earlier life, I'd prided myself in knowing a whole lot of stuff just by building things in my own time (a TCP-IP stack from scratch, a Java compiler etc). But at Cambridge, I was told the "Dragon Book" (Compilers, by Aho, Ullman and Sethi) was so 1970's! I can't tell you how inadequate and how unprepared I felt.

In just the areas I was interested in (PL, concurrency, distributed systems), I was surrounded by researchers (at the cs dept and the microsoft research lab in the adjoining building) who _defined_ world-class. Robin Milner working on Distributed Pi Calculus, Tony Hoare on separation logic, Simon Peyton Jones on Haskell and type systems, Alan Mycroft, Jon Crowcroft advising the creation of the Raspberry Pi, Ian Pratt and Steven Hand on the Xen hypervisor, Peter Sewell on a rigorous (machine-checked) definition of systems and protocols.

But me, I didn't understand any of it, at least in the first year! I had never read a non-systems paper in my life; I didn't know the meaning of academic rigor. Those four years were the hardest of my life. Age was a factor. There was a distinct difference in stamina. Later I discovered that it was more fear that stymied my progress. I used to love math in my younger days, but I realized that lately, I was putting the more formal books back on the shelf "to get back to later". In contrast, Younger kids (and particularly the ultra-bright ones who land up at Cambridge) had no such fear at all because their formative math education had been top-notch.

On the other hand, my age served me well elsewhere. I had money, I was happily married (and still am, thank you!), so half my brain wasn't stuck on relationship issues. I didn't have to impress my peers with my ability to drink. I could travel freely to conferences on my own dime. I could quit any time (or so I told myself; I'd probably have regretted it if I had quit). It helped that we didn't have kids and that my wife was immensely supportive. There was another "mature" student also with the same background and outlook as me who'd sold his company for a few tens of millions (he was on the original Pentium design team!) and come in search of knowledge. He had two kids. He had a tougher time than I did not because of his family, because of the choice of his subject (quantum computing). But ultimately, he too has done well from himself.

Any how, I knew all along I would be very glad when the program ended, on two different axes. First, that the hard period was behind me. Second, that all this learning would fundamentally change me. I'm happy to say it did. I'm happy to report that I fared well -- my dissertation was nominated for a British Computer Society dissertation award. Privately, I felt I was trained just well enough to _start_ a PhD program. That imposter syndrome never left me! I have met many many PhDs who have felt that. I wish someone had counseled me on it.

I'll leave you with this. The amount I learnt makes my toes curl with pleasure. Then there's the meta-learning. When you spend so much time reading papers and rigorous arguments, you begin to have confidence in reading a paper completely beyond your ken, and getting to its essence. That's the real value.

Thank you. The PhD was full time. I am not a fan of part-time anything .. either you are doing two sub-par jobs, or you are busting a nut doing two full-time jobs.

In my earlier responses, I haven't credited my wife enough. It is one thing for me to take a chance, but it is altogether a different ball of wax for her to say we are in this adventure together.

What’s wrong with computer modern?

To each their own of course but I rather love that typeface

Computer Modern looks decent in print, which it was designed for (pick up any book by Knuth, not a modern book typeset with LaTeX). It looks less good on screen, partly because on-screen output barely existed at the time it was designed, and partly because what you've seen is probably not really Computer Modern: https://tex.stackexchange.com/a/361722/48

That's an interesting comparison. K&R did nothing for me, I honestly did not understand C until I read Harbison & Steele.

> it connects programming to larger and vital human endeavor

What endeavour exactly?

K&R still holds a place for me as one of my favorite programming books. It may not hold up today, especially not for new readers, but at a time when the alternatives were Pascal, Fortran, Basic and Assembly, the C Programming Language was an intoxicating blend of power and elegance. In addition to serving as an introduction to C, K&R was opinionated in a way that I hadn't seen from other programming books to that point, with as much emphasis on style as how to get things done. It's the Strunk and White of programming (or was at the time).

I agree SICP is better than HtDP, but CTM?

CTM is in many ways a SICP sequel, and equally ambitious.

Sussman is still teaching SICP through his Adventures in Advanced Symbolic Programming [1].

The Python course happened clearly due to politics and popular appeal. Sussman expressed his disappointment about it multiple times. Abelson did the same in the interview that's linked in this thread.

It is sad but a good example of how far the academic institution has fallen in this century. Ultimately it is the students that really lose out.

[1] https://groups.csail.mit.edu/mac/users/gjs/6.945/

The programming language itself is irrelevant. After you have learned the concepts sicp introduces you can learn any language much faster.

I feel these moves are part of a general move towards "industry ready" skills and away from fundamentals earlier and earlier in computer science programs (even prestigious ones). Whether that's a good or bad thing is a separate discussion from your opinions on SICP.

What's your personal experience with SICP? It sounds like you were a student in one of these courses ("we never used it again") but you also wrote "We never had any readings from SICP." so I'm not sure what you took and when. Did you work through SICP and still find it overrated?

Not sure about the video lectures, but I'm fairly certain the original course was taught to MIT undergrads as an intro to CS and EE. See https://people.eecs.berkeley.edu/~bh/sicp.html and https://mitpress.mit.edu/sites/default/files/sicp/course.htm....

I don't totally disagree with you btw. Pretty sure in that interview with Hal Abelson someone mentioned above, he admitted the book leaned a little heavily on calculus because all MIT freshmen had to take that course, so it seemed a natural source for examples. Perhaps not as natural to someone who hasn't taken a calculus course in a decade (me). I still got a lot out of the book though.

The second half of the book (Ch 4 & 5) I think are paramount to SICP, and arguably the apex of the book.

There's an interview of Abelson floating around where he is asked why there was so much calculus in the examples and exercises. His response was that it was written for students who had just finished multiple semesters of calculus, so it made sense to use it. He goes on to indicate they made a second version, handed out as class notes to students in art degrees where the calculus was all replaced.

I also think you are introducing functional programming the wrong way to beginners. It's best and most intuitive use imho is in a math class. For example this book: https://cs.wheaton.edu/~tvandrun/dmfp/ has little prereqs, and will teach the reader both programming and math regardless of educational background. It really, really shines when it comes to learning counter-intuitive things like cardinality. I'm not the only person who thinks so either, here is one of the curriculum designers of Bootstrap, a US highschool programming curriculum, explaining how naturally that style of programming fits with algebra classes. https://www.janestreet.com/tech-talks/curriculumn-design/

Oh, boy, you should really finish reading the book! The second half is amazing. I just looked through the table of contents and almost all the things I remembered most fondly are in chapters 3, 4 and 5. It's all about understanding computing paradigms and related concepts by implementing them. It does circuits, object-oriented programming languages, dataflow languages, logic programming, register machines, garbage collection, compilers, etc.

Throughout the authors have very good taste in choosing the level of detail and realism in which to implement things to let you quickly get at the core ideas without getting bogged down in technical points.

As for the first half only being fit for fortran-programming engineering students, I remember that very differently. I only remember a few examples as requiring calculus, say Newton's method, some numeric integration procedures, symbolic differentiation, power series implemented as lazy lists of coefficients, maybe one or two more. And other than the power series, I don't remember any of those examples as requiring more than just high school calculus ---which makes sense, because I think the course is meant for college freshmen, which will have only completed high school calculus, and probably are taking a more advanced calculus class concurrently.

Although judging from my own undergraduate students it is probably best not to assume most students remember calculus from high school. Plus, I understand there are countries, such as the US, where calculus isn't even compulsory in high school! So maybe removing those few calculus examples would make the book seem friendlier and shorten it by 10 pages or so.

The first half of the book is basically just warm-up material to set the scene. Chapters 4 and 5 are what make it truly special.

The pure-math focus is what made it a slog for me to get through, though I'm clearly not the intended audience. I was 20+ years out of college when I first read it and it had been over a decade since the last time I'd had any reason to think at all about many of the areas of math it takes as a given that the reader knows like the back of their hand. To be fair, I would have been more comfortable with the examples if I'd read the book in my first year of college, with high-school calculus still fresh in my mind. But as it was, I spent way more time reading Wikipedia pages about the math concepts in the examples than I spent thinking about the concepts the book was trying to use those examples to illuminate.

It was worth the read. I just think with a wider variety of examples, I could have gotten the exact same benefit with far less extraneous effort.

This is not true. I've watched conversations on this over the years on HN, and inevitably you get a few people saying the math is nothing to worry about, and then a bunch of people saying they had to give up because they didn't have the math background (oftentimes these are professional programmers).

My recollection from the bit of time I spent with it was that most of the examples were drawn from mathematics, often times relying on implicit bits of knowledge that would lose a reader unless they'd had long interest/experience in math.

I think the issue in divided opinions here is a matter of lost perception of the range of math knowledge: I've noticed this same communication difficulty when playing new people at Go and they ask whether I'm good or not. I never really know how to reply because on an absolute scale I'm an abysmal player—but against anyone who's never really studied the game I'll appear incredibly skilled.

When people answer that SICP requires very little math background, I think that's an accurate phrasing relative to a more global scale of math knowledge. But in the realm of folks with no particular interest in math, it requires a relatively sophisticated knowledge of mathematics.

If a high-schooler is training for math olympiads or they're on track to study math/CS/etc. at a top-tier university, they'll probably be fine. All the others will likely be completely lost.

Here's another example from today's thread: https://news.ycombinator.com/item?id=21301474

:)

Thanks, did a quick glance, looks great. Might be perfect for my needs.

Amusingly, the author of that book (Brian Harvey) was my professor for my first CS class, in 1996, where we used this very edition of SCIP.

Thanks. How do SICP and HDP compare?

I did a quick glance and HDP seems to use DrRacket, but is the material comparable, with HDP just more appropriate for beginners??

Last I looked in Europe the price is more like $65, about the same as a Raspberry Pi 4 with 4GB of RAM.

I know technical books are expensive and the book has 688 pages but it seems expensive.

If somebody wants to ship their used SICP book in Romania I would love to take it. It's on my wish list since forever.