#77 in Computers & technology books
Use arrows to jump to the previous/next product
Reddit mentions of Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)
Sentiment score: 22
Reddit mentions: 40
We found 40 Reddit mentions of Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science). Here are the top ones.
Buying options
View on Amazon.comor
- New
- Mint Condition
- Dispatch same day for order received before 12 noon
- Guaranteed packaging
- No quibbles returns
Features:
Specs:
Color | Navy |
Height | 1.2 Inches |
Length | 9 Inches |
Number of items | 1 |
Release date | July 1996 |
Weight | 2.0502990366 Pounds |
Width | 6 Inches |
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.
The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.
Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.
Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.
SICP(although married to a language) teaches very very good fundamentals.
Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.
SICP definitely.
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
It reminds me of one of Raymond Chen's blog posts where he reminds you that the a NULL garbage collector is a perfectly valid implementation:
------------
Everybody thinks about garbage collection the wrong way
-----
When you ask somebody what garbage collection is, the answer you get is probably going to be something along the lines of "Garbage collection is when the operating environment automatically reclaims memory that is no longer being used by the program. It does this by tracing memory starting from roots to identify which objects are accessible."
This description confuses the mechanism with the goal. It's like saying the job of a firefighter is "driving a red truck and spraying water." That's a description of what a firefighter does, but it misses the point of the job (namely, putting out fires and, more generally, fire safety).
Garbage collection is simulating a computer with an infinite amount of memory. The rest is mechanism. And naturally, the mechanism is "reclaiming memory that the program wouldn't notice went missing." It's one giant application of the as-if rule.
Now, with this view of the true definition of garbage collection, one result immediately follows:
> If the amount of RAM available to the runtime is greater than the amount of memory required by a program, then a memory manager which employs the null garbage collector (which never collects anything) is a valid memory manager.
--------------------
Bonus Reading
------
MIT Press - Maintaining the Illusion of Infinite Memory, Chapter 5, pp. 540:
> If we can arrange to collect all the garbage periodically, and if this turns out to recycle memory at about the same rate at which we construct new pairs, we will have preserved the illusion that there is an infinite amount of memory.
That's what they teach in universities, isn't it?
> Educators, generals, dieticians, psychologists, and parents program. Armies, students, and some societies are programmed.
- First words of Structure and Interpretation of Computer Programs
Honestly, if they are already using DrRacket, The Structure and Interpretation of Computer Programs (SICP) has aged very well and, for an undergraduate class, is probably at least as good as anything else. You will want to strategically choose which parts you cover. It is still being used at MIT, for example.
(Edit: SICP, not SCIP.)
I highly recommend The Haskell School of Expression by the late great Paul Hudak. Also you should learn as much as you can about Lambda Calculus in general like for example this paper.
After that you should learn as much as you can about types, Types and Programming Languages is really important for that.
Finally don't skip the important fundamental texts, mainly Structure and Interpretation of Computer Programs and the original video lectures by the authors (about the nerdiest thing you will ever watch ;)
Lisp is like magic - it's the programmable programming language - if you learn it, everything else kind of pales in comparison :P
One fascinating aspect of lisp is that it's based on lambda calculus, which is basically a cleaner alternative to Turing machines (Turing machines are basically a mathematical way to describe computable problems). After learning about lambda calculus, Turing machines looked like a hack to me. A decent non-mathematical guide I found introducing them was this: http://palmstroem.blogspot.com/2012/05/lambda-calculus-for-absolute-dummies.html
Even though lisp allows for a lot of functional programming, it's not purely functional, and can be used to write object oriented code, or anything else really.
The books I'd recommend to learning it are:
The best way I know how is by solving problems yourself and looking at good solutions of others.
You could consider going back to "fundamentals".
Most programming courses, IMO, don't have nearly as many exercises I think they should have. Some books are particularly good on their exercises list, for example K&R2, SICP, and TC++PL. Deitel's has long exercises lists, but I don't think they're particularly challenging.
There are some algorithms/DS books which focus on the sort of problem solving which is about finding solutions to problems in context (not always a "realistic" one). Like the "Programming Challenges" book. In a book like that, a problem won't be presented in a simple abstract form, like "write an algorithm to sort numbers". It'll be inside some context, like a word problem. And to solve that "word problem", you'll have to find out which traditional CS problems you could solve/combine to get the solution. Sometimes, you'll just have to roll something on your own. Like a new algorithm for the problem at hand. In general, this helps you work out your reduction skills, for once. It also helps you spotting applications to those classical CS problems, like graph traversal, finding shortest plath, and so forth.
Most algorithms/DS books though will present problems in a pretty abstract context. Like Cormen's.
I think, however, people don't give enough credit to the potential of doing the exercises on the books I've mentioned in the beginning.
Some books I think are worth reading which also have good exercises:
I imagine the other Stroustrupp programming book also has good exercises, but I've never read it. Brian Kernighan is not only the author of K&R2, but of many other books. You could look at his stuff.
Depending on what you mean by good code, though, you could look at other books.
There are also the math books. I'd not discard those. And also, there are other programming books as well. Some I've never read, but want to, like Programming Pearls:
Not only those, but, anyway... The point is that you can look at those books to find examples of good code, good exercises, challenges and so forth.
Here are some books I've mentioned previously:
By the way, there are websites with programming challenges for you to look at too. Like https://projecteuler.net/ and others. Just start looking this up and you'll find plenty. They all tend to start dumb easy and move up the difficulty to pretty damn difficult stuff from what I've heard.
Edit: SICP is available for free (http://mitpress.mit.edu/sicp/) together with videos from the course taught at MIT in 85 (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/).
https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
SICP, and Lisp/Scheme programming in general, got me to really appreciate computing on a mathematically elegant level. Read the first couple of chapters (http://web.mit.edu/alexmv/6.037/sicp.pdf, free PDF!) and you'll be hooked.
Taking in mind that you may not have access to a computer:
If you've got no background already, I'd recommend The Little Schemer / The Seasoned Schemer books as they teach programming as if it were arithmetic, so it can be studied without a computer, working out the examples with pencil and paper or just very carefully in your head -- the examples are all very small, and worked through step by step. It moves very slowly though.
If you're looking for something more advanced, there is Structure and Interpretation of Computer Programs (SICP) which again takes a mathematical approach to computing, so the examples are meant to be just as well worked out like algebra as they are put into a computer. It helps a lot to have a computer, but I had fun working through it on a long plane flight, taking notes and working through the code on paper.
SICP's examples can all be worked through on a single sheet of paper, but ramp up quickly in difficulty, so they can definitely keep you busy.
Here are some books that I feel have made me better professionally. They tend toward the comp sci side, some are more useful than others.
Lastly, find some open source projects and read their papers, then read their code (and then the paper again, then the code...etc)! Then find their blogs and read those too. Then find them on Twitter and follow them. As others have said, the field is evolving very quickly, so half the battle is information sourcing.
The usual advice is "get out and program!" and that works, but it can be very tricky coming up with something to write that's also satisfying. The idea is that you learn best by doing, and that many topics in programming can't really be learned without doing. All that stuff is true and I'm not denying that at all, but some of us need more. We need something juicier than spending hours configuring a UI for a project we couldn't care less about. It shouldn't be an exercise in masochism.
I guess what I'm saying is that there are a lot of ways to learn to write code and books are great if you can really sink your teeth into them (a lot of people can't). Code Complete is a great book on the practice of programming. You also say that you "get" OO pretty well, but it might open your eyes to read up on design patterns (e.g., Head First Design Patterns). You have a long way to go before you really get it
In addition to those, you could delve deeper into your languages of choice. There's no way around JavaScript if you're a web programmer, and a book like JavaScript: The Good Parts is pretty enlightening if you've got some experience in JavaScript already. It's a pretty interesting and unusual language.
But sometimes programming is about building gumption, so instead of just being practical, try to figure out what you like about computers and keep going deeper into it. If you have an interest in computer science and not in just building apps, then something like Structure and Interpretation of Computer Programs could instill in you an enthusiasm for computers that trickles down to everything else you do. If you're more interested in web design, there are probably similarly interesting books on artistic design principles.
I think what I'm ultimately saying is that you should find what you enjoy doing and just go deeper down the rabbit hole, getting your hands dirty when it's appropriate and interesting.
Self taught professional software engineer here.
Which language you learn is not as important as learning about data structures and complexity analysis. Code organization is also very important.
Pick one high level scripting language (like Python, Ruby, Perl, etc) and one low level systems language (C, C++, Rust, etc) and learn them both inside out.
A couple of books I recommend:
As far as practical skills go, you need to learn how to use
git
(or whatever VC system the companies you are interested in use). You need to learn how to use Unix systems. A great introduction is The UNIX Programming Environment. You need to learn how to read other peoples' code, open source projects are great for that.When you are getting ready to interview, there is no better resource than Cracking the Coding Interview.
You are welcome :).
This is one of the best book to learn programming http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871. It's freely available and the class at MIT which uses this is here http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/
Peter Norvig's advice http://norvig.com/21-days.html
Programming Pearls : http://www.cs.bell-labs.com/cm/cs/pearls/
At https://www.codeeval.com you can solve questions and get interview calls.
You may also want to brush up your design skills as few interviewers might ask those kind of questions. http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124 might be a good place to start.
I think http://www.geeksforgeeks.org is a good place to look for nicely explained solutions and you can find almost all the questions ever asked in a software engineering interview at careercup.com
Structure and Interpretation of Computer Programs (SICP) is still one of my favorites.
In no particular order:
Structure and Interpretation of Computer Programs
Code Complete
C Programming Language(K&R)
The Pragmatic Programmer
The Mythical Man Month: Essays on Software Engineering
Introduction to Algorithms and/or Algorithms
C++ has more meticulous detail that just about any other language.
This book would be a good place to try again. Or if you're really ambitious, this one. Both will teach you more of what programming is really about, using a language that has a minimum of syntax to deal with.
There are a lot but my favorites are
https://www.amazon.com/Purely-Functional-Data-Structures-Okasaki-dp-0521663504/dp/0521663504/ref=mt_paperback?_encoding=UTF8&me=&qid=
https://www.amazon.com/Structure-Interpretation-Classical-Mechanics-Press/dp/0262028964/ref=sr_1_2?crid=3RF2M50NKPULH&keywords=structure+and+interpretation+of+classical+mechanics&qid=1572889989&s=books&sprefix=structure+and+inte%2Cstripbooks%2C207&sr=1-2
https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871/ref=sr_1_1?crid=1CSGG60L6328Q&keywords=structure+and+interpretation+of+computer+programs&qid=1572890005&s=books&sprefix=structure+and+inte%2Cstripbooks%2C413&sr=1-1
There are also more mathy type theory books and category theory books you should check out but I'd probably start with those 3
Structure and Interpretation of Computer Programs
Some schools don't cover much in the way of discrete math, formal languages, automata, or proofs... at least not very rigorously. My opinion here is colored by my own experience (and subsequent disappointment, but thats another story), and I'm sure most schools sort of exist on a spectrum. YMMV.
Some books that come to mind (might not be to surprising if you spend a lot of time on CS forums):
[Introduction to the Theory of Computation](
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser-ebook/dp/B00B63LSA6)
CLRS Introduction to Algorithms
SICP
I think it's interesting to look at the history of computer science-- read about Bertrand Russel, David Hilbert, the Vienna Circle, Alonzo Church and his students (Alan Turing was one). Computer Science as an academic discipline was kind of born from the questions mathematicians and philosophers were trying to ask in the early 20th century. It's just as much about language as it is about mathematics. I could probably write a wall of text on the topic, but I'll just leave it at that. :)
K&R -> The C Programming Language by Brian Kernighan and Dennis Ritchie
SICP -> Structure and Interpretation of Computer Programs
The Pragmatic Programmer
If you only read one work on the topic, it should be The Art of Computer Programming by Don Knuth: https://www.amazon.com/dp/0321751043/
The textbook for MIT's 6.001 (introduction to computer science) is the much loved Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman: https://www.amazon.com/dp/0262510871/ . Originally it was in Scheme but the 2nd edition is in Python.
Finally, because people asking about computer science are often asking about something a bit broader than pure computer science, I recommend Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. It is a thorough tour of computing in practice at every level, top to bottom. https://www.amazon.com/dp/073560505X/
Depending on the subject. Like there's a lot of foundational subjects in CS and programming that are still relevant since decades ago. Like this book https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
which was on teachyourselfcs.com
Introduction to Algorithms
Structure and Interpretation of Computer Programs
I linked to Amazon but obviously these can be easily found as .pdfs.
I'm in a similar boat to you. I studied Computer Science at university but it was a really watered down curriculum (we even did Excel as one of our first year modules for fuck's sake; I was so desperate to code that I made a VBA frontend haha), so there are many gaps in my theoretical knowledge.
I'm currently reading MIT's Structure and Interpretation of Computer Programs. It's based upon Scheme, a dialect of Lisp, but covers many important topics, such as:
Now I just need to find more time to read it!
Read a lot of books. Everything is usually available as a pdf on the internet and the ones that aren't are $10 to rent on Amazon. Here's the ones that I've read that relate to this project.
Java
Android
Programming in general
No soy OP pero aprovecho para preguntar, que opinás de SICP? Empezé con Elisp hace unos dias y me pareció interesante, pero no se si vale la pena leerlo.
SICP is definitely useful for pretty much everyone. It's also free, although you can get the paper copy with the famous cover if you really want to.
Note that all of the examples are in Lisp, which is weird and scary to newbies. Since it's a functional programming book, you'll find that it approaches programming very, very differently than other tutorials and books, which cover imperative programming.
---
Sipser and its ilk aren't really useful outside of the classroom. I think that Theory of Computation is important for people to learn, but it's not really relevant to programming in general.
Exactly. There's a low market for course books in India, so the prices are really low (as with all international editions). Almost all of my friends haven't heard of any books like TAOCP, and SICP. Everything's so cheap! They're missing out on so much!
Hey look! Peter Norvig and pg! http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871/ref=sr_1_1?ie=UTF8&qid=1376132102&sr=8-1&keywords=sicp
Buy this book and read them a chapter every night as a bedtime story. It has wizards and suchlike so is very workable for children.
SICP
Check out Structure and Interpretation of Computer Programs.
https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
I'm pretty sure you can find a PDF for free, if that's too much.
That makes sense, I guess I am slightly despairing because it is such a huge project and I am a sole developer and because of how much it is all tied together it takes a full day to just add a simple button, and to add all the changes all through the code base
​
Thanks for the a) reassurance and b) the recommendation
​
When you say SICP do you mean this book? https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871/ref=asc_df_0262510871/
Books:
The Pragmatic Programmer ($30)
Clean Code ($40)
Structure and Interpretation of Computer Programs ($40)
T Shirts ($20-30):
Works on my machine
Hello world
Other:
A nice coffee mug or teapot for the office
Nerdy desk top calendar
Thank you! I'm actually realizing that I learn more from my textbook than I do from the lectures for my intro class, so after my midterm tomorrow I think I'm going to focus on reading ahead for the next couple weeks and spending the second half of summer getting a handle on data structures and algorithms.
Aaand I just looked it up, the data structures course just has a C reference book and the algorithms course doesn't have a required textbook. I'll have to look into which textbooks are commonly used for those classes elsewhere.
I'm also planning to read MIT's Structure and Interpretation of Computer Programs at some point, cause I heard it was a really good intro book. Should I try to get through that first and then hit up data structures and algorithms?
Just "Structure and Interpretation of Computer Programs" - http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
On the internet I'm seeing an unofficial textbook version that is free, while on Amazon they sell the original. Are they the same book or should I grab one in particular?
Haskell Programming from first principles
Excellent choice if you are kinda new to programming. Really thorough.
Programming in Haskell
SICP
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586
Also if you want something really challenging:
http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Free below:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html