Is SICP/HtDP still worth reading in 2023? Any alternatives?

The concepts in SICP are timeless. There's nothing to be lost going through that book.

There are video lectures you can use to accompany the book: https://youtube.com/playlist?list=PLE18841CABEA24090

Also, I highly recommend the courses How to Code: Simple Data amd How to Code: Complex Data on edX that are based on HtDP.

Background: SICP was the textbook for my undergrad intro to CS class, though I was already a self-taught programmer at the time.

SICP provided a different way of understanding programming. I enjoyed the class, did well, and became a big fan of Scheme for quite some time.

But the text was written for a different era, one dominated by C, PASCAL, and COBOL and when parallel programming was rare. In a time where almost all programming required working with low-level, basic programming constructs designed around the CPU's architecture, using Scheme to teach future non-academics was a great way to open their eyes to different ways of thinking about programming.

But it's close to the 40th anniversary of the first edition and past the 25th anniversary of the second. A four core CPU is low(er) end. Phones have 4+ cores. Even watches have dual-core CPUs. Ruby, Java, JavaScript, Python, Go, Rust, and a zillion frameworks are all available and widely used.

It wasn't possible to get performant Scheme on the hardware of the time. Now that we have the hardware, other languages have taken what Scheme could do and done it better.

Are the concepts useful? Certainly. But if your goal is to be a better programmer now, I'd pick a different book. If you're a Python programmer, pick a (modern, recent) Python book. If you're a JavaScript dev, then a (modern, recent) JS book.

If SICP was teaching woodworking, it would be the no power tools, start with a standing tree method. It's fascinating, it's neat, there are cool concepts to learn. But it's of little relevance, day-to-day, in a world filled with tools that let you focus on the goal instead of a million tiny details.

Since, astonishingly, neither full title is mentioned in the post or the comments:

SICP = Structure and Interpretation of Computer Programs: https://mitp-content-server.mit.edu/books/content/sectbyfn/b...

HtDP = How to Design Programs: https://htdp.org/

Sometimes I think gratuitous use of acronyms (initialisms for the pedants) has been the biggest impediment to learning throughout my career.

Try SICP at some point, no matter what else you learn.

HtDP is also worth taking a look at, and is much easier than SICP.

LLMs will mostly statistically plagiarize code. (Some people will rationalize "The tool generates the boilerplate, so that I can focus on the harder problems, because I am a mental giant who is above mere coding, and this is totally not open source code laundering", and then slap the code into a Git commit with their name on it, while making "cha-ching" cash register sounds.)

Instead of LLM, if you want to learn from other people's open source code, you can just read it in the original form (and not pretend you wrote it).

You can also practice writing your own code. Find things you want to do, and instead of using an LLM or Googling for something to copy&paste, work through the problem yourself, and build that understanding and mental machinery.

And when that starts getting routine, experiment with different approaches within the same language, as well as with different languages. You will add to your toolkit of approaches, and start to build up a feel for when they are appropriate, and various implications.

Advanced, once you have some basic programming skills: Start building things that have to work reliably and securely, have to be maintainable and evolvable at a good cadence, have to be done in the context of a team where everyone is working towards product success, etc.

SICP is an amazing book that will make you a better programmer, but might not help you with the task of writing better professional Python programs. If you aspire to understand computing systems from first-principles, there's no better resource that SICP. I've read it multiple times and I learn something new each time.

Do the exercises too!

SICP gets challenging in the very first chapter. You should aim to do about 1/3rd of the exercises, knowing that you can come back and do more later. The first chapter will certainly improve your ability to reason about recursive code. If you lose motivation later in the book (like I did), you will still have gained something.

There are versions of SICP adapted for Python like this one: https://www-inst.eecs.berkeley.edu/~cs61a/sp12/book/ and https://wizardforcel.gitbooks.io/sicp-in-python/content/.

I can't compare them to SICP, but if your only concern is the relevance of the examples then these may be worth looking into as a supplement or replacement for the original.

The best way to decide if a book is worth reading is to start reading it.

If it isn't stop and set it aside for later. Because your future self might be one of the people who thinks it is worth reading.

If it is, keep reading until it isn't. By "keep reading" I don't necessarily mean reading as if cramming for an exam. It's ok to read books slowly. Just as it is ok to not finish books (sufficiently slow reading is indistinguishable from not finishing a book). Good luck.

If you will go past first chapter, you will find wealth of knowledge, that is not programming language/api/backend/frontend specific. SICP is a book that is a bit hard to start.

This is a thing that I miss about C++ programming language, third edition by Stroustrup. The "Design using C++" section of about 100 pages in the end made me, at a time, better programmer. I do not read it now, though, to keep my good memories about it =)

Meh. Python is for scientists. Lisp is for engineers. Which is to say the languages were designed for different language design methodologies. In the old days of Lisp we didn't have large libraries of pre-existing functionality, so it was important for programmers to know how to construct complex functions from simple functions. But now we have python with its expansive partially documented standard and semi-standard libraries. You don't need to know how to rewrite that lump of functionality. You just need to know how to write small test programs that verify you understanding of how it's supposed to be used. And if you find you need to do something that's not supported, you just change what it is you're trying to do.

The flip side of this is that there's a large corpus of programs demonstrating idiomatic python. "There's only one way to do it," was a mantra I heard from Pythonistas in the 2000s. Maybe it's still a cultural value in that community. That would explain the large corpus (that and it being a popular language.)

I've yet to see a LLM spit out even half-way decent Lisp (CL, scheme or even e-lisp). My suspicion is the corpus of available code is small and its language features tend to generate less "boilerplate."

Having taught "practical lisp" in the 90s, SICP was frustrating because of its insistence on describing idiomatic Lisp in text, but with far fewer examples than comparative texts in other languages (k&r c or PASCAL User Manual and Report.)

There seems to be a tradition of this in Scheme and CL books. Where you could easily find books in the 80s entitled "${N} PROGRAMS IN BASIC" or some such, which were useful to provide a corpus of idiomatic code learners could use to build an intuitive understanding of the language. In the Lisp world no such books were available, and members of that community seemed to want learners to develop a wholly rational approach to learning.

So... if your purpose is to have a language that can be generated by ChatGPT, definitely pick Python. My experience with automated tools is they absolutely do not understand how to refactoring lisps effectively.

A great book by one of the auhors of HtDP is DCIC and it uses a programmimg language called Pyret and chapter 3 covers a transition from pyret to python.

https://dcic-world.org/2023-02-21/index.html

Do you have any examples you can share of GPT4 being degraded?

Working through the original SICP (including doing ALL of the exercises!) had the largest tangible positive effect on my ability to code as someone who has a CS degree. After finishing I felt much more confident as a programmer.

I’m mainly a TS/JS node and react dev and found much of what I learned from SICP translated into a deep understanding of both, especially with regards to higher order functions, closures, state management/hooks in react etc. The subtler aspects of coding (at least in JS/TS but also generally) all kind of just started to make sense.

Would definitely recommend

I haven't started it yet, but I have great expectations of ”Software Design for Flexibility: How to Avoid Programming Yourself into a Corner" by Hanson & Sussman.

Hopefully someone else can provide a review?

SICP is a great and mind-expanding book; but I came to it fairly late, at a time when (I think, I hope) I was already decent at "elegant" programming, so it's hard for me to say if it'd help you program elegantly. Probably, but I don't think that's one of its chief concerns.

On the other hand - HtDP is explicitly focused on teaching you patterns of thought that will help you create well-structured programs. It's also significantly easier, so I'd recommend it for your purposes full-throatedly.

Concepts, Techniques, and Models of Computer Programming is also a great book.

I think so. Let me ask you this, what changed that would make it irrelevant? There have not been any earth shattering advances in language design that make it obsolete.

It may not align with your ambitions as a programmer, but math and functional programming still apply.

I'll just add, that if you would like to read clean python (incidentally often about natural language processing) Norvig's work is well worth a look - explified by the essay on writing a spell-checker:

http://norvig.com/spell-correct.html

Now dominated by notebooks, linked to from norvig.com:

https://github.com/norvig/pytudes#pytudes-index-of-jupyter-i...

If you want to write professional python code, read python books and courses. Take algorithms and data structures courses. Take compiler courses if you so choose. Work hard to be the best you can at your work. If you are doing all this, feel free to glance over the first chapter or two of SICP, it's Calculus concepts and esoteric explanations will probably turn you off. If you're foolish enough to continue, don't, it will take over your precious time and learnings you could invest in the newest frameworks and LLMs, which make you into a more productive programmer anyway. If the first chapter of SICP is still echoing in your mind about "procedures as general method" and you daydream about opening and closing parenthesis, then it'll open up your mind to pleasures of programming you never new existed and stay with you forever. Your code could probably improve too, but in a tangential sort of way. SICP is the best programming book i've ever read, and one of the best of any kind.

there are a couple reasons to read those books, but the most important reason is simply to expand your wealth of knowledge. will you be writing scheme? probably not. will you benefit from knowing all the algorithms and practices that were used back when scheme was more common? almost definitely. because even if you don't use those algorithms and practices, they will surely inform your opinion of which algorithms and practices you do want to use.

i say this as someone who has not read either of those books and doesn't even know what the acronyms refer to: knowledge is good. it'll take you many years to re-learn the knowledge that is already written in those books if you don't read them.

there is a practical limit to how much knowledge you can just throw into your brain, but these surely must be some important and well-renowned books if you throw out the acronyms without clarification, so i doubt the ROI could possibly be negative

Edit: I’m essentially self taught as well, apart from one class about algorithms.

To a large extent, reading books about old tech is still interesting- you’ll just have a better appreciation of what you have now, how it came to be, and what was explored before. It will also show you a simpler version of what you have now, so easier to understand: reading the manual of the 6502 or i386 is not the same thing ( a single readable text file ) as the many manuals of the latest Intel CPUs, totaling thousands of pages !

I grew up reading manuals of old computers, old computer magazines, books about random tech ( from expert systems to system programming in pascal, prolog, etc ) because my father would buy random books. I’ve never regretted doing so, it just gave me a broader overview of what was possible.

In any case, sicp is great, just read it.

Going to stick my neck out here: I read a lot of technical books, have a masters in math and 10+ years professional experience but man that book was too much of a slog for me (only made it a few chapters).

It sure _seems_ like a no-brainer to read such a classic, but I wonder how many copies languish on the shelf without ever getting finished (same goes for The Art of Computer Programming).

Don't let this discourage you from giving it a shot, but also don't be discouraged if you aren't able to finish it. Just keep reading and challenging yourself as best you can -- a few years of that and you'll be miles ahead of 99% of devs out there.

Consider having a look at Object-Oriented Software Construction by Bertrand Meyer

https://bertrandmeyer.com/OOSC2/

If you are concerned with the core concepts of computing with Von Neumann-esque machines then SICP will certainly cover it.

Will it make you better at your job? No.

The only thing I walked away with after SICP in undergrad many years ago is how much utter bullshit and non-innovation there is tech with new hotness and frameworks all the time. They can all be reduced to SICP.

Anyone read this one?

https://cs.uwaterloo.ca/~plragde/flaneries/FICS/

Functional Introduction to Computer Science

SICP is the bomb. I wish I had picked it and Scheme up 15 years earlier. Literally mind expanding.

Sure lots of it is not as applicable now as it was, but it should absolutely be on your bookshelf in addition to more modern texts.

I spent most of my professional code slinging career doing Python, but IMHO it is critical to learn to read CS books in many languages. If you use any lexically scoped language, reading the chapter on environments and what happens when you go from pure functions to a language that sets variables is invaluable.

SICP is a beautiful book. The Youtube lectures are just as good.

I think it won’t ever hurt to know the topics in SICP. The interpreters and other components presented in the book will help the user navigate so many different problems, and the use of Scheme will instruct the reader in functional programming.

The presentation is very gradual and easy to follow (as far as any text in CS can be easy).

If you follow SICP in Racket, you will get know a language that can be used to do anything - Racket has a formidable library.

It is also worth reading the Little Schemer at the same time. That will teach you to be truly comfortable in a recursive style.

I dont know about practicality but Ive read a good amount of SICP and find it very entertaining

I'm not convinced that they're worth it for people who know how to program. If you want to write better Python at work, learn how to write better Python at work; don't waste your time on learning how to write a loop in scheme.

Yes.

HtDP more so. It builds a thinking and problem solving framework for your mind. That is recursive thinking based on the data structure.

Once you can think that way you can code in any programming language with its niche syntax or constructs.

If it is just as a gentle introduction to lisp, and you go ahead a little bit with “Practical Common Lisp” to learn CLOS, I think it will pay off every second you invest in studying it.

And that is just taking advantage of 1% of it.

> after GPT-4 became nerfed by OpenAI

Care to elaborate on this? I didn't have access until recently, is there really that much difference in performance?

SICP is absolutely worth reading (and even working through in your language of choice!)

Is there any concrete evidence that GPT-4 was lobotomized?

What is HtDP?

not worth