Rating: 
Summary: nothing spectacular here
Review: I was hoping, based on the comments of some people, that this book would be somewhat of a bible for programming...they said it's the best book of programming ever written. I was quite disappointed. One of three things usually happened when I read about a new topic in this text: 1. I already knew some things this book talks about. They are, in fact, fairly obvious, like abstraction. 2. The idea was fairly interesting, but it wasn't possible to implement it outside of Scheme. In other words, this idea became useless. 3. Some things were just a pointless waste of time. Purely philosophical discussions. In short, this book told me nothing new. A huge disappointment. I don't understand what these people see in it.
Rating:
Summary: Not terribly interesting
Review: I can't say this book is absolutely horrible, but it isn't good either. I read it on the advice of some guy who liked it, but I didn't. The breadth and wealth of topics discussed is staggering, but none of them are treated especially well, and some seemed hardly of any relevance. I still think the way they presented structures such trees and lists, with pairs, is a very braindead approach. C style pointers are much more intuitive and flexible. Aside from that, this text might be OK as a simple reference of what's out there, but there are definitely better books on just about any topic presented in this text. I only got through chapter 4 and got very bored along the way. Buy at your own risk. This book is way overrated and boring.
Rating: 
Summary: An excellent summary of the real rules of programming
Review: Programming is not about the semantics of a particular language. If you want to learn simple C++ as soon as possible, this is not the book you should read. However, don't expect to do anything significant from the above without hard-earned lessons that can be had from SICP. This book is golden. It considers issues important to programmers of all levels of experience. And, I would argue it does so clearly and precisely. Though I came to this book (through MIT's introductory class, 6.001) with a firm grounding in programming fundamentals developed from Unix shell scripting and a little C, I know countless others who read it with little to no exposure to programming. This book requires a *lot* of time and attention to be used well, but its lessons are worth the time. What this book doesn't explain (and what detractors on this page have noticed) is that scheme standard is not consistently deployed. And, no doubt, scheme has some real problems with efficiency, particularly since accessing values in a data structure requires a number of steps proportional to the depth of the structure. Scheme trades elegance for practicality, which is exactly what learning programmers should do.
Rating:
Summary: waste of time
Review: This book is filled with pompous statements and philosophical discussions. Who cares? No one. Instead of teaching really useful things, such as algorithms, or tecnhiques, the text spends huge amounts of space on pointless philosophical discussions. For example, when assignments are introduced...(e.g. x = x + 1), the authors take up a boring discussion about the conceptual difficulties and implications this introduces into the language. Again, who cares? Millions of lines of code are written in C every year and everything works just fine. You can tell from the book's preface that the aim isn't to teach you programming, but instead to philosophise about conceptual issues...whatever that means. In other words, this text belongs more in a philosophy course than in a computer science course. There's more talk here, and less real action. It supposedly teaches you how to think about programming, but that is already accomplished by C courses, which teach objects and functions. Aside from that, it does a decent job of introducing Scheme. But here again, that language is strongly tied to the book's philosophy. It is nearly impossible to write anything useful in the language, as it's designed to demonstrate some finer points of reasoning about computer science, and is not designed as a practical programming language. If you are looking to learn practical skills, don't get this book, it'll only waste your time. If you are interested in "philosophy of programming" mumbo jumbo, you might like this book. Although, I should warn you, the text pretends to teach both things, but does neither well. This is pure "programming for its own sake" type of text. If you like that, fine, but if you want to program for the sake of accomplishing something useful, there are only a handful of sections in this book that discuss anything of relevance and you'll just waste your money.
Rating:
Summary: Not fun at all...
Review: When I had to take a Scheme course in college, I was already intimately familiar with C++ and assembly programming, so when the professor commented as to how fun to use and simple Scheme is, and how well written this book is, I got into a bit of a lazy gear and prepared for an easy time. Well...I was wrong!!! Or rather, the professor was wrong. This book, and the Scheme language especially, is just horrible. I was an experienced programmer, and I still found it a tough time trying to write programs based on this book. I knew what recursion was, but I wasn't prepared to deal with a language methodology that did not allow functions with multiple statements, but instead forced everything to be done with recursive calls. Iterative processes are done recursively, mind you!! This book is supposed to teach "proper programming practice" to fresh students with no programming experience. Instead, this book, coupled with the programming philosophy of Scheme reads like a decree from an evil dictator. Without much ado, it covers abstractions such as passing procedures and data around as one and what's more, uses complex math topics as examples for what can be implemented with Scheme!! The book does a shoddy job of explaining the language. I've found countless inconsistencies between what the book says and how the language works. For example, the book says that nil is a built in constant for an empty variable, yet the scheme implementation doesn't recognize it. That's just one example. I've talked with beginner students, and they all mention how the C programming class was much easire than scheme. There you have it, the book is supposed to introduce beginner to proper programming, but instead, it imposes on them a very strict and IMHO very crappy language, couple with an overall tone of a graduate level computer sciece or math course. I really think if taught properly, a langauge like C++ can be a much better tool for beginners. In any case, beginners steer clear of this terrible book, and experienced programmers too...it won't tell you anything new. You'll come out feeling like you've been grabbed by the hair and dragged around in mud.
Rating:
Summary: Hell of a Starting Point...
Review: As a sophomore at MIT, I took 6.001, the class from which this book sprang. I wish I could say this book was a great beginner's text -- but it is most assuredly NOT. It is REALLY BLOODY DEEP and you must take it a step at a time. But when all is said and done, you'll find that it has covered a VAST amount of material. Don't think of this as a LANGUAGE book -- it's NOT. It's a LINGUISTICS book for programmers; that is, it will teach you theory and methodology, and let you nick off and learn Java on your own (which couldn't hurt). The book is aimed at MIT students; you should know that their problem sets are traditionally among the nastiest to be found. Even the exercises in the book sometimes call for the reader to stretch his or her mind in a brand new way; but there is no better way to learn. Other than taking 6.001 itself, of course...
Rating:
Summary: a smart person's programming primer
Review: Turning tradition upside down, this book builds up abstraction and theory rather than teaching where to put your semicolons to introductory computer science students. The upside to this is not that I can now sit down and write a commercial program, but rather that I can translate a problem in my head into an actual algorithm, something that other texts make you learn over a long time. Sure the book is challenging, but in the eyes of a computer nerd that's what makes this book so great.
Rating:
Summary: Focus is on the art of programming
Review: Unfortunately, most of the computer books that I read focus on cookie cutter solutions to problems. As a professional software engineer, I dont just want "howtos" for a small collection of problems. SICP goes a long way to expanding your capacity to solve problems in a timely fashion. Be prepared to work! This book is very knowledge dense, and each exercise pays large dividends for the time invested. From a programmers point of view, you will fall in love with scheme very quickly. Keep in mind this book is about the larger art of programming and not just scheme. It just happens to be a powerful language for expression of high level abstractions and ideas. If you are tired of books that teach syntax and simple solutions, and you are ready for the next level in skill development, read SICP and do the exercises. It will become one of the most rewarding experiences of your software carreer.
Rating:
Summary: Excellent advanced theory text
Review: As I student at MIT, I have found the text completely indespensible in all many classes - ranging from the introductory course for which it is meant and advanced artificial intelligence and software engineering classes. The coverage of the text is unparalleled in depth and comprehensiveness. I very highly recommend this text to anybody who is interested in studying the more advanced mechanisms of code, rather than just the simple for loops and objects of standard, modern languages.
Rating:
Summary: It's the classic.
Review: This is known as "The Wizard Book" -- and for good reason. This book is lucid, clearly explained, and has a greater density of profound ideas per page than any other textbook I have ever seen. There is no other text which clearly presents so much of the foundations of computer science. Doing it in one semester is a frantic pace -- but it's well worth spending two or even three semesters covering it well. However, college studies aside, as a professional you will want to own this book and reread it from time to time. The stuff in it will strike sparks off the things you've been doing elsewhere and give you new ideas and perspectives -- routinely. This is an extremely valuable book to own. I've recently gotten a new copy just because mine was getting worn out -- and it didn't wear out with light use....
| 
