10 ms·

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

• sharts 3y ago
  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.
• karakot 3y ago
  Concepts, Techniques, and Models of Computer Programming is also a great book.
  • billfruit 3y ago
    Perhaps even better than the the other two.
  • Al0neStar 3y ago
    This is a hardcore book.
  • iainctduncan 3y ago
    oh thanks, I don't know this one!
  • sn9 3y ago
    For those interested in working through all three, the order to do so would be HTDP -> SICP -> CTMCP.
    • nextos 3y ago
      HtDP is a great book, but probably too elementary for the average HN reader looking to begin with SICP.
      • sn9 3y ago
        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.
      • emptysongglass 3y ago
        The design approach to programming it teaches you will serve you for the rest of your career.
• LoganDark 3y ago
  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
• starside 3y ago
  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.
• bmitc 3y ago
  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 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.
  • scns 3y ago
    Second that recommendation. Kiczales is a great teacher, IMHO. https://en.wikipedia.org/wiki/Gregor_Kiczales?wprov=sfla1 https://en.wikipedia.org/wiki/Gregor_Kiczales?wprov=sfla1
    • bmitc 3y ago
      Yea, he is! And he helped write the book on CLOS and the metaobject protocol.
  • tobinfricke 3y ago
    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.
    • jstx1 3y ago
      Not necessarily as relevant, programming has changed a lot since SICP came out. Sussman says so himself - https://youtu.be/OgRFOjVzvm0 https://youtu.be/OgRFOjVzvm0
      • db48x 3y ago
        Did geometry become irrelevant once we stopped caring about field boundaries along the flooding river Nile?
        • joaogui1 3y ago
          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?"
• Buttons840 3y ago
  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.
  • rg111 3y ago
    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.
    • namaria 3y ago
      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.
• amackera 3y ago
  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!
  • f1shy 3y ago
    > 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.
  • cbm-vic-20 3y ago
    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.
  • nine_k 3y ago
    Somebody said: "I studied Lisp and Haskell to write better Python and Javascript"; I find it extremely applicable to my daily practice.
• webnrrd2k 3y ago
  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?
  • thatcherc 3y ago
    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.
• daggersandscars 3y ago
  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.
  • bmitc 3y ago
    Your only critique is that SICP is old. Computing power and performance are irrelevant to SICP.
    • f1shy 3y ago
      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.
      • 3y ago
• nelsontodd 3y ago
  I dont know about practicality but Ive read a good amount of SICP and find it very entertaining
• memco 3y ago
  There are versions of SICP adapted for Python like this one: https://www-inst.eecs.berkeley.edu/~cs61a/sp12/book/ https://www-inst.eecs.berkeley.edu/~cs61a/sp12/book/ and https://wizardforcel.gitbooks.io/sicp-in-python/content/ 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.
• brudgers 3y ago
  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.
  • JohnFen 3y ago
    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.
• jstx1 3y ago
  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.
• omnicognate 3y ago
  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/books_pres_0/6515/sicp.zip/index.html https://mitp-content-server.mit.edu/books/content/sectbyfn/b... HtDP = How to Design Programs: https://htdp.org/ https://htdp.org/ Sometimes I think gratuitous use of acronyms (initialisms for the pedants) has been the biggest impediment to learning throughout my career.
  • deleted 3y ago
    [deleted]
  • ASalazarMX 3y ago
    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).
    • JohnFen 3y ago
      > I think IT reached bottom when we started using numeronyms like L10n (localization) or K8s (Kubernetes). I agree. That practice is the worst.
    • mebble 3y ago
      indian news channels have entered the chat
  • diarrhea 3y ago
    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.
    • jonsen 3y ago
      3 min × n nor (number of readers)
• ParallelThread 3y ago
  What is HtDP?
  • tobinfricke 3y ago
    "How to Design Programs" (https://htdp.org/ https://htdp.org/)
• wk_end 3y ago
  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.
  • mario-main 3y ago
    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.
    • wk_end 3y ago
      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.
• Al0neStar 3y ago
  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 https://dcic-world.org/2023-02-21/index.html Do you have any examples you can share of GPT4 being degraded?
  • embeng4096 3y ago
    re: GPT4 degrading -- From this recent study: https://arxiv.org/pdf/2307.09009.pdf 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.
• brainzap 3y ago
  not worth
• f1shy 3y ago
  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.
• agomez314 3y ago
  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.
• rdelpret 3y ago
  Is there any concrete evidence that GPT-4 was lobotomized?
  • ShamelessC 3y ago
    (No)
• neilv 3y ago
  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.
• vjust 3y ago
  SICP is a beautiful book. The Youtube lectures are just as good.
• retrocryptid 3y ago
  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.
  • nickpsecurity 3y ago
    “Python is for scientists. Lisp is for engineers.” Then what does that make Hy language? https://hylang.org/ 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.
• miki123211 3y ago
  > 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?
• galkk 3y ago
  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 =)
• rsrsrs86 3y ago
  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.
• e12e 3y ago
  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 http://norvig.com/spell-correct.html Now dominated by notebooks, linked to from norvig.com: https://github.com/norvig/pytudes#pytudes-index-of-jupyter-ipython-notebooks https://github.com/norvig/pytudes#pytudes-index-of-jupyter-i...
• iainctduncan 3y ago
  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.
• iainctduncan 3y ago
  It is also worth reading the Little Schemer at the same time. That will teach you to be truly comfortable in a recursive style.
• beeburrt 3y ago
  Anyone read this one? https://cs.uwaterloo.ca/~plragde/flaneries/FICS/ https://cs.uwaterloo.ca/~plragde/flaneries/FICS/ Functional Introduction to Computer Science
• Agingcoder 3y ago
  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.
• pistolpete333 3y ago
  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
• shaunxcode 3y ago
  SICP is absolutely worth reading (and even working through in your language of choice!)
• noob_eng 3y ago
  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.
• cyrc 3y ago
  Consider having a look at Object-Oriented Software Construction by Bertrand Meyer https://bertrandmeyer.com/OOSC2/ https://bertrandmeyer.com/OOSC2/
• deleted 3y ago
  [deleted]
• philomath_mn 3y ago
  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.