Structure and Interpretation of Computer Programs

A lot will depend on where you are in your maturity as a programmer. And what sort of work you want to do. I've always done well following Don Lancaster's advice: Hit the basics, HARD. Most modern software "innovations" are really just a restatement of David Parnas' paper from 1971. He suggested programs should be split up so that the data used by modules can't be affected by the other modules. "Data hiding." Once you get a grounding in the history and literature of programming (which all other professions do without thinking), you'll start to see the "sameness" among all the supposed difference. Once you see the "sameness", you'll know what is truly important to know/master, and what is not. As a recent grad, I'll tell you that the first thing I learned was to ignore all the "software engineering" stuff that schools teach. The reality is that I would be asked, "Build a tool to do X". So I'd start through the process, building a design and the data flows, starting to build the code. Then I'd get "It also has to do Y." And I'd have to throw away most of what was written. Eventually, I learned the two rules Ken Thompson taught:…

SICP

I just get into flow state when working in lisp, more than any other language family. Running and writing code blended together with a connected REPL is like being jacked into the machine. Imaging how much of an improvement a connected debugger is over reading through logs. This is that much of an improvement over a connected debugger. The code is live running right in the editor all the time. More like magic than debugging. And then macros, both anaphoric and hygenic, that let you write your own language inside the lisp itself. They should be used extremely sparingly, but when used at the right time it can literally change the language itself to better suit your need. And then the code itself being a data structure, it all feels so connected, integrated, and unified. I have never had as much fun as I do when working in Lisps. I haven't done it for money in a while, but maybe one day again. Let Over Lambda and SICP are what really got me turned into a lifetime lisp lover. By the end of LoL you make a version of Forth inside of lisp! https://letoverlambda.com/

Wow, this is interesting, very few books I've read more than once! Even fewer are non fiction, but they sure do explain a lot about me: - Complex PTSD: From Surviving to Thriving by Pete Walker helped me process a number of assaults that happened to me as a child - Designing Data Intensive Applications by Martin Kleppmann helped me understand intuitively how databases work and how to use eventual consistency to handle workloads - The Highly Sensitive Person: How To Thrive when the World Overwhelms You by Elaine Aron this helped me process my and my families neurodivergence. - Structure And Interpretation of Computer Programs by Ableson and Sussman. Great book, it's how I learned to love Lisp. I felt like I grew 10x in skill from completing all the homework. - Starting Strength: Basic Barbell Training by Mark Rippetoe. This is the book that got me into powerlifting as a regular part of my fitness. I used this to heal my back, neck, and wrist pain. Changed my life. - Color and Light: A Guide for the Realist Painter by James Gurney. The GOAT of plein air painting himself teaches so much about how light works on complex forms. I've dog-eared this book.…

cannot recommend sicp enough: https://mitp-content-server.mit.edu/books/content/sectbyfn/b... (https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book.html) uses scheme to illustrate how to think about computation abstractly.

The Road to Wigan Pier - Orwell Antifragile - Taleb What is Life? - Schrodinger Structure and Interpretations of Computer Programs - Abelson

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.

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.

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/)…

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

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

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.

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.

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.

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

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 =)

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

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

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

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.

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.

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.

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

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.

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

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

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.

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

K&R (yes, it's outdated now, but it is still a fine model for how to write a clear and concise textbook). SICP. Computer Graphics: Principles and Practice by Foley and van Dam (plus a bunch more authors now).

SICP (Structure and Interpretation of Computer Programs) https://web.mit.edu/6.001/6.037/sicp.pdf

Here is a secret which you might find reassuring :-) Most people (including myself) don't do exercises. Merely doing exercises is overrated. What one needs to do is Read a book, follow closely any worked out examples and try and get at the essence of things; Everything else is secondary. For example when i first read SICP years ago, i was working on Protocol State Machines and was stuck (at work) on how to design a verification framework for the same which our clients needed to satisfy themselves that our implementation worked correctly as the official specifications laid out. SICP gave me enough knowledge to understand the problem and the enthusiasm to design a simple DSL to solve the same. Thus by reading it and without doing a single exercise (nor learning Scheme well) i had a huge ROI on my Time invested in reading that book. So have confidence in yourself, and read anything and everything that you find interesting without beating up yourself over not doing it "properly". The point is to get exposed to new concepts/ideas and gain new perspectives/insights on already known knowledge.

Depends on what the journey looks like. If you're dead set on becoming a software developer it's a great and solid introduction to programming and computing. But if you're not, I'd recommend resources targeting more popular and lower friction languages than scheme such as JavaScript. I've read it after 5 years of professional experience and it was a very good read.

- The Way of The Superior Man. The only "self help" book I give any credit. It really boils down to encouraging people to have a purpose in life and accept ourselves. - The Stupidity Paradox. Ever feel the world works in a "stupid" way? That your organization keeps promoting stupid ideas? Read this book and get into the roots of functional stupidity. It's a bit repetitive, but extremely insightful book. - Structure and Interpretation of Computer Programs. The book I most recommend for any software professional.

