Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) by Harold Abelson (PDF)

Description

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.

User’s Reviews

Editorial Reviews: 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 theFree Software Foundation. Additionally, he serves as co-chair for the MIT Council on Educational Technology.Gerald Jay Sussman is Panasonic Professor of Electrical Engineering at MIT.

Reviews from Amazon users which were colected at the time this book was published on the website:

⭐Inductive reasoning aims at simplifying functions just enough to make them general. Simple does NOT equal easy! When Functional Programming (and its predecessors– combinatory logic (1925) and lambda calculus (1930)) were first invented, they were aimed at clarifying mathematical logic. This “holding variables constant” or binding or eliminating them for “pure” (mathematical) functions, has been extended to Functional Programming, initially to better understand what programming is in general, then to evaluate mathematical functions while avoiding some of the complicating factors (side effects) of imperative/procedural programming.Because of this, when you think of a function in imperative, you immediately think of variables, and such functions can very easily morph both at the algo/function f(x)-> g(x) level, and at the x (variable level) itself (data changing as you execute). In functional programming (the subject of this text), a function is, well, a MATH function! So, evolving from math, and consisting OF math, it would be a little surprising to criticize the fact that this IS A MATH BOOK. (Sorry, it is). On the other hand, holding those variables constant and looking directly at functional mappings (particularly recursion) can “AHA” us into seeing how computers and programming “really” work without the complications of heavy imperative morphs.After C# 3 and in some Perl, these tried and true oops also have some functional classes now, so we are moving toward a more hybrid world, making this book FAR from out of date, even though it is “temporally” older. As well, some of your favorite math, research and engineering programs (Maple, Mathematica and R, for example) have numerous functional features. The old FP standbys are, of course, Lisp, Scheme, Hope, Haskell, Clojure, Racket, Hope, Scala, F#, etc. which you probably think of more as “math” programs. But, hopefully not a surprise, SQL itself strives at far less mutable value structures than imperative, and thus tilts toward functional also.FP, to be very honest, WAS designed to teach and understand programming (at compile/interpret levels, not necessarily algorithms, computational complexity or even advanced data structures), not originally create useful programs! “R” and many others have proved that to be aiming low, and the newer FP books do of course get deeply into more recent data structures.Thus, the reason for so many negative reviews! This is NOT your usual “how to program” or even “what are programs” text– it really is about linking mathematics and computer science at both high and deep levels. So, if you aren’t really up on math (from basics like sets and real number mappings all the way up to Lie Algebras and tensors), you might get lost with this rare gem of a book. On the other hand, the pain of working through it will give you a perspective on computer science that will forever change your point of view. Even if you code all day like I do, you’ll LOVE taking this journey both to the 30,000 foot level, as well as down to the real action between compiling and interpreting– via the MATHEMATICS of “pure” functions, minus the confusion of changing states, variables and data we play with every day in the imperative version of functions. Don’t believe that this “simplification” makes things easier to get– unless you know functions from a deep math view, this will be a tough climb.But… worth it if you’re willing to do the work! Most other books on “discrete math” are really UI catch ups for all the computer/math that’s now been removed from High School curricula, making this one of the few “real deals” that are at a bright, high undergrad level, NOT catch up. By removing calculus from HS requirements, we’re teaching 2,500 year old math, and adding the basics brings us up to 1666 or so. This book rapidly catapults our function math vs. function computing into the new century! Highly recommended IF you’re not turned off by advanced math functions, mappings, properties, etc. The next time someone asks how a special or CAS function can run faster interpreted than compiled, you’ll have a MUCH different answer! And of course the heart of all dynamical systems today includes differential equations, which are essentially recursive function processing.BEFORE AND AFTER: If you’re not “quite” ready for this level of FP and Lisp, you can get a great, inexpensive backgrounder with Dover’s

⭐. Mathwise, many Dover books on the keyword recursive functions will help. For a freebie intro, Graham’s famous “on lisp” is now available as a free download, and is a bit above the level of this book. For the “greatest intellectual programming book ever written” (far beyond the level of this book, covering advanced Lisp macros, closures, etc.), check out (AFTER reading this):

⭐. Only 1% of programmers really understand Common Lisp, and only 1% of those would tackle the unhygenic macros in Let Over– yet it is so intellectualy challenging that coders and engineers at all levels are astonished when they read it. Shows how high the bar can really get! (Lisp tends to do that, right?).IS IT DATED? In answer to a bunch of emailers asking that, NO– the principles of functional are still the same, even if Common Lisp and Scheme have been updated. In fact, today, combinations of functional, imperative and logical are happening more and more (called mixed paradigm programming). However, if you want a GREAT, VERY RECENT book as both a warm up and an update to Abelson, try this little beauty by the same author as the Little Schemer:

⭐. It will fill in where Abelson is a little out of date AND prepare you for his depth. WARNING: PLEASE BE SURE to get the 2nd Edition of Abelson, he updated it significantly for the relationship between time and memory, a relationship that is even today undergoing a LOT of research in many fields.

⭐Having first watched the authors’ excellent video lectures that were built upon the first edition of this textbook I naturally had very high expectations when I set my hands on the second edition. The breadth of the material covered by this book is very much in line with its title. The central topic of the book, as one would expect, are computer programs. And it is here that the book really shines, progressively refining the readers’ idea of what a computer program essentially is through multiple interpretations and re-interpretations of that idea.That being said, this book does take the unconventional approach: it uses a relatively unknown language called Scheme and goes into considerable effort to promote functional programming, an approach still considered pariah in the industry. But this is no flaw in my opinion. Current trends in programming language evolution indicate that many ideas that were hitherto the sole province of functional programming will become more and more present in mainstream languages.The beauty of Scheme is that it hardly has any syntax and its few special forms can all be learned in a very short time, liberating the reader from the so ubiquitous tyranny of syntax that plagues the majority of programming textbooks out there. The Scheme that the authors present in this book has no looping constructs: believe you me, there really is something special in writing loops via function recursion – it reminded me of my high-school days and the infamous goto’s I would regularly get chided for by the teacher. Interestingly, in the fourth chapter of the book you get to implement some of these absent looping constructs yourself.Another nice thing about the book is that it constantly keeps challenging you: the exercises get progressively more difficult and there are very few one could skip on the basis of them being trivial or non-engaging.I was surprised though, to have seen that many colleges did, or still do, use this textbook as a basis for a first course in computer programming. I find this inappropriate because there is far too little in the way of teaching the essential algorithms and program design patterns for beginners to really profit from here. In my opinion, the material in this book is more suited for computer science sophomores instead.One of my biggest gripes with this text had to do with the way the exercises were laid out: on far too many occasions, the book doesn’t present you with enough of workable code to test and verify your solutions – while an experienced programmer will have easily dealt with this issue by consulting MIT’s 6.001 course webpage and downloading the code set for the book, a soloing beginner could possibly be frustrated to the point of giving up on the book. The stream section in chapter 3 is especially troublesome since there is no officially provided workable code at all either in or outside the text – again, the solution is pretty simple, but to a beginner probably insurmountable without assistance. I strongly suggest using the DrScheme environment and switching to Lazy Scheme for the purposes of this section. In fact, one can use DrScheme for most of the book, as it’s far more user friendly than MIT Scheme Emacs and diverges from MIT GNU dialect of Scheme in only a few sections of the book. One annoying feature of DrScheme is that it has recently rendered set-car! and set-cdr! procedures obsolete: fortunately, the solution is simple. Just add “(require r5rs)” at the top of the definition window.A second potential problem for students that I see, is a thorough lack of commentary on domains and codomains of functions in the programs. Since Scheme is a dynamically typed language, there is no self-documentation present as there would be were the programs written in a typical statically typed language such as C++, and for a streamlined reading experience such documentation is a must.With all of this in mind, and considering this textbook as an intermediate rather than beginner level material, I rate it as very good, with potential for excellence should the problems I mentioned be resolved.If you decide to read the book, I warmly recommend that you watch the eponymous video lectures in parallel as they are thoroughly entertaining and on some occasions go into interesting theoretical discussions not to be found in the book (you definitely don’t want to miss the lecture on the metacircular evaluator as it’s far more clear than the presentation in the book and concludes with some really nice lambda calculus hacks).

⭐Can’t recommend this book enough, though it is a difficult text for a beginner. Many beginner textbooks emphasise quickly learning how to write programs whilst this one teaches the underlying principles first. This book has no ‘hello world’, but makes you think about what is going on “under the hood”.

⭐I never used this book at Uni, and always developed either Haskell/Scala or C++; this is great way to review algorithms using LISP.

⭐This book has to be read as a self study. Mind you, this is not an easy read as a self study book. It will frustrate you no end; but the results will surely be rewarding.

⭐A classic, before the fall (they started using Python). I advice buying second edition, and hardcover, not softbound.

⭐a must-have book for understanding the fundamentals of computer programming.

Keywords

Free Download Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) in PDF format
Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) PDF Free Download
Download Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) 1996 PDF Free
Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) 1996 PDF Free Download
Download Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science) PDF
Free Download Ebook Structure and Interpretation of Computer Programs – 2nd Edition (MIT Electrical Engineering and Computer Science)