I saw “The Little Schemer” a few days ago at my local Barnes & Noble so
I bought it and started reading it. I’ve read 8 out of the 10 chapters
so far and here are my thoughts…

• The format of this book is bizarre and interesting. Rather than
  straight paragraphs of prose, it is structured as sort of a hypothetical
  dialogue between the authors and the reader. It’s very “question and
  answer”. The book does little or no explanation of anything
  really. Rather, they rely on the reader to figure things out by
  observing patterns. This is kind of disconcerting and refreshing at the
  same time. Even the basics of Scheme are not explained; at least in the
  traditional sense of the word “explain”. For example, believe it or not,
  this is the opening sentence of the book: “Is it true that this is an
  atom: atom?”. My immediate reaction to this was to
  flip around and make sure that I had not accidentally skipped a
  page. This was very weird for me, though not catastrophic, as I was
  able to pick things up as I went along. On the other hand, I have some
  prior familiarity with Lisp; I suppose this could be even more jarring
  for someone completely new to the Lisp family of languages. For me,
  the format was weird at first, but I quickly got accustomed to it and grew
  to even like it.
• The preface of the book mentions that the book was based on “lecture
  notes from a two-week ‘quickie’ introduction to Scheme for students with
  no previous programming experience and an admitted dislike for anything
  mathematical”. This is really hard for me to imagine. Though the book
  has a fun little conversational tone, it’s fundamentally about
  recursion, and I can’t imagine non-technical folks getting very excited
  about this. If they are not put off by the lats, cars, cdrs, and
  S-expressions, then I would think they would go nuts when the book
  starts talking about relations, functions, and one-to-one
  functions. Though probably if you are reading my blog and especially
  this post, this is probably not an issue for you.
• This is not really a technical book, like say, “Advanced
  Programming in the Unix Environment”. This is a computer science
  book. It’s not really about teaching you Lisp or Scheme; it’s really
  about recursion and getting you to think that way. I haven’t
  encountered a single loop thus far – it’s all recursion. This is kind of
  a mixed bag to me, as the book does a very nice job of teaching recursion,
  but recursion is not a technique that I use a lot, as my job doesn’t
  typically entail writing factorial, Fibonacci, or quick sort
  functions. On the other hand, engineering is about problem solving and
  it seems that this book might help one to think differently about
  problem solving, which could be valuable.
• This is not a book to read if you’re on a diet. They use food for
  most of their examples and even encourage you to eat the foods that they
  discuss as a reward for getting through parts of the book. If I had
  heeded their advice, I probably would have eaten, in a single sitting, a
  hot dog, a peanut butter and jelly sandwich, an ice cream sundae, and
  two slices of cake. This book could be disastrous for you if you are
  bulemic, though I suspect that bulemia is probably not widespread in our
  profession.
• Parts of the book can be pretty boring at times, as it walks you
  through the complete execution of a recursive function, for
  example. But there are some interesting things too. My favorite
  chapter thus far has been Chapter 8: “Lambda The Ultimate”, which
  gets into more advanced topics like
  continuation passing style and
  currying.
  Oddly enough, in their description of currying, they missed an
  obvious opportunity to talk about Indian food. Mmmmm…chicken tikka masala…
• Has the book bestowed on me magical programming powers, as I
  mentioned in this post? I don’t know – I feel the same. Except that
  perhaps I sleep better at night after reading a few pages of tracing a recursive
  function step by step. And perhaps I
  have a bit more enthusiasm for my C programming, since it doesn’t
  require thinking recursively or looking at code with umpteen parentheses
  in a row with no whitespace. Perhaps the book has subtly affected the way I think about problem
  solving in a positive way? I don’t know – hard to say. It feels like the book is sort of
  mind-stretching, but it’s hard to say how much of it translates to practical benefit.
• If you’re looking for a Scheme implementation for trying out code from the book, you might want
  to look at Guile (just an apt-get install away on my Ubuntu Linux system) or LispMe, if
  you don’t mind typing or scribbling Lisp on a PalmOS device.

Books on Lisp from Amazon.com