Format: PaperbackChange
Price:$34.66+ Free shipping with Amazon Prime
Top positive review
8 people found this helpful
4.0 out of 5 starsHas the feel of a game
ByJonathan Aquinoon January 3, 2008
This book consists of dozens of exercises that you solve using little snippets of recursive code. It definitely has the feel of a game - Sudoku moreso than Call of Duty.
The key to enjoying this book is to not get hung up on the non-code questions. The book is written as a list of questions and answers, and it's frustrating to try to answer the non-code questions because they are often unguessable:
Q: Is that bad?
A: You must beware of shadows
Quickly read through the non-code questions and answers. But try to answer the code questions - that's the stuff that's fun and interesting.
Q: Write fun? with set? and firsts
A: (define fun? (lambda (rel) (set? (firsts rel))))
You'll find pencil and paper to be too slow for this stuff; a text editor is more convenient. But you need not bother running the code through a compiler - the answers are given on the same page.
The key to enjoying this book is to not get hung up on the non-code questions. The book is written as a list of questions and answers, and it's frustrating to try to answer the non-code questions because they are often unguessable:
Q: Is that bad?
A: You must beware of shadows
Quickly read through the non-code questions and answers. But try to answer the code questions - that's the stuff that's fun and interesting.
Q: Write fun? with set? and firsts
A: (define fun? (lambda (rel) (set? (firsts rel))))
You'll find pencil and paper to be too slow for this stuff; a text editor is more convenient. But you need not bother running the code through a compiler - the answers are given on the same page.
Top critical review
5 people found this helpful
3.0 out of 5 starsNot worth the cost
ByAmazon Customeron February 26, 2017
I absolutely loved the fist half or so of this book: it's one of the best introductions to the type of thought patterns you need to deal effectively with recursion and functional programming I've read (out of maybe three or four, so take that for what you will). But the last few chapters go completely off the rails, tackling topics that require a fair bit of context ... and providing none of it.
It's also a little expensive for what's essentially a glorified worksheet made from what the authors admit were teaching notes for a class you're not taking. Since only about 2/3 of the book is useful, I probably wouldn't buy the book again.
It's also a little expensive for what's essentially a glorified worksheet made from what the authors admit were teaching notes for a class you're not taking. Since only about 2/3 of the book is useful, I probably wouldn't buy the book again.
Search
Sort by
Top rated
There was a problem filtering reviews right now. Please try again later.
ByMichael Vanieron February 20, 2001
This is a wonderful book for people who enjoy having their minds stretched. It starts from the most elementary concepts (this is a number, this is a symbol) and then proceeds to teach you how to program in scheme (a lisp dialect) using a question-and-answer approach, with the questions on the left hand side of the page and the answers on the right. Most of the teaching is by example; the authors show you something several times in several different guises in order to get you to understand the pattern underlying the programming examples. This form of teaching-by-pattern-recognition is especially useful for scheme, because lisp-based languages represent such a different paradigm from more conventional computer languages that it really helps to have the pattern in mind when you want to write a new function. The authors show how the basic elements of lisp (atoms, numbers and lists) can be used to solve an amazing variety of problems, many of which would be much harder (or impossible) in more conventional computer languages. Most of the book is so easy that a complete novice who had never programmed before could understand it, but the authors sneakily keep increasing the complexity until in the last three chapters they cover continuation-passing style, the applicative-order Y combinator (!) and writing a scheme interpreter in scheme (!!). Some of these topics would go over the head of most computer science Ph.D.'s (go ahead, ask one what the Y combinator is -- I dare you!). This is not the book to read if you're looking for a "teach yourself visual basic in 20 minutes" kind of book, but if you like programming and you enjoy having your mind stretched, you could not do better than this book (or its companion book, the Seasoned Schemer).
87 people found this helpful
Helpful
Not Helpful
ByJustin Hamiltonon June 7, 2011
Little Schemer is without a doubt one of the best books I have ever read on the subject of recursion, and what is interesting because they never really go into a formal definition of what recursion is, as most texts on computer science try to. Instead they show the reader time and time again what recursion is, while providing a great series of rules (commandments) on how to get the most out of recursion, particually in a tail-recursive language like Scheme.
The book is structured as a series of questions and answers. Each page has several questions on the left hand side, with answers on the right hand side. The overall interpretation of the book is that you can read this without a computer, using pencil and paper to work through the many questions in the book.
As the reader progresses they will continue to develop and reimplement many useful tools in Scheme that become more and more practical as the text goes on. What is great about this method is the pacing and the steady revealing of topics and good practices presented by the author. Because they gradually accustom the reader to topics like recursion, list operations, and lambda, by the time they show how define is unneccessary in Scheme due to the Y Combinator this rather challenging concept seems somewhat intuitive.
Overall I think this is one of the greatest computer science books I have ever read. Sure it may not formally define things or be the absolute easiest text to read on the Scheme language itself, but this book should not be used as a reference product - it should be used as a tool bye which the reader strengthens their fundamentals in computer science and programmer, whether or not they ever touch Scheme again.
The book is structured as a series of questions and answers. Each page has several questions on the left hand side, with answers on the right hand side. The overall interpretation of the book is that you can read this without a computer, using pencil and paper to work through the many questions in the book.
As the reader progresses they will continue to develop and reimplement many useful tools in Scheme that become more and more practical as the text goes on. What is great about this method is the pacing and the steady revealing of topics and good practices presented by the author. Because they gradually accustom the reader to topics like recursion, list operations, and lambda, by the time they show how define is unneccessary in Scheme due to the Y Combinator this rather challenging concept seems somewhat intuitive.
Overall I think this is one of the greatest computer science books I have ever read. Sure it may not formally define things or be the absolute easiest text to read on the Scheme language itself, but this book should not be used as a reference product - it should be used as a tool bye which the reader strengthens their fundamentals in computer science and programmer, whether or not they ever touch Scheme again.
ByA customeron February 4, 2004
I am reading this book now, after wanting to get back into LISP programming after a ten year hiatus. My last memory of LISP was when I learned it in high school with an excellent teacher. I wish we had had this book back then! As it stands, I devoured the book in a few sittings -- its amusing, fast paced, rigorous and low-BS structure make it an excellent read.
I'm of the last generation of students who were able to switch on a computer and get a BASIC prompt. The huge heft of "introductory" programming books today leaves me cold and uninspired -- I would hate to have seen these when I was first exploring the excitement of programming.
The Little Schemer, by some of the old gurus of the (I believe) MIT Artificial Intelligence Lab (if not that particular lab, then at least those early, heady days in the '70s when AI wasn't a joke), reminded me of what it used to be like -- slowly building up a repertoire of commands and associated concepts that made programming seem a lot more like playing a Bach fugue and a lot less like debugging window objects. Things like recursion -- the essential part of this book -- are inherently wonderful.
Were I teaching an advanced class for high school students, this book would be at the top of my list. Were I wanting to introduce a liberal arts student into the joys of mathematics, this book would be at the top. Were I wanting to deprogram a bad-habited CS student, this book. Indeed, with so many Universities wanting to stuff some kind of logical, syntatical reasoning requirements into their required courses, this book should be a best seller.
It is a book that recaptures the joys and frustrations of programming and goes a long way to explaining why so many of the brightest people of the 20th century, at some point or another, sat down and cons'ed up a list.
I'm of the last generation of students who were able to switch on a computer and get a BASIC prompt. The huge heft of "introductory" programming books today leaves me cold and uninspired -- I would hate to have seen these when I was first exploring the excitement of programming.
The Little Schemer, by some of the old gurus of the (I believe) MIT Artificial Intelligence Lab (if not that particular lab, then at least those early, heady days in the '70s when AI wasn't a joke), reminded me of what it used to be like -- slowly building up a repertoire of commands and associated concepts that made programming seem a lot more like playing a Bach fugue and a lot less like debugging window objects. Things like recursion -- the essential part of this book -- are inherently wonderful.
Were I teaching an advanced class for high school students, this book would be at the top of my list. Were I wanting to introduce a liberal arts student into the joys of mathematics, this book would be at the top. Were I wanting to deprogram a bad-habited CS student, this book. Indeed, with so many Universities wanting to stuff some kind of logical, syntatical reasoning requirements into their required courses, this book should be a best seller.
It is a book that recaptures the joys and frustrations of programming and goes a long way to explaining why so many of the brightest people of the 20th century, at some point or another, sat down and cons'ed up a list.
ByPaul C. Gormanon March 2, 2012
The Little Schemer has a unique approach to teaching some of the most important concepts in programming. It isn't a reference, and doesn't teach much about any particular programming language, but it does ease you into thinking about functional programming concepts. If you've only worked with C-like procedural languages, the Little Schemer is a great way to make functional programming seem less alien.
BySvetoslav Barabonkovon December 17, 2014
It is a great book for someone who wants to learn the recursion concept in programming. Not only this, one can learn how with few simple functions to build a full blown language. Cons is a lack of more detailed comments on the advanced stuff at the end of the book.
ByErik A. Nielsenon November 5, 2013
This is a wonderful and thought-provoking book -- almost a gateway drug to higher math and computer science concepts that does not in itself require anything more than basic high-school math.
It is also an excellent and non-trivial introduction to Scheme/Lisp, and more importantly, to thinking about recursive programming. The progression ramps up quickly, so be sure to read very carefully. If you skim this book you will quickly be lost within a couple of pages, so be very sure to read and re-read anything that you don't completely understand. It's also very important to go through each mini-program carefully to make sure that you understand its syntax and effects. By the time you get to the chapter on the applicative-order Y-combinator the slightest misinterpretation of a function will have your brain spinning in circles.
The format of the book is wonderful. I wish more books were written using the socratic method.
It is also an excellent and non-trivial introduction to Scheme/Lisp, and more importantly, to thinking about recursive programming. The progression ramps up quickly, so be sure to read very carefully. If you skim this book you will quickly be lost within a couple of pages, so be very sure to read and re-read anything that you don't completely understand. It's also very important to go through each mini-program carefully to make sure that you understand its syntax and effects. By the time you get to the chapter on the applicative-order Y-combinator the slightest misinterpretation of a function will have your brain spinning in circles.
The format of the book is wonderful. I wish more books were written using the socratic method.
ByEric Wolfon March 5, 2015
Easily the best book I've read on learning how to solve problems using functional programming techniques. It is unique in that all you need is paper, a pencil, the book and time. You do not need any prior programming experience. I am a programmer and though I do not often use functional programming, I feel this book has improved my skills overall. It teaches how to think over how to do things with a specific syntax.
Programming, especially functional programming, requires thought patterns that are different from those that a person encounters in the everyday world. it takes time to grow the brain circuitry to handle these concepts and this book has about the perfect pacing to keep that learning happening at the appropriate rate.
This is a book of exercises that teaches a few extremely simple concepts that weave together into a useful and complex whole. Each chapter is well thought out and builds from the previous; it takes one about a day to get through each chapter. Don't rush it; let your unconscious mind digest the knowledge and relax between chapters.
I have not seen this format and technique in other books; it works very well for me. Bravo and thanks, Daniel Friedman!
Programming, especially functional programming, requires thought patterns that are different from those that a person encounters in the everyday world. it takes time to grow the brain circuitry to handle these concepts and this book has about the perfect pacing to keep that learning happening at the appropriate rate.
This is a book of exercises that teaches a few extremely simple concepts that weave together into a useful and complex whole. Each chapter is well thought out and builds from the previous; it takes one about a day to get through each chapter. Don't rush it; let your unconscious mind digest the knowledge and relax between chapters.
I have not seen this format and technique in other books; it works very well for me. Bravo and thanks, Daniel Friedman!
ByCode Monkeyon December 1, 2009
This is a delightful little book that talks about recursive functions
and computation, and almost accidentally introduces the reader a few
important bits of the Scheme programming language. The format is a
question and answer dialog in two columns, and the reader is expected
to try and answer questions for themselves before looking at them.
Experienced programmers reading this book will find reminders about
why programming is a joyful activity. Novices will be rewarded if they
actually try to work out the answers for themselves: the answers cover
some of most beautiful and meaningful concepts in computer science.
The book covers a lot of ground. It starts by drilling the reader on
how to understand recursive structures (lists and numbers) and develop
functions to operate on them. People familiar with recursion will
probably breeze through this, but for everyone else it is worth
sweating through the details. The last 70 pages move fast: a
functional approach to programming, programming with continuations,
unsolvable problems, recursion as function application (the
Y-Combinator!), and a simple Scheme interpreter, are all introduced
with a sequence of probing questions, perceptive answers, a few cute
cartoons, and many references to foods. All the code examples can be
run in nearly any recent Scheme implementation, and doing so would go
a long way towards enjoying the material.
If one had to criticise this book it would probably be for covering
too much too quickly! The concepts covered here often take months (or
years) to understand, leave alone master. It would be easy for a
novice to miss the point here: the book is a taste of why computation
is a subject of great elegance and beauty, and is meant to make the
reader want to go out and study the subject in great detail. It is
really hinting at the great ideas out there awaiting the reader. Next
time you try Schönfinkelisation you will always be glad you read a
books like this!
and computation, and almost accidentally introduces the reader a few
important bits of the Scheme programming language. The format is a
question and answer dialog in two columns, and the reader is expected
to try and answer questions for themselves before looking at them.
Experienced programmers reading this book will find reminders about
why programming is a joyful activity. Novices will be rewarded if they
actually try to work out the answers for themselves: the answers cover
some of most beautiful and meaningful concepts in computer science.
The book covers a lot of ground. It starts by drilling the reader on
how to understand recursive structures (lists and numbers) and develop
functions to operate on them. People familiar with recursion will
probably breeze through this, but for everyone else it is worth
sweating through the details. The last 70 pages move fast: a
functional approach to programming, programming with continuations,
unsolvable problems, recursion as function application (the
Y-Combinator!), and a simple Scheme interpreter, are all introduced
with a sequence of probing questions, perceptive answers, a few cute
cartoons, and many references to foods. All the code examples can be
run in nearly any recent Scheme implementation, and doing so would go
a long way towards enjoying the material.
If one had to criticise this book it would probably be for covering
too much too quickly! The concepts covered here often take months (or
years) to understand, leave alone master. It would be easy for a
novice to miss the point here: the book is a taste of why computation
is a subject of great elegance and beauty, and is meant to make the
reader want to go out and study the subject in great detail. It is
really hinting at the great ideas out there awaiting the reader. Next
time you try Schönfinkelisation you will always be glad you read a
books like this!
ByJoel Adamsonon May 16, 2008
This book is excellent for explaining concepts of Scheme and Lisp. I highly recommend it for people that like logic puzzles and who are trying to uncover the Zen-like nature of programming in Scheme. This book emphasizes functional style by showing how many situations recursion applies to, and how you can use it to achieve various programming techniques (for example continuation-passing style).
Although this book is not a technical introduction to Scheme or Lisp, it does get very technical. The last few chapters introduce continuation-passing style, the Y operator, and building an interpreter. Earlier chapters focus on list processing and uncovering some basic computer science techniques (e.g. that fact that numbers in a machine are representations of the concepts we have for numbers).
This is a great book to read or skim any time, read with pencil and paper, or to actually code the examples. I've read it in various ways three times.
Although this book is not a technical introduction to Scheme or Lisp, it does get very technical. The last few chapters introduce continuation-passing style, the Y operator, and building an interpreter. Earlier chapters focus on list processing and uncovering some basic computer science techniques (e.g. that fact that numbers in a machine are representations of the concepts we have for numbers).
This is a great book to read or skim any time, read with pencil and paper, or to actually code the examples. I've read it in various ways three times.
BySumimuson September 5, 2005
This book is not a comprehensive description of the Scheme language -- the R5RS Scheme report is freely available for that purpose. It is rather a playful introduction to a programming style that has defined Scheme, or LISP in general. The authors use a dialogue approach to introduce each new concepts that makes programming complex software possible. But you will not find complex programs in that book -- which does not mean that you will not see some complicated ones. I believe the book can be a playful refresher for people who studied LISP a long time ago. And it could even stretch the mind of experienced programmers who never deeply studied LISP or Scheme. This is not a book for dummies.
There's a problem loading this menu right now.
Get fast, free shipping with Amazon Prime
Prime members enjoy FREE Two-Day Shipping and exclusive access to music, movies, TV shows, original audio series, and Kindle books.
|
Your recently viewed items and featured recommendations
After viewing product detail pages, look here to find an easy way to navigate back to pages you are interested in.
Back to top
Get to Know Us
Make Money with Us
Amazon Payment Products
- Conditions of Use
- Privacy Notice
- Interest-Based Ads
- © 1996-2018, Amazon.com, Inc. or its affiliates
