Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science) 2nd Edition

by Harold Abelson (Author), Gerald Jay Sussman (Author)

229 customer reviews

ISBN-13: 978-0262011532

ISBN-10: 0262011530

Why is ISBN important?

Trade in your item
Get a $8.23
Gift Card.

Trade in
Learn More

Have one to sell? Sell on Amazon

Rent

$28.09

Due Date: Aug 11, 2017 Rental Details

FREE return shipping at the end of the semester.
Access codes and supplements are not guaranteed with rentals.

In Stock. Rented from Amazon Warehouse Deals , Fulfilled by Amazon

List Price: $86.00 Save: $57.91 (67%)

Free Shipping

Add to Rental Cart

More Buying Choices

5 New from $107.81 20 Used from $54.63 1 Rentals from $28.09 1 Collectible from $139.00

27 offers from $28.09

See All Buying Options

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student

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.

Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)

Available from these sellers.

Customers who bought this item also bought

Page 1 of 1 Start overPage 1 of 1

This shopping feature will continue to load items. In order to navigate out of this carousel please use your heading shortcut key to navigate to the next or previous heading.

Daniel P. Friedman

67

Paperback
$24.99
Matthias Felleisen

18

Hardcover
$64.34
Frederick P. Brooks…

290

in Microprocessor Design
Paperback
$23.81
Brian W. Kernighan

659

Paperback
$42.44
Gerald Jay Sussman

5

Paperback
$33.11
Charles Petzold

370

Paperback
$14.96

What other items do customers buy after viewing this item?

Code: The Hidden Language of Computer Hardware and Software Paperback

Charles Petzold

370

$14.96
Code Complete: A Practical Handbook of Software Construction, Second Edition Paperback

Steve McConnell

461

$26.79
The Pragmatic Programmer: From Journeyman to Master Paperback

Andrew Hunt

347

$28.94
Clean Code: A Handbook of Agile Software Craftsmanship Paperback

Robert C. Martin

344

$38.82

Editorial Reviews

Amazon.com Review

Abelson and Sussman's classic Structure and Interpretation of Computer Programs teaches readers how to program by employing the tools of abstraction and modularity. The authors' central philosophy is that programming is the task of breaking large problems into small ones. The book spends a great deal of time considering both this decomposition and the process of knitting the smaller pieces back together.

The authors employ this philosophy in their writing technique. The text asks the broad question "What is programming?" Having come to the conclusion that programming consists of procedures and data, the authors set off to explore the related questions of "What is data?" and "What is a procedure?"

The authors build up the simple notion of a procedure to dizzying complexity. The discussion culminates in the description of the code behind the programming language Scheme. The authors finish with examples of how to implement some of the book's concepts on a register machine. Through this journey, the reader not only learns how to program, but also how to think about programming.

About the Author

Hal Abelson is Class of 1922 Professor of Computer Science and Engineering at Massachusetts Institute of Technology and a fellow of the IEEE. He is a founding director of Creative Commons, Public Knowledge, and the Free Software Foundation. Additionally, he serves as co-chair for the MIT Council on Educational Technology.

Gerald Jay Sussman is the Matsushita Professor of Electrical Engineering in the Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology. He is also the coauthor of Structure and Interpretation of Computer Programs (MIT Press, second edition, 1996).

NO_CONTENT_IN_FEATURE

Product details

Series: MIT Electrical Engineering and Computer Science
Hardcover: 657 pages
Publisher: The MIT Press; 2 edition (July 25, 1996)
Language: English
ISBN-10: 0262011530
ISBN-13: 978-0262011532
Product Dimensions: 9.1 x 6.2 x 1.4 inches
Shipping Weight: 2.3 pounds
Average Customer Review: 4.5 out of 5 stars See all reviews (229 customer reviews)
Amazon Best Sellers Rank: #355,038 in Books (See Top 100 in Books)
- #19 in Books > Computers & Technology > Programming > Languages & Tools > Lisp
- #70 in Books > Computers & Technology > Programming > Languages & Tools > Compilers
- #431 in Books > Textbooks > Computer Science > Software Design & Engineering

If you are a seller for this product, would you like to suggest updates through seller support?

Important information

Ingredients

Example Ingredients

Directions

Example Directions

Customer Reviews

229

4.5 out of 5 stars

5 star		63%
4 star		8%
3 star		5%
2 star		1%
1 star		23%

Write a customer review

See all verified purchase reviews

Top Customer Reviews

The best programming book ever, if you're a certain kind of person

ByJaime Silvelaon August 26, 2014

Format: PaperbackVerified Purchase

This was the book that made me want to be a computer programmer. When I read it, I had no knowledge of programming beyond a little Pascal, and rudiments of C.
It had a massive impact on me. It consumed me, to the point where I had difficulty finishing assignments for my classes (I did not study CS as an undergrad). What the book does is give you a vocabulary and knowledge about programming that is hard to find anywhere else.

The text, the examples and exercises, have a mathematical flavor, and that may turn off many potential readers, who would rather gadget around than find elegant solutions for the 8-queens puzzle or efficient algorithms to compute Fibonacci numbers.

