Rating: 
Summary: Misguided intro, but great theory
Review: Frankly, I'm appalled at the elitists comments made by many of the 5-star reviewers. It's that very superior attitude which prevents the comp-sci field from creating more scientists rather than code monkeys and justifies poor pedagogy and technical writing for the sake of "scientific integrity."
SICP is neither masterpiece nor pariah. No other introduction to computer science has a truer grasp of the "soul" of computer science. Not only that, but there is ALOT of useful theory in here, if you have the patience to look.
But, the book suffers for dreadful writing and advocacy of a language that can be really quite a horror for beginning programmers. On one hand, the authors took an approach that should have been brilliantly successful. On the other, they did a terrible job explaining fairly simple ideas (or, rather, ideas that should have been simple.)
But, the truth is SICP has SO MUCH to offer. Unfortunatedly, the book is only as educational as the CS professor who teaches it. It turns out that the Berkeley professor who said that SICP is "the greatest CS book ever written" is the finest CS teacher at Berkeley. Unfortunatedly, most CS professors are not even 1/10th as good as he is and therefore help make SICP a tortorous excursion.
As a EECS major at Berkeley, I've come to realize just how important theory is in the field of CS. And to that end, I think it is as easily critical that theory should be taught with the utmost respect, not only for the field but the students. SICP is a brilliant master, but often a contemptuous teacher.
Rating: 
Summary: Fantastic book, but not for beginners
Review: The reviews of this book are just hilarious; I've never seen a book with reviews so sharply polarized between one and five stars. I think the reason for this is that most of the one-star reviewers had this book rammed down their throats in an introductory CS course, and it blew their minds. This doesn't surprise me; despite the fact that the book is meant to be an introduction to computer science, for most students it will be just too abstract and too difficult. I've been programming for over ten years, and I had to work really hard to understand a lot of the concepts presented here. Nevertheless, I think this is a great book because it discusses lots of ideas that receive inadequate or no coverage elsewhere. The material on compilers, for instance, is difficult (and idiosyncratic because they're compiling scheme, which has its own pecularities compared to, say, compiling C) but if you can work through it you get a pretty deep understanding of what's going on, without having to get bogged down in parsing or other trivial stuff. My suggestion: DO NOT read this book if you are just learning how to program; come back to it after a few years of experience and it will stretch your mind. Also, if you're having trouble I recommend Harvey and Wright's "Simply Scheme" as a much gentler introduction to the same material.
Rating: 
Summary: important concepts presented poorly
Review: I think you'll need a good prof. to learn anything from this book. If you like to learn on your own, you'll need to find better texts that this one. It's fairly dry/uninspiring and there's a lot of fluff mixed in with a bit of interesting material here and there. I didn't enjoy reading it at all.
Rating: 
Summary: You Might Learn a Thing or Two
Review: My CS professor at UC Berkeley, introduced his course as the best CS course at Berkeley because it uses the "greatest CS book ever written." For all the pain and long hours it has put me through, I must admit this book taught me concepts I never knew. This book is not for the casual reader who wants to learn practical programming, but rather for someone who wants to really be hit hard by all the important topics in Computer Science today. Good luck!
Rating:
Summary: cryptic and uninteresting
Review: This book is good to read when you have trouble falling asleep. Everyone I know, including the professor, were often confused. In the end, he abandoned the book and started teaching from his own notes, and learning Scheme and the concepts became a pleasure. The problem is the author, who thinks that because he's from MIT, he can just write drivel and it will sell. Everything in this text can be explained much more clearly and precisely if done by a good teacher. But the book makes no such effort, and as a result, it's boring and often difficult to understand. If you really want to learn the foundations of programming, buy a book by Knuth, for instance. SICP, though, is probably the worst, most arrogant and pompous text on programming, but it teaches nothing.
Rating:
Summary: what a bore!
Review: A major timewaster. The book doesn't teach anything worthwhile at all. Trees, recursion, encapsulation....those things are taught in beginning C courses and in any case, this book doesn't present them very well. The other 95% of the text is useless drivel. The authors don't seem to have any desire to be lucid..they just want to have the book with the most topics stuffed into it, regradless of whether they can all be presented clearly or not. I agree with other reviewers who said this book makes major promises, but doesn't deliver on them.
Rating:
Summary: a very painfull process
Review: I originaly was introduced to this book in college by a teacher who said the text would open heretofore unknown vistas to me. It was supposed to turn me into a deeply understanding computer scientist, and not just a code monkey. I found out those promises didn't come true. Two semesters later I was feeling lucky to have finally finished the course, and was angry to have wasted so much time. This book quite simply doesn't deliver what it promises. Instead, it tries to be as coprehensive as possible, covering so many topics that I was dizzy, but it does a very bad job of explaining anything in detail. The end result is that I learned nothing. Apparently the authors believe quantity is better than quality. In any case, you won't get anything out of that text...and it certainly won't make you a better computer scientist, though it pretends to. Don't waste your time and money.
Rating:
Summary: Extraordinarily good as an intro to CS text
Review: ...not an intro to programming, mind you, but an intro to computer *science*. Rather than giving a few tips, tricks, and pointers, this book teaches the *fundamentals* of computer science. Beginners looking for a quick and dirty way to learn programming should look elsewhere. If all you care about is the quickest path from zero to mediocre skill in programming, skip this book. However, if you actually want to be any good at programming and be able to *fully* understand what's going on, this book is an EXCELLENT investment, not only in terms of cash, but in terms of the time you spend reading it. My first introduction to this book was as an EECS major at U.C. Berkeley in '91. I can't stress enough the incredible advantage you will have after reading this book over someone who took the path of least resistance and learned programming from a Teach Yourself In 21 Days book. Anybody can learn how to program, but it's literally impossible to be a truly *good* programmer without a rock-solid understanding of the fundamentals, and that's precisely what this book is good for.
Rating:
Summary: unenthusiastic presentation of computer science
Review: After reading this book, I went away having learned absolutely nothing. I knew about good program design techniques, such as abstraction, but I haven't been taught anything more. The problem with the text is that it tries too hard to cram all there is to know about computer science into one book. I understood what was going on, but ideas seemed disconnected. I felt as if I was at a car dealership, with someone blabbering at my ear and I'm not able to examine anything in detail. A better idea would be to get a nice, thick book on any specific topic after you learn the basics of programming from a C text. This book tries to present compilers, query systems and hardware design, but it'll leave you confused at best and won't teach you, because the presentation is not thorough.
Rating:
Summary: ...
Review: If you read books carefully and try to understand their meaning, you'll be frustrated by this text. If you read 'popular' books as a 'trophy' collection activity and don't think about content...this book is for you. It's from MIT..all the prestige you need in one little text...who cares about the actual conent? Those who do care, stay away. Some of the most fundamentally important material is gathered here and butchered in the most horrific way. I suggest you look at specific books on topics such as hardware design, compilers, etc...this book will only cause pain and won't explain them.
|