Maybe Structure and Interpretation of Computer Programs (SICP)?

Neuromancer Snow Crash Blindsight (Just some fun fiction to bolster one's passion for their chosen profession. Obviously TAOCP, SICP, K&R, and other books in their ranks are better answers.)

Computer science: Knuth's TAOCP. And Sipser's Introduction to the Theory of Computation. Programming: SICP, K&R, and Stroustrup. Siebel's Practical common lisp. Artificial intelligence: AI a modern approach. Signals and Systems: Oppenheim's book Probability and statistics: Probability Theory: The Logic of Science by Jaynes

A few open books scattered through the house: Billion Dollar Spy, Hoffman (I’m kind of obsessed with Cold War espionage) SICP, JS edition (great read, I do a lot of JS work and I’ve learned a lot, despite time spent studying the language itself, and I’m still in the first chapter) Topoi, Goldblatt (tough read, but Category Theory calls to me) The Order of Time, Rovelli (his work is the clearest explication I’ve yet encountered of how QM might really be) Helgoland, Rovelli (ibid)

Great question, I'm definitely going to check out some of the other books here. For me: 1. Structure and Interpretation of Computer Programs. It's a very challenging book (currently 2 years into reading it with a couple of friends), but really helps demystify the different layers of the stack. 2. Coders at Work. Really interesting to hear how they think about programming (and their differing opinions from each other). I found the audiobook really good

- The Little Schemer - The Algorithm Design Manual - Structure and Interpretation of Computer Programs - Elements of Computing Systems (nand2tetris book)

No matter how long you've been a programmer, you're always looking for new ways to hone your craft and learn new techniques. One of the best ways to do that is by reading books on programming—as in, books that are actually about programming. Here's our list of 10 of the best. 1. Code: The Hidden Language of Computer Hardware and Software 2. Clean Code: A Handbook of Agile Software Craftsmanship 3. Refactoring: Improving the Design of Existing Code 4. The Pragmatic Programmer: From Journeyman to Master 5. Don't Make Me Think, Revisited: A Common Sense Approach to Web Usability 6. The Mythical Man-Month: Essays on Software Engineering 7. Structure and Interpretation of Computer Programs 8. Introduction to Algorithms (The MIT Press) 9. Programming Pearls (2nd Edition) 10. The Art of Computer Programming

* The Art of Unix Programming * Code Reading: The Open Source Perspective * SICP

I agree with you. They assume the level of math of an MIT freshman. And the level of computer experience of a modern 11 year old. So sometimes they lean on the math in situations where a professor today might explain something in terms of a computer. Take a step back and try to understand the concepts that they are explaining, even if your math is a little rusty. I love SICP, it really make functional programming click for me. The other book I recommend in this space is Advanced R.

There are few books with more eureka moments. Mine was discovering functional closures and object instances are two sides of the same coin.

SICP for CS and programming. That book (and its exercises) really instilled in me the thought patterns that drastically improved my programming skills and made me realize how important fundamental CS knowledge is to being a good programmer. What I learned from that book was: becoming comfortable with recursion, realizing the importance of abstractions, functional programming concepts and it gave me insights into how interpreters and the machine work. I studied math in university and the book that really improved me mathematically was baby rudin. I really struggled with this the first time I worked through it and had to also fall back on Abott's analysis book, but after my first analysis course I worked through Rudin again and it just clicked. The exercises are really well chosen and the text is just so on point. Every sentence in the book is extremely carefully chosen and of fundamental importance to what Rudin wants to teach you. It's really rare that you find textbooks that almost kind of have a certain magic to them, like you are directly taught by one of the greatest minds in that field. These two books definitely meet that criteria.

SICP. I only read a little, but that little bit was enough for something to really click for me. When I dropped it, I felt like "Before, I knew some syntax, but now I actually understand how to put a program together". Also, this is kind of cheating since I went through the "Nand 2 Tetris" video course, but there is a book that goes along with it, "The Elements of Computing Systems". The course really drove home for me the power of simple, well-designed layers in building complex systems, since the end goal of building a CPU from scratch sounded impossibly intimidating at the start but by the end I was comfortable in explaining every detail. I think it counts since the book covers the same material.

I also enjoyed it, but I read it probably a bit late in my career. I remember reading some parts and thinking "wow, if someone had explained this to me like that when I was learning". But then, I'm not completely sure what would have been my experience if SICP was my first contact with CS. I started with GWBASIC, then COBOL, then C; 1st edition already existed by then, so I could have learned with Scheme!

I would not recommend a single book for everyone to read, because people have different tastes and interests - and even if you recommend a single book based on people's interests - if they are really interested in that and the book is important to that interest it's likely they've already read it. So probably a recommendation on any field should be made based on calculations both of how essential it is, but also how it's reading may change assumptions about the field if the person has not read it. It seems somewhat arrogant. And in the end it's annoying to get recommended a book one considers essential to the field, as it implies one does not know what one knows. All that said - for the field of: Fantasy - Gormenghast America - Democracy in America Programming - Structure and Interpretation of Computer Programs

CLRS does about 5 pages on linked lists. If you want more, my advice would be to implement one in your language of choice, then look at the API for the standard lib impl of a linked list in your language of choice (if there is one). Otherwise, for more reading on linked lists, read through adlist.c from redis, by antirez. Next, one of the best books (IMO) on algorithmic thinking is SICP. Get through a few chapters, do the exercises, grok recursion, etc. In no particular order: Algorithm Design Manual, Skiena Algorithm Design, by Kleinberg/Tardos Algorithms, Sedgwick 4th ed. (also Algorithms in C) If you find you need or would like more math: Discrete Mathematics (Epp is an easier read, Rosen seems more verbose) Mathematical Proofs, Charrand For interview prep: Elements of Programming Interviews (EPI) Designing Data Intensive Applications

SICP is a fantastic and difficult book. I got through about 50% and have a much bigger appreciation for programming now. FYI - The original was written in Scheme. There is a newer version based in python which I haven't tried. Edit: The python version is highly contested. Scheme is the more difficult and therefore the best way to understand these principles.

For me it's boring old SICP. It's just that good.

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

* Getting Things Done by David Allen This book taught me so much about how to manage my life, and taught me how to review my own systems. * SICP, On Lisp, and Let over Lambda It's hard to pick one exactly, because really it's about opening your mind to radically different programming paradigms than what's popular. Learning lisp well enough gives you confidence to attempt to create new programming languages, through code generation, or even mentally thinking about an API as a language rather than just a series of functions.

Gini is a legend. We were all lucky to get her and SICP.

The course: Object Oriented Programming at the University of Minnesota The book: Structure and Interpretation of Computer Programs This was back in the early 90s, we learned OO with Scheme. SICP is where I credit my programming ability even today. I think that if I'd taken OO via C++ my eyes wouldn't have opened like they did with Scheme and SICP. I was, at the time, programming products in C++ for my father's software company while taking classes and I remember a student ask the professor (Dr. Maria Gini, an amazing instructor) why we were learning OO with a dead language instead of a language we'd actually use like C++. And I remember thinking to myself "I'd like to learn something other than C++ anyway". Dr. Gini simply said "because this is how I choose to teach the subject." (something like that). It was an amazing experience, definitely one of my top 3 classes taken at University.

SICP takes _ages_. I'm working through it myself but have realised it's going to be a background project for the next year or so. No idea how MIT freshman do it so quickly!

Structure and Interpretation of Computer Programs (SICP)

I only ever read the first 2 chapters of SICP but always intended to go back, I just need something a bit lighter during lockdown.

If you are interested in the computer science in general I highly recommend: 1. Structure and Interpretation of Computer Programs (available for free, e.g. here http://sarabander.github.io/sicp/html/index.xhtml 2. https://computationbook.com/ Also, I haven't read it yet, but this book has been praised here a lot recently: https://www.amazon.com/Designing-Data-Intensive-Applications... (https://www.amazon.com/Designing-Data-Intensive-Applications-Reliable-Maintainable/dp/1449373321)

I appreciated getting from maths to CS with Structure and Interpretation of Computer Programs: https://mitpress.mit.edu/sites/default/files/sicp/full-text/... (https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html)

The entire book Structure and Intrerpretation of Computer Programs is like that. It explains how to implement the language Scheme in any language (by decomposing the problem to small enough atomic entities you can implement and combine them in any language). I suppose it’s excellent practice since the book uses only Scheme, so the reader must implement the primitives of the interpreter themselves. So you need to figure out how to implement tiny things yourself (which is fun) and then goes on to show how those combine together into a wonderfull whole.

Structure and Interpretation of Computer Programs, where the reader implements a Lisp

Best business books: -Secrets of Sandhill Road -Hackers and Painters -The Great CEO within -Venture Deals -Predictable Revenue -Zero to One -The Hard Thing About Hard Things -Lean customer development -Lost and founder -Lean B2B -From Impossible to Inevitable -Traction Best computer science books: -Competitive programming 3 -Structure and interpretation of computer programs Best for fun (non-fiction): -Meditations -Sapiens -How to win friends and influence people -A brief history of time -Self-reliance -Frente a la estrella polar

Structure and Interpretation of Computer Programs [1] [1]: https://mitpress.mit.edu/sites/default/files/sicp/index.html

For me a fun book has to be clearly written and present new (for me) ideas in a somewhat aesthetic way. Density I suppose is secondary. SICP is one of the best examples of the right balance, also Elements of Computing Systems.

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

The Art of Computer Programming Structure and Interpretation of Computer Programs Purely Functional Data Structures Programming in the 1990s A Logical Approach to Discrete Math

Structure and Interpretation of Computer Programs is frequently recommended here. I would especially recommend understanding section 3.2, which I've found very helpful for understanding the environment model of other languages. Computer Systems: A Programmer's Perspective has a lot of good explanations of hardware/os subsystems that can be hard to find detailed explanations of elsewhere. I especially like the sections on virtual memory.

For CS theory, I would rather suggest you to focus on classic CS courses, here's my list: 0. Do not touch "Introduction to Algorithms" until you are in a dream job. 1. CS 61A: The Structure and Interpretation of Computer Programs https://cs61a.org/ 2. CS61B: Data Structures http://datastructur.es/sp16/ 3. Coursera: Princeton Algorithm https://coursera.org/learn/algorithms-part1 4. CMU 15213 CSAPP https://courses.cs.washington.edu/courses/cse351/16sp/videos... (https://courses.cs.washington.edu/courses/cse351/16sp/videos.html) 5. Keep moving.

Structure and interpretation of computer programs (free online) https://en.wikipedia.org/wiki/Structure_and_Interpretation_o... (https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)

Probably not able to completed during a single 3 months unless you do it full time, but I picked up a copy of SICP [0] and started reading through and working through every-single-problem. I got stuck so far on one problem in the first chapter toward the end at the moment. I will say, Scheme is fun! The problems can be challenging, short, and very rewarding. However, maybe I'm not very smart and feel like I might have a very hard time with it. I'm not that great at math I don't think, nor do I consider myself genius like. Did people who go through this book do every single problem and figure it out themselves? There are a lot more problems then I expected. They are also, so far, some to be quite challenging and math heavy. It does really feel like it helps get my brain thinking differently about a lot of problems and I love it! But it also feels like I might start grinding a lot and burn out on it. Any tips or help or suggestions how to get through it successfully, get a good amount of education out of, and continue to be excited to keep moving forward? [0] https://www.amazon.com/dp/0262510871 I know it's free online, but I wanted a physical edition.

I am amazed by "Structure and Interpretation of Computer Programs". Unbelievably good on the technical side and all around a nice introduction to programming, highly recommended

Please don't... every time a thread like this shows up on HN, I end up impulsively buying some of the recommended books. I'm usually very happy about the purchase, though. :). Humor aside; not sure if favourite of all times, but definitely impacted my thinking a lot: - "Rationality: From AI to Zombies" - https://intelligence.org/rationality-ai-zombies/ - read this when it was still a bunch of posts by 'Eliezer on LessWrong. It cleaned up my thinking quite a bit, and introduced to couple new ideas from economics, sociology and epistemology. - SICP, obviously. - "How to Win Friends and Influence People", and "How to Stop Worrying and Start Living" - from the father of the whole genre of self-help/personal development, and one whose books are still probably the only good ones in this genre, Dale Carnegie. They explain exactly what it says in their titles.

Don't know about changing my life, but these books changed the way i look at things: The Tao of Pooh: Benjamin Hoff Slaughterhouse-Five, or The Children's Crusade by Kurt Vonnegut TI 99/4a basic reference manual Structure and Interpretation of Computer Programs, by Abelson, Sussman Object Oriented Analysis and Design by Grady Booch Darkness at Noon by Arthur Koestler Thieves in the Night by Arthur Koestler All the King's Men by Robert Penn Warren The Good Earth by Pearl S. Buck The Little Prince, Antoine de Saint-Exupéry. War and Peace by L.N.Tolstoy Chapaev and the void by Pelevin

Structure And Interpretation Of Computer Programs.

This is the most influential book I have read in my SE career. It's not a LISP book. It's a book about programming fundamentals. E.g. Objects are covered as well. They even build a register machine at the end. I think a translation to a more modern language (lua!) would boost adoption quite a bit.

Structure and Interpretation of Computer Programs: https://mitpress.mit.edu/sicp

Code Complete. I found Code Complete to be as eye opening for day to day work as SICP is while learning in University.

- Structure and interpretation of computer programs More by nostalgia than by need - The art of computer programmming - Hacker's delight These two are of great help when doing programming challenges. Hacker's delight is about bitwise tricks. - Open Data Structures Useful for a quick refresh on data structures.

SICP, the foundation on which my career rests.

If anyone is interested in SICP, I strongly recommend finding videos of the lectures (which are free online) and watching those, then going back to the book for reference and exercises. I found the SICP book very hard work until I discovered the actual lectures that it is meant to support.

Structure and Interpretation of Computer Programs (SICP) by Abelson, Sussman, and Sussman. Full text is available here: https://mitpress.mit.edu/sicp/full-text/book/book.html (or PDF at https://github.com/sarabander/sicp-pdf). It is IMHO the most important book on programming and programming languages ever published.

yes, no need to buy it. and you are right, the value lies in the exercises. I started doing them in Clojure. I recommend doing as many as you can and then you'll find plenty of solutions online to compare your results. It's worth it

SICP is online for free (legally) from MIT's website, or there are some community version with cleaner layout. See: https://news.ycombinator.com/item?id=13918465 I've only worked through Chapter 1. The text is interesting, but most of my learning has come from the exercises. You should plan to do the exercises. Also, don't worry if you have to skip a few exercises and come back to them later. Don't allow yourself to be bogged down and loose interest over a single difficult exercise.

SICP In case you didn't know, have a look at http://lesswrong.com/lw/3gu/the_best_textbooks_on_every_subj... (http://lesswrong.com/lw/3gu/the_best_textbooks_on_every_subject/)

Gödel, Escher, Bach awakened my intellectual curiosity about formal systems and other autistic modes of beauty as a teenager. After "The Selfish Gene" it was the first book I bought and read on my own volition, so I have to credit it as a major influence. Structure and Interpretation of Computer Programs for showing that you can think rigorously and compose beautiful programs out of simple pieces. Contingency, Irony, and Solidarity by Richard Rorty for showing that it's possible to think and feel about politics while maintaining a profoundly ironic and groundless mind. The Body in Pain by Elaine Scarry for its beautiful view of civilization as materialized caring and of the inflicting of pain as metaphysically destructive. Being-in-the-world by Dreyfus for introducing me to Heidegger and showing how continental philosophy inspired by Heidegger was a major force in the evolution of AI and how AI researchers tended to be influenced by rationalist philosophy in the vein of Descartes which leads to huge misunderstandings of the nature of being.…

SICP (Structure and Interpretation of Computer Programs). Structured very well. Each exercise builds on a concept of the previous exercise, getting increasingly difficult. 1984 by George Orwell. I am told that we're increasingly moving towards a mix of 1984 and Brave New World (I haven't read the latter).

