Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: Is SICP/HtDP still worth reading in 2023? Any alternatives?
120 points by behnamoh on July 20, 2023 | hide | past | favorite | 98 comments
I'm a self-taught programmer but I recently realized I need to really understand how to write programs elegantly. GPT-4 was a huge motivation for this because whenever I asked it to rewrite the code like a professional Python programmer, it would come up with amazing things. But after GPT-4 became nerfed by OpenAI, I felt a void: how can I keep writing elegant programs? My answer is: I should learn how to do that myself.

SICP uses Scheme, which I don't mind. My main concern is that it's an old book. Are there ideas and concepts not discussed in the book which are crucial in today's programming landscape? Will I be better off reading a book that uses Python in the first place?




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.


This.

That was my journey as a self-taught programmer who at one point realized had to learn the timeless foundations.

And then MIT's 6.005 [1], where you will apply all this with a realistic language (Java, although the concepts carry to any language), and learn how to design, code and test programs that "have no bugs, are easy to understand and ready for change".

And also learn a bit about algorithms, I don't think that one can design and understand properly without. And what is O(2^n) today will still be that in 100 years. MIT's 6.006 is amazing, both professor and TA [2].

I've seen Knuth's TAOCP recommended around here. Don't even consider that, do a course like 6.006 first, the Everest shouldn't be the first mountain you climb. Likewise favour HtDP over SICP at first, I've been there.

If after all this you are still interested in LLMs, I recommend EdX's "Large Language Models: Application through Production" [3]

[1] https://ocw.mit.edu/courses/6-005-software-construction-spri...

[2] https://ocw.mit.edu/courses/6-006-introduction-to-algorithms...

[3] https://www.edx.org/course/large-language-models-application...


As if to prove your point, those video lectures are from 1986.

I took the course in 1999.

And yes the material is just as relevant today.


Not necessarily as relevant, programming has changed a lot since SICP came out. Sussman says so himself - https://youtu.be/OgRFOjVzvm0


I would wager that Sussman is being friendly and diplomatic towards his department here. I think the move away from SICP was primarily due to Sussman and Abelson tiring of teaching the course, which I believe Sussman says here or in another talk, changing tides in the landscape of universities and their relation to the job market, and a departmental political move. The move to Python was probably as much of a marketing choice and personal choice based upon leadership in the department than anything. There's an MIT professor, John Guttag, that wrote the Python book that they use and that's used in MIT's MITx and edX courses. I doubt he just wrote it and then the department just happened to later switch to Python and adopt the book.

I think Sussman's answer is more of an observation of the result of the switch and not an explanation why. MIT is a slave to fundraising, and I suspect the industry trends of programming languages, funding sources, job market, and other marketing and political decisions led to the change over anything actually technical.


Did geometry become irrelevant once we stopped caring about field boundaries along the flooding river Nile?


I think the real comparison is "has the proportion of the population that needs to know how to take care of farm animals gone down?"


I don’t really think so. If you decide to become a farmer, then care of farm animals may be very relevant to you. Similarly, if you decide to become a software engineer or computer scientist then SICP is very relevant to you.

Not everyone uses geometry every day, but engineers do. And we all depend on engineers, so the understanding of geometry is a fundamental underpinning of our entire society. The same can be said of computer science. We don’t all program for a living, but the structure and interpretation of computer programs (the literal structure and interpretation, not the book) is becoming an ever larger factor in how our society functions.


Second that recommendation. Kiczales is a great teacher, IMHO.

https://en.wikipedia.org/wiki/Gregor_Kiczales?wprov=sfla1


Yea, he is! And he helped write the book on CLOS and the metaobject protocol.


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.


> focus on the goal instead of a million tiny details.

This attitude is why my 16 core machine with 100Gb of ram feels about as fast as my Windows 95 machine felt 25 years ago. It's why software seems to scale with the computers that run it.

GP: Read SICP. even if you don't end up writing any Scheme, you'll be a better programmer for it.


Starting with hand planes, dovetail/carcass saws, and chisels... and then moving to a table/bandsaw, jointer, planer etc. IS the best way to learn woodworking. Diving into riving wood, green joinery, etc. brings you to the next level.

Power tools are accelerators, not fundamental tools. Your analogy of woodworking is excellent, but I believe you draw the wrong conclusion from it.


aside from the fact SICP now has a javascript edition, if you pick a book that focuses on whatever random modern javascript/python programming language you're not really studying anything like the material in SICP.

SICP is more like studying the actual composition of wood itself than it is about tools. this is still important whether youre using new or old tools.


And because javascript has real lambdas and lexical closures, you probably lose less studying SICP in JS than you would in e.g. Python.


Your only critique is that SICP is old. Computing power and performance are irrelevant to SICP.


Not only that. Now precisely because multicore is the only path to follow when we reach the end of the Moore’s law, we need more than ever functional programming. Is no coincidence that there are so much new languages that are trying to use those concepts, including a big revival of Lisp.


