Customer Reviews

The Little Schemer - 4th Edition

5 star:		(26)
4 star:		(7)
3 star:		(2)
2 star:		(0)
1 star:		(9)

 

 

In 1974, Daniel P. Friedman published a remarkable little book called The Little LISPer. It was only 68 pages, but it did a remarkable thing: It could teach you to think recursively. It used some pretend dialect of LISP (which was written in all caps in those days). The dialect didn't fully conform to any real LISP. But that was ok because it wasn't really about LISP, it was about recursive functions. You didn't need a computer in order to work through the exercises. After reading the book, I was changed. Or perhaps transformed. Or altered. In a good way. There are very few books that deeply change the way that you think. This is one of those books.

The format is a programmed text with questions on the left side and answers on the right. The way you use it is to read a question, think about the question, come up with an answer, and then compare your answer to Friedman's answer.

He used the names of foods as the symbols that are manipulated by your functions, and little jokes were scattered around to pull you back when things get so deep that your head is going to pop off. It even has a place reserved for JELLY STAINS!

The book has been through several revisions. The latest, The Little Schemer (Fourth Edition), updated by Matthias Felleisen, now conforms more closely to a real programming language, Scheme, and has new chapters which delve much deeper into recursive function theory and language processors.

Felleisen is not as comfortable with the programmed text format, so instead of questions and answers, he has a deranged dialog going on which reads a little like Sméagol and Gollum discussing fishes.

The Little Schemer is not a complete book on programming. It is weak in practical concerns like documentation, defensive programming, and computational efficiency. The development of a system of arithmetic from three primitives is delightful from a mathematical perspective and shockingly horrible from an engineering perspective.

It also will not teach you very much about Scheme. It touches on only a very small part of the language: a very good part.

Despite its flaws, the book has a very loyal following and that is because it works. It teaches one thing, a thing that is very difficult to teach, a thing that every profession programmer should know, and it does it really well. These are lessons that stick with you. You need to grab a sandwich and study this book.

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).

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.

This book was distributed to us, in a CS class, at Rice University in manuscript form. If you are looking for a for a great introduction to Scheme, you've found it. To summarize my reasons for liking this book:

1. It has an enormous amount of information packed into easily readable portions

2. More complex concepts are tied to the simpler concepts they depend upon

3. Material is organized in order of complexity

4. Each concept is described from many angles

5. When describing syntax, the sub-parts of complex syntax are explained well too, providing a fuller explaination. Thus, one develops a better intuitive sense of the language

6. Last but not least, it is excellently written, the style is entertaining but does not compromise profundity. You won't be falling asleep. It's a rivetting read!

I think this is a marvelous book.

The preface proclaims "Things You Need to Know to Read This Book" - The reader must be comfortable reading English, recognizing numbers, and counting. This perhaps understates the problem, but Friedman and Felleisen do an excellent job of introducing the reader to recursion and Scheme through the use of a formal methods. Concepts are built element-by-element and the reader learns by participating in the socratic "question and answer" style of learning. The examples train the reader to think recursively and present methods for developing recursive programs. Everything is built from first principles -- for example, a system of arithmetic and an equation interpreter is built only from number?, add1, and sub1.

I highly recommend this entertaining book. The material is straightforward and interesting, yet it hints at much more weighty computer science problems. I think it would an excellent text from which to teach college underclassmen (or perhaps even advanced high-schoolers), especially as a first computer science course or as an adjunct to an algorithms class.

The Little Schemer is most emphatically not a reference to the Scheme programming language. Nor will it tell you how to get your Scheme Interpreter to print "Hello World!" These are not flaws, though, any more than my TV's inability to cook a TV dinner is a flaw.

The Little Schemer is written to teach you how to think about programming using recursion, which is the natural way to program in Scheme. And at this, it succeeds brilliantly. It starts with the simplest ideas and then proceeds inductively from those elements to develop programming patterns.

Few people find it natural to think in terms of recursive functions. Scheme's programming style may seem even more foreign to those who have done all their coding in procedural languages, such as C, Java, and Visual Basic. The value of The Little Schemer is in the way it transforms the unnatural into the natural.

I had exposure to Lisp in an excellent languages course I took, but forgot most of what I learned. I decided that I would like to learn Scheme to improve the way I think about certain things, and this book does just that.

This book isn't a reference for the structure of the Scheme language. It's a guide to learning to think for Scheme; a guide for amazing recursion.

I can't imagine that the reviewers who complain about a lack of structure in this book got very far. The format is a little odd for the first couple of pages, since they immediately start asking questions without having told you anything, but it's an excellent way to learn, and I became accustomed to it very quickly. There is certainly a logical structure to the book, and it has to be read sequentially. The arguments about the book's lack of logic must be from readers offended that the authors don't spell out an outline for you ahead of time.

The Little Schemer is a unique book that introduces the reader to recursion by way of the scheme programming language. This book is not a full introduction to scheme, only a small subset of the scheme programming language is introduced including the keywords car, cdr, cons, cond, lambda, quote and define along with a few built in functions like eq?, null?, add1, and sub1. Indeed, to define even local variables you will have to wait for the second book in the series titled appropriately The Seasoned Schemer. This book introduces basic notions of what to do in scheme such as using cons to build lists, but it focuses on the idea of recursion which is introduced in chapter 2 and then enlarged upon throughout the book. All through the book there are references to famous computer scientists and their contributions giving the reader a fascinating glimpse into the theory behind programming a computer. Functions as first class values are introduced in chapter 8 and in chapter 9 the Halting Problem is introduced as well as the Y-Combinator. Finally in chapter 10 you build a simple scheme interpretor for the keywords you have seen so far. I found chapter 9 to be difficult and still do not understand it fully but otherwise I found the book to be very illuminating especially in regard to it's presentation of recursion. I highly recommend this book anyone who programs a computer. Even if you don't work with scheme the introduction to recursion will be an invaluable aid to programming in any language.

This is, without doubt, the best book I've ever read on computer science. It is also the strangest. It covers an astonishing range of ideas, from the practical matters of Scheme syntax, to some aspects of Goedel's incompleteness results.

The pedagogical style is semi-programmed. That is, learning proceeds by question and answer, almost Socratic. I found it most useful to read the chapters away from the computer. This made it necessary to think through each question. Afterwards, I would go to the computer, work through each exercise and then experiment.

Were I still teaching Computer Science, I would be inclined to use this book and approach for the first semester of an undergraduate course for Computer Science majors.

Not software engineering. Not application development. But if you want to learn what computer science is all about, this book will set you off in the right direction.

Computer science is, of course, a useful tool in engineering and development, but the things you learn here will enable you to think thoughts that you might not have ever dreamed possible. It's a book about the very nature of computation, taking you from seemingly trivial beginnings to the outermost limits of what computational machines can and cannot do.

Despite the title, I would recommend that you get some experience as a Scheme programmer before you embark on this book; if you already know some Scheme, then you will be able to better focus on the computational theory that this book is really about. Either way, buy it. Read it. Then read it again, and again, and again...