I've lent this book to several friends who were interested in learning to program, and in all cases they have returned it to me, saying it went over their heads.
There seem to be two camps in computer programming:
- the gadgeteers, who want to hook devices together and make them do fun things
- the scientists, who appreciate computing as a medium in itself
This book is for the second type.

11 comment 26 people found this helpful. Was this review helpful to you?YesNo

Describing Lisp as a functional programming language isn't the best approach

ByThe Green Dasheron June 19, 2017

Format: PaperbackVerified Purchase

A few comments, if I may.

Lisp is not a functional programming language. It was never designed to be a "functional programming" language. But because it was the first to use some functional programming capabilities many decades before they became available in other languages (eg functions as first-class objects) it has always been given that association. Lisp most certainly doesn't fit just that category - it is decidedly imperative in many (most) ways, with the difference being that the language gives nearly unrestricted power to the programmer to decide how to use it. The macro capabilities of Lisp are untouched by anything else, and Lisp's primitives are more accurately described as meta-primitives. Perhaps more than any other language, it is truly multi-paradigm. So to my mind, talking about Lisp as primarily a functional programming language betrays a lack of subject understanding.

I have learned to be agnostic about OOP as a design paradigm. For those who have drunk that particular kool-aid, the CLOS provides a capable way to deploy software. But most Lisp programmers don't take long to realize that the ideas of encapsulation and scope are realized in Lisp as closures, a much more general and powerful abstraction. OOP is but one implementation of this abstraction. See Doug Hoyte's wonderfully opinionated book "Let Over Lambda" for the most advanced treatment of Lisp closures and how they can be used to build other languages (or even, trivially, implement most OO techniques). You should have read Paul Graham's "On Lisp" to fully understand the Hoyte book.

Lisp wasn't designed to be easy to use. It wasn't designed to coddle a programmer. It's a powerful collection of primitives and design features (eg homoiconicity) that provide a platform upon which intelligent people can use reasoning and mathematics to construct powerful software. This book, dated and pedantic as it seems, provides most of the basic CS tools needed to tackle problems using a "wholemeal" approach. If you approach this book as if it were a how-to cookbook, you will be disappointed - it's a lot of work for that. If you approach it in a way that allows it to open you to ways of programming that you most likely have not thought about before, then there are some amazing things to learn from this book. It helps if you have an innate fundamental curiousity about Computer Science rather than just a simple urge to "learn a new language".

The dialect of Lisp used by this book is Scheme, which has traditionally seen most use in academic settings because illustrating some concepts is simpler than with today's mainstream dialect, Common Lisp. For purposes of this book though, it doesn't matter - you're reading this to learn a way of programming that is fundamentally different than what you've done before. The minor language differences are not material here.

0CommentWas this review helpful to you?YesNo

Computer Science...Art?

ByB. Deanon January 27, 2009

Format: HardcoverVerified Purchase

You need it, too. I won't pretend to have more useful insight into the art and craft of programming, or into SICP's relationship to it, than Paul Graham or Peter Norvig- if you want to know which reviews to trust, look these cats up.

The discussion in the reviews usually concludes that this is the book that separates the computer scientists from the mere programmers. There is a definite logic to this. If you want a book that will have you churning out code that does something helpful in half an hour(because you don't think the several ways to calculate the Fibonacci Sequence are helpful), by all means, pick up Learning Perl or just read the Python documentation. They are great tools. If, however, you want to tool up on problem-solving technique a whole level or three higher up, SICP is for you. The Wizard Book is about learning to think better.

Here is where I diverge from the idea that this book is for only computer scientists, though. I am an artist, graduated from college with a BA in art, going to graduate school for an MFA. SICP is one of the books that changed how I work and think. It will make you a better programmer if you read (and reread (and reread)) it in the same way that learning Latin will make you understand language itself in a whole new way. I use ideas from SICP constantly, to design software, but also to design staircases. The book is slow-going, no doubt about it, but you'll have a whole new mental toolset at the end.

One caveat- this book is freely distributed in its entirety on MIT's website. I still bought a copy, though: who knows how long this internet thing will last, but SICP is going to be relevant forever.

0Comment 21 people found this helpful. Was this review helpful to you?YesNo

Content: 5 Stars. Printing: 0 Stars

ByGeri Perryon July 31, 2016

Format: PaperbackVerified Purchase

The content is phenomenal. But shame on you MIT Press for the actual printing of this book.

There are numerous reviews here that discuss the merits of this book. Rather than repeat what's already been said numerous times, I'm going to tell you something new that you should know before purchasing this (expensive) book. For $50, MIT Press could have done MUCH better.

1. The paper is cheap. Highlighting will show through on the opposite side. Terribly annoying.
2. The binding is cheap. For a book of this caliber and price point, it should have a "lay flat" binding.
3. The covers are cheap. I've only been reading the book for 1 week, and the clear plastic coating is already peeling up from the edges of both front and back covers.

This is easily a 5-star book with regards with its content. Unfortunately, MIT Press gets 3 for making extremely poor printing decisions. Maybe greedy is a better description. Books of this caliber should last a lifetime. This one won't come close.

Regards ~ Jason Perry (purchased by Geri Perry)