How to Design Programs

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.

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... (https://ocw.mit.edu/courses/6-005-software-construction-spring-2016/)…

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

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.

Second that recommendation. Kiczales is a great teacher, IMHO. https://en.wikipedia.org/wiki/Gregor_Kiczales?wprov=sfla1

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.

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.

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

Yes, big second from me. HTDP taught me how to how to work with through complex data structures/problems in a really clear and simple way.

How to Design Programs: https://htdp.org/ I already had a strong programming background in Java, C, JavaScript and PHP. I thought an introductory programming class at the Master’s level would be a waste of time. Going through rigorous program design in Racket was a mind expanding experience. I was amazed how much programming we did before reaching the assignment statement (set!) otherwise the first thing taught in typical introductory programming courses. The format of the class was a big part of the experience though: all assignments pair programmed and then presented to a panel by a randomly chosen member of the pair. A close second would be PLAI: https://www.plai.org/. As experienced through the Brown University online version of the Design and Implementation of Programming Languages: https://cs.brown.edu/courses/info/csci1730/ It gave me a very thorough and engaging grounding in the various programming language idioms and constructs and how they actually work.

Bjarne Stroustrup's Programming - Principles and Practice Using C++. Unparalleled combination of real-world pragmatism and rigor. Plus, since you learn C++, this book prepares you better than most for more advanced books/courses on compilers, operating systems, computer architecture Hon. mentions: HtDP and accompanying Simple Data and Complex Data courses on edX; Part I of Sedgewick & Wayne's Computer Science book and accompanying booksite and free Coursera course

1. SICP 2. How to Design Programs 3. Software Design for Flexibility: How to Avoid Programming Yourself Into a Corner

You don't really need much math for SICP. You can learn a few random pieces of math from SICP, and without background that will be harder and you might feel like you're missing out, but these are just examples; you can just trust the math works and focus on how they implement it in code, it's structure of the code they want to teach you about. And, it gets better, IIRC from chapter 2 there is much less math. What happens in the first chapter, is that SICP is exploring various control structures (and abstractions over them) before teaching any compound data structures at all. So all it has to work with is numbers. But as number theory teaches us, numbers actually have a rich internal structure, and SICP uses that to make "interesting" examples! (This aspect of SICP is one of the big critiques in the paper http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-h... (http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-htdp-vs-sicp-journal/paper.pdf) which explains the motivations beyond HtDP textbook. In particular, HtDP shows compound data structures first, and uses those to start with explicit methodology for data-directed design of code.…

How To Design Programs pursues a similar goal. Esp. 2nd edition has largely been rewritten and uses a more modern programming language. Maybe give it a try?

How to Design Programs. It helped make explicit the very concept of mental models.

Most notably, Blood Meridian. It had probably been more than fifteen years since I last reread it. What was unusual was that as soon as I reread it, I turned around and reread it again. [edit] Among programming books: How to Design Programs...I've got a print copy. There's a lot of sophistication and relevant experience behind its programming fundamentals content (e.g. tests and documentation before (2002) tests and documentation became the new black).

How to Design Programs 2E http://www.ccs.neu.edu/home/matthias/HtDP2e/ This book is much more than the intro to programming that it appears to be. It is a foundational approach for producing robust programs, regardless of your implementation language or level of experience.

SCIP should always be in the list as one of the best programming books ever written. Others are 'Simply Scheme: An introduction to computer science', simply scheme is an alternative to "How to design Programs", http://htdp.org/, both books are written for non-programmers but they provide a gentle introduction to many advanced topics covered in SCIP. I prefer "Simply Scheme". Another one is the "Little Schemer" http://www.amazon.com/The-Little-Schemer-4th-Edition/dp/0262... (http://www.amazon.com/The-Little-Schemer-4th-Edition/dp/0262560992).

Well thats an interesting question. Among the best is certainly "How to design Programs", http://htdp.org/ It's about Scheme. It does a better job than SICP I think, even though it still needs some endurance to get through. Generally, there are plenty of good books, you get some ideas usually by combining knowledge from different books... Even though this may sound a bit old-fashioned, simply in terms of quality and self-containedness, "The C Programming Language" by K&R is by far the best technical book I've read. You can certainly download it as PDF somewhere.

I'm attempting some self-taught coding (my degree is in history), and after much dithering, have started with How to Design Programs (htdp.org). SICP is beyond me at this point, and I wanted to get a good grounding in general concepts and good design before jumping into some other more (theoretically lucrative)language. HtDP is wonderful at what it does, and while perhaps a tad dry in writing style, it is, for me, a page turner in terms of engagement and presentation of new ideas.

Why not HTDP or SICP?

In addition to what others have said, I would add The Little Schemer to the list. It may not seem like the most practical book, but it will make you a better programmer. Beyond that, I would reiterate the following suggestions put forth by others: -- How to Design Programs (get version 2. Racket, the IDE for this book, is practically plug-and-play, so you won't waste time prepping your development environment) -- Think Python by Allen Downey (i haven't read this one, but it comes very highly recommended. the excerpts I've read show that Allen communicates the concepts very clearly) -- Eloquent Javascript (very good introduction, all examples can be done directly in the browser with the specially-made console. This eliminates the time and confusion you will experience trying to set up a development environment with other languages.) On top of those I'd also add: -- The C Programming Language by K&R (if you are interested in C) -- Dive into HTML5 (if you are interested in web development. HTML is a markup language, but you are going to need it to be able to build web stuff. This book complements Eloquent Javascript nicely) -- Land of Lisp…

You could try starting with "How to Design Programs" at http://htdp.org (or buy the dead tree version). That book has been very helpful for some people. The programming language environment used in HTDP can be downloaded from http://racket-lang.org. If you'd prefer Python, a real gem of a book is Core Python Programming by Westley Chun. Python btw, is an excellent choice for a first programming language.

SICP and HtDP are good for starting out. I often use Scheme when I teach compilers, and I've got a few Scheme-related blog posts designed for the curious student: * Church encodings: http://matt.might.net/articles/church-encodings-demo-in-sche... (http://matt.might.net/articles/church-encodings-demo-in-scheme/) * Macro-generating macros: http://matt.might.net/articles/implementation-of-scheme-vect... (http://matt.might.net/articles/implementation-of-scheme-vector-struct-in-syntax-rules/) * Programming with continuations: http://matt.might.net/articles/programming-with-continuation... (http://matt.might.net/articles/programming-with-continuations--exceptions-backtracking-search-threads-generators-coroutines/)

I would recommend you start with The Little Schemer and follow up with The Seasoned Schemer (the sequel to the other book). These two will give you a good feel for some aspects of Scheme programming, but they will not go into the same depth about the fundamentals of computer science you'll get from SICP. After reading them, then you should advance to either How To Design Programs as suggested before SICP or if you're feeling really ambitious jump right to SICP.

+1 for HtDP, after which the schemer series, followed by SICP. Also, read this: http://norvig.com/21-days.html

From my own personal experiences, try "How to Design Programs" (HTDP) by Felleisen et al as an introduction to Scheme. Its a great educational book which really prepares you for SICP. Also if you want to give Common Lisp a try, I'd highly recommend "Common Lisp: A Gentle Introduction to Symbolic Computation" by David S. Touretzky. Its an old book but well worth its price in gold. It is the simplest way to really get Common Lisp and its concepts.