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 An Introduction to Functional Programming Through Lambda Calculus (Dover Books on Mathematics). 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): Let Over Lambda. 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: Realm of Racket: Learn to Program, One Game at a Time!. 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.
Enjoy fast, free delivery, exclusive deals, and award-winning movies & TV shows with Prime
Try Prime
and start saving today with fast, free delivery
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Frequently bought together
This item: Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)
$55.00
Get it as soon as Friday, Jan 17
In Stock
+
$41.84
Get it Jan 22 - 28
In Stock
+
$26.86
Get it as soon as Friday, Jan 17
In Stock
Total price: $00
To see our price, add these items to your cart.
Choose items to buy together.
More items to explore
Page 1 of 1 Start overPage 1 of 1
Refunded immediately after I received it
Indian version got bad quality, I thought it was self printed book.
Top reviews from other countries
-
JorgeReviewed in Mexico on October 18, 2021
Entendimiento general de bases de programación
-
-
- |Rg|Reviewed in India on June 28, 2021
One of the best book you will ever read on Programming
This has been recommended as the best introduction to Programming and CS by many prominent Computer Scientists and programmers alike.One of the best book you will ever read on Programming|Rg|
Reviewed in India on June 28, 2021
I see why.
This book is one of the most thought provoking and informative books that I have ever read about programming.
It teaches you programming from ground up including advanced programming techniques such as metaprogramming.
Now, be aware that this book is hard. But it is hard in a very responsible way. I mean, many STEM books teach you some concepts- only the basics, and then leave you to solve exercises that you cannot practically solve without the help of professors or TAs. Or without seeking help from the internet.
This book is not that. It is very responsible and self-contained in a way that you can solve all the problems in this book just by reading this book and working through examples. The exercises are not easy, and requires severe brainstorming and trying, but I assure you can solve all of them without any help or hints. I love the way the book is very responsible.
And if you carefully read through the books and solve all the problems, you will literally transform as a programmer. Your improvements and understanding of the field will be immense.
This is going to be hard. So embrace yourself.
The months I worked through the book, were one of the best learning periods of my life. I enjoyed it a lot.
Two tips for future buyers-
1. Do not use Scheme even if the book tells you to. Use Racket programming language which is a modern superset of Scheme. You will be able to do with Racket everything you would have been able to do with Scheme. Use the drracket IDE or a text editor of your choice.
2. There's an MIT OpenCourseWare video lecture series on this book. Look for it. I highly recommend them.
Finally, if you are unable to finish this book, do not worry. There are plenty of successful software professionals out there who have not read this book.
But if you want to embrace the hard journey of becoming a great programmer, then this book is for you. If you want to have deep fun for some months, this book is for you.
Some comments on the product.
- I bought an old book for ₹500+, and it is as good as new. It is literally a new book. Only 1 inch of the plastic in the cover were torn which I solved through glue. I am very happy to get this book for ₹500+. I would have returned the faulty book if I bought a new one, for sure.
- Pages are very thin, as this book is locally printed. But don't fret on that. Just rejoice that you can buy this great book in India in ₹800+. This is a great deal.
Images in this review
