HN Reader

I haven’t seen it in the comments yet, but you can watch Abelson and Sussman teaching the material from this book from recorded lectures in 1986.

I still find their description of how to create and group abstractions in various layers to be useful personally and as a mentor. (In the videos, lesson 3A, 1:07:55)

https://m.youtube.com/playlist?list=PLE18841CABEA24090

Just dropping in to say that The Elements of Programming Style is worth reading three times — and I have read it many more times than that, and benefitted from it. Here's my review (from 2010) if you're interested: https://reprog.wordpress.com/2010/03/06/programming-books-pa...

My favourite part of SICP and something that has stuck with me for years is the idea of "wishful programming". That is where you build something top-down by simply wishing you had the lower-level routines. Then, of course, you actually go and build those lower-level routines until you reach the bottom. I find this way of thinking works really well with test-driven development. Write a test against functionality you wish you had, then go and fulfill that wish. Most developers seem to build stuff bottom-up and then end up with something that isn't really what anyone wished for.

Next to SICP, I like the entire "The Little *" series as reading twice (or more) material. And Types and Programming languages. For applicable (in what I do anyway) CS. But not only reading though; implementing as well; I need to repeat these things otherwise I forget parts.

I myself, but probably because I knew and respect the guy, I reread the works of Dijkstra ever so often; books + papers. Not really applicable anymore, but good for the brain and he was a good writer (imho).