* "The history of western philosophy" by Bertrand Russell. A fun read so far (~100 pages). Russell is not afraid to tell the reader that he really dislikes Plato, and thinks he destroyed western philosophy. * SICP (Structure and interpretation of computer programs). Learning Scheme for fun now with this book. I'm only in chapter 2 so far, but it is really fun * "Gödel, Escher, Bach" by Douglas Hoefstadter. The story in one line: he have a theory that consciousness aries from "strange loops". Along the way he talks about fractals, programming, patterns in music and in pictures,... * "The Idiot" by Fyodor Dostoyevskij. Fun read.

SICP made the biggest difference; it really changed the way I approach mutability and state management in everything I write (To name just this).

Thinking Forth; Software Tools; SICP; Abstraction and Specification in Program Development; Essentials of Programming Languages; Paradigms of AI Programming; I'd like to list something about OO too, but no book I know really measures up to learning from other programmers. But there's Mark S. Miller's thesis Robust Composition. (in roughly chronological order. As you can see from the chronology, it took me a long time to start to like OOP.)

To get comfortable with recursion, you should check out a simple functional language like Scheme (https://mitpress.mit.edu/sicp/full-text/book/book.html)

These are indications of the weakness of Java and C, not SICP. I do not mean this as empty snark; it is something you can see across the board in programming language evolution. It is virtually impossible to propose a new general-purpose programming language today that does not have closure support, which is the biggest thing you're finding missing from C and Java to use the techniques in SICP. (It is not the only thing, but it is the biggest thing.) You'll note Java is going to bolt them on soon, or recently bolted them on, but it'll be another decade before Java is using them fluently either way.…

Structure and Interpretation of Computer Programs. I have attempted some of the problems in Lua, Python, Erlang and Ada. It is very doable. So not just for Scheme.

Getting Real - got me out of the corporate grind SICP - got me out of the OO grind Each one had a significant positive impact on my life. And both a free online! https://gettingreal.37signals.com/ http://sarabander.github.io/sicp/

This is a bit unorthodox, but I personally got a lot out of taking the LISP code in Structure and Interpretation of Computer Programs, and mentally translating the examples and solving the exercises in Javascript. There's apparently versions of the text around with the exercises pre-translated, though translating it myself was valuable to me. Obviously, this will more teach you how to write good code that happens to be in Javascript, rather than taking an already-solid programmer and showing them the nitpicky details, idiosyncrasies, and browser APIs of Javascript.

Gravity's Rainbow, Thomas Pynchon (1973). The Platonic ideal of the Postmodern novel that combines a deep understanding of modernity with deep understanding and pessimistic view of technology. Purgatory, Dante (1320). No other work so elegantly grasps Christian Sanctification and it's true difficulties. Philosophical Investigations, Ludwig Wittgenstin (1953). Like Pynchon, Wittgenstein understood quite well the exhausting pedantic nature of modern life. A book that can stand on it's own without having read much philosophy, this work attacks the foundations of most of "Modern" (I would label this as post Medieval philosophy ). Structure and Interpretation of Computer Programs, Abelsson, Sussman, Sussman (1985). For me, the definitive "Programming is what exactly?" book. Computer Systems, a Programmer's Perspective, Bryant & O'Hallaron (2012). The Concrete Systems yin to SICP's abstract yang. BattleCry of Freedom, McPhearson (1988). The best Civil War history in the past generation that also lays bear how much of what we view as modern crisis in the U.S. ( partisanship, horrendous propagandized media coverage, etc ) is as old as the country itself.

Bill Gates famously said that anyone who finished TAOCP should send him their resume, but to me, anyone who has read and done all the SICP exercises would be a good hire, and it is a far more achievable task. I had been programming for about 10 years or so when I read it and did all the exercises. It seriously leveled-up my abilities, in my opinion.

SICP I read it twice and it is still a gem

I finished it up a few months ago and I cannot recommend it enough. The real soul of SICP is in it's exercises however. It asks you to build on your own prior work in inventive ways, challenging you to solve the exercises correctly, but also to do so in a maintainable way. I wrote up some supplementary material to make the experience smoother for a practicing programmer: High-level requirements of the chapter subprojects, Pitfalls and paradigms embedded in some of the footnotes, Answers to (nearly) all exercises, a testing framework for Chapter 4 interpreter (including the JIT compiler), a GUI for running Chapter 5 virtual machine here: https://github.com/zv/SICP-guile

I think if you have the time you should read SICP. It is not just about APIs, but my understanding of good APIs too increased a lot after reading this.

Structure and Interpretation of Computer Programs. I need to implement a superset of lisp so I figured why not go to the basics. It has been a very fun read so far. Was particularly happy to see the chapter that starts with a quote from On Human Understanding.

SICP (Structure and Interpretation of Computer Programs) - https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html... (https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%_toc_start) (free version)

Chomsky's oeuvre on politics, in general. There isn't one single book that states a thesis, it's about a perspective. So perhaps start with The Chomsky Reader. An easier-to-digest intro is the documentary Manufacturing Consent. The twist is that a lot of the things you think of as "bugs" in the political and economic systems of the Western democracies are "features" from the perspective of powerful elites. But the meta-lesson is that big questions can be answered. If you get past the mythology in your culture, and read primary sources, you can really figure this stuff out. Chomsky can go off the deep end at times (and his fanclub does so a lot), but his documentation is meticulous. Well worth reading. For very different perspectives on programming, check out Structure and Interpretation of Computer Programming (read it a decade ago and I use techniques from there every day.)…

Sicp is available for free https://sicpebook.wordpress.com/ebook/

SICP

It depends on personal taste. But if I were going to a country I never visited before, there would be very little time to do anything else other than sightseeing, mingling with the locals, learning about their culture, their history, the food, and if you are anywhere near one, visit the national parks and take the safari. Document everything you see. Take a good camera with you, and if you don't know how to use an SLR, this is the perfect time to learn some basic tricks. Once you pick a camera, you can find some tutorial on the web, which teaches you the basics for that brand/model. I would use this time out to "take a break" from computer science. But if you can't stay away from it, pick up a book like SICP (http://mitpress.mit.edu/sicp/). This is one of those books which you want to read away from all distractions and think deeply about. If you can, download the accompanying video lectures: http://ocw.mit.edu/courses/electrical-engineering-and-comput... (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/)

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

There are just so many... Headfirst series (JavaScript, HTML, jQuery... all of them) Discover Meteor Refactoring: improving the design of existing code Database design for mere mortals MIT books (SICP, Algorithms) Oh, and of course... Human Interface Guidelines by Apple. One of the best UX books on app design. All books are ebooks for me, so this list is impossibly long.

Surprised it hasn't been mentioned yet. Hands down the most eye opening technical book I've read is SICP. http://mitpress.mit.edu/sicp/ http://sicpebook.wordpress.com/ebook/

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.

The books on and around my nightstand: + Joy of Clojure. A recent gift[card]. I put off learning Clojure because of it's more complex syntax. I'm both glad I did, and that I have this book now that that's the no longer the case. + ANSI Common Lisp. Lisp was out of reach at the time when my younger self might have pursued computer programming, and realizing around two years ago how accessible it had become got me to download Lisp in a Box and then buy the used copy. Currently visiting, this book orbits in and out of the rotation with a cometary periodicity. + Art of Computer Programming: Volume 3, Sorting and Searching Twenty-five years ago or so I bought volume I and about 15 years I donated it to the community radio station's books sale [WMNF 88.5]. I spent about $25 dollars including shipping for used copies of the first three volumes from Amazon last year. Right now each is on a different floor. The proximate reason Sorting and Searching is by the bed: I'm taking Algorithms I on Coursera and it is the first one that really dives into algorithms. A deeper reason is that Knuth always reminds me how much more there is to know - I'm getting better at the maths, but haven't learned…

I'm a big fan of SICP. I'd describe it as "hard-core": requiring hard work, but extremely rewarding for the people who take the time and effort to go through it. I'd recommend the following three books to similarly cover the three main areas of higher mathematics (analysis, algebra, and topology): 1. Principles of Mathematical Analysis by Rudin (http://www.amazon.com/Principles-Mathematical-Analysis-Inter... (http://www.amazon.com/Principles-Mathematical-Analysis-International-Mathematics/dp/007054235X)) 2. Algebra by Artin (http://www.amazon.com/Algebra-2nd-Featured-Titles-Abstract/d... (http://www.amazon.com/Algebra-2nd-Featured-Titles-Abstract/dp/0132413779)) 3. Topology by Munkres (http://www.amazon.com/Topology-2nd-James-Munkres/dp/01318162... (http://www.amazon.com/Topology-2nd-James-Munkres/dp/0131816292))…

The only book on mathematics actually reassembling SICP I found is "What is mathematics?" by Richard Courant. I have read it after reading SICP, largely because I very much liked some of the more mathematical fragments in SICP, and surprisingly it felt like an actual follow up - it spends significant amount of time highlighting high level trends in mathematics, like use of abstraction and generalization, using very concrete examples. Sounds familiar?

Untethered Soul. Just finished it but I can already say it has influenced me more than anything spirituality related I have read in the last 10 years. The power of this book is it's clearity and simplicity. It's not a new age book and not a how-to book. I feel I made a huge leap to a new level of inner tranquility. Maybe it's just the right book at the right time and something I needed to hear but it amazes me how direct the words speak to me. There's also a short article of the same author on huffington post if you want to get an idea of what is it about. As the OP asked for two books and we're on HN I'd say SICP

0) The C++ Programming Language by Bjarne Stroustrup 1) Structure and Interpretation of Computer Programs by Abelson and Sussman 2) Kvachi Kvachantiradze by Mikheil Javakhishvili

