So there I was, 18 years old, having been raised on a toxic stew of MS-BASIC, Apple II assembly and some MPW Pascal. My mind was poisoned. Everything I knew about programming was wrong. I read book after book on programming and CS, but none of them really seemed to make a real dent in my style.

Enter SICP. In a few months, this book reshaped my concept of what it meant to program a computer. It does not spend time teaching a language; Scheme is presented precisely because its syntax and commands can be covered in about ten minutes, and its structure becomes absolutely transparent within a few days of looking at Scheme code. It does not spend time walking the reader through common coding tasks, as a Learn X In 24 Hours text might.

SICP teaches the fundamentals of programming mastery. Abstraction, modularity, design paradigms, compilation and interpretation, and more topics are presented in a style which is exactly as simple as it can be, and no simpler. Scheme allows these topics to be covered without becoming mired in details which would otherwise plague the implementor.

It will not show you how to write a GUI, scrape a web page, develop a social networking website or create a network server. It will, however, guide a dedicated reader through an exploration of immensely powerful programming technique, and it will prepare the reader to solve any problem in any language for the future.

SICP is not a machine gun, putting power into casual hands. It is a light saber, rewarding discipline and practice with unstoppable capability.

This is the best book on programming I have ever met in my life and, most probably, will ever meet.
It not only surprised me and made me think "Oh my god, how come I didn't think this way/about these so incredibly important things before?" dozens of times in every single chapter during every of my 3(in a row) readings of it but it actually changed the way I think about programs and the way I write them.
The authors have a perfect sense of balance between complexity and importance: they never skip important things silently and they never dig too deep into dull subtleties, instead they point out the really meaningful points and either invent a solution before the reader's eyes or give clues that inspire the reader to work out the solution himself.

The book does not teach most of the basic algorithms and data structures, like quicksort of graph path finding (except for several examples that fit well for the purpose of a particular chapter), it is not a programming reference: it is a manual on methods of computation: exactly what the title says. So, in case you have a pragmatic problem you can't just take the book and find a solution: I guess this is the reason for low ratings. But if you read the book thoroughly, you will definitely become an order of magnitude better programmer and that is much more important than knowing concrete algorithms.

I also extremely highly recommend the same-named video course by the same authors at http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/ : I first was intrigued and shocked with it and only afterwards saw and immediately bought the book. It is a pity I have not yet had time to watch all the lectures (I watched about a half).

I'm an undergrad who is currently taking an introductory class in C.S using the book as the primary textbook (actually, the only textbook). Sadly, I'm taking it with another class in computer architecture with heavy emphasis on system programming (a la C, MIPS). Like one of the reviewers having pointed out, the excessive zeal of pedantic and theoretical C.S has left the students clueless about the connection between reality and fundamental ideas presented in the book. The authors enforces a grand vision of solving problems independent of programming language. Sadly, this is not the case in practice (I have been trying to port some algorithms in the book into C, oh boy, what a frustrating experience). This vision has left me a very bad impression on Scheme (a good-for-nothing language invented by geeks to impress other geeks).

Some people have said they liked the book. At the beginning of semester. I liked the book too, since programming in functional style is completely new to me (who major in C.S wouldn't delight at learning new thing). HOWEVER, the more I delved into the book while taking a computer architecture course at the same time (in which I have to design a complete 8-bit CPU from ground up, as well as doing a lot of low-level programming), the more I feel there are some fundamental issues with using Scheme (or any other functional languages for that matter) as a tool to interpret and design machines and programs. It just struck me as very odd to design a computer "recursively". How ironic that the book is called "STRUCTURE and INTERPRETATION of computer programs".

I agree with some reviewers in here who bashed C in favor of Scheme. C is not a very good language, but C deserves praises. There are reasons why it has been around forever (both in academic and in industry), and at this rate, I don't see how any functional languages would emerge out of academics as replacement for C. The authors in book braggs that only Fortran has been surviving longer than Scheme, but besides surviving in the this textbook (which has been pushed down my throat by my school), I haven't seen Scheme anywhere else.

This textbook reminds me of the Feynman series in Physics. A series which everyone talks about, but when it comes to reality, it's just best used as a supplementary to look up for reference and self-congratulate as being "smart" rather than the one used to teach and learn from.

I discovered this text, I believe, while browsing The Aerospace Corp Library in '90. I was immediately taken with it, wishing my own undergraduate program in CS had incorporated its use. The first two chapters on procedural and data abstraction are much better CS preparation than learning Java or C++ or Ada or Pascal. Abstraction and specificiation in software development are absolutely necessary if software "art" is ever to become a "science."

I used this text last year to teach a one year introduction to computer science to some rather advanced homeschooled high school students. Scheme is a much better choice for a teaching language than C++ or Java. There is no need to deal with memory management issues as with C++ and the development model is simpler than with Java. And scheme makes many things easier to achieve than with other languages: higher-order procedures (chapter 1) and hierarchical data (chapter 2).

For my own enjoyment and personal enrichment I have used chapters 4 and 5 as a basis for my own explicit control evaluator for scheme in C++.

A classic. Every CS graduate should do remedial work now and read this text, if they have not done so already.

I purchased this texbook for my first computer class since it was required. It's a great book, but I'm glad we did not cover it entirely. Too much material, and Scheme is not that popular of a language. Price was right though!

This is a 'must have' book for anyone wishing to practice the craft of programming. It is enigmatic in that it requires little background in programming, but leads swiftly and easily into non-trivial concepts. Of course one must do the exercises, which are varied and practical, the most they ask of the reader is that they understand basic mathematics of Leibniz and Newton. This book will not teach you a collection of tricks, it will give you a way to think about programming. There are a set of lectures by Abelson and Sussman based on the book available at no cost on the Web. Even though they were produced over a decade ago they are well worth watching, and add an interesting flavour to the text. All the software you need to use this text is available for free for a number of platforms. If you are an experienced programmer this is a fun read, if your intention is to learn the art of computer programming, start with SICP, and add Knuth to your bookshelf for reference.

This book trains your mind to do meta-circular interpreters and higher order functions, recursion, and other things schemers take for granted. hey you with thoes 1 * reviews your just a bunch of blubbers

Excellent book to teach computer programming, especially if you are willing to use Scheme.

A truly wonderful book. What else can I say?

I discovered it about 10 years into my career in software, on a recommendation from a friend from MIT where it is used for the introductory CompSci course (6.001). Originally, I didn't think a book used in a first course of computer science can contain anything I didn't know already. In the end, I ended up getting Scheme (the LISP variant used for exercises in the book) and spent almost two months working through the exercises in the book. Why? Because it challenged and changed the way I think about software.

Over the years, my thinking was influenced by Wirth's Pascal (abstract data types), later by the C/C++/Java people (K&R, Stroustrup,Gosling) and the OO people (GoF). But Abelson and Sussman presented a richer and more powerful approach - software systems as layers of languages and linguistic abstractions, with linguistic abstractions serving primarily as means of formulating and exploring problems and, only then, as means of specifying algorithms for computers to execute. They get that point across by providing reasonably challenging exercises in LISP using first functional programming (the lambda is fun!!), then data abstractions and generic programming (you end up writing a symbolic algebra program), followed by objects and state (the delayed stream approach is really nice). At this point you are about half way through the book but the really interesting stuff is ahead: first modifying the LISP evaluator to implement lazy evaluation and non-deterministic computing, and finally, implementing the evaluator on register machines.

While working my way through the book, I went through the MIT 6.001 course materials on the MIT OCW website, as well as the Berkeley SICP course which are both based on this book. Both courses are, no doubt, excellent, but in the end I found the best approach for me was to simply stick with the Abelson and Sussman and do the exercises.

-- for someone who never has to deal with industrial software. But there is greatness here, so let's start with that.

The book is entirely based on a Lisp dialect. That gives a very strong mathematical note to the whole text, where functions of functions arise early on. This book lays out an aggressive first course in programming, introducing valuable topics like lazy evaluation, logic programming, interpreters, and constraint propagation. These, of course, have many applications and even more implications; the base concepts are useful far beyond the case studies presented here. The students of this course also receive vivid demonstrations of the hazards of parallelism, and the merits of stateless functional programming in eliminating change-of-state race conditions.

Sorry, to say, I'm not a functional programmer. I use imperative languages (call them dys-functional if you must). So do 99.9% of all commercial software developers. They're stateful languages, and reflect the fact that the world has state. It may be elegant to move back and forth along the static, four-dimensional space-time trajectory of moving objects with respect to fixed ones. In practice, however, a car ramming a wall should not be considered a reversible event.

One must also note that the early versions of this book date to the 1980s, before object orientation became widespread. Even the later edition (1996) ignores the basics of OO practice, since they couldn't be captured in the version of Lisp favored here. Instead, examples (ex. p.189) propagate the pernicious practice of hand-coding polymorphism via switch statements or manual table management. I'm not an OO absolutist by any means. I'm painfully aware of its limits, and willing to recommend functional style when it solves specific problems. I am fully cognizant of the iron and silicon that lie under my program, however, and of the mutualism between hardware and software. In all the years I've been building software and hardware, I've never seen a "functional" computer. Sooner or later, all of them store bits - if nothing else, the functional program itself.

There's a lot of good in this book, including a great example of how to design a programming course for a brilliant novice. Believe me, the smart students can be harder to handle than the plodders (but worth it). This may outstrip the plodders, though. And, in the end, it teaches only Lisp - a language with negligible presence in the working world.

//wiredweird

whats this programming thing all about? thats what I thought mid-way through a business major in college. so i grabbed this book, because I'm a snob and I thought MIT, comp sci book, this should be a good, definitive introduction.

i read parts of the first chapter. and found myself fascinated. i got sidetracked, finished my finance degree, dabbled in some comp sci classes and c++ books.

Then I returned, mature enough to read the complete book. It was amazing, inspiring. a whirlwind tour of interesting ideas in computer science. it taught me what a program was capable of. I was so inspired, i set out to become a programmer and took some more computer science classes. Start work as a programmer. but if i had never read SICP, and just learned from my classes and co-workers, computer science and programming would be a drudgerous, pointless task to be outsourced to offshore developers.

instead, despite the tedium of having to support poorly designed applications integrated with poorly designed third party software, reading stacks of technical documentation, i continue to be inspired by sicp. it teaches me that there are so many ideas to be explored. that the computer and the software it runs isn't just a filing cabinet or a business process automator. its way to explore problems and think about them. cooperatively with users and designers.

chapter 3 and 4 i keep find myself revisiting. i often find myself thinking about them, grasping them a little deeper each time. i still have some ways to go in be able to actual apply the ideas from the discussion of streams vs mutable objects at teh end of ch 3. i wish i could spend my whole career applying the ideas from the event propagation system, the constraint network, the non-deterministic solver, and the relational programming to different problem domains. i'll try, but you also run into limits with users. users can understand and conceptualize filing cabinets / data entry systems. they have problems when you start talking about more abstract systems.

i like the conscious decision to not waste time talking about class hierarchies. i love the idea of beign treated like a designer, and being walked through so many different aspects of how things work with prototypes. its almost spoiled me. whenever i see a new system now, i often find myself asking - walk me through how this thing works from the inside out. closed source systems annoy me because of SICP.

thank you for writing this inspirational book!

Superb! I wish I had read this book in my first year of computer science. I read it 9 years late! [BTW, I am a professional computer engineer.] It is the difference between memorizing multiplication tables and knowing how to multiply!

I've been a professional in the computer science industry for years, and I still find new gems, leading to ah-hah! moments, each time I pick this book up. Saying that I underappreciated this book when I first read it is an understatement. Based on many of the reviews here, I suspect this is a common phenomenon. Those who care deeply about computer science love this book; those who see this book as the only barrier between them and a passing score in their current CS course clearly do not.

This book teaches you to think about problems in a different way, a way which stays with you forever. I guess LISP is like that in general. The mechanics and specific techniques are not as important as comprehending the entire material at a higher level.

Read it once, read it twice...heck, read it once a week from now until you die. I plan to.

Great computer science book overall. I really wish I had read this years ago. This book gave me a lot of insight into concepts that I thought I already knew.

There are some bad reviews here on Amazon which are a little hard for me to understand. I can certainly see how this book isn't for everyone - it requires a certain way of looking at things. But then, computer science itself requires that same way of looking at things. If you think Java is a great language for teaching computer science, you won't like this book. But please reconsider your career choice. (And I can't help but address the assertion in one of the reviews that "virtually every conventional algorithm is NOT implementable in scheme". Obviously this is completely and laughably false, but I would absolutely love to know what the reviewer was thinking - how could someone get such a ridiculous idea in his head?)

I do have a few problems with the book. Firstly, the book fairly often describes a few procedures to you, and then wants you to complete exercises using the procedures. But you have no actual implementation of the procedures, and thus you cannot run any of the code you are writing (sometimes hundreds of lines). Frankly, this sucks. One of the great things about computer science is that you get immediate feedback when you code. You write it, run it, bam, there's your result. In most cases, the book does eventually give you the implementations for the missing procedures, but in at least one case, it does not.

Another problem with the book is that it does not provide answers for the exercises. This is unfortunately a common situation, not just in computer science. This is probably OK in a classroom setting, but what about us autodidacts? I'm not sure of the answer to a few of the open-ended questions in this book and there's basically no way for me to find the answer.

Lastly, considering the book is supposedly an "introductory" computer science textbook, it's too bad it's not quite suitable for someone who is smart but who has no programming experience to just pick up and use directly. There are too many peripheral issues not addressed for such a person.

I do consider these serious problems. The fact that I'm still giving the book 5 stars shows how good I think it is despite these issues.

The book is like Da Vinci's Mona Lisa. It can choose who would like it and who wouldn't, not the other way around. A must read for any computer engineer.

This book is a must have IMHO. I'm a professional architect/programmer for over 20 years, and I wish my professors could have used this book for our intro CS course! I just read this book for the first time recently (wish I found it when it came out!). I found it insightful, refreshing...and unlike some others: fun. If you care about your craft and enjoy programming, you'll want (and probably like) this book. If programming is just a way to pay your bills, you probably won't like it.

It is unfortunate that many of this book's detractors apparently see value only in books that are clearly and directly applicable to their current situation and requirements. Sad really, this is a symptom of why the art of programming is a vanishing art (I refer you to the Story of Mel. Now, that's a Real Programmer).

This is a book for the rest of us. This isn't a dry book (cookbook) on syntax, tricks, snippets and samples. This book captures not only the science of programming but the art; it describes the essence of programming; the philosophy of programming.

I also like this book because I like Scheme (as well as Lisp, and Prolog, and ...) but that is just an implementation detail.

...and finally if Paul Graham recommends it, it has to be good ;) because he is one of the most thought provoking essayists on programming today (with a real track record to back it up).

SICP takes you to the heart of Computer Science. It teaches you to be a computer scientist, not a programmer.

Being a Berkeley graduate having taken the 61A course with A+ (couldn't believe!), I can only say that this is a book that you read in your spare time, not when your have a project due in two weeks (or a final tomorrow). It is more philosophical than practical, and is for the aspiring computer scientists rather than those who need to get out there to make some money and buy stocks.

And it is quite advanced in theory for an introductory text. Beginners are better off with books that approach these ideas from a practical programming perspective.

This is a fantastic book. I agree with the reviewers that say this book as little to do with contemporary software design and practice, and that's a shame, because if this book HAD more influence on contemporary software design, programs would work much, much better.

This is a book about writing software, controlling complexity, identifying abstractions. It is filled with intelligence and wisdom. It is also a lot of fun.

Barry Mazur (talking about mathematics, not programming) once characterised the encounter with a genuinely new concept in terms of Gabriel Garcia Marquez's experience on reading the first lines of Metamorphosis, when he literally fell off the sofa in shock, thinking 'I didn't know you were allowed to do that'.
I still remember the same shock, even if I didn't literally fall of my chair, when, as an undergraduate, I encountered the first edition of this on the new acquisitions rack in my departmental library: I must have been the first person in the University, in Northern Ireland even, to read it, which I did, from cover to cover, over several days sitting in the library, even before it was released into the stacks.

The reason why Structure and Interpretation is the best there is, is that it manages, not just once, but several times, to deliver that fall-off-a-chair intellectual jolt. People who complain that you can only do such things in Scheme, and therefore that the ideas are pointless, are missing the point.

However gave this book low ratings just doesn't get it

Of all of the computer programming texts I have worked with, this is by far the worst and most confusing I have ever seen. But besides being confusing, it is also pointless. I've been programming for quite some time, and I have never had to use 90% of what is in this book. (Mostly because virtually all common languages come with high level constructs in their libraries for performing the kinds of low level operations that this book wants you do to by hand.)

The book attempts to introduce object oriented concepts using a language that is not at all suited for object oriented programming. But worst of all, it doesn't even explain these concepts using analogies that people can understand. And so beginning computer science students are throughly confused by the content of this book.

The language used (Scheme) has no practical real-world application. It is not even well suited as a teaching language because its syntax and constructs are unlike anything used in any common language today. In fact, trying to understand this book if you already have Java or C experience might be worse than starting from scratch, because Scheme is such a backwards language.

Basically, a confusing and poorly written textbook that teaches a totally irrelevent language which has no real world use (and doesn't do a very good job of teaching it at that).

I never heard so many interesting and different views expressed for any book.some call it a waste of time and others a classic.Some refer it as an apptitude test for comp sc and others a book that has nothing to do with modern software engineering.
I think everyone is right at its own place. It all depends on how you look at things.Their is a set of inquistive ppl in the world who wants to know why and how of every thing .. why this apple is falling towards the ground and not the otherway .. isn't this a stupid question, a lil crazy for Newton to think this way so is this book.
The author starts by exploring what a program is. what is data,procedure,abstraction,modularity what we can do with it .how to model systems and why ? well all these are trivial questions and why do we care..we are living in a world of MFC's,API's,Integrated Environments..True thats why this book is a waste of time and has got nothing to do with modern software engineering.
But if you care why the apple is falling towards the ground and if you have the faculty to wonder you are going to like this book. It will give u insight in to the programing will make u think in terms of programming and not languages.. may be will add to ur creativity..This book is not easy to read.I think this book is equally difficult for a fresher and a 10 yrs exp guy.It all depends on how gifted u are. if u have it, it doesn't matter how many years u have put in to comp sc.
If you want to make an apple pie from scratch, you must first create the universe.SICP is all about this.

I have very mixed emotions about this book. On the one hand, it is perhaps the best introductory work on the philosophical and theorectical issues of computation, dealing with many concepts that normally are either taken for granted by most programmers, or else are completely unknown to them. If you get past the dry, analytical tone (and the rather flat punnery), it actually becomes quite engaging. It is a book that demands careful thought on the part of the reader, and can reward dilligent and thoughtful study. It scrutinizes even such seeming obvious concepts as recursion and assignment, and often reveals a great deal of hidden complexity to them.

However, by itself it is not a very good primer to progamming, either in theory or in practice. The examples given are often unnecessarily tortuous, especially given the imperative to teach strict functional design in the first several chapters. Too much effort has been given to keeping it at 'pure' and 'general', and there is little attempt to connect the important ideas with how they appear in actual use.

Among the flaws is too great a concern with language independence, and specifically, an obsession with presenting the fewest possible language constructs needed to achieve a given purpose. It makes no attempt to present the Scheme language itself except where it is absolutely necessary in order to give an example; while this is done to keep the discussion as general as possible, it often has the effect of confusing the student. Many example programs which would be crystal clear with the use of certain language facilities are made hopelessly incoherent because the authors wanted to enforce 'language independence'.

Also, because many aspects of the language are ignored as irrelevant, the students learn only a small part of the language itself, and are left with the impression that Scheme is a hamstrung, pedantic language lacking in many obvious features. From reading SICP, few would ever imagine that it supported strings, characters and vectors, or had an iterative construct (do), an escape mechanism (call/cc), a macro facility (let-syntax and syntax-rules), or even basic stream I/O (read and write). Scheme is a simple enough language as it is; it need not be pared down any further no matter how noble the purpose.

More importantly, much of the presentation so abstracted as to be completely divorced from real practice, especially in the sections on imperative and OO programming. While this is a good thing in many ways, as it shows the conceptual underpinnings which are so often lost in day-to-day programming, no attempt is made to draw a connection between the theoretical abstractions and the concrete practices. The ideas are left floating aimlessly, and the student is left with no clue as to their relevance or value - which is a pity, because they truly are important, and understanding them can make the difference between a true programmer and a mere coder.

The section on logic databases is an excellent example of this. While it presents all the elements of keys, querying, unification, etc. in a lucid, detailed fashion, the databases are represented solely as list structures. No mention of files is made at all, in this section or anywhere else in the book - the word 'file' does not even appear in the index. Nor does it reveal that most database work today is based on the relational calculus, not predicate logic.

Similarly, the discussion of streams concentrates solely on their use as a way of representing change in state over time; not only are ports (Scheme's stream I/O mechanism) ignored, at no point is the student given any hint at all that the primary use of streams is for input and output. This is like discussing driving without ever admitting the existence of roads; it is abstraction run rampant. While the discussions are wondefully insightful, the student isn't given any way to apply them, even within the context of study.

In the end, I would strongly recommend this book as a supplement to an introductory course based around another Scheme text, such as Simply Scheme. While I think that every serious student of computer science (as independent from software engineering) should study it, really requires the work of a gifted teacher to make it clear, and it should never be used as the sole text. It is a brillant piece of work, and a wonderful source of key insights into programming, but it does not stand alone.

Hi

I bought Structure and Interpretation of Computer Programs and the Instructor's Manual hoping that the answers would be in at least one of them. No answers. I'm not enrolled in any school so don't have access via that route. Could someone please let me know where I can get them. Would greatly appreciate it.

Kevin

Note that his book has 657 pages, not the alleged 556 pages mentioned in the "product details".
In my humble opinion, the best book ever written on the subject.

As has already been noted in other reviews, any discussion of programming languages is as prone to generating pointed, excited intercourse as a discussion of religion is. Those who think of a college education as preparation for a job have got it all wrong. It is preparation for life.

Your success in life will depend on your ability to learn for you will need to learn far more after college than you did during college. Those who think that computer science should be taught in "marketable" languages should note that computer languages come and go. Ask a COBOL programmer. Knowing how to construct software is more important than the language of implementation. My brother is a software architect for Microsoft and most of the people that are lucky enough to get an interview are hard pressed to write code to manipulate linked lists or trees let alone discuss these most fundamental data structures!

Computer scientists in academia do all of us out here in the real world a great disservice by foisting upon us this confusing melange of mathematics and software engineering. I find the two years devoted to learning calculus and differential equations more pertinent to mechanical and electrical engineering when logic, discrete mathematics, algorithm analysis, and automata theory, which are more appropriate to software engineering, get short shrift.

SICP is an excellent step in this direction and scheme is an excellent vehicle for discussing these concepts and more. Furthermore, these concepts can be developed with a lab-oriented, engineering approach. Contrary to the beliefs of some, any algorithm can be implemented in scheme. What sets scheme apart from other languages is that a scheme program can then be devised to analyze that algorithm giving a rigorous and concrete development of the analysis of algorithms!

When it comes to software engineering learning a computer language should be the most trivial of tasks. If you can't implement a software design in the language chosen, you will be without a job. This book is by far the best for learning scheme and the fundamentals of programming and it is already considered a classic. There are, however, less challenging ones such How To Design Programs and Simply Scheme. If you find learning scheme to be difficult then you should expect learning any computer language to be difficult. For those that think the language of the day is a route to a job you might find a shorter program at a community college more suitable. Community colleges are geared towards supplying people that meet the needs of the market today.

This book is an excellent companion to The Little Schemer. TLS is a profound and witty tour of recursion theory, but does not touch on the practical considerations of creating efficient programs (and does not claim to do so). SICP provides the assiduous reader with the distinction between a procedure's definition (which may well be recursive) and the process it generates (which may be iterative). It provides the means to make informed choices about program design. In particular, the book centers on writing language interpreters, which is an excellent strategy for understanding all of the problems faced in real-world programming.

Because the book evolved from an MIT undergraduate course, the exercises tend to be thematically related to engineering concerns (math, physics, etc.), whereas TLS uses food. Do not be put off by this emphasis on math applications; the book is broadly applicable to all domains of program design, and is not *about* mathematics or engineering. Then again, you might consider the book to be an engineer's approach to program design, in that its emphasis is on correctness and efficiency, and not on abstract beauty or brevity.

It should go without saying that you will not get anything out of the book if you do not do as many of the exercises as you are able.

SICP is an excellent, perhaps the best, advanced introduction to computer science and programming. It covers topics such as functional abstraction, data abstraction, OOP, program design, constraint programming and logic programming, always from a language design point of view. You will need a decent mathematical background to follow it.

If it's such a great textbook, then why half of the reviewers hate it? Elementary: SICP is not just a textbook, it's also a Computer Science aptitude and vocational test. If you read it and like it, then Congratulations! You are a real programmer and computer scientist, with hair on your chest. If you don't like it, then you should be studying something else. Law, mortuary science, whatever, but not CS.

I would have to agree that this book has very little to do with modern software engineering. While some experience with meta-languages is certainly beneficial, spending an entire semester writing scheme progs is a solid waste of time. C++ and Java have been on a market for a Number of years (c was founded in 81), and all of the potential employers "appreciate" ur knowledge of them. Another point I want to bring is in regard to some previous reviews oversimplifying the transition from meta language to C++. Not only it is not easy, but it is also quite confusing. May be reading C++ in 24 hours gives you the idea that you are a big guy, but believe me, C++ is much more powerful than that. Take a look at The C++ Programming Language by Bjarne Stroustrup is you feel you are ready to face the challenge, but please don't stop your quest at the page X.

Review the quagmire the reviews, phew! Ok, what is going on with this book? Clarity in a nutshell, to boot!

The Book; in 300 years folks will be studying scheme and will be studying scheme right out of this book. However; Graham's, Norvig's and Knunth's books will be as accessible as a horse and carriage on I-95, I-90, I-80, I-40, and "the five."

Why is scheme important and why will scheme last? Simple. Scheme was the first version of "Lisp" to really get "lambda" correct. Scheme's ties to pure mathematics is terse complementing ~sicp~ is dense. Sicp is the most important printed literature to develop from our species in the 20th century. Why is scheme important and why will it last.

Ok, onto the Lisp posse:
Suggest a ~better~ book. Let's write "different." On scheme, Simply Scheme and How to Design Programs rock! Maybe sicp is not for you? Yeah, that does not mean you are not interested in functional programming, and you are not interested in scheme, and you are not interested in pure mathematics. Suggest a different book.

The missing case of the Lisp posse:
Maybe you are interested in C, C++ and interested in functional programming, and maybe you do not find scheme friendly. Try Haskell. And remember that there are other functional languages too: ml, o'caml. Maybe you are not satisfied with a course, a functional programming course, a CS theory course, whatever, that is taught in scheme. Well, get some guts and goto your CS dept's. Dean and demand that the university/college teach Haskell.

I think the coolest version of Lisp I have ever seen is Chaitin's version he cooked up for "~the books~." And Chaitin
rocks!

~peace yo!~

I'm not sure who the target audience is (besides the poor
MIT undergrads who are force to sift through this [junk]), but
having taught (as an assistant to a professor) a lower-level
computer science class (one not dealing with Scheme, thankfully)
I have asked many freshmen abou their thoughts on this book and
the class taught out of it.
*ALL*hated it. Some PhD students, whose specialty was programming
languages, tolerated it, while other PhD students also hated it.
So there you have it. If you are into programming languages like
Scheme, this text is for you to salivate over Hal Abelson's
self fornication (how else would you call the senseless drivel
he wrote?). Otherwise, stay away. Beginning CS students will come
away frustrated, as virtually every conventional algorithm is
NOT implementable in scheme, and those who aren't beginners
and have no inherent interest in Scheme will simply find the
book a waste of time.

This book might be a good read if you are at the beginning level or have at least ten years of computer experience. Don't read it in an intermediate state. Also it is the type of book that is a great enjoyment for people with idle brainpower. To be a successful professional in the computer field it is not necessary. It maybe even misleading. Here you have to manage solid day-to-day work and not feel like an inventor of a new language.

Prerequisites for the book are some interest in philosophy and linguistic and a slight remembrance of a few years of college math.

It contains lots of small intellectual gems. Complete explanations of a language interpreter and a compiler are more down to earth.

This book, is the first part of a 3-course introductory sequence (AKA the 61 SERIES) in "Computer Science" here at Berkeley. I'll tell you this,,, I must say that the word "INTRODUCTORY" doesn't belong there..!

I am currently enrolled in what most CS students from berkeley would recognize as CS 61A. This is one BEAST of a course! I am struggling really hard to get that "A" grade. It is a very time consuming course (that is,,if you really try to truly grasp the essence of SICP and want a good grade). There are soooo many times where i went through extreme pain and frustration just to solve "ONE" of those problems in the book! FOr example,

THE MOBILE PROBLEM!!!!!! -for those of you that know

Though, i have to say, the book is an "underlying" foundation for the Upper Division courses. It introduces you to many real-world topics,techniques, concepts like parallel distributing, object-oriented programming, streams, data-directed programming, message-passing,,, coercion, as well as environment diagrams, how to keep track of changing local state, and the main BIG IDEA,,,

DATA ABSTRACTION!

It teaches you how to write programs efficiently. Although it doesnt teach you how to program in JAVA, or C/C++,, who cares!!!! Scheme is da bomb!! and besides, after getting through with this book, you can LEARN ANY PARTICUlAR PROGRAMMING LANGUAGE ON YOUR OWN!! and in a FEW DAYS!!!! ITs cuz this book stresses you the main concepts in computer science and programming, and so...if you wannna learn JAVA, all you gotta do is just learn the syntax! Same with any other high-level programming language!!!

I can see why this book gets mixed reviews. On the one hand, it is very well written and covers some interesting ideas, but on the other hand, it has absolutely nothing to do with modern software engineering practice. If you just want a good stimulating read, then by all means buy it, but if you want to learn something of practical value to the software engineer you must look elsewhere. It also strikes me as being rather old fashioned and doesn't issues such as distributed computing or object orientation adequately.

This book is not about learning lisp. It's even only fringely about learning how to program. What's contained in it is more than a simple description of abstraction, or modularity, or anything else you'd find in an introductory text. It even escews talking about those concepts in their simplest form to a degree. It approaches them from a 50,000 foot level, discussion how everything is an abstraction, and by layering these abstractions we can build comprehensible programs. This book has the possibility to change how you think if you listen to it.

That being said, it is _not_ a book on how to build software. I've seen many good software engineers discard this book because most of the code presented has no business anywhere near a real software engineering project. Even a lot of the concepts portrayed don't belong in day to day use.

But at the end of the day, this book gets the closest I've seen to explaining the hard parts of computer science and software engineering. It's a book about patterns without explicitly discussing them. It's a book about how design software without much explicit discussion of the design process. Much like some of the abstractions and "meta" concepts that it presents, it's a book that teaches you how to learn how to learn about programming...