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

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

231 customer reviews

ISBN-13: 978-0262011532

ISBN-10: 0262011530

Why is ISBN important?

Trade in your item
Get a $8.99
Gift Card.

Trade in
Learn More

Have one to sell? Sell on Amazon

More Buying Choices

7 New from $108.06 18 Used from $59.40 1 Collectible from $139.00

26 used & new from $59.40

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

68

Paperback
$33.61
Matthias Felleisen

18

Hardcover
$65.64
Gerald Jay Sussman

5

Paperback
$34.00
Charles Petzold

385

Paperback
$15.71
Noam Nisan

86

Paperback
$30.07
Brian W. Kernighan

671

Paperback
$49.08

What other items do customers buy after viewing this item?

The Pragmatic Programmer: From Journeyman to Master Paperback

Andrew Hunt

348

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

Steve McConnell

463

$34.09
The Little Schemer - 4th Edition Paperback

Daniel P. Friedman

68

$33.61
Code: The Hidden Language of Computer Hardware and Software Paperback

Charles Petzold

385

$15.71

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).

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: 231 customer reviews
Amazon Best Sellers Rank: #351,919 in Books (See Top 100 in Books)
- #20 in Books > Computers & Technology > Programming > Languages & Tools > Lisp
- #53 in Books > Computers & Technology > Programming > Languages & Tools > Compilers
- #405 in Books > Textbooks > Computer Science > Software Design & Engineering

Would you like to tell us about a lower price?
If you are a seller for this product, would you like to suggest updates through seller support?

NO_CONTENT_IN_FEATURE

Important information

Ingredients

Example Ingredients

Directions

Example Directions

Customer reviews

231

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

Rated by customers interested in

What's this?

Software Engineering Books

4.5 out of 5 stars

Engineering & Transportation Books

5.0 out of 5 stars

Computer Science

4.8 out of 5 stars

Is this feature helpful?

Thank you for your feedback.

Top customer reviews

Great book. Has changed my perspective on the subject

ByIkki Fenixon December 31, 2016

Format: PaperbackVerified Purchase

Great book. Has changed my perspective on the subject. I would classify it as an advanced book in the subject of computer programming. If you have a solid understanding of the fundamentals of computer science I recommend reading this book.

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

A groundbreaking way to look at computer science

ByRalph Optionalon March 4, 2013

Format: HardcoverVerified Purchase

This book was a series of lecture notes and handouts when I attended school. I purchased a bound copy long after I'd take the course, to introduce my children to this way of thinking. Abstraction, Lisp, and the Object-oriented style of programming are all introduced. The problem sets go into useful application areas, and the writing style is straightforward. You may have to search a bit to find a vintage Scheme compatible with the exercises used in the book - people on the Internet (particularly the scheme community) are very helpful here.

Good luck! This will change how you think about software, and in a mind-expanding way.

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

A Classic

ByVijayon February 2, 2017

Format: PaperbackVerified Purchase

I wish I would have read this book 10 years back... This is a classic. Must read for every computer scientist.

0CommentWas this review helpful to you?YesNo

Amazing Book with Some Negatives

ByNavySealon April 22, 2013

Format: PaperbackVerified Purchase

I will explain the bad and then the good things about this book. There are a couple of bad things, but chief among them the ridiculous assumptions the author makes about the reader. If you do not have a solid mathematical background DO NOT GET THIS BOOK. You will be hopelessly confused at multiple points. The authors do not explain any mathematical reasoning save a few examples. That is my main complaint, but I did have a thorough mathematical background before using this book. One other thing is that the book doesn't go through algorithmic complexity, which is a fairly important concept. This book does explain many computer science techniques fairly well. Out of the parts I have read the only topic lacking is message passing. I found the section to be quite short. If you can read a section and reflect it will allow you to grasp the implications of the material in front of you. WARNING: You do need critical thinking skills and the ability to analyze what you are reading. One other thing is that some of the problems given throughout the book can be REALLY difficult. If you get stuck don't be afraid to ask for help or look up an explanation online. Other than that I will be holding on to this book for years to come. I did enjoy going through it.

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

Three Stars

ByVijay Misraon August 30, 2017

Format: PaperbackVerified Purchase

0CommentWas this review helpful to you?YesNo

Worth the trouble.

ByPatrick Carrollon February 24, 2000

Format: HardcoverVerified Purchase

Working through this book reminded me of a couple of lines from "Zen and the Art of Motorcycle Maintenance": "How do you paint the perfect picture? Make yourself perfect, then paint naturally." How do you write perfect code? Make yourself perfect, then write code naturally. This book is a great way to perfect yourself for coding. If you find the approach a little too dry and academic, then try "The Little Lisper" or "A Little Java, A Few Patterns." These don't cover the same range of subjects, but they get you thinking in a good way about how to develop solutions.

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

Excellent book for learning concepts in Computer Science

Byairekanson September 24, 2012

Format: PaperbackVerified Purchase

This book is great for people that want to learn the key ideas in Computer Science.
I've never seen a book covering so much topics and explaining them in such a easy-to-understand way.
It talks about Functional Porgramming, OOP, Data-directed Programming, Concurrent Programming, Stream-Oriented Programming.
Especially the OOP part. I think it helps me to understand the Object Model behind a lot of other OO language.
And in chapter 4, it guides reader to write a real Scheme interpreter. By reading through this chapter, I understand the internal mechanism of the interpreter, and several different interpreter models, including lazy evaluation, indeterminism programming and logic programming.
I've learned a lot from it.