Functional programming doesn’t help with multicore. The real problem with multicore programming is data dependency, of which mutability is merely a special case. functional programming doesn’t help prevent you from depending on a certain computation and forming the bottleneck of your program.


There's a big revival of lisp?


Many ideas that come from lisp, and for which lisp was long ridiculed, are now mainstream, like garbage collection, closures, a big runtime, a huge library (nowadays lisp is criticised for its small library), typed data (instead of typed storage), exploratory development in an interpreter coupled with an optional compiler...

I don't consider languages with these features lisps, but I think the GP's statement is only quite mildly hyperbolic.


That's not a revival of lisp itself, just it's ideas becoming pulled into more mainstream languages. I wouldn't call Python having a REPL to be a lisp revival, but you can disagree.


Erlang and especially Elixir with macros are not too far off of Lisp and are two of the more popular functional languages.


Multicore is a continuation of Moore's law not its end.


This so much.


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.


At least it's not as annoying as military fans, who will write whole sentences of acronyms and euphemisms, glued with the minimum of words, as if it was some secret war transmission.

I think IT reached bottom when we started using numeronyms like L10n (localization) or K8s (Kubernetes).


> I think IT reached bottom when we started using numeronyms like L10n (localization) or K8s (Kubernetes).

I agree. That practice is the worst.


indian news channels have entered the chat


Yep. I avoid acronyms as much as possible for that reason. They are rarely worth it. An accumulated 20 seconds saved typing is not worth the eventual 3 minute hunt towards deciphering later on.


3 min × n nor (number of readers)


thank you

Acronyms and initialisms with no explanation are passive aggressive gatekeeping.


I'm not saying text should be full of acronyms/initialisms, but they serve a purpose of compressing the content. Maybe the chosen acronyms/initialisms don't work for you and that'd be a fair point.


In good writing you should ideally use the full name of the thing you're going to abbreviate with the acronym in parenthesis after the initial "expanded" version. e.g.

"My article is about How to Design Programs (HtDP)..."

Then later the article: "In the HtDP book it mentions...."

This makes life easier for those less familiar with the subject matter.


This is a technical forum, it's reasonable to expect readers who discuss a thread about a specific subject of interest to be familiar with the common vernacular and idioms related to that subject. If you can't understand the initialisms, maybe that's a sign that particular thread isn't for you, and that you likely have little of value to add.


This is a rather short sighted and somewhat gate keeping mentality. Acronyms are often contrived and separate from the common vernacular and idioms related to a subject matter.

As a software developer with a forty year career behind me I'm quite familiar with the "SICP" book. But for some reason my brain won't persist the connection between the full title and the SICP acronym when I bump into it. Yet somehow I can recall what each and every assembly language mnemonic means across a fairly broad range of micro and mini computer processors.

> maybe that's a sign that particular thread isn't for you, and that you likely have little of value to add.

Sure I may not have much to add, but the reason to read a thread, article or essay is to become familiar with the subject matter because it sounds interesting. Don't assume your reader is an expert in decoding your special and often made up acronyms.


I've read and understood them both but didn't recognize them from the initials. In another comment here, someone said

