|
|
Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science) (Hardcover)
by Harold Abelson, Gerald Jay Sussman
| Category:
Programming, Language & tools, Computer science |
| Market price: ¥ 680.00
MSL price:
¥ 608.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
One of the true classics in computer science, now in its revised edition. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Harold Abelson, Gerald Jay Sussman
Publisher: The MIT Press; 2 edition
Pub. in: July, 1996
ISBN: 0262011530
Pages: 657
Measurements: 9.1 x 6.2 x 1.4 inches
Origin of product: USA
Order code: BA15194
Other information: ISBN-13: 978-0262011532
|
|
Rate this product:
|
|
- Awards & Credential -
One of the most read texts in the field of computer science ever written. |
|
- MSL Picks -
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.
(From quoting a guest reviewer)
Target readers:
All computer science students and teachers and programmers.
|
|
Customers who bought this product also bought:
 |
Beautiful Code: Leading Programmers Explain How They Think (Theory in Practice (O'Reilly)) [ILLUSTRATED] (Paperback)
by Andy Oram, Greg Wilson
A programming book that is simply a beauty in the eye of the programmer. |
 |
Ajax in Action [ILLUSTRATED] (Paperback)
by Dave Crane, Eric Pascarello, and Darren James
To quote Val's Blog, "A tremendously useful field guide specifically written for developers down in the trenches... waiting for the killer solution... " |
 |
Introduction to Algorithms (Hardcover)
by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
An academic masterpiece, this book is the definitive reference for data structures and algorithms with rigorous coverage of the most widely used algorithms. |
 |
Combinatorial Optimization: Algorithms and Complexity [UNABRIDGED] (Paperback)
by Christos H. Papadimitriou, Kenneth Steiglitz
Published in 1952, this books is a masterpiece on Combinatorial Optimisation. |
 |
Web Standards Solutions: The Markup and Style Handbook (Pioneering Series) (Paperback) (Paperback)
by Dan Cederholm
An excellent book contrasts the old way of designing web pages with new while, showing the reader the advantages of using web standards. |
 |
Eric Meyer on CSS: Mastering the Language of Web Design (Paperback) (Paperback)
by Eric A. Meyer
A collection of 13 redesign projects, each illustrating different aspects of CSS layout techniques and HTML, with a philosophy, a way of thinking, and a collection of ideas underneath. |
 |
Beginning Linux Programming, Fourth Edition (Paperback)
by Neil Matthew, Richard Stones
A well-written book for beginners that covers a wide range of topics, starting from shell programming and ending with device drivers.
|
 |
C: A Reference Manual (5th Edition) (Paperback)
by Samuel P. Harbison, Guy L. Steele
Simply indespensible, this widely acclaimed is probably the only C reference a serious programmer needs. |
 |
How to Lie With Statistics (Paperback) (Paperback)
by Darrell Huff , Irving Geis
|
 |
Expert C Programming (Paperback)
by Peter van der Linden
Unparalleled in content and very engaging to read, this book is a must read for all C programmers. |
 |
C Programming Language (2nd Edition) (Prentice Hall Software) (Paperback)
by Brian W. Kernighan, Dennis M. Ritchie
Classic, bestselling introduction that teaches the language and illustrates useful algorithms, data structures and programming techniques. |
 |
What Is Mathematics? An Elementary Approach to Ideas and Methods (Paperback)
by Richard Courant, Herbert Robbins
A 1996 revision of a timeless classic originally published in 1941 and "a lucid representation of the fundamental concepts and methods of the whole field of mathematics." (Einstein) |
 |
Concrete Mathematics: A Foundation for Computer Science (2nd Edition) (Hardcover)
by Ronald L. Graham, Donald E. Knuth, and Oren Patashnik
Overall this is a must-have book for anyone in CS even thought it's a little bit too hard for non math-trained people. |
 |
Programming Pearls (2nd Edition) (ACM Press) (Paperback)
by Jon Bentley
A compendium of 15 columns previously published in Communications of the ACM, Jon Bentley's book has been a real classic on computer programming. |
 |
CSS Mastery: Advanced Web Standards Solutions (Paperback) (Paperback)
by Andy Budd, Simon Collison, Cameron Moll
A brief but concise book that covers everything you need to know to build an effective web standards CSS site. |
 |
Head First Design Patterns (Head First) [ILLUSTRATED] (Paperback)
by Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
Written in a typically Head First refreshing style, this is one of the easiest to read and absorb among the major reference sources for design patterns. |
 |
Thinking in Java (4th Edition) (Paperback)
by Bruce Eckel
A book that has many awards and raves from programmers worldwide for its extraordinary clarity, careful organization, and real life examples. |
 |
Head First Java, 2nd Edition [ILLUSTRATED] (Paperback)
by Kathy Sierra, Bert Bates
A wonderful job of explaining not only the how-to, but also the "why" of Java fundamentals, in very down-to-earth language. |
|
|
Harold Abelson is Class of 1992 Professor and MacVicar Teaching Fellow, and Gerald Jay Sussman is Matsushita Professor of Electrical Engineering, both in the Department of Electrical Engineering and Computer Science at the Massachusetts Institute of Technology. They have each received major computer science education awards: Abelson the IEEE Computer Society Booth Award and Sussman the ACM Karlstrom Award. Julie Sussman is a writer and editor, in both natural and computer languages.
|
|
From Publisher
Structure and Interpretation of Computer Programs has had a dramatic impact on computer science curricula over the past decade. This long-awaited revision contains changes throughout the text. There are new implementations of most of the major programming systems in the book, including the interpreters and compilers, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published. A new theme has been introduced that emphasizes the central role played by different approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming and lazy evaluation, and nondeterministic programming. There are new example sections on higher-order procedures in graphics and on applications of stream processing in numerical programming, and many new exercises. In addition, all the programs have been reworked to run in any Scheme implementation that adheres to the IEEE standard. Visit the SICP2 web site!
|
Joseph Osako (MSL quote), USA
<2009-01-24 00:00>
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. |
|
|
|
|
