Rating: 
Summary: This book is the bomb
Review: The comments written about this book on this site are glaringly stupid. One guys writes, "one of the assignments is to write a scheme interpreter in scheme! How much dumber can you get?"Well, obviously not much dumber than you. You don't writing a think meta-circular interpreter would teach you anything about computer languages? (Isn't that the point?) Or programs expressed at the most mathematical level possible? You probably don't think learning about recursion is very important either. Oh yeah, that's just something you had to learn about when there weren't loops. Obviously, if all you do is hack perl scripts, don't buy this book. If you don't want to learn something really important that requires doing things a different way other than to which you're accustomed and getting at the basis of things, don't buy it. The fact that the material in this book is taught to freshmen at MIT and Berkeley and other top computer science programs in the nation might say something to you. It may come off as archaic and worthless to some, but that couldn't be farther from the truth. The more I reflect on the things I learned from SICP, the more I realize they are important. The lambda calculus and scheme are simplicity and elegance at their finest. The difference between the understanding those people have of this material and that which is illustrated by the comments by 'programmers' here reminds me that they're right, this book isn't for programmers. It's for people who want to learn computer science.
Rating:
Summary: Get this book from Barnes and Noble it's only $52!
Review: this book is $52 at barnesandnoble.com where it is $65 here. :\ Hey, gotta be loyal to the price, right? R
Rating: 
Summary: Overrated
Review: I am assuming this is, as stated, aimed at people starting to learn computer science. I read the first two and a bit chapters for a first semester course. It attempts to teach people computer science by a bottom-up approach, teaching all the theory first. This is stupid, as evidenced by all the low reviews. I'm not denying that theory is important, or denying that the theory here is good. Practise programming for a period of time and then read this. Having said that there is nothing singularly special here, no ideas that aren't found (and probably learnt better) elsewhere. The book's approach is ambitious, but basically the authors aren't clever enough to pull it off. For example the writing is quite poor, and the examples (Newton's sq root approx, horner's rule spring to my mind) completely uneducational. I didn't enjoy reading it.
Rating:
Summary: What does Scheme have to do with it?
Review: I have read a lot of reviews here which lament the use of Scheme for teaching the fundamental concepts in this book. People have stated that while the book pretends to be language-independent it relies solely on Scheme, which invalidates the point. I disagree strongly! I think part of the problem is that it takes a bit of time to really "grok" Scheme. If you've never been exposed to it before (as I haven't), Scheme may seem strange and unnecessarily arcane to you at first. However, after doing it for a bit you will realize (as I have) that Scheme is amazingly flexible, succinct, powerful and unbelievably elegant. It incorporates all the features that other languages such as C++ take for granted and skip over, and exposes the real machinery behind them, without introducing a whole host of obscure syntactical details. This clarity and elegance of Scheme has helped me understand all other languages I have to deal with so much better! Thus, in presenting the topics of this book in Scheme, the authors are actually succeding in making their discussions language-independent! Truly, the difference here lies in what your goals are: if you want to program in some specific language and just memorize it, this is not a book for you. However, if you actually want to understand how that language works, this will be akin to an epiphany for you. A very good book!
Rating:
Summary: The Classic
Review: This is one of the great classics of computer science. I bought my first copy 15 years ago, and I still don't feel I have learned everything the book has to teach. 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?
Rating:
Summary: This book is the best book on computer science I've read,
Review: with the possible exception of Knuth. It surpasses the other classics. It contains an enormous amount of material, clearly presented. The authors have an excellent command of English. Beware that the material is highly conceptual, and if you are looking to master pragmatic skills, this is not the book for you. It is nothing like "Teach Yourself C." If, however, you are looking for a conceptual understanding of computer science generally, this is the best book possible.
Rating:
Summary: Its the Best! Its the Worst! Why the split?
Review: I think its fascinating that there is such a split between those who love and hate this book. Most reviews give a bell-shaped curve of star ratings; this one has a peak at 1, a peak at 5, and very little in between. How could this be? I think it is because SICP is a very personal message that works only if the reader is a computer scientist (or willing to become one). So I agree that the book's odds of success are better if you read it after having some experience. 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 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 a particular problem. 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.
Rating: 
Summary: A solid textbook
Review: I fall between the polarized views of the reviewers of this textbook. This is a well-written introduction to Lisp programming and Scheme, and introduces many important concepts in Computer Science. The problem with it is that it is not a suitable book for a beginner -- I don't consider it a gentle introduction to computer science -- and for someone experienced enough to be comfortable with its ideas, it doesn't introduce many interesting ideas until Chapter 3. Unlike other people I guess, I found the reading sometimes difficult, but interesting and comprehensible. I didn't learn much of anything (except Scheme) until the Brandeis course I took reached the discussion of the environmental model of evaluation. But from there on I learned some interesting ideas, especially about the interpretation of computer programs, non-deterministic programming, and logic. Unfortunately we didn't get to the last chapter on compilation, but I might look at that this summer. At Brandeis University, this is the second course in the major, not counting two optional intro courses which are designed for non-majors and people with little background who want to be majors. But even with the interesting ideas, it was mainly Lisp that I learned, which I don't consider a waste of time by any means.
Rating: 
Summary: terrific waste of time
Review: There are many things wrong with this book, but perhaps the worst is its shameless lying when the authors promise you profound knowledge of computer science and end up delivering a cheezy promotion of Scheme. They only concentrate on aspects of programming as it involves Scheme and don't make any effort to teach computer science as an art or as a science. They don't teach anything that's applicable in general, or will give you better understanding of the issues involved in writing good software. All they do is present trivial topics such as basic data structures and programming example, and it's all using Scheme. I ended up learning Scheme and nothing else. There are plenty of other good books which cover the art of programming so generally that you'll find information useful in any programming project. For example: Cormen, Leiserson, Rivest "Introduction to algorithms", Knuth "The art of computer programming" (3 volumes) ... these are all highly regarded books. All I hear about SICP from students and professors alike is that they wish the book ceased to exist. Don't listen to the others on this page...the book won't teach you to be a better programmer, and it won't teach you how to understand programs. It'll simply waste a lot of your time.
Rating:
Summary: The book is WONDERFUL!
Review: This is an excellent book for any CS person. If you have a CS major, you MUST read this book. The text is extremely clear, chapters are well organized, examples are great, topics discussed are fascinating(e.g. constraint propagation, streams, etc.). I must also mention that authors provided the text with excellent footnotes that give interesting information about this or that topic. The book teaches PROGRAMMING for people who want to become PROGRAMMERS in a VERY interesting manner and using a VERY good tool. Don't be misled by the fact that the book is based on Scheme programming language. Some of you might think that Scheme is purely academic stuff(a.k.a "not very practical"). That is not true. Scheme is good for many reasons, but I would like to point out two of them that make it an excellent language to learn: 1) Once you practice in Scheme for a week, you will no longer need to bother about syntax. This allows you to concentrate on the problems you want to solve, rather than on the tool you want to use to solve the problems. (Analogy: Suppose you want to learn how to drive a car. "With Scheme" you just learn some basic stuff about the car and then improve your driving skills by actually driving the car. "With languages such as C, C++, Java, etc." you first spend a couple of years on learning how the engine of the car works, how to fix the wheels, replace this and that and then work on your driving skills.) 2) Besides the fact that Scheme is an interesting language by itself(Learning it will get you into some interesting computing topics such as tail recursion, list processing, OOP, OOD, the concept of a function being used as data), it can also be the first step towards learning Common Lisp. Thank you.
| 
