Structure and Interpretation of Computer Programs by Harold Abelson

Structure and Interpretation of Computer Programs Reviews

• 
  Stefan Kanev

  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:
  
  
  https://github.com/skanev/playground/...
• 
  Nick Black

  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.
• 
  Michael Nielsen

  This is a gorgeous book.
  
  It's a famous book within its field, and for years I put off reading it, assuming it would be difficult, technical, and esoteric. I opened it up one day, and discovered that it's just marvelous, full of glorious ideas, beautifully explained. I quickly inhaled the first quarter or so of the book, and later went back and read a few other large chunks. I look forward with anticipation to the right time to read the remainder.
• 
  Michael

  A work of art. SICP will make you a better programmer in the same way that reading Dostoevsky will make you a better writer.
• 
  Neill

  If you are a programmer or are majoring in computers in college in any shape, form, or fashion, read this book. Let me reiterate: If you're a programmer and you don't read this book you're worthless. If you're a sys admin, and you write with scripting languages to do administrative tasks, and you don't read this book, you're worthless. If you program for websites using javascript, ajax, .NET, etc., and you don't read this book, you're worthless.
• 
  Lorin Hochstein

  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.
• 
  Zhi Han

  In an ideal world, everybody learns Scheme as their first programming language and knows recursion, lambda, closure and multi-paradigm programming as his/her first step to programming. The software of that world would be more efficient, more manageable, more straightforward, more readable and contains less bugs. Unfortunately, this does not apply to most working engineers, including me.
  
  Brian Harvey [
  link] is right. This is one of the best books ever written in computer science. It uses a narrative structure to explore the formalism for the foundation of computer programming languages. It amazes me how the book can be done in such a beautiful way that reading the book does not feel like reading a textbook at all. The Berkeley videos at YouTube makes the lectures freely available on the web, which are really helpful for reading this book.
  
  The book is a wonderful exposure of the fundamentals of functional programming way of thinking, providing complete implementation of all the algorithms in Scheme. And the authors explain all the details of the algorithms, the challenges, the effort, a little bit of the history and the solution. Nothing is hided from the reader, and everything seems to be so beautifully simple. This book demonstrates a style of combining narrative and theoretical development in a book. As the book goes on, more and more and the technical details are revealed and in the end everything just makes sense.
  
  I feel lucky that I read the book. Even though I was not lucky enough to read it as a college freshman.
• 
  Bjørn Borud

  It has been more than a decade since I last read this book. I didn't think this was a good book for teaching young people how to become programmers when I first read it and I think it is even less true today. There are two reasons I think this. First off: I think this is a book that people who have forgotten what it was like to learn programming tend to recommend. Usually after falling in with the Lisp crowd and spending a considerable amount of time boring everyone around them by bemoaning the fact that "nobody loves Lisp, and by the way, all the good parts of other languages stole from Lisp". Nobody I know started with material like SICP -- they wrote programs, ran into unknown problems and then were motivated to hit the books before hammering out more code.
  
  Which brings us to my second reason: today kids don't hit the books. They hit Stack Exchange to look for solutions they can cut and paste, and have attention spans that makes the MTV generation look like a bunch of stoic philosophers having their two hour afternoon nap. A five second ad on youtube makes their heads nearly explode. This book will be a hard sell.
  
  People learn to program because they want to write software. Not read books. At least not at first. Sure, there is a tiny minority for whom this book will be the best thing since cat videos on youtube, but those are the people you see cornering some poor sod at a party and boring them to tears.
  
  If you want to teach people how to write software you have to start by accepting they want to write software that does stuff in the real world. And for that you need a far more pragmatic approach. This book comes later.
• 
  Keith

  Twenty hours of video lecture by Abelson and Sussman are available through
  MIT Open CourseWare, though it is worth noting that these classes used the first edition of the textbook.
• 
  Ettore Pasquini

  One of the most inspiring computer books I ever read. Brilliantly written, it almost makes you want to read it like a "normal" book. The AI course I took only required to read a few parts of it, but I continued reading this book instead of other things I was supposed to read. (I gave it credits for the A I actually got. :))
  
  It's not just about LISP, really. It teaches you about a powerful, expressive tool (LISP) but it goes beyond simple syntax and shows you how to actually phrase the problem correctly in order to solve it in the easiest, most elegant way. I loved programming more after reading this book.
• 
  Satyajeet

  
  
  
  
  Downloadable PDF version here:
  
  https://github.com/sarabander/sicp-pd...