The Structure and Interpretation of Computer Programs (http://mitpress.mit.edu/sicp/)

Blood Meridian, Cormac McCarthy. Philosphical Investigations, Ludwig Witgenstein. The Analects. Structure and Interpretation of Computer Programs, Ableson and Sussman. The Hamet and The Town and The Mansion, William Faulkner.

"The Forever War" by Joe Haldemann. Possibly the best science fiction I ever read! "The Structure and Interpretation of Computer Programs" and its video lectures[1]. Highly recommended! [1]: http://ocw.mit.edu/courses/electrical-engineering-and-comput... (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/)

Some favorites from my bookshelf: Benjamin Franklin's autobiography, Thinking Fast and Slow, Fooled by Randomness / Black Swan, SICP, Zen Mind Beginner's Mind

If they already have some experience with high level languages, I would introduce them to K&R's C Programming Language. It does a good job of introducing some low-level topics, like pointers and memory management. I also second the books that teach using Scheme, like SICP. I think learning Lisp and C introduces many important concepts. Also, learning a web stack is very educational. Learning how a web application works (Internet protocols, server side code, databases, etc) taught me a lot.

SICP! http://mitpress.mit.edu/sicp/ Or, a prettier version that was on HN some time ago: https://github.com/ieure/sicp

Here's a good list of highly-praised books. Most of them look like they could make it past the censors: http://stackoverflow.com/questions/1711/what-is-the-single-m... (http://stackoverflow.com/questions/1711/what-is-the-single-most-influential-book-every-programmer-should-read) From those I personally recommend "Structure and Interpretation of Computer Programs" and "Gödel, Escher, Bach". SICP might not make it through, but GEB definitely would (although its direct relevance to day-to-day work in web development may be questionable, it should do a lot to spark an interest in computer science).

This is absolutely the right direction--thanks! The one book on the list that might get kicked back is "Structure and Interpretation of Computer Programs". Too bad, since it's probably the most concrete. This is a great starting point, thanks again.

Not sure if this is the right direction or not. In different ways they are all, essentially, about programming... http://www.amazon.com/Code-Language-Computer-Hardware-Softwa... (http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=sr_1_1?ie=UTF8&qid=1328659335&sr=8-1) http://www.amazon.com/Elements-Computing-Systems-Building-Pr... (http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/0262640686/ref=pd_vtp_b_1) http://www.amazon.com/Structure-Interpretation-Computer-Prog... (http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871/ref=pd_vtp_b_6) http://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/... (http://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567/ref=pd_vtp_b_12) http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master... (http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=pd_vtp_b_13) Good luck!

Why not HTDP or SICP?

If you did not tell me that SICP was actually made for something else, I would think that it was custom-designed for self-taught programmers to fill in their gaps, at least the ones that matter. If you actually finish that book you'll be ahead of the vast bulk of programmers who graduated with computer science degrees in terms of practical software engineering.

I am also self-taught, although I dropped out of University two years into a CompSci/Engineering double major, so I will recommend some resources to you that helped me immensely. Each of these books has an associated MIT course with lecture video, notes, etc. available online. First is Structure and Interpretation of Computer Programs[1], which you can read online, and the associated course at MIT, which is 6.001[2] Second is the famous 'Dragon Book', Compilers: Principals, Techniques and Tools[3] and the associated course which is 6.035[4] Extras would be the Python book 'How to think like a Computer Scientist'[5]. MIT course 6.00[6] uses the book as a reference, and the courseware is again available online. Other than that - the usual suspects on learning C (K&R), UNIX (TAOUP[7]), the bash shell along with grep, sed, awk, more algorithms(CLRS[8]), functional programming and machine learning. Take your time, it takes years to build the relevant experience and knowledge and you are never done.…

It really depends on what you feel you're missing and what you're hoping to do (definitions of "daily work" vary widely). If you're looking to get up on theory by doing your own program of sorts, you could do worse than start with these (in roughly this order): Structure and Interpretation of Computer Programs - Abelson, Sussman, and Sussman Introduction to Algorithms - Cormen, Leiserson, Rivest, and Stein The Art of Assembly Language - Hyde a digital logic book (not sure which is most recommended), and an architecture book (see reply by tftfmacedo) Modern Operating Systems - Tanenbaum Introduction to the Theory of Computation - Sipser Compilers: Principles, Techniques, and Tools - Aho, Lam, Sethi, and Ullman (a.k.a. "Dragon Book") Programming Language Pragmatics - Scott…

Programming is more about thinking in a certain way than algorithms or data structures (those are the tools). You should check out the book Structure and Interpretation of Computer Programs -- I found it "enlightening"

I think you mean Tony Hsieh? I haven't finished it, but the Structure and Interpretation of Computer Programs was by far my favorite book that I've been reading this year. It really opened my eyes to a lot of new ideas, as it apparently has for so many other people.

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/)

My vote goes to SICP as well, however if you don't have much time http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme.html is helpful.

SICP by a mile, for one reason: the SICP videos: http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma... (http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures/) That's the best 20-hour introduction you could ask for.

I second that. Sicp, though, is quite hard conceptually (for instance, I've been baffled by church numerals and the y combinator), but in a good way. You may want to read something more entry-level before, though.

SICP isn't so much about Scheme, but language design principles, the beauty of abstraction, the dangers of mutable state, and the inability of a reactionary, functional approach to compensate for the lack of a mutable state. But I would still go with SICP.

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.

I would recommend a classic that you haven't read that isn't directly about a specific programming language, since it would seem to me that the virtue of reading a book about a specific language when you aren't in front of a computer is dubious. (Note I didn't say it had no virtue, I just find it dubious. YMWV.) Already mentioned is Code Complete and The Pragmatic Programmer. I'd add The Mythical Man Month, still a classic, but note that's a relatively short book and may not last long enough. (A depressing read in some ways; decades have passed and what's in the book is arguably common wisdom, yet I still encounter the errors outlined in that book every year.) Godel, Escher, Bach (mentioned by caffeine) is a love it or hate it book; check out a couple of summaries and see what you think. Personally, I don't recommend the SICP unless you're actually working through the exercises to some extent, and without a computer it's too easy to think you understand it when you don't. If you have already read all those, well, I'd suggest replying and saying so. :)

