The Little LISPer

The Little Schemer #1

by Daniel P. Friedman, Matthias Felleisen

There are surprises in store for the diligent reader of this masterful introduction to recursion as a fundamental tool for expressing and solving problems. With wit and wisdom, The Little LISPer unfolds some of the most beautiful concepts in mathematics, computer science, and logic.

The authors' goal is to show that recursive thinking is first of all fun, that it is powerful, and that the programming language Lisp allows one to express ideas recursively and naturally. There are hard problems along the way, but their solution brings mastery of recursive, functional, and meta-linguistic abstractions, developing skills in the underlying creative programming in Lisp. The Little LISPer is an interpreter for the language is developed using the tools of the book itself .

Genres: Programming, Computer Science, Technology, Nonfiction, Computers, Software, Technical

222 pages, Paperback

First published January 1, 1974

About the author

Daniel P. Friedman is Professor of Computer Science in the School of Informatics, Computing, and Engineering at Indiana University and is the author of many books published by the MIT Press, including The Little Schemer and The Seasoned Schemer (with Matthias Felleisen); The Little Prover (with Carl Eastlund); and The Reasoned Schemer (with William E. Byrd, Oleg Kiselyov, and Jason Hemann).

Reviews

[Kyle · Rating 5 out of 5]

Is this book great?          Yes, it is an awesome book.
Why is it awesome?       The entire book is written
                                            as a series of questions,
                                            which forces you ask
                                            yourself questions about the
                                            content along the way.
Doesn't that get annoying?  Not really.
Will I learn Lisp?           Not really.
What will I do?              Master recursion. Build a
                                            Lisp.

[Phil · Rating 4 out of 5]

Is this a good book?

Yes, it is. Now go have a sandwich.

[Kyle · Rating 5 out of 5]

Reading this book, I couldn't stop thinking about how much I would have loved and treasured it when I first started getting interested in programming in middle school. It's not necessarily written for children, and I'm not saying it's not a fun/stimulating read for an adult, but that's the perspective I want to review it from.

Around that time I spent hundreds of hours playing around with QBasic, and I remember being so curious how it "worked"... Not from a registers and pointers perspective, but how the computer took text like "2 + 3" and reasoned about it. This is exactly where TLS starts. The style is a little silly and conversational, along the lines of _why's Poignant Guide to Ruby (but muuch less so). It starts from simple principles and a few basic commands, walks you through how to think about a program line-by-line, and eventually builds into some seriously challenging concepts.

Some of the material will be over the head of even the most intellectually curious 12-14 year old (I took several Scheme and Lisp-based courses in college, and the section on Y-combinators is still over my head), but if they are anything like I was, they will devour the first 2/3 and be fascinated by the magic of the final 1/3.

[Mark · Rating 2 out of 5]

hrm. The Little Schemer seems like a great book for a 12 year old grad student; that is to say, the style and the difficulty of the concepts in the book are somewhat at odds.

It starts out in a cutesy style, with back and forth questions and answers, whimsical instructions to make yourself a pb&j sandwich or eat a slice of cake... but about half way through the conceptual difficulty ramps up considerably. It ends up covering currying, the halting problem, multi-argument continuation passing style, derivation of the applicative order y-combinator... it gets out of hand very quickly, and I have to question whether the terse exposition is really the best way to explain these concepts. The Little Schemer may not be the best book for beginners, and I really think a modern introduction to recursion would be clearer in a language with algebraic data types and pattern matching instead of Scheme.

Too clever by half, and more cute than clear, I think.

[Christian Brumm · Rating 4 out of 5]

Just finished the book, good read, unusual book. The leading topic is Recursion. The book is written in a question-answer style that needs getting used to but is well designed an kept me interested. I found the style a bit tiresome at the beginning, because the matter starts off quite easy and the presentation does not really allow you to skip lots of stuff completely, as you will never know what you have missed. Its really designed to be read cover to cover.

I think the book changes pace dramatically in chapter 8. Chapters 1-7 I found really easy to follow, then it gets a lot harder. Maybe its just because the concepts in these chapters are completely new to me.
Chapter 8 introduces the use of closures to "return several arguments" from a function (by building up lists in the closure), which is kind of hard, but something every programmer can relate to.
Chapter 9 continues the treatment of recursion and recursively defined functions. On the side, it introduces the halting problem/incompleteness theorem and ends with the definition of the adaptive y-combinator, which seems to be some way to do recursion from lambda-calculus. The book does not go into any great detail here, I guess the sequel (The Seasoned Schemer) has more.
Chapter 10 builds a scheme interpreter in scheme, at least in theory. Did not get mine to work quite yet (will revisit this soon however, good stuff :)).