• 
  Hưng Đặng

  <đang cập nhật>
  Cuốn này tớ đọc lướt từ tháng 1. Mà do đọc lướt nên không làm bài tập. Rất nhiều các review khác tin rằng đây là một tội lớn và chắc là thế. Ý tưởng của tác giả đến với tớ rất mơ hồ.
  
  Lý do review 4 sao ko phải do thiếu sót gì của tác giả mà phần nhiều là tớ ko chạy một dòng Scheme/Lisp nào cả nên bỏ lỡ rất nhiều những kiến thức ở đây.
  
  Một lượng kha khá Toán được học và ôn tập như phương pháp Newton để ước lượng căn bậc 2. Nhắc lại phương pháp Euler để tìm UCLN. Lý thuyết của Lamé và Fermat. Số phức được áp dụng để mô tả data-directed programming. Một số từ vựng TA về Toán mà tớ ko biết "linear combination, polynomial, rational function and trigonometric function" là những thứ sẽ được đọc thêm.
  
  Về lập trình tớ học được khái niệm Higher order procedure mà sau này đc áp dụng ở rất nhiều nơi như HOF hay HOC. Khái niệm về lamda có vẻ giống anonymous function. Tìm giá trị của phương trình bằng phương thức half-interval. Closure đc đề cập ngay ở dữ liệu phức tạp. Cấu trúc dữ liệu "pair" đc giới thiệu để xây dựng 1 cấu trúc phức tạp hơn "list".
  
  Có một câu mà tớ thấy phản ảnh triết lý "single source of truth": It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures.
  
  Trong chương 2, tớ đc thấy biến đổi dữ liệu từ dạng list sang dạng binary tree. Tớ sẽ muốn tự triển khai dạng dữ liệu này sau khi đọc xong. Chương cũng đề cập đến module hóa code và cách thức dùng data direct programming tránh naming conflicts. Ngoài ra "message passing" là phương pháp hay khác đc sử dụng nhiều trong chương 3 mà tớ sẽ muốn được nghiên cứu sâu hơn.
  
  Chương 3 tập trung nói về oop mà ở đây từ hay đc dùng là assignment. Oop mặc dù với khả năng module hóa cao nhờ các object lại gặp phải vấn đề rất lớn về sự phức tạp khi object biến đổi. Sự phức tạp này tăng gấp bội khi ta sử dụng đa nhiệm cùng oop. Cũng từ đây tớ nhận ra sự dễ hiểu của fp khi i/o nhất quán nhưng với lập trình hiện đại, ko thể tránh khỏi việc biến đổi state (thường là object). Về xử lý đồng thời là một thách thức lớn với oop mà một phương pháp đc đề cập đến ở đây là "serialization". Khái niệm "stream" - chia nhỏ dữ liệu lớn có gì đó tương đồng với Promise mà t học trong js. T ko tưởng đc sự phức tạp lớn đến đâu khi áp dụng stream cho state để xử lý đồng thời.
  
  Chương 4 phát triển ý tưởng ngôn ngữ lập trình cần phù hợp với vấn đề mà nó giải quyết. Từ đó giúp ta suy nghĩ tốt hơn về vấn đề phải đối mặt. Trên ý tưởng này, chương dạy cách xây dựng "evaluator" cho một ngôn ngữ. Tới thời điểm này Lisp đc sử dụng khác đi cho công việc quản lý database.
• 
  Rick Sam

  I used to work at a Startup, quite an interesting life.
  
  I went back to connect the dots of Computing in Business World.
  
  While people can code in many different languages, or new tools, frameworks, might pop up.
  
  Actually, if you understand the foundation stuff, you can comprehend it.
  
  I came across this book, to help me understand, behind the scenes of Computing.
  
  As with the reviews, I do believe this is an important book.
  
  It's going to help you form abstraction. It will give you the foundational base.
  
  Sometimes, I dream that a Computer is layers of the movie Inception.
  
  Too many times, I come across people in industry -- who would say, I program in 10 different languages, and thump their chest. There's nothing wrong with a person who has the ability to program in 10 different languages.
  
  The more important ability -- is to master abstraction, represent problem-sets and solve them. For this, one can use a programming language of his own choice contingent upon the requirements.
  
  If you do not read this book, Yes, I'd reiterate you'd be a garbage programmer. This is regardless of domain or language.
  
  I really appreciated this book. It uses LISP. I think, what matters to a reader is raising the ability of understanding. If you want a summary of it, do send me a message.
  
  I would recommend this to anyone involved with building software, researchers, engineers.
  
  Deus Vult,
  Gottfried
• 
  Jake

  I can't quite say how good this book is - and as such - you should prob ignore my star -ing. I mostly gave it 4 stars as a response to what I took from it.
  
  I will admit though, I have committed the crime of not doing any of the exercises on my computer, and as such there is a great deal that is lost - from the authors intent, and to my review . The text is mostly a run through of exercises, and that if studied, bring about a understanding of very simple computer programs. It will further, introduce the reader to the logic of software - in a primitive sense - and moving forward, allow the reader to seek out more sophisticated texts and experiences with software.
  
  This certainty aided me in understanding the types of logical issues software developers typically deal with, and how it is they resolve those issues. For this, I give it my rating - as I am most appreciative. Perhaps though I may change my view of the book as I move further into the literature. Who knows
  
  Recommended for :
  
  - those interested in how your computers do things and are willing to start small
  - intro level software developers
  - those who enjoy logic + puzzles ,and are willing to take a new approach
  - mathematicians interested in computers