"Hackers and Painters" or "Founders at Work" are both good books if you haven't picked them up yet. Not language learning or directly programming but interesting none the less. A book more directly related to programing would be "Structure and Interpretation of Computer Programs" or "The Little Schemer." bring a notebook and do problems out of them like defunkt said and it will help in all your programming.

I'd have to disagree, because the short term reason is a pretty big one. Not saying SICP sucks, I think the original poster would benefit from reading it..but at this point if he/she/it is working on said project NOW and needs a good Java/Struts book NOW, SICP isn't going to be that helpful. Only in the long run.

Why so harsh? I think he'd be better off reading SICP than a java book, despite the short term reasons to do otherwise. And so what if it's in scheme? if he can't understand scheme then he's not a proficient programmer.

SICP

SICP

SICP, of course. Is this a trick question? Oh, 8-bit. The 6809E reference manual. Motorola sent it to me for free when I wrote asking where I could buy it.

I'm surprised no one mentioned SICP. I would also add: - The Little Schemer - Linux in a Nutshell - Unix power tools

- Structure and Interpretation of Computer Programs (SICP) - Paradigms of Artificial Intelligence Programming (PAIP) - Godel Escher Bach (GEB) - All books from Gibson, Asimov, Sterlig, Huxley and Douglas Adams

