- Series: MIT Electrical Engineering and Computer Science
- Hardcover: 657 pages
- Publisher: The MIT Press; 2 edition (July 25, 1996)
- Language: English
- ISBN-10: 0262011530
- ISBN-13: 978-0262011532
- Product Dimensions: 6.2 x 1.5 x 9.2 inches
- Shipping Weight: 2.3 pounds
- Average Customer Review: 236 customer reviews
- Amazon Best Sellers Rank: #671,916 in Books (See Top 100 in Books)
To get the free app, enter your mobile phone number.
Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science) 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
Customers who bought this item also bought
Customers who viewed this item also viewed
What other items do customers buy after viewing this item?
Abelson and Sussman's classic Structure and Interpretation of Computer Programs teaches readers how to program by employing the tools of abstraction and modularity. The authors' central philosophy is that programming is the task of breaking large problems into small ones. The book spends a great deal of time considering both this decomposition and the process of knitting the smaller pieces back together.
The authors employ this philosophy in their writing technique. The text asks the broad question "What is programming?" Having come to the conclusion that programming consists of procedures and data, the authors set off to explore the related questions of "What is data?" and "What is a procedure?"
The authors build up the simple notion of a procedure to dizzying complexity. The discussion culminates in the description of the code behind the programming language Scheme. The authors finish with examples of how to implement some of the book's concepts on a register machine. Through this journey, the reader not only learns how to program, but also how to think about programming.
About the Author
Hal Abelson is Class of 1922 Professor of Computer Science and Engineering at Massachusetts Institute of Technology and a fellow of the IEEE. He is a founding director of Creative Commons, Public Knowledge, and the Free Software Foundation. Additionally, he serves as co-chair for the MIT Council on Educational Technology.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
To use an analogy, if SICP were about automobiles, it would be for the person who wants to know how cars work, how they are built, and how one might design fuel-efficient, safe, reliable vehicles for the 21st century. The people who hate SICP are the ones who just want to know how to drive their car on the highway, just like everyone else.
Those who hate SICP think it doesn't deliver enough tips and tricks for the amount of time it takes to read. But if you're like me, you're not looking for one more trick, rather you're looking for a way of synthesizing what you already know, and building a rich framework onto which you can add new learning over a career. That's what SICP has done for me. I read a draft version of the book around 1982, when I was in grad school, and it changed the way I think about my profession. If you're a thoughtful computer scientist (or want to be one), it will change your life too.
Some of the reviewers complain that SICP doesn't teach the basics of OO design, and so on. In a sense they are right. The book doesn't directly tell you how to design and write an object-oriented program using the subset of object-oriented principles that show up in the syntax of Java or C++. Rather, the book tells you what those principles are, how they came to be selected as worthwhile, how they can be implemented from the ground up, and how a different combination of principles might be more appropriate for some particular problems. This approach requires you to understand the range of possibilities, and to think about trade-offs as you go through the design process. Programming is a craft that is subject to frequent failure: many projects are started and abandoned because the designers do not have the flexibility, experience and understanding to come up with a suitable design and implementation. SICP gives you an approach that will succeed, but it is an approach based on principles and wisdom, not on a checklist. If you don't understand the principles, or if you are the kind of person who wants to be given a cookbook of what to do rather than to think creatively, or if you only want to work on problems that are pretty much like the problem you worked on last time, then this approach will not work for you. There are other approaches that will be more reproducible for a limited range of simple problems, but there is no better way than SICP to learn how to address the truly hard problems.
Donald Knuth says he wrote his books for "the one person in 50 who has this strange way of thinking that makes a programmer". I think the most amazing thing about SICP is that there are so FEW people who hate it: if Knuth were right, then only 1 out of 50 people would be giving this 5 stars, instead of about 25 out of 50. Now, a big part of the explanation is that the audience is self-selected, and is not a representative sample. But I think part of it is because Sussman and Abelson have succeeded grandly in communicating "this strange way of thinking" to (some but not all) people who otherwise would never get there.
Because of this, when you think of a function in imperative, you immediately think of variables, and such functions can very easily morph both at the algo/function f(x)-> g(x) level, and at the x (variable level) itself (data changing as you execute). In functional programming (the subject of this text), a function is, well, a MATH function! So, evolving from math, and consisting OF math, it would be a little surprising to criticize the fact that this IS A MATH BOOK. (Sorry, it is). On the other hand, holding those variables constant and looking directly at functional mappings (particularly recursion) can "AHA" us into seeing how computers and programming "really" work without the complications of heavy imperative morphs.
After C# 3 and in some Perl, these tried and true oops also have some functional classes now, so we are moving toward a more hybrid world, making this book FAR from out of date, even though it is "temporally" older. As well, some of your favorite math, research and engineering programs (Maple, Mathematica and R, for example) have numerous functional features. The old FP standbys are, of course, Lisp, Scheme, Hope, Haskell, Clojure, Racket, Hope, Scala, F#, etc. which you probably think of more as "math" programs. But, hopefully not a surprise, SQL itself strives at far less mutable value structures than imperative, and thus tilts toward functional also.
FP, to be very honest, WAS designed to teach and understand programming (at compile/interpret levels, not necessarily algorithms, computational complexity or even advanced data structures), not originally create useful programs! "R" and many others have proved that to be aiming low, and the newer FP books do of course get deeply into more recent data structures.
Thus, the reason for so many negative reviews! This is NOT your usual "how to program" or even "what are programs" text-- it really is about linking mathematics and computer science at both high and deep levels. So, if you aren't really up on math (from basics like sets and real number mappings all the way up to Lie Algebras and tensors), you might get lost with this rare gem of a book. On the other hand, the pain of working through it will give you a perspective on computer science that will forever change your point of view. Even if you code all day like I do, you'll LOVE taking this journey both to the 30,000 foot level, as well as down to the real action between compiling and interpreting-- via the MATHEMATICS of "pure" functions, minus the confusion of changing states, variables and data we play with every day in the imperative version of functions. Don't believe that this "simplification" makes things easier to get-- unless you know functions from a deep math view, this will be a tough climb.
But... worth it if you're willing to do the work! Most other books on "discrete math" are really UI catch ups for all the computer/math that's now been removed from High School curricula, making this one of the few "real deals" that are at a bright, high undergrad level, NOT catch up. By removing calculus from HS requirements, we're teaching 2,500 year old math, and adding the basics brings us up to 1666 or so. This book rapidly catapults our function math vs. function computing into the new century! Highly recommended IF you're not turned off by advanced math functions, mappings, properties, etc. The next time someone asks how a special or CAS function can run faster interpreted than compiled, you'll have a MUCH different answer! And of course the heart of all dynamical systems today includes differential equations, which are essentially recursive function processing.
BEFORE AND AFTER: If you're not "quite" ready for this level of FP and Lisp, you can get a great, inexpensive backgrounder with Dover's An Introduction to Functional Programming Through Lambda Calculus (Dover Books on Mathematics). Mathwise, many Dover books on the keyword recursive functions will help. For a freebie intro, Graham's famous "on lisp" is now available as a free download, and is a bit above the level of this book. For the "greatest intellectual programming book ever written" (far beyond the level of this book, covering advanced Lisp macros, closures, etc.), check out (AFTER reading this): Let Over Lambda. Only 1% of programmers really understand Common Lisp, and only 1% of those would tackle the unhygenic macros in Let Over-- yet it is so intellectualy challenging that coders and engineers at all levels are astonished when they read it. Shows how high the bar can really get! (Lisp tends to do that, right?).
IS IT DATED? In answer to a bunch of emailers asking that, NO-- the principles of functional are still the same, even if Common Lisp and Scheme have been updated. In fact, today, combinations of functional, imperative and logical are happening more and more (called mixed paradigm programming). However, if you want a GREAT, VERY RECENT book as both a warm up and an update to Abelson, try this little beauty by the same author as the Little Schemer: Realm of Racket: Learn to Program, One Game at a Time!. It will fill in where Abelson is a little out of date AND prepare you for his depth. WARNING: PLEASE BE SURE to get the 2nd Edition of Abelson, he updated it significantly for the relationship between time and memory, a relationship that is even today undergoing a LOT of research in many fields.
I have learned enough to write a couple books on Lisp that (currently) have four to five stars. Yet SICP, which is pretty much the bible of our world, has only three? How can this be?
Reading the reviews made it clear what happened. An optimistic professor somewhere has been feeding SICP to undergrads who are not ready for it. But it is encouraging to see how many thoughtful people have come forward to defend the book.
Let's see if we can put this in terms that the undergrads will understand -- a problem set:
1. Kenneth Clark said that if a lot of smart people have liked something that you don't, you should try and figure out what they saw in it. List 10 qualities that SICP's defenders have claimed for it.
2. How is the intention of SICP different from that of Knuth? Kernighan & Ritchie? An algorithms textbook?
3. Does any other book fulfill this purpose better?
4. What other programming books first published in the mid 1980s are still relevant today?
5. Could the concepts in this book have been presented any better in a language other than Scheme?
6. Who is al? Why is his name in lowercase?
Most recent customer reviews
*Structure and Interpretation of Computer Programs* – the second edition of which...Read more