Overall a very good read. Will have to re-read chapters 8-10 to really get it.

This helped me feel a little less confused about Y-combinators:
http://www.ocf.berkeley.edu/~abhishek...

[James Watson · Rating 4 out of 5]

The Little Schemer is an excellent introduction to computer science concepts as they relate to the Scheme/Lisp way of programming. It is heavily focused on recursion as a core, fundamental part of computer programs in a way that many other computer science books are not. Functional programming concepts are covered, but this is not a strictly functional book. Concepts are presented naturally and their importance emerges from the examples. The book never stops to say "Okay, here comes an important concept called X". (A summary of contents appears at the bottom.)
You will notice immediately that the book is written as a question-and-answer dialogue with a combination of prose and code. The entire book is in this format. Some questions are conceptual, some relate to the step-by-step execution of code, and some questions are prompts for the student to write code as a sort of exercise. These exercises are normally answered a question or two down the line.
Whether you work out the exercises or wait for the answers, please type all the code. This book is meant to be read in front of a computer! The book does not always assume this, but each step is much more meaningful when you observe its effects. The book's format lends it to a step-by-step investigation of the workings of a computer program. This is intentionally contrary to the common format where exercises/interaction are preceded by pages and pages of explanation/theory.

== What this book is not ==
* "My First Computer Programming Book" - Schemer assumes you have familiarity with computers and you do not need help getting Scheme up and running. This book is probably not for children unless they are unnaturally patient.
* An extensive guide to Scheme features - Schemer actually makes a point of using as few built-in functions as possible so that the student is building their own tools to support further learning
* A guide to programming efficiency - Example code is written in a way that teaches best, but doesn't necessarily execute the fastest

== What this book is ==
* A completely approachable alternative to SICP (Structure and Implementation of Computer Programs) - This book, plus "The Seasoned Schemer", cover much of the material SICP does, but in my opinion is presented in a less academic and more understandable way than SICP.
* Very methodical - Step-by-step is Little Schemer's way. It may seem slow if you already understand a concept being presented
* Example-driven - Please type in all the examples, or you won't absorb the material!

== Summary of Contents ==
0. Preface - NOTE: Contains code REQUIRED to run programs in the book!
1. Toys - The basic building blocks of a Scheme program and basic functions
2. Do It, Do It Again, and Again, and Again - Recursion as a means of dealing with long lists of data
3. Cons the Magnificent - Building lists and data structures from basic parts
4. Numbers Games - Build functions that work with lists of numbers from (almost) scratch
5. *Oh My Gawd*: It's Full of Stars - Working with nested, branched data structures using recursion
6. Shadows - Create domain-specific languages (new syntax), without macros, like it's no big deal.
7. Friends and Relations - Working with sets and set theory, the easy way
8. Lambda the Ultimate - Solving problems flexibly by passing functions as data
9. And Again, And Again, And Again - Concerns computability, the halting problem, and the Applicative-Order Y Combinator. This is the weakest chapter in the book, and the explanation of the Y Combinator was the only one I did not understand. A very good explanation of this concept is located here:
http://www.ece.uc.edu/~franco/C511/ht...
10. What Is the Value of All This? - A good question. This chapter combines concepts and code covered and written in previous chapters in order to build a small, working version of Scheme, inside Scheme! This chapter offers some insight into how a computer handles the code you write for it, and building a working Scheme interpreter is deeply satisfying.