(I'm going to ignore the prohibition on "programming/technical books".) - GEB - SICP - anything by Paul Auster or Hermann Hesse - most Haruki Murakami, especially "The Wind-up Bird Chronicle" - Joan Didion, "Where I Was From" - Richard P. Gabriel, "Patterns of Software" - Durbin, Eddy, Krogh, and Mitchison, "Biological Sequence Analysis" - Italo Calvino, "if on a winter's night a traveller"

Ender Series - Orson Scott Card Rama Series - Arthur C Clarke Firestar Series - Michael Flynn 1984 - George Orwell Structure and Interpretation of Computer Programs - Some guys at MIT (I know it's technical, but couldn't resist, it's just too good) Anything by Bret Easton Ellis, Greg Bear, Stephen Baxter, and the above mentioned authors.

Favorite computer book: Structure and Interpretation of Computer Programs - ISBN 0-07-000484-6 - Whether you actually like Scheme is beside the point. I got this book for an intro class into functional programming, and we only used sections one and two... but I enjoyed it so much I went through the rest of it on my own during Christmas break. Was probably the greatest experience I have had programming since first groking OO. Favorite non-computer book: Ender's Game - ISBN 0-812-55070-6 - I have probably read this about 10 times. All the other books in the series are good too, but it really stands apart from the rest. As an aside, the Economist is probably the best (IMHO) news source out there, as it actually goes in depth as to the causes of events, rather than just listing them with pretty explosions. It's also delightfully devoid of sensationalist stories normally found on TV News or Newspapers. Added bonus: you get a nice discount if you subscribe as a student. Not sure I could recommend it highly enough.