Curious to hear folks opinion on the newer Software Design for Flexibility: How to Avoid Programming Yourself into a Corner (https://www.amazon.com/gp/aw/d/0262045494)?

It’s interesting, SICP and other many other “classic” texts talk about designing programs, but these days I think the much more important skill is designing systems.

I don’t know if distributed systems is consider part of “Computer Science” but it is a much more common problem that I see needs to be solved.

I try to write systems in the simplest way possible and then use observability tools to figure out where the design is deficient and then maybe I will pull out a data structure or some other “computer sciency” thing to solve that problem. It turns out that big O notation and runtime complexity doesn’t matter the majority of the time and you can solve most problems with arrays and fast CPUs. And even when you have runtime problems you should profile the program to find the hot spots.

What computer science doesn’t teach you is how memory caching works in CPUs. Your fancy graph algorithm may have good runtime complexity but it completely hoses the CPU cache and you may have been able to go faster with an array with good cache usage.

The much more common problems I have is how to deal with fault tolerance, correctness in distributed locks and queues, and system scalability.

Maybe I am just biased because I have a computer/electrical engineering background.

The article has a broken link for the free copy:

https://mitp-content-server.mit.edu/books/content/sectbyfn/b...

https://web.mit.edu/6.001/6.037/sicp.pdf

I hadn't seen a blessed PDF version until today. Circa 2001, only the HTML version was freely available, and someone converted it to TeXinfo: https://www.neilvandyke.org/sicp-texi/

If anyone wants to work through SICP today, you can run the code in MIT Scheme, or in DrRacket: https://www.neilvandyke.org/racket/sicp/

SICP helped me understand early on that there were many models of programming, even though I'd learned a limited number in my undergraduate. It was one of the books that helped me feel equipped to read the docs of any language, library or framework and have some notion of how to orient myself.

I really wanted to like SICP but Lisp throws me off. I love Haskell and Standard ML however! Did others have a similar experience? Might be interesting to read a book similar in spirit to SICP but using a different language as a vehicle (No, I don't want to do SICP in JavaScript).

My second reading made me dig the footnotes and references, and there's a big world of beauty out there too. IIRC there's a paper where Sussman and some team made a custom design programmable processor to compute celestial bodies properties (trajectories). Mind bending as usual.

SICP is the best book to read as one's first book when studying computer science.

After many years of hobbyist programming (and consuming 'structured programming' books as well as languages from Pascal to Common LISP) we used Abelson & Sussmann at my undergraduate comp. sci. course, and it was eye-opening.

It demonstrates the simplicity, beauty and interactivity of Scheme while teaching you that computer science is the layering of different kinds of abstractions (from procedural abstraction and data abstraction, over defining your own (domain specific) language and implementing a compiler for it to defining new hardware in software). All of it seems so effortless, how only true masters can make things look like.

Make sure you buy the second edition, not the first or more recent ones, however (which use Python instead of Scheme - ugh).

I've been programming for 25 years and have owned the book for about 10 years. I just recently started to work through it and started with Dr. Racket.

There are things to love about Dr. Racket: hovering over a variable and visually seeing its connections to other places in the code is really cool. But ultimately I was a bit frustrated that it wasn't vs code.

So I stood up an configuration that let me use vs code (cursor actually) to work through the exercises. The LLM integration into cursor is cool as you can give it your code and whatever narrative you wrote and ask for feedback.

I am a tiny way through the exercises but having turned my code, the responses that I write, and the feedback that I get from the LLM into a static site.

It's been a fun way to spend a little time. For sure, I'm not getting the full benefit of working through SICP just with my own thoughts (without the aid of an LLM), but it's neat to see how you can integrate an LLM into the exercise.

Original version: https://mitp-content-server.mit.edu/books/content/sectbyfn/b...

Javascript version: https://sourceacademy.org/sicpjs/index

I don’t quite get the cult status of SICP. I read it and it’s a fine beginner programming book, but nothing more.

My twice reading list:

  - Godel, Escher, Bach - Hoffstadter
  - The Soul of a New Machine - Kidder
  - The Emperor's New Mind - Penrose
  - The Connection Machine - Hillis
  - Algorithmics - Harel

I’m working through it now, for someone with a computer engineering, EE or math background I think this is a great resource to get started with CS fundamentals.

Perfect book and if you don’t have a version - get it!

I picked up SICP expecting to read something really interesting or profound with the way it's been hyped up over the years however it's more of a how-to manual for working with Scheme/LISP and frankly that didn't interest me. Unfortunately most people have come to accept that LISP isn't a particularly effective way of programming even if some people get really excited by the idea of mutable and interchangeable data and code it's just not as powerful as they make it out to be and the obfuscation of program flow and execution and the lack of separation/delineation of data and code proves to be a hinderance more often than it is helpful. This doesn't discount LISP's contribution to computer science historically and how it's influenced modern day language design over the years, just that in my opinion LISP/SCHEME is more of a historical curiosity than a modern day guide to effective programming. (And certainly one that has no place as the introductory class at MIT). Anyway I've said something negative about SICP so prepare for this to be downvoted to the bottom :)

and CSAPP i think

SICP is available for free: https://web.mit.edu/6.001/6.037/sicp.pdf

If you want to get it elsewhere, the full info is: Structure and interpretation of computer programs by Hal Abelson and Jerry Sussman (MIT Press. 1984. ISBN 0-262-01077-1).

Programming Pearls is another book that rereads well. It's also short, too, which makes rereading it possible.

i'd also recommend "Concrete Abstractions: An Introduction to Computer Science using Scheme" by Max Hailperin, Barbara Keiser, Karl Knight.

http://www.gustavus.edu/+max/concrete-abstractions.html

I took cs61a at Berkeley as my very first computer science class I couldn't program I never tried to so scheme was my first language.

My ta told me that everybody should take the class twice when you first come in and when you're graduating.

When you first take it especially if you know other languages like C at the time you don't get the full depth of the problems you're given a great introduction and you think you understand everything but you don't realize the depth of complexity. Message passing the metacircular evaluator, continuations as the basis of all flow control, etc

You think they are neat tricks that you understand the curriculum because you can do the homework you don't understand how those neat tricks are really the basis of everything else you'll do.

When you're graduating you've had time to go through all your classes you realize just how foundation was principles are and you get so much more out of the book.

Well I didn't take the class a second time I need help grade and TA for a couple semesters.

I work as a quant developer and in trading now and even though my field has nothing to do with that I still think it's the basis of me as a developer.

There are some great books, and every book means something different to each person who reads it.

K&R influenced a generation of programmers.

Hennessy and Patterson influence a generation of architects.

etc. etc.

It's not just SICP.

But the greater point: a book can be meaningful, and we can always use more good ones.

> The computer revolution is a revolution in the way we think and in the way we express what we think. The essence of this change is the emergence of what might best be called procedural epistemology — the study of the structure of knowledge from an imperative point of view, as opposed to the more declarative point of view taken by classical mathematical subjects

Ironic, given the increasing use of functional programming in domains where old-fashioned imperative/OO programming used to reign alone.

I’m slowly making my way through it a second time and thoroughly enjoying it. The first time through it seemed quite abstract, albeit only because of my completely lack of real world programming. The second time through it a revelation as I now have a strong base of experience through which to understand it (experience which it also, informs!).

I am using Elixir’s Livebook to take notes and complete the exercises. It is very helpful to have a live notebook tool while reading it!

I've read DDIA twice and I plan to read it again when the new edition comes out. And I will probably read it every couple of years again too. I can't really think of any other book I feel so strongly about personally.

Always fun to see one of my professors from the quite tiny, but awesome computer science department at St Andrews on HN!

Hot take: SICP and SD4F "considered harmful (without counterpoint)"*.

Why? The modus operandi of problem solving in these books is object oriented programming masquerading as functional programming, and it is presented as a _neutral_ beginner book. It is _not neutral_. This is a very opinionated approach to programming.

To be fair, I do not believe the authors intended for this style of programming to be taken as gospel, but it is often presented _without counterpoint_.

The most powerful technique introduced -- implementing complex behavior via extensible polymorphic generics -- is virtually unmaintainable without a compiler-supported static type checker. You would know that if you ever tried to implement the code yourself in a dynamic language of your choice.

The ramifications of these choices can be felt far and wide and are largely unquestioned.

Ironically, they make code hard to understand, hard to extend, and hard to maintain. I need to reiterate, I do not believe the intention of the authors was to suggest these ideas should be used beyond a pedagogical setting, but they often are.

As a specific critique to SD4F, which states as a goal making code more resilient by emulating biology, I would point to Leslie Lamport's talk on logic vs biology[1].

I would add that I think SICP would be fine if it were taught in tandem with Paradigms of Artificial Intelligence Programming by Peter Norvig[2]. PAIP offers a completely different approach to solving problems, also using lisp. This approach is much closer to constructing a language to model a problem and then solving the problem symbolically using the language created. Areas that use OO techniques, such as the chapter in CLOS, are clearly marked as such.

In other words, I say "SICP considered harmful" because thrusting it upon an eager newcomer as a trusted neutral guide to beginner coding (without offering any counterpoint) could set them back by a decade, filling their head with "functional object oriented programming" concepts that don't translate well to industry or CS.

[*]: I say this as someone who has thoroughly studied both books, implemented the code, taken Dave Beazely courses to have the information spoon fed to me (dabeaz is awesome btw, take all his stuff) and used the techniques in production code bases.

[1]: https://lamport.azurewebsites.net/pubs/future-of-computing.p...

[2]: https://github.com/norvig/paip-lisp

> In fact, I’d go further and say that it’s the only computer science book of that age that I’d happily and usefully read again without it being just for historical interest: the content has barely aged at all. That’s not all that unusual for mathematics books, but it’s almost unheard of in computer science, where the ideas move so quickly and where much of what’s written about is ephemeral rather than foundational.

I recall that when MIT stopped teaching with SICP, one of the main claims was that programming now is often not about thinking abstractions through from first principles, and creating some isolated gem of composing definitions. Instead, we interact with and rely on a rich ecosystem of libraries and tools which often have individual quirks and discordant assumptions, and engineering then takes on a flavor of discovering and exploring the properties and limitations of those technologies.

I think now, (some) people also are at the point of not even directly learning about the limitations and capability of each tool in their toolbox, but leaning heavily on generative tools to suggest low-level tactics. I think this will lead to an even messier future, where library code which works on (possibly generated) unit tests will bear some fragile assumption which was never even realized in the head of the engineer that prompted for it, and will not only fail but will be incorporated in training data and generated in the future.

This is great, but it’s not what I get paid for. I’ve yet to work at a place where I thought, “If only I had read SICP, things would be easier.”

I work with distributed systems, writing business logic and dealing with infrastructure concerns. For me, learning about databases, quirks of distributed systems, and patterns for building fault-tolerant services is more important than reading the nth book on structuring programs, deciding which algorithm to use, or figuring out whether my algorithm has O(1) or O(n) complexity.

This doesn’t mean CS fundamentals aren’t important—they are—but I work in a different space. I’d get more value out of reading Designing Data-Intensive Applications than SICP. If I were in the business of building frameworks or databases, I’d probably be the target audience.

That and the art of computer programming

There are many layers and dimensions. As pointed out that these days systems design, integration and how to interface is more important (and in fact in older days as well not sure why it becomes these days as system analysis is a job higher than programmer usually, at least 3-4 decades ago).

We need someone knowing this, just like we need someone to run the nuclear plant we use. But we do not need much those but we need more how to use electricity. Hence unlike another post physics are not the key even if it is more foundational.

For personal growth, it might be still though.

But frankly lisp is such a non-multi-system language, it has a hard time to deal with external world by its nature. It can be done as lisp is really the god level programming language. But as said it is NOT used by the gods for a reason.

We need find a system level language to express ourselves so that we can stand in giants. We need giants but no need to be one.

Many classics are worth reading twice. Knuth, Tanenbaum, Stephens, PAIP, ...

I love SICP, but in industrial software I'd point to "The Mythical Man Month".

its watever

I considered reading SICP recently but this changed my mind:

> It's old and feels old. originally in scheme, they recently re released the book in JavaScript which is more approachable to today's audiences and there are still good things in there about encapsulation and building dsls. ymmv. Though the language and programming design concepts hold up, we're playing at higher levels of abstraction on more powerful machines and consequently the examples sometimes seem too tiny and simple.

I had studied economics in a similar way, but learning slightly old/outdated ideas demotivated me - I was much more interested in learning what works and what's considered the best way to do things, not what had been considered a good idea at some point in the past.

I don't want to be a downer on SICP (especially since I haven't even read it), but I hope this info might help others (or elicit a strong refutation).

TAOCP