(Note that although SICP also implements a Scheme evaluator, Schemer's is more understandable to me. That is one of the many reasons I rate this book above SICP.)

[E · Rating 5 out of 5]

This is one of those books that changed me. By following a set of "commandments" presented in this book I learned to think clearly about functional programming, recursion and the Y-combinator. It also helped me ease into currying and other combinators like the S, K and I.

After you read this book, you should read "To Mock a Mockingbird" and also start learning Haskell.

The power of types in Haskell will one day compel you to understand the language of Category theory in mathematics, and after you figure out that, you will be enlightened.

[blake · Rating 5 out of 5]

A pet peeve of mine is how the quality of books on technical subjects (computers, specifically) has decline so radically since (*kaff*) I stopped writing them. Seriously, a famous book on Rails—perhaps considered the canonical book, it's so popular—epitomizes the awfulness of it all. How, you ask? Well, I went through said book and counted the number of things you had to learn in the first chapter and came up with a total 17!

17 things, Bob.

Only two of those were actually Ruby and Rails. The others were packaging tools, testing tools, clever DSLs for doing things like HTML that didn't actually relieve you of having to know HTML, and a great many of these things presented with the conceit, "Well, it's just like English so you know what it does."

Except of course it isn't English, and even if it were English, it wouldn't be precise enough to be useful.

Contrast now with The Little Schemer. It's not that this is an easy book. Despite being under 200 pages in a friendly, sparse two-column format sprinkled with cartoons and loaded with food references, it can at times be brutal. But that's not because it's overloading you with a bunch of unrelated material; it's because it's teaching you something very abstract and often rather challenging: functional programming.

I actually read through this in a short time because I wanted to read the The Reasoned Schemer and I didn't want to find myself struggling with the syntactic differences between Clojure and Scheme. Even as someone who's been getting results out of FP for two years, in going through the exercises (which you must, it's the whole point of the book), I found it necessary to take breaks and really chew on a few things.

The point, though, is that this book tells you a little something, has you get used to the idea and the action of doing it, then it tells you a little something more. Then with all the little somethings, it builds to a new concept, a new action, a new set of little somethings.

There are ten commandments given, introduced as the concepts are introduced, then refined when the concepts are refined. Ultimately, though, all very simple, if not always, in the words of a certain Clojure creator, easy.

What you don't find is anything that isn't functional programming. In fact, the main issue I had with the book was figuring out how and where to run the code. (Racket is a great choice, I discovered: There's a simple IDE called Dr. Racket that lets you write code, test code, and even step through code if you get stuck.)

I had a smaller problem with the "We're going to use a word without defining it precisely" approach—normally that's just "throw the book away" territory for me, and you'd be surprised how many books do this—but it's actually done well here: You're led to infer the meanings of these "undefined" terms through many examples. Much like the "commandments", this means you get a definition for the word that works, then you get a refinement later on.

It's very well done. I wish I could say this heralded a sea change in the world of technical writing but, as it turns out, this book is an update (actually considered the fourth edition!) of The Little LISPer, first written in 1974.

It's not really surprising: Modern books are geared toward "git 'er done". You don't learn how to web program here. You don't even learn how to read a file or print anything out. You don't display any graphics or connect to the Internet. (The final chapter here has you building a Lisp interpreter, which is pretty impressive for a 200 page beginner book, but not "practical".) But that stuff all changes, and none of those books will last for 40 years. None of them will change the way you think, either.

But this book can, if you go through it.

[Gaelan D'costa · Rating 4 out of 5]

Reader response, freshly finished: Unsure how I feel about this book.

I really love the didactic style. I found it easy to keep pace. It taught Scheme in a really digestible way .... until the end.

At least, I think it stopped being that digestible by the end. As someone who knows Scheme and understands the concepts (reasonably well), I found slowing down to be difficult, and I also didn't feel the book convinced me why I'd go through the contortions the latter half of the book made me go through.
With my "non-programmer" hat on, I was willing to take the leaps of faith required in the first half of the book while it immediately paid off, by about "Shadows" I stopped seeing why I was learning what I was learning. The authors were being too cute (or maybe holding onto too much for the sequel "The Seasoned Schemer")

Anyone who wants to teach someone programming concepts would do well to learn this book and encourage the use of a REPL. It's a great book for someone who understands programming languages, PL theory, and PL concepts to learn how to teach them to others in an approachable way.

I'd like to see how someone who has no idea or agenda for learning how to program would do with this book. I feel most people would really benefit from the first half and then get frustrated by the second.

[Matt · Rating 5 out of 5]

The Little Schemer is geared toward luring you into first the syntax, then the concepts behind Scheme, recursion, and functional programming. While probably of most interest to programmers or the mathematically inclined, the book claims to have been based off lecture notes for liberal arts students.

The book has a very interesting dialog mechanism for teaching. After the introduction, there is little to nothing in the way of paragraphs of information. Instead, it is more of a lightweight Q&A which very much shows you keywords or concepts first (as much as text can), then tells you about it as/after you work through it.

It's been 11 years since I used Scheme and The Little Schemer caught me up with the basics quickly, with just a pen and a pad. It also illustrates continuations better than any site I've found on Google, and that alone was worth my time so far. Finally, the material is pretty dense and it may take more than one reading (and some application!) to really "get" the stuff in the later chapters.

[Bharat · Rating 5 out of 5]

Easily one of the solid and neat introductory books to LISP. Used Racket lang with IDE as DrRacket to code and learn alongside this book. What is K&R for C Programmers, this book series by Daniel P Friedman, could be for people wanting to learn LISP. Going through this book allows people to think about programming in a new thinking way.

[Evan Snyder · Rating 5 out of 5]

Great great GREAT read that teaches you how to think recursively. I typically don't give technical books 5 stars, because as as helpful as they are, they usually aren't game-changing. While I understood what recursion is and how it works, I always struggled writing recursive code...until now. The book is written entirely in a question and answer format, which I found disconcerting at first, but turned out to be immensely effective. The book centers around the language LISP, but, even if you will likely never look at LISP code again (which I probably won't), the lessons are easily transferable to other languages.

[Jon Gauthier · Rating 5 out of 5]

A really fun read that reinforced my understanding of recursion and some FP concepts. Intermediate Lispers or people with a good grasp of basic functional programming can safely jump forward at least a few chapters (though you'll miss some function definitions used later on).

I was unsure about this book (it seemed a little basic) until I reached the section on continuations. From that point on, I was pretty amazed by the code. You'll find Y-combinators and metacircular interpreters explained in plain English, with simple examples.. absolutely worth the read!

[Michael · Rating 4 out of 5]

The Little Schemer is a classic computer science text and there are very good reasons for it: it's poignant, entertaining and teaches you more about Lisp than many of the bigger books around. This is not a complete guide to Scheme as a programming language, it's a book about concepts. Highly recommended!

[Satyaki · Rating 5 out of 5]

Reading books like this and SICP remind you why it's a pity that functional programming is no longer a part of the basic CS curriculum...
Some obligatory bitching about Java

[Koen Crolla · Rating 2 out of 5]

I expected to enjoy this a lot more than I did. If you're looking to learn Scheme but don't have any experience with it whatsoever—and especially if you don't have any experience programming at all—this book will be near worthless to you. If you already have some experience but would like to flesh it out a bit more, like I did, its gimmicks will get on your nerves really quickly.
The Little Schemer spends a tremendous amount of time focussing on trivialities while skipping over far too many fundamentals and important not-so-fundamentals. It doesn't teach you any usable Scheme but somehow still manages to teach bad habits, and it makes the whole language look more convoluted and less interesting than it actually is. This edition immediately tries to sell you The Seasoned Schemer at the end, and it's possible the two books combine to form something non-useless. I don't intend to find out.

[Fotis Koutoulakis · Rating 5 out of 5]

This was easily, one of the most mind stretching, informative and entertaining computer science books I have ever read (at least thus far).

The main theme throughout the book is recursion, and the book guides you through implementing basic numerical arithmetic through recursion, set functions through recursion, evaluators (both very basic ones in chapter 6, and more sophisticated metacircular ones in chapter 10), an interesting introduction to the halting problem (interesting because most introductions to the halting problem use turing machines as the model of computation, but this uses only functions, demonstrating a lambda calculus formulation of the same problem), and a derivation of the applicative order y-combinator (a mechanism to implement recursion in anonymous functions, as far as I understand the mechanism that implements recursion in lambda calculus).

A great read, highly recommended to any computer scientist, either formally trained or self educated.

[Andrew · Rating 4 out of 5]

Thoroughly didactic, and a considerable brain twister, this book and its exercises did a great deal for my programming skills. In particular, it furnishes stepping stones of a craft to decompose computing problems into recursive solutions.

I found the last two chapters fiercely difficult, and cannot say that I truly retained them. However, I greatly enjoyed the opportunity to glimpse deeper mathematical aspects of the lambda calculus.

For anyone wishing to learn a lisp-like, I thorough recommend time with this book, paper and pen, and a lisp interpretter

[Nathan · Rating 2 out of 5]

This book is a series of questions geared towards helping the the reader learn the material by figuring out the answers.

I think this book is best studied, rather than read, in short bites, taking plenty of time to understand each concept. I'm finding I can get through 2 or 3 pages per sitting. The book builds on prior concepts to aid in understanding new concepts.

So far, its taught me more about LISP than any other book, white paper or man page I've read.

Next I need to start reading 'An Introduction to Programming in Emacs Lisp'.

[Subhrendu Sarkar · Rating 5 out of 5]

One of the best scheme books till date.
Profoundly simple, easy and powerful.

Hope all books can be this easy.

[Emad Elsaid]

I couldn't complete it to the end, it was repeating itself and I was bored after page 80 though

[Mouna Cheikhna · Rating 5 out of 5]

I enjoyed reading this book a lot, had a lot of fun implementing the functions in it, specially the last 3 chapter are outstanding.

[Sebastian · Rating 5 out of 5]

A maths textbook written for children, that is in its fourth edition. Does the Venn diagram for those categories overlap for any other book?

'The Little Schemer' starts by asking you if the word 'atom' is a string of characters (it is), and manages within less than 200 pages of short, Socratic questions to have you ponder some of the most fundamental ideas within maths and computer science such as the Halting problem and how interpreters can run on themselves. And it's not like these ponderings are trivial, the textbook 'Types and Programming Languages' says to read 'The Little Schemer' for a derivation of the Y-combinator.

Friedman's book is in the rare category of the truly playful and utterly profound. Mind bending exercises that stretch your hat finish off with calls to get cake and pages are reserved for jam stains. A true pleasure, one to re-read several times.

[Dan Drake · Rating 5 out of 5]

I learned so much from this book, even though I would have said before starting that I understand recursion, a bit about lambda calculus, closures, lexical scoping, and so on -- but working through this gave me so much new insight and appreciation into all those topics.

I really like the dialectic, Socratic style -- in some ways, it mirrors what happens when a person reads code and "plays computer", and is really suited to these kind of computer science topics.

[Angus · Rating 5 out of 5]

Teaching entirely novel things is hard. Teaching a person to appreciate the need for something before that something has been given a name is even harder. It's not done in undergraduate Java-school computer science. It's vital that we convey the jargon. Polymorphism, encapsulation and inheritance are definitions we're taught because we know that HR people who interview us will ask these questions. Clearly a strong indicator of computer programming acumen is the ability to spout the jargon, right?

Blaise Pascal is credited with the following: "I would have written a shorter letter, but I did not have the time."

The Little Schemer is a shorter letter. It is one of the most beautiful technical books that I have ever read and here's why:

Why?

Well, it starts out as a textbook that teaches lisp, a computer language, and ends up touching on some of the hits of theoretical computer science. The Halting Problem, recursion, the Y-combinator. None of these things is named until after it is taught.

What does this mean?

It means that a concept isn't named until the student understands it through performance.

Wait, how does a book make you perform?

It's written in the style of a dialogue between student and teacher. You try to answer your teacher's question before they do themselves.

Yeah but where's the performance there?

The best way to answer many of these questions is to write them down.

Oh okay, so what kind of answers?

After a fashion, mostly code.

And you just write it down? Why not type it in?

The book will tell you if you're on the right track.

So it's kind of like a REPL but on paper then?

Yeah, sort of, which means you train your own brain as a lisp interpreter.

That sounds hard.

It is a little, but you always know exactly where you get stuck so you can go back and read over the last few questions again.

Well geez, that sounds amazing.

It's maybe the best programming book I've ever read.

Where do I get it?

There are some PDFs or you can buy it off amazon. Once you've ordered that, have a peanut butter and banana sandwich. You've earned it.

[Patrick Coakley · Rating 5 out of 5]

When I first bought The Little Schemer, I absolutely did not like it. I had heard all of these great things about it after researching Lisp and Scheme books, and it was probably the first book I picked up in order to learn more. I remember picking it up, and after a few minutes of flipping through I just didn't "get it." So I decided to try it again later. And so I did. That second time, I somehow started to understand what was going on a bit more, but still only got a chapter in before giving up. I waited some more and tried it again. Once again, I got further. And so this cycle continued until I could sit down and do several chapters in one sitting.

So, going back to my original reasoning for buying this book: it is actually not a great resource to learn Scheme. However, it is an amazing resource to learn things that will help you learn Scheme, and functional programming in general. It is also the kind of book that you could pull it off the shelf and go through at any time, giving it a longevity that is not really common among computer science books. And yes, it is a computer science book regardless of how it may present itself.

I also want to note that there is a difficulty ramp towards the end. I have not completed the entire book due to the last few chapters, which introduce some more complicated concepts that before. I see this as a good thing, however, as it gives me a reason to keep coming back. You can't really say this about many other books in the genre: it was relevant 40 years ago, it is relevant today, and it will be relevant in 40 more years.

[Bram · Rating 4 out of 5]

After reading Gödel, Escher and Bach I was determined to learn a LISP, just because I wanted to see what the fuss was about. I won't bother anyone with the details, but arriving at Scheme was a struggle at best.
Being familiar with recursion for the most part on the Prolog and Haskell side of things I was a little hesitant to use this book as my introduction to scheme. And, sure enough, I blew through the first 6 chapters in a day. The second day, I decided that it would be useful to program all the things in parallel to the next chapters, which had me going back to previous chapters to write out these functions as well. This was very useful if only to get familiar with the syntax of Scheme.
Then, the final 3 chapters of the book broke my brain a little. I was not at all familiar with continuation so this was a struggle. Chapter 9 and 10 were very difficult, but also a lot of fun. I'm definately re-reading those in the near-future.
I don't know why, but the kiddy-style of the book and the unusual Q/A build kind of work very well and make it less textbook-y. It at least worked a lot better for me than the daunting "Practical Common LISP" (which is probably a very good programming-book, but which I found extremely boring).

[Alice · Rating 5 out of 5]

A strange book. A truly strange one.
Okay, this is NOT a book that teaches Lisp or Scheme or whatever. It is not a reference book also.
But it is a book that gently drags you into understanding. Someone told me it teaches to think recursively - oh yeah, that it does. I think. Can't be sure really.

I didn't actually do any examples (well, only in my head), just read through it, and it was good even like that. The most valuable thing about The Little Schemer is that it feels like an enthralling journey into the oceans of awesomeness. It won't explain you how to write an application in Lisp nor give the details of Scheme, but it will make you understand how this languages work (even if a little) and, most importantly, will make you want to scream 'YOU CAN DO THAT?!' here and now.

Especially when you get to the applicative order Y combinator. Took me about 2 hours to get how it works (though again without doing any examples and without even pen and paper as the book suggests - didn't have the chance then, was reading basically while walking), but that was epic.

[Apoorva Anand · Rating 5 out of 5]

There IS a steep increase in the learning curve from chapter 8 (as the other reviews mention) but IMO it is worth it.

TLS teaches you not only about recursion, but with all the gollum-like back and forth between the questions and the answers, it teaches you the right kind of questions to ask while programming.

I believe anyone with a little bit of free time can complete the first 7 chapters and this would help them understand recursion and lexical scoping. Chapter 8 introduces the concept of collectors/continuations. Still wrapping my head around the last collector of chapter 8. The derivation of the Y combinator in chapter 9 to implement recursion is absolutely beautiful (took me several rereads to finally understand it) and Chapter 10's implementation of an interpreter is great and ties everything up perfectly (This simple version of an interpreter is easier to understand than one might think).

Overall, I'm glad I read it but I have to be careful about continuing on with the Schemer series. I really don't want to invest too much of my time diving into the world of functional programming.

[Robert Postill · Rating 5 out of 5]

It's difficult to express how interesting this book is. The format is a set of questions and answers, which is initially quite an odd read. However as the book unfolds you begin not only to appreciate the book's quirky style but also the power of the lessons contained within the book. It is a testament to the power of the material that by the last chapter you have sculpted a scheme interpreter from the bones of some really simple functions at the start of the book. In fact what this book demonstrates is the awesome power of recursion.

There are some things that you're not going to get from reading this book. For instance there is no discussion of scheme's place in the world of programming languages or any work on data structures. But then there a large number of other books that touch just those subjects yet do a poor job of discussing recursion.

This book is a gem, buy it and understand that behind the odd format is great power. You might well need to buy more programming books but this one is must-have to understand recursion.