• 
  Hunan Rostomyan

  This is one of those books that changes you. If I could save only one computer science book from destruction, this would be it. The book features LISP, but the insights are universal.
  
  I had the fortune to take my first computer science course with Brian Harvey, who helped digest some of the trickier ideas in the book.
  
  It's been 10 years; I have to re-read it.
• 
  ambivalent_crab

  This is a famous book which most of the people related to programming know about, since it often shows up in various "top N cs/programming" books lists.
  Naturally, I decided to give it a shot, started and dropped it a couple of times.
  Eventually, I've got some free time and spent about a year with this book, trying to solve as many exercises as possible.
  
  That was certainly not an easy road, but I'm glad I've taken it.
  The amount of things I've learned from this book is astonishing, and some concepts were so wild that I would literally grab my head and ask: "Is this real world?".
  Every chapter was brilliant in it's own way, but chapters 4-5 are probably my favourite. Hard to believe how much you can build using such a minimalistic tool.
  
  This book taught me some things that weren't explicitly mentioned on the pages.
  First, if I haven't implemented something, I probably don't understand it. Interpreter had always been a mystery until I actually implemented a rudimentary analogue.
  Second, testing in dynamic languages is must have. I had some real quality time debugging through multiple layers of interpretation only to discover that I actually had to return a list of one element instead of the element itself.
  Or, maybe just use statically typed language that eliminates problems like these at compile time. Despite my fascination with Lisp as dynamic and homoiconic language the pain was too real.
  
  The book is not without its cons, of course (no pun intended). One thing I disliked was introducing code and exercises that use functions not yet introduced. Maybe it was designed to be a pure thought process, but I can't say it was interesting. Another one is that some of the exercises didn't have appropriate tools to try them out, for example multithreading exercises in chapter 3.
  
  For everyone considering working through it I would suggest to concentrate on exercises, they reinforce the material very well. Also, I found it helpful to manually type provided code from the book to understand it better.
  
  My solutions to the exercises:
  https://github.com/nevermourn/sicp-so...
• 
  Kirill

  The first few chapters of this book will make you think that it is a Scheme manual. However, do not be fooled, the book is much deeper than that. After the first few chapters, introduce you to Scheme, it discusses important differences between different paradigms of evaluation: applicative order, lazy evaluation, and data streams. The book also covers logic programming and non-deterministic programming languages. From there, you will explore the inner workings of interpreters. Finally, the book goes on to show how to build a simple compiler and explains how compilers are different from the interpreters.
  
  The beauty of the book is that to go through all of those topics you only need to know Scheme. The authors do not digress into different technologies: even the assembly language in this book is built using Scheme.
• 
  Leonid

  Absolutely awesome book.
  I think, some real-life experience with various programming languages and paradigms can help you understand a lot, but here authors pack huge amount of info and years of real-life experience into (moderately) small package, highlighting differences in perspectives, how you see the code and it's execution, when applying different approaches.
  
  I mostly scanned through two last chapters, sadly, not understanding them in such details as I wanted to, but that's my fault.
• 
  Theodore

  9 years ago I added this book on my to-read shelf, according to Goodreads. Genius, as expected. Probably my favourite computing book of all time.
• 
  Ondrej Sykora

  This is without discussion one of the books every software engineer should read.
  
  It does a great job at deconstructing common principles of computation and basic element of computer languages, and shows how they can be implemented as extensions of a much simpler language. Things that other languages take as granted (such as dynamic dispatch of methods) are analyzed in detail I haven't seen anywhere else in one place. That all said, the book is still quite approachable and it should be easy to understand for anyone with elementary knowledge of computing and mathemtaics.
  
  The only downside is that the style is a bit dry, which makes the book less enjoyable if you already know most of the concepts e.g. from university lectures or from other books. But even so it is a worth read.
• 
  Graham

  This book is more than just a technical manual. It teaches foundations of lasting value in an elegant machine language that has been around in one form or another since the 1950s.
  
  Whilst the material gets impressively advanced just a couple of chapters in, I'd also recommend this book to friends who've never written code before. The language used is built from very simple components and the exercises are progressive. This could be followed by a curious novice in much the same way that a coffee table book of crosswords or logic puzzles could be followed recreationally.. this is the kind of book that makes computing simple and fresh again even for experienced professionals, teaching some deep topics as it does so.
• 
  Joel McCracken

  If I could go back and tell myself where to start with computer science, this would have been it.
  
  It may be a little tough for beginners, but I feel that if you know enough to get through the first chapter or so, you will be set.