Structure and Interpretation of Computer Programs (MIT Electrical Engineering and Computer Science)by Harold Abelson, Gerald Jay Sussman, Julie Sussman Published 25 Jul 1996
|Structure and Interpretation of Computer Programs (MIT Electrical Engineering and Computer Science).pdf|
Download Structure and Interpretation of Computer Programs (MIT Electrical Engineering and Computer Science) (2014) PDF ePub eBook
- 1. Register a free 1 month Trial Account.
- 2. Download as many books as you like.
- 3. Cancel the membership at any time if not satisfied.
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 (MIT Electrical Engineering and Computer Science)" Reviews
The book was awesome! Abelson and Sussman have created a masterpiece. It provides a great introduction to computer science. The book contains a lot of back referencing and you need to understand previous material in order to grok what you're currently reading. The exercises are key - you can probably accomplish it without doing them, but they really, really help reinforcing the knowledge. They are also fun to do.
The book starts slowly. It might seem a bit basic for the experience programmer, yet I still found it worth to work through the exercises and appreciate the fine points the authors are making. It's worthy to note that the first 2 chapter (out of 5) don't even introduce state. They just elaborate a lot on functions and lists. Chapter 3 becomes more interesting, as state and environments are introduced.
The real gem lies in the final two chapters. Chapter 4 covers interpretation. It starts with writing a rudimentary Scheme interpreter (in Scheme) and continues with two modifications - a lazy version and a non-deterministic version (an interpreter that performs backtracking). The chapter concludes with a logical programming language akin to Prolog. Chapter 5 goes into compilation. First it explores a register machine simulator and afterwards it implements a Scheme evaluator in that register machine using the primitive instructions. The final step is writing a compiler that compiles Scheme code to primitive instructions.
The cherry on the pie is the last three exercises. First you have to compile your Scheme interpreter to the register machine simulator. Afterwards, you have to implement the evaluator in C (based on the one you wrote for the register machine) and provide with the necessary runtime operations (which mostly means memory and garbage collection). Finally, you modify the compiler to generate C code and compile the interpreter, resulting to a Scheme implementation on C.
Apart from fun, the material is a great introduction to a wide variety of topics. If you just want to have a sense about computer science, this is a great book. While it won't go into more advanced topics (such as various compiler optimizations, parsing or advanced data structures), it does a great job of wetting your appetite and giving you and overview. Plus, I cannot state that again - it is so much fun to read and do the exercises.
It took me quite a while to read. I've been wanting to complete it for ages. I started seriously in March 2012 with a study group. We managed to keep up to nearly the end of chapter 3, after which I continued on my own. Out of the time since, I've spent 19 weeks in total on reading and doing exercises. I have my solutions (and various other notes) on GitHub:
I read this on the advice of Dr. Eiselt, Dean (at that time) of the College of Computing, after asking him via email "alright, I'm taking classes and whatnot, but I want the Stygian deep; I want to go down as far as I can; I want and need to read those books which have shaped the great computer scientists before me, the real thing." Having probed the shelves of computer science and mathematics since, I remain convinced he could have given no better advice to a precocious freshman. Used for several decades at MIT, this second edition is more than thorough enough for an introduction to computer science anywhere. Taught using the Scheme system (with its close bindings to the type-free λ-calculus), this canonical work covers register machines, logic programming, nondeterministic evaluation, the relations of recursion to iteration, and a wealth of carefully-woven-in jewels from number theory and discrete mathematics. Every programmer thinking himself the real deal owes it to himself to read through this grand work, epic in scope and breathtaking in sudden illuminations.
A work of art. SICP will make you a better programmer in the same way that reading Dostoevsky will make you a better writer.
Nearly a decade ago when I first started college as a wide eyed computer science student, this book instilled a deep passion for programming into me. To this day, I can pick up and reread any section of this book and that passion is reinvigorated. There have been volumes written about the brilliance and beauty of this book by people smarter than me. Every bit of this praise is deserved, and I do not need to add to that chorus. I would instead like to mention a different facet of what makes this book so great. This book is fun, this book makes the art of programming fun.
My favorite fiction books are by far and away the Harry Potter books. I do not find the prose of these books all that great, the action isn't entirely amazing, and the neither the characters nor the plot are particularly special. So what makes the Harry Potter books so great? I think it is the way J.K. Rowling's describes magic, and the world that is built up around magic. She puts you in the shoes of these characters, and captures how awesome it would be to be able to do magic.
Abelson and Sussman do the same thing with SICP, but the magic is real. Anyone can pick up this book and a Scheme interpreter and do great and magical things. This book made the University of Minnesota my Hogwarts, and I cherish it for that.
I must now lay one heavy critism upon this book, though really not on the book itself, but rather the context in which it is generally used. This book is not appropriate for introductory computer science courses. I was a teaching assistant for eight semesters for the introductory computer science course at the University of Minnesota that uses this book. Over that time, I went from thinking this book was perfect for this course, to strongly thinking this book was perfect, to a gradual realization that this book is not very good at all for the course.
I spent a not insignificant amount time studing is cognative learning theory while in graduate school. What I learned from literature in that field paired with my own observations are what lead me to eventually realize this book is not appropriate for an introductory course. A certain segment of people are motivated by the abstract, and learn from general prinicples. I think this book is perfect for these people. Professors tend to disproportionately be motivated in this fashion, and I think this accounts for popularity of this book.
This is not a majority of people however, this is not even a majority of students who graduate with Computer Science degrees. A python or ruby book focused on practical, real world examples and examples that have a graphical or tactile component in some way would do a vastly better job motivating computer science for the typical student.
I think a lot of professors do not realize this. More distributingly though, there are many professors who realize this but continue to advocate this book because they feel it weeds out the people that cannot cut it in computer science. This is a profoundly wrong and chases a lot of people away from the field who would have a lot to add once they left the confines of acedamia and it self selecting focus on the abstractly motivated. If acemdemia did not filter and select in this manner, I think you would see more diverse population of top tier programmers. I think you would see more programmers with social skills, programmers with less arrogance. This in turn would help the whole community. Asking for help would be less stigmatized, "not developed here" would be less of a problem. Standards bodies developing specifications would likely have more individuals who focus on the practical implicaitons.
I have however strayed wildly into the arena of complete speculation. What I am trying to say ultimately is that I think this is a must read book for computer science students, but I think it would be more appropriate for half of a junior level course on programming paradigms than the whole of an introductory course on programming more generally.
Imagine two sophomore computer science majors in a dorm room late at night. One of them, possibly under the influence of a recently decriminalized substance, turns to the other and asks, "Have you ever thought about what a computer program is. I mean, have you ever *really* thought about it?"
This book is a good answer to that question. The title is apt, it really is about the structure and interpretation of computer programs. It's an enlightening read, but I write this as somebody who has been programming for twenty years now. It's hard for me to imagine how a novice would react to this sort of book.