Which book should I choose to get into the Lisp World?

Question

I am an undergraduate computer science student. I have completed two out four years of my degree. I have not had an interaction with any Lisp family of languages. I have strong background in C, Java, x86 assembly and Javascript (at least that's what I think).

I have read that Lisp can teach me some of the core computer science concepts. I am currently stuck in the choice between How to Design Programs (HTDP) and Structure and Interpretation of Computer Programs (SICP). I have read about 50-70 pages of HTDP and it feels quite beginner. So, I did some research on SICP and found SICP teaches Scheme. I have also read that Scheme is old and learning Racket would be a better choice. Which book should I choose?

Note: I wish to pursue further education in Computer Science possibly in researching about Programming Languages.

Answer 1

How to Design Programs is a truly fantastic text. Should you choose to read it, I suspect you will be able to learn many useful things from it. However, I hesitate to recommend it as an answer to your question as-stated for two reasons:

1. HtDP is ultimately a textbook, and it is not written to be read front to back. Rather, it is primarily intended to be used alongside a course taught by an instructor who knows how to use it most appropriately.

2. More bluntly, HtDP is simply not a book about Lisp.

Yes, HtDP uses a programming language (or, more accurately, a family of programming languages) that happens to be a Lisp. But this is somewhat incidental, and the book can be adapted to other languages (and sometimes is in practice). Moreover, the language used by HtDP is not Racket, nor is it even Scheme—instead, HtDP uses a family of languages specifically designed for teaching, which intentionally lack many of the features that are traditionally considered the qualities that make Lisps interesting.

So what is HtDP about? True to its name, it is a book about how to design programs. It is not about how to design Lisp programs, and although it certainly does have a somewhat functional bent, its ideas are applicable to all programming languages. This is why it is often used as an introductory text. The Lisp is not the point, so if you want to learn about Lisp, HtDP is not going to leave you terribly satisfied.

---

Given the above, it may sound like I am strongly recommending that you read Structure and Interpretation of Computer Programs, instead, and that is not entirely untrue. Unlike HtDP, SICP is not an introductory text (as much as people sometimes seem to pretend otherwise), but it’s also not really about Lisp, either. Rather, SICP covers some of the foundational ideas in the field of programming languages, and it explores these via simple interpreters written in Scheme. Many of the ideas in SICP are definitely “Lispy” in some sense, and you say you’re interested in perhaps pursuing the field of programming languages, in which case I suspect you will find SICP quite edifying. On the other hand, I personally think many of its ideas are presented better elsewhere (though many would disagree, so YMMV).

Ultimately, the question comes down to what you really want to learn about. Here are a few possibilities:

• If you want to learn about writing programs in Lisp or about functional programming more generally, I recommend reading The Racket Guide. The Racket Guide does not exactly present itself as a book, but it is structured like one, and it provides a very thorough introduction to programming in a full-featured Lisp that covers everything from the bare basics to compile-time metaprogramming to higher-order contracts. The Racket Guide is a wonderful resource that will give you everything you need to start writing real Lisp programs (and then some).

• If you want to explore the foundations of programming languages using a Lisp as a vehicle, then I recommend Programming Languages: Application and Interpretation by Shriram Krishnamurthi. PLAI covers much of the same content as SICP, but it does so in a more precise and less handwavy way, and it also covers more topics, such as garbage collection.

• If you want to learn specifically how to implement a simple Lisp, then I actually think it’s quite possibly more illustrative to do that in a language that isn’t a Lisp. Write You A Scheme uses Haskell as its implementation language of choice, which I think provides a particularly lucid grounding for the ideas it introduces.

Ultimately, all of the things I’ve mentioned here—including both HtDP and SICP—are good reading, so I wouldn’t worry too much about which one you pick. It would certainly be counterproductive to feel overwhelmed by choice and not end up reading any of them, so don’t get stuck in analysis paralysis. But personally, based on the contents of your question, I think The Racket Guide and PLAI would both be great choices to help you get started on your journey into Lisp and programming languages.

(Disclaimer: I am a regular contributor to Racket and am currently employed working on GHC, the Haskell compiler. I like to think my suggestions are relatively unbiased in spite of my personal interests, but then, we all do. :))

Answer 2

As someone points out in the comments, Racket is a Scheme implementation. But I wouldn't worry about which Lisp variant you learn at first, not even whether it's a Lisp-2 (Lisp) or Lisp-1 (Scheme); the things you need to learn initially will be taught pretty much as well in any variant.

The book I recommend you start with is The Little Schemer by Daniel Friedman.

The first few chapters are essentially simple exercises that will introduce you to the basic idioms used by many functional programming languages that imperative programmers are generally not used to, including manipulation and use of singly-linked lists, iteration via recursion (rather than loops), functions as first-class objects, lambdas (anonymous functions), and so on. The book's question-and-answer format helps you practice with these idioms; this is key because easy and fluent use of them is absolutely essential in most functional programming languages, even ones as different from Lisp as Haskell or ML.

The later chapters of the book go deeper into what you might call the very heart of functional programming, covering both things less discussed, such as currying, and some fairly complex things, such as the applicative-order Y combinator. The book ends with the following; if you have difficulty wrapping your mind around it, well, that's why you need to do the exercises in the book:

(define Y
  (lambda (le)
    ((lambda (f) (f f))
     (lambda (f)
       (le (lambda (x) ((f f) x)))))))

From the start you may find that short (less than 200 page) book looks overly simple; don't be fooled. Depending on your previous experience, some parts may indeed actually be simple for you, but if so, you'll get through them quickly and waste little time. But if there are any questions that you don't fully understand, don't skip them; go back and contemplate them and do your own exercises based on them until you are confident you have mastered them.

The book can easily be worked through with pen and paper, and that's the way I recommend you do it. However, if you feel you want to use an interpreter, almost any Lisp or Scheme interpreter will do, though you may have to look up a few details for your particular version of Lisp or Scheme that differ from the book. The book does have some footnotes giving Lisp equivalents of the Scheme functions/macros they use, where the Lisp functions/macros differ.

Answer 3

The problem with learning any of the Lisp family of languages after learning several others is that Lisp and its progeny use a different paradigm. Changing paradigms implies changing the way you think. It isn't about syntax, but about a mental model of the nature of computation.

There is nothing naive about SICP, but you need to get beyond the first few pages. Once you have internalized the thought process, you can move to other functional languages, just as you can move from Java to Python, say.

The big difference between pure functional languages and those you already know is the replacement of "state" represented by variables with "expressions".

Racket and Scheme share many things, including an abstract syntax. But the most important thing they share is the computing model; the paradigm and that will be the biggest hurddle.

But, either of those books should be fine for a first look at FP. The authors are among the finest around and all have a very deep knowledge of their respective topics.

Answer 4

The best book to get into Lisp is Peter Norvig's PAIP - it showcases the core Lisp multi-paradigm approach and also some unique Lisp features that make it suitable for solving problems dealing with knowledge manipulation.

The other great book for those who, like you, have significant conventional programming experience is Peter Seibel's Practical Common Lisp which introduces Lisp in the familiar context of those language's approaches.

Finally, for those who have very little programming experience or for kids, Conrad Barski's Land of Lisp may be a good accessible and light-hearted introductory book.

Answer 5

Frame challenge, don't start with a book. Start with Problem 1 on Project Euler (spoiler, Problem 1 is just Fizz Buzz) and Google/Stack Overflow/language documentation and just write some code. Your first code will be terrible Lisp since your brain will still want to work procedurally and that's OK, imo actually experiencing this is the best way to really know how Lisp is different from procedural code.

I think Project Euler is particularly good for this because a) a lot of the questions have very elegant recursive solutions so the reward for writing idiomatic Lisp is high, and b) there are usually several Lisp solutions posted in the forums for easy problems so you can see how other people solved the same problem. (Plus you get a bonus of seeing how people solved it in other languages.)

Then you can go read a book and build an academic understanding on top of your intuitive understanding.