> TAoCP (er, Knuth's "The Art of Computer Programming")

I also would not have recognized TAoCP as referring to the Knuth book. Not all corners of the tech world commonly refer to tech books by their initials. That doesn't mean they have nothing useful to say about them.


I agree. This is another acronym I struggle to recognise when I see it despite being reasonably familiar with the first three volumes since my high school and college days back in the 80's.


I've read SICP cover to cover and completed every exercise, so I recognised that one. I had to look HtDP up.


Some things just become so well-known and ingrained in the culture (in certain circles) that writing them out fully feels excessively long, especially when mentioned several times in a conversation. Most software engineers do not expand abbreviations like RAM or GPU or RDBMS.

OTOH it's really important to spell them out at a right time, to help people not yet in the know understand them. So thank you!


Thank you for this. I was wondering.


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!


Likewise, TAoCP (er, Knuth's "The Art of Computer Programming") is even _older_ than SICP, and will definitely not help with writing better professional Python programs, but is steeped in first-principles goodness. Even so, I end up turning to it every once in a while; once while figuring out some tricky allocation code, and another to see if I could find a way to skip a few steps in a piece of code that needed to run in a tight loop.

It's certainly not required reading to be a successful programmer in the 21st century, but like SICP, it offers a different way of looking at things that may help influence some of your decisions on how to build something.


> but might not help you with the task of writing better professional Python programs

Let me disagree here: right now I’m doing mentoring with some python programmers where I work, they watch the videos, read the relevant part of the book, and we have a discussion together after each part. I hear constantly “oh yeah, I can apply that here or there”, “this streams concept is so good”, etc etc etc. I think it is most valuable if your background is “only” Algol family languages.


Somebody said: "I studied Lisp and Haskell to write better Python and Javascript"; I find it extremely applicable to my daily practice.


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.


This.

I wish I learned it earlier in my life. Before I realized what you said, I procrastinated on so many books and never started many I wanted to read.

After I realized this, I finished way more books, and learned many new things even when I didn't finish books. You don't need to finish books to learn new things that make you better.

Even you read four chapters of a book, you are still those four chapters wiser than yourself who hadn’t read those four chapters.


I agree wholeheartedly. Admittedly I am a bit compulsive about buying books. It's mostly focused on history and computer science. But once I realized the goal was not to read as many books as possible but to read as much of books as possible (especially compared to other sources like random blogs/news), a big weight lifted from my shoulders. I no longer feel bad about having many books I haven't/won't ever finish. But I have many sources on topics that interest me, and physical books are random access. I can always check the index or the chapter list and just read a bit on some topic that comes to mind. Invariably I end up expanding my world view a little bit.


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.


I agree. I'd also add that it's useful to skim through such books as well, maybe casually reading things here and there that catch your attention.


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.


“Python is for scientists. Lisp is for engineers.”

Then what does that make Hy language?

https://hylang.org/

Re Languages with lots of example code and LLM’s

With translators or things like Hy lang, one could get the LLM’s to solve your problem in Python before converting it to another form. Then, you just need a translator. If lacking one, it’s easy to translate by hand.

The practicality of this concept will probably vary by use case. My experiments had GPT doing sketching, implementations, boilerplate, and even porting Python to Rust. A legally-clear LLM trained on multiple languages could probably be fine-tuned to do Python to LISP conversions. If not, Hy might be a stepping stone, too.


Is there any evidence of anyone using Hylang (other than the community that invented it?)


It's funny that you asked that and then someone posted an app that's almost entirely Hy language. I'm just sharing it so you have one example:

https://github.com/atisharma/llama_farm/tree/main

The AI's have limited ability to either handle large documents or track conversations. This tool is an attempt to solve that problem. It works with OpenAI and open-source AI's.


Probably not. I mentioned it because it’s existing work that bridges the two. It also might spark HN users’ creativity about how they might do it differently.

For instance, I was exploring two ideas. One was how to turn Python into something with no dependencies, more powerful, and fast. I considered converting it to Lisp to use their compilers and macros. Another exploration was, like ShedSkin, converting it to C/C++ but without Python dependencies. It would be easier for me to generate code from Lisp syntax than Python syntax.

So, you know, just sharing tools that might get people’s minds going.


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

Well, Lisp is noted for its terse and succinct notation [1], so it makes sense that, LOC-for-LOC there is less of it around than Python.

________________

[1] I am told. I wouldn't know. I'm a Prolog programmer.


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?


re: GPT4 degrading --

From this recent study: https://arxiv.org/pdf/2307.09009.pdf

> For example, GPT-4 (March 2023) was very good at identifying prime numbers (accuracy 97.6%) but GPT-4 (June 2023) was very poor on these same questions (accuracy 2.4%).

There is more in the study but I just grabbed a short snippet as an example.


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?


I'm reading that right! It's cool. It's all Scheme, so get ready for that if you haven't seen it before. It's really interesting stuff though, all about how to make really extensible systems. I'm not sure how much I'll use the tools it talks about day to do, but it is really neat to have a much deeper understanding of things I often take for granted like pattern matching (regex) and generic dispatch and games solvers can be implemented from directly scratch.


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.


Would you recommend HtDP to a non-beginner? Like SICP, it seems to cover fairly basic concepts and aimed at first-year CS students.

I always feel like I'm missing out on some sort of magical programming secrets that will expand my mind like a spiritual retreat when I'm in these threads. But it's just CS 101 except you use Lisp? I don't get it.


HtDP isn't really mind-blowing the same way SICP can be. It basically just tries to give you a mental framework and tools for breaking problems down into simple, composable, testable pieces - in terms of the work you're doing it's CS 101, but it's a particularly good implementation of CS 101. There's "senior" engineers at my company that I think would benefit from reading and absorbing HtDP. But, if I'm being honest, yes, an experienced developer would likely find it tedious.

SICP's big mind-expanding thing is that it teaches CS 101 through the process of building, from within a computational system, an entirely new computational system - various kinds of programming languages and later even a machine and compiler. In this sense it kind of peels away a lot of the magic of how computers and programming languages work. For lots of CS students - and even professionals - who've never really thought about what makes their Python interpreter tick, that's a big discovery. It's also a real pedagogical feat.


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


For those interested in working through all three, the order to do so would be HTDP -> SICP -> CTMCP.


HtDP is a great book, but probably too elementary for the average HN reader looking to begin with SICP.


The OP mentioned SICP more because it's famous, but the core of their desire is to improve as a self-taught programmer, and I've heard from even experienced developers that the design recipe and systematic techniques taught in HTDP have benefited them, and they're more directly related to the problems OP described as wanting to solve.

Worst case, they find it too elementary and wasted a few weeks or months.


The design approach to programming it teaches you will serve you for the rest of your career.


This is a hardcore book.


Perhaps even better than the the other two.


oh thanks, I don't know this one!


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/


Anyone read this one?

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

Functional Introduction to Computer Science


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.


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?


(No)


What is HtDP?


"How to Design Programs" (https://htdp.org/)


not worth




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: