Home - Game Programming

If for no other reason, you should buy Land of Lisp because of the extreme levels of unadulterated nerdery filling its pages. The price of the book is almost worth that very spectacle alone. However, as an added bonus the content of the book is top drawer. The first incarnation of Lisp was discovered by John McCarthy over 50 years ago, so it's difficult to imagine that a book on the subject bringing a fresh perspective, but Land of Lisp pulls it off in spades. The book manages to carve its own unique niche in the Lisp book landscape through a masterful blend of cartoons, game development examples, interesting prose, and a highly sharpened whit.

The author, Conrad Barski M.D., takes the reader through a whirlwind tour of Common Lisp and some of the fundamental principles of game development, but interestingly enough it never feels rushed. He accomplishes this feat by sticking to a very important strategy summarized as, "providing something useful at every stage". That is, every example in the book is meant to fit into the context of the larger game examples (e.g. a text adventure, Dice of Doom, etc.) while simultaneously teaching a lesson about Common Lisp *and* provide utility in isolation. It's really a thing of beauty the way that Mr. Barski manages to build useable games piecemeal while teaching important concepts along the way. To illustrate what I mean, let me give an example. The Dice of Doom game example starts with a very small 2x2 board and the program parts needed to represent it. Mr. Barski then builds pieces on top of this substrate to generate positions, while extolling the virtues of decoupling the logic of the game from its representation. It's at this point that the game is playable against a human opponent, but at no previous stage was the code left in a state of flux -- each one was fully amenable to tinkering, tweaking, and experimentation. As an added bonus, the whole implementation by this stage was an incredible 13 lines! (that is actually not true, it's more than that, but by using Common Lisp the implementation was incredibly concise) As if this feat was not impressive enough, Mr. Barski then adds game AI into the mix while explaining the famous minimax search algorithm. He then makes the game more efficient using some techniques common in functional programming, including: closures, memoization, tail-calls (with caveats), and lazy programming. As expected the game itself becomes more feature rich as these lessons progress as stronger AI (i.e. better evaluation) is added, more efficient search techniques are introduced (i.e. alpha-beta pruning), and heuristics are used.

All in all, I am very impressed with the quality of Land of Lisp. As a co-author of a Lisp programming book I appreciate the amount of effort required to pull off a genuinely unique book -- I would be happy to achieve a fraction of the quality of Land of Lisp. This book will appeal to the long-time Lisper and the neophyte and I highly recommend buying it today.

Not since the long out of print "A Fortran Coloring Book" by Roger Kaufman and MIT Press has there been a programming language textbook that was this much fun :-) Lisp is a powerful, self-extensible language; it is the second oldest programming language in continuous use; its implementation was based on a 1958 mathematical paper by John McCarthy on the Lambda Calculus. It also for many years was the main language taught in MIT's basic course for Computer Science 6.001 the "Structure and Interpretation of Computer Programs".

While this book would be worth purchasing for the Nerdly Jokes and Comics by themselves, it is a full but easily paced treatment of a language that allowed the implementation of most Artificial Intelligence research. The easy, carefully designed pedagogy (teaching) follows the development of several entertaining and challenging games including 1980's style text adventures (like Zork and Adventure). But advanced topics are covered in some level of depth with examples including development of a HTTP server, a full chapter on Functional Programming, and another on LISP Macro's and the development of Domain-Specific Languages (DSL's). Some Artificial Intelligence methods such as MINIMAX are briefly covered in the game examples developed in this book. Reader's seeking some understanding of Functional Programing will achieve this understanding in a widely used and classic programming language rather than the more recent and arcane Haskell.

This is a fun and relatively easy ride through one of the oldest higher-level programming languages and one with considerable life still in it. It could form the basis of a child's early programming background or a comprehensive adult's introduction to a powerful Computer Science tool. It is the interesting project of an MD's interestingly twisted obsession and valuable to anyone interested in techniques of programming. A great read...

--Ira Laefsky, MSE/MBA
IT & HCI Researcher and Consultant formerly on the Senior Consulting Staff of Arthur D. Little, Inc. and Digital Equipment Corporation

This is an amazing book. If you are interested in seeing what Lisp is about I would argue that this is the best possible place to start.

Although there are many wonderful books about common lisp, Land of Lisp stands above others for beginners because its explanations are clear and its fun to read. And, if you need a break from reading, perhaps you can play a game - one you just wrote.

As a person who doesn't know Lisp, I bought this book hoping it would be a good place to start learning, but I feel like a person should have some familiarity with Lisp before reading this. I'm 6 chapters in and the pacing seems weird. I flew through the first 3 or 4 chapters but around chapters 4 or 5 new concpets started getting introduced really quickly. Also, I wish there was more emphasis on where were going with the game when coding it. I feel a little lost while I'm writing the code. I've concluded that the best way to go through this book for me is to read each chapter, then read it again while working through the code. I guess I just need a little more hand holding then this book provides. It is funny, I love the cartoons and I think if someone had a little familiarity with Lisp it would be a great book for them. I'd also like to see programming challenges at the end of each chapter to help reinforce what was learned. At the end of the day this book isn't bad but I'd start with The Little Schemer (which I'm reading now and is awesome), then move onto one of the free Lisp books online, then read this.

I'm a professional software engineer and I am thoroughly enjoying this book, and surprisingly, LISP. I bought the book mostly because I had heard LISP had some strange voodoo that other languages couldn't hope to match (and because the LoL promotional video was awesome!) I never realized what I was missing out on! Talk about a cool programming language. I think I am going to at least prototype some of my smaller work projects in LISP and see if I can convince my coworkers to go with it. Maybe we'll like where it takes us and eventually do some large-scale projects.

Anyway, this has to be the coolest programming book I have ever read. I very highly recommend it.

I'm already fairly expert at Scheme and Clojure, so I already know how to "think in LISP". Consequently, I can't really judge how effective the book is for self-learners who are learning LISP and/or programming for the first time. I suspect the book may move at too brisk a pace for true beginners, but I'm not certain.

As a teacher of computer science, I tend to prefer teaching out of books with a coherent pedagogy. How to Design Programs is my favorite textbook. Simply Scheme is another good one.

Land of Lisp doesn't seem to be grounded in any kind of modern pedagogical philosophy. Instead, it has a kind of retro feel that is appealing in its own way. This book takes me back to the 80s, learning how to program by typing in complex BASIC programs out of magazines and books. Many of the programs I typed in, I didn't understand 100%. But each time I entered a program, I learned something, and then by tweaking the programs and seeing what it would do, I learned a little more. One of my favorite middle school memories is the time I managed to understand a text adventure BASIC program well enough to write my own. Land of Lisp, in fact, has code for a rudimentary text adventure engine, as well as a blatant "Retro type-in game" of Robots that fits compactly in less than a page of code. So it's easy to see why this book evokes in me a sense of nostalgia.

I think Scheme is a better language for learning programming than Common Lisp. Common Lisp lacks a bit of Scheme's elegance, and it's just harder to get a Lisp environment up and running. But Land of Lisp doesn't make any apologies for Common Lisp's quirks. On the contrary, it revels in the cars and the cdrs, and the convoluted loop macro and format strings which allow you to write some ridiculously concise code (like the retro type-in robot game). The book repeatedly brags about how amazing Lisp is, sometimes to the point of overstating the case for dynamic, functional languages. This is not a book that will attract non-programmers to programming, but for that rare breed of person who was "born to program", the book has an infectious enthusiasm for programming in general, and Lisp specifically.

In my mind, the truly special thing about Land of Lisp is its inspired collection of engaging and well-chosen projects, which are quite a bit different from the run-of-the-mill exercises in a typical textbook. As a teacher, I am glad to own this book because I'm always on the lookout for great project ideas for my students. A book with one great project is usually worth the price -- this book has several! I intend to use these project ideas with my Scheme students. Obviously, the programs translate the easiest to other Lisp dialects, but even if you don't teach Lisp, I'd recommend purchasing this book and trying to port these projects to your favorite language. Orc Battle, for example, should be doable in any object-oriented language. A number of the projects would probably work well in Python. I would advise against trying to tackle these projects in Java (the resulting programs would be too verbose), but a modern multi-paradigm variant of Java, (e.g., Scala), should work just fine.

Land of Lisp is an intermediate-level book that teaches Lisp by way of game programming. Interspersed with light-hearted illustrations, LoL is a real page-turner and is one of the most interesting programming books I've read. Important Lisp concepts such as macros, higher order functions and generic programming are clearly explained. One whole chapter is devoted to Lisp being applied to Domain Specific Languages, which is highly applicable and relevant to modern web programming. Along the way, the author also teaches fundamental concepts such as recursion (although not as much emphasis on this as compared to Scheme, for example), code reuse (the "Don't Repeat Yourself" principle), functional programming, closures, basic algorithms like MiniMax, depth-first search and a whole lot more.

Because the author assumes the reader has a basic grasp of his operating environment, setting up a Common Lisp implementation (editor/compiler) is not covered in detail. If that idea is too daunting for you, then you may wish to refer to the beginning chapters of Peter Seibel's Practical Common Lisp or David Lamkin's Successful Lisp as a starting point and come back to LoL when you're more comfortable with how things work.

All in all, I would say, "buy this book!". Highly recommended.

The bottom line is that this book is fun! By choosing to teach Common Lisp using 1980s style text games the author has come up with an original and clever idea that avoids all the usual boring examples found in computer language books. Nevertheless, he covers all the important topics (including the hard stuff like macros) with enough detail to explain them well. He eschews talking too much about the theory behind Lisp (e.g. he mentions the lambda calculus but doesn't dwell on it) and that makes the book entirely practical and a good introduction for a beginner.

Since I have experience with Lisp I was a little disappointed towards that end when I wanted more, more, more, but for someone who has no to little experience of Lisp or functional programming this book is wonderful. It's rare that reading a technical book makes you happy, but the author's writing style and cartoons keep you smiling along as he explains what to many people is an esoteric language.

I'd recommend this book strongly as the first book to read on Lisp. After that migrate to Paul Graham's On Lisp.

I have only read thru chapter 3 so far, but I really like this book. The author takes a complex subject and breaks it down so you can really understand it. The book outlines very clearly the basics of Lisp and why it is such a useful language in the first few chapters. I highly recommend this book if you are new to Lisp or just want to learn programming from a different perspective. I am looking forward to reading some more...

Conrad Barski's book 'Land of Lisp' is a first rate book for learning Common Lisp. I gave the book four stars simply because of a personal prejudice against giving five stars to any book except for timeless masterpieces.

Lisp is hard, no doubt about it. I've read about ten Lisp books so far, and have written a fair amount of Lisp code, and I can't say that I have a grasp on it. Part of the problem is that Lisp doesn't have an authoritative implementation or development environment. Barski does a fair job of getting a novice up and running, not as good a job as Peter Seibel in 'Practical Common Lisp', but a much better job than Norvig, or Graham, or most of the others.

Barski also hasn't written a textbook or reference, which is both good and bad. I would strongly recommend the reader supplement his reading with both a text (Touretsky has one available online at no charge) and a reference (the Lisp Hyperspec, for example). Some might feel that this lack diminishes the book, but I see it as a judgment call based on the fact that one book can't contain everything.

The strongest part of LoL, in my opinion, is that Barski presents an attractive learning environment with intelligent projects.

The weakest part of the book is that it doesn't cover Lisp in any systemic way, but this is only a fairly minor defect, given that more systemic treatments are readily available.

I don't know whether I would recommend LoL for a complete beginner who wants to self-learn Common Lisp -- I think a traditional text (like Winston & Horn, Lisp 2nd) might be more appropriate for a complete novice. However, I certainly think that LoL would be a great second book for a self-learner.

And finally, I would like to thank Conrad Barski for giving us such an engaging treatment of Common Lisp. LoL is really a first class book.

Last summer I had my 15 year old son in our offices and had him learn Lisp using my favorite Lisp books. After the first day he asked: "please dad, don't you have anything with games that I can write?" and I had to disappoint him. So next year I'll try again with Conrad's book. I read through the whole book and I had so much fun. Thanks for writing this. And I'm definitely going to take the periodic table of Loop and turn that into a big glossy poster.

Ever since I first learned about it, I was eagerly awaiting the release of Land of Lisp. If you have never heard about the book before, have a look at this promotional cartoon music video. Yes, that's right, this book comes with its very own promotional cartoon music video!

[...].

Your reaction to this video is actually a pretty good indicator on wether or not you are likely to enjoy this book. If you can't take the cartoons and strange humor, "Land of Lisp" will probably not be for you. If you do however, you'll be relieved that the book is at least as awesome as the video and probably even more.

People believing that Lisp has been dead since the AI winter may be surprised by the release of new book on the language in 2010. They may however have missed the release of Peter Seibel's Practical Common Lisp in 2005, which managed to expose the language to a wider audience again, a feat I think "LoL" might achieve too.

For me the best part about Conrad Barski`s book is its very readable and entertaining style, combined with cartoons and the use of small games as demonstrations of the techniques introduced in the book. I think this is what makes "LoL" really stand out from the other Lisp books: it's neither as academic as most of the texts focussed on Scheme (with The Little Schemer being an obvious exception), nor is it as dry as Seibel's book (which otherwise is a pretty good read) or as dated as Paul Graham's On Lisp which was written while Common Lisp was still in the process of being standardized. For many people "Land of Lisp" may very well be there first contact with the language, and I think with its funny and easy to follow style it may get quite a few people hooked.

The book is structured in 4 main parts, the first of which - called "Lisp Is Power" - serves as a general introduction to the language, explaing the basic syntax and so on. The second part ("Lisp Is Symmetry") introduces the reader to flow control, data structures, input and output, lambda expressions and more. In the process you'll write the first part of a game engine for text based games, a great little version of Hunt the Wumpus called "Grand Theft Wumpus" and "Orc Battle", a small strategy game played in the REPL. The third part ("Lisp Is Hacking") introduces us to the powerful and sometimes disputed "format" and "loop" commands, as well as streams. Game-wise you'll encounter a little simulation of an evolving world as well as "Attack of the Robots", a retro game where your aim is to get rid of some robots by making them collide with each other. The last part ("Lisp Is Science") introduces functional programming techniques, macros, DSLs and laziness. Besides finishing the text adventure started in an earlier chapter, you'll also write "Dice Of Doom", a Dice Wars clone that's the most complex program of the whole book. Last but not least there's an epilogue, where the author gives a brief overview of several important topics that got little or no exposure up to that point, like CLOS or the condition system.

As a final summary I'd say that "Land of Lisp" is a truly great achievement. It's fun to read and does a good job of introducing the reader to the most important concepts of Lisp, by giving a taste of the language's power, without being overwhelming. For more experienced Lispers this might make the book significantly less interesting, since some really nifty things only get mentioned in the epilogue. If you are among them, Seibel's book is probably what you want to read (if you haven't already, which would be surprising). I'd also advise you to not get too excited about the "game development" part of the book, except for the last one all the games are rather minimal and simple, so don't expect writing 3d shooters or anything like that. They are however awesome examples of the concepts introduced in the individual chapters and way more fun than the contrived examples one finds in way too many programming books. For new Lispers or people who need to brush up on their Common Lisp skills (e.g. when migrating from some other Lisp) this comes highly recommend, but even more senior Lispers might want to get a copy, even if it's only for the odd cartoons.

I did not want to buy this book. I have a pretty busy schedule and I /knew/ that if I had it on my desk it would have made things worse. Moreover, Lisper have the tendency to make every other language inadequate; considering that I am (unfortunately) not going to use Lisp in the near future, that would be on the demotivational side of things. Just hope to be able to use clojure, but that's another story.

The introduction is one of the funniest pieces of half-technical writing I ever read. In the rest of the book the humor is present and that is great value. I don't consider myself a Lisp expert; however, it's about a decade since my first exposure to Lisp, I have recently dig into scheme and used quite an amount of functional, logic, dynamic, high-level and whatever languages. That means that I was afraid the first chapters of the book would just be very boring to read (because I already know the contents), but perhaps a necessary evil to familiarize with the concepts and the philosophy of the book, which could prove useful when reading more advanced stuff.

Well, I was right and I was wrong. I was right since it's pretty hard resisting to read the book, even though I have some compelling things to do (or maybe more so). O was wrong because the first chapters are a pleasant reading /even if you know/ the concepts presented. Perhaps it is even more interesting as my brain is not involved into understanding difficult new concepts but can just enjoy the beautiful presentation of familiar stuff.

Besides, the book is a wonderful introduction to the functional way of thinking and covers relatively advanced topics. You can really learn Lisp from the book, even if you don't know a thing about Lisp and functional programming. However, it is nice to read for someone familiar with FP and not with Lisp. I believe that it is funny even for experienced Lisp hackers, as the comics and jokes inside the book are really funny.

I've read Practical Common Lisp, and while that is an amazing book, I wish this book had come out sooner so I could read this one first. Land of Lisp is a joy to read. The author is very responsive to questions posted on the online forum.

First of all, for a beginner that wants to learn about Common Lisp (Such as what I was when I got this book), this will definitely do the job. This book is definitely geared towards beginners that want to learn the language. With that being said, there are a few things that this book could have done better, in my opinion. No beginner should approach any book and decide "When I finish this book I am going to be an expert", it just does not work that way. So, my complaint? Well, this book does cover the basics and some more advanced techniques, but it also moves quite quickly. The author provides you with key principles that you will be able to understand and use in your own programs, but a lot of the games we write in the book are quite complicated. He takes the basics concepts and definitely takes them to the next level. This really isn't a bad thing, for someone who has been around the language for a while, but for a beginner, it would have been nice to see some examples that just use the key concepts. I definitely learned a lot from this book, but I am going to have to read more books on Common Lisp before I am totally able to see myself writing code that matches some of the examples in this book. Overall, the book is great. Just wish there was a few more basic examples to help get my mind in the right place.

The author, Dr. Conrad Barski has pulled off a feat which was earlier thought to be unimaginable -- he has written a book that teaches its readers something as complex as Lisp with the amount of fun usually found in a nursery fairy tale book. It's a great work of art.

Highly recommended!

I've had a bug eating away at me for many years to set aside some time and learn more about this thing called "Lisp". My initial exposure to the language was 15 years ago, via a little-known game called "Abuse", which itself was written in C, but contained a modding facility that read and understood add-ons written in Lisp. Years went by, and I continued to put off my research, moving forward in my web application development career path, which essentially took me further and further away from functional programming. As luck would have it, a recent surge of interest regarding Clojure in web apps has since spawned, which caught my attention...and inevitably brought the "bug" back to life.

I looked around for any sort of contemporary reading material on Lisp, as much of what exists is dated and terse, so I was therefore very excited to see this book with a gigantic green alien on the cover, and whose pages are littered with comics. I had high hopes that it would be an interesting venture, and I was not disappointed: Land of Lisp is an incredibly clever, intelligently presented textbook on the Lisp language, its history, and importance in the realm of functional programming. I got a real sense of passion from Barski in his delivery of the material; he clearly loves the language himself. More importantly, he demonstrates a finely tuned understanding of not only its syntax and use, but also its value and place in programming. This is evidenced by the fact that Barski spends an equal amount of time introducing you to core fundamentals of Lisp, as well as covering the history of why these parts of the language exist--a part of programming textbooks that is often left out. This is important for old and new programmers alike, because it paints a complete picture of the language--not only what it does--but why, and the 'why' is often necessary to take a programmer out of the hobbyist mentality and into the realm of becoming a true professional.

Barski even goes so far as to cover the myriad of dialects that Lisp has spawned (including Clojure), and spends some time exposing the reader to the bias that the various Lisp communities have with each other, which I found fascinating. Having been in software development for nearly two decades, I can empathize with the author on language communities having their religious convictions for a particular dialect, and I was surprised (and impressed) that Barski took the time to cover this darker side of programming in Land of Lisp.

All of this is just icing on the cake, however, as the core material delivers exactly what it promises: a unique and fun look into the Lisp language, by way of many small, digestible programming examples in the form of games. The first half of the book has the reader working on stand-alone games, each taking advantage of a new part (read: benefit) of Lisp, slowly introducing the reader to the realm of functional programming. The second half of the book is a series of smaller programming tasks that all build towards a final web-based game. This, coupled with the author's clever wit and humorous artwork has lead me to be thoroughly satisfied with this textbook. If you have any interest at all in any of the dialects which are based upon Lisp, I strongly urge you to start at the core language to caused them all to be, and do so via Land of Lisp. I have a feeling you'll come away with a new found respect for functional programming, and may even become a "Lisper" yourself.

I read this book while I was writing CoffeeScript: Accelerated JavaScript Development, after Paul Graham tweeted about it: "Turns out the border between genius and insanity is a pretty cheery place."

This book is a lot of fun. You write games, and there are occasional comics, some of which are brilliant. (I would happily pay for a T-shirt of with the slogan "SIDE EFFECTS SHALL RECEIVE NO MERCY!") And you really get a taste of the succinctness and power of Lisp when you build a web server in just a few lines.

The one question I kept asking as I read this book was: Why Common Lisp? Clojure--a Lisp dialect that runs on the JVM, giving it great performance and access to the rich Java ecosystem--is starting to take over the world. I think it's safe to say that far more "real" code is being written in Clojure right now than in Common Lisp or Scheme. And then there's JavaScript (inspired by Scheme, and arguably "an acceptable Lisp" in its own right, despite the shortage of parentheses). It's in the unique position of running in all major browsers, and Node.js has made it a first-class server language as well. Of course, JS suffers from its C-like syntax... but that's why there's CoffeeScript.

In short, Land of Lisp didn't convince me that I should become a Lisper (despite the promise of an ample beard), but then, it's not really trying to. The marketing for this book just says, "It'll make you a better programmer!" And that's true. While most of the capabilities of Lisp have found their way into modern languages like Ruby, Python, and JavaScript, it's hard to appreciate how natural and elegant those features are without knowing Lisp. This is a great read for programmers of all stripes.

I just finished reading "Land of Lisp" from cover to cover and running
all the examples.

What a great book! It reminds me of when programming was fun and done
by amateurs in the Eighties on things like Amiga 500s. Now we're all
'professionals' (including me) and I miss the fun when hobbyists were
writing cool math, graphics, and game hacks. This book brought me
back to those days.

The programming book ever!

The book is easy to read and very comprehensive. Going from one chapter to another you will start falling in love with this weird and charming programming language.

I once wanted to learn Lisp. I purchased the very, very good Patrick Winston's Lisp (3rd Edition), and learned a lot from it. Then I found another excellent book, Peter Seibel's Practical Common Lisp, and thought it to be the ultimate self-teaching tool. But I was wrong: this "Land of Lisp" is the answer to those avid to learn Lisp. It's modern, practical, intelligent and fun. Filled with so funny and clever illustrations, this book can change your mind about this 50-years-old language.

But there is a caveat: it's better to find on the internet a basic tutorial, read it through, and only then read this book. The experience will be better, and even better if you already know some programming language. To the utter beginner, the everytime classic Common Lisp: A Gentle Introduction to Symbolic Computation is a way better choice.

First up, I'm just starting out with Common Lisp, and yes this is the first book I've bought regarding the subject. I wanted to learn a bit about functional programming, my only exposure to which was a Haskell course at uni. I came across the book quite randomly while looking for "functional programming" books, and looking sort of fun, I decided to buy this one (I figured at least I'd be building games and plus, this was meant to be a "recreational" book).

To the point now. I may not have any other experience with Lisp books, but I do with books about other programming languages and this book is by far the one I like most. It's laid back but manages to offer something new on practical every page. I don't enjoy re-reading books much so I make a list of stuff like "What is quasiquoting? How does it work? Write a simple function using quasiquoting" and then noting the page, in this case, 73. That way I make a list of the stuff the book teaches and I just have to go through the list later on. I seem to be taking "notes" or whatever you want to call them for almost every page of the book.

btw I haven't finished the book so I guess it might get worse later on but I really do doubt it. I was so pleased with this book that I had to make a comment (I also don't comment much on books, good or bad... only about the ones I like it seems).

I learned lisp long ago, but then ended up using other languages like C and then Python for the last 20 years or so. I wanted a book that reintroduced me to lisp, but didn't dumb it down or use trivial examples with no meat on the bones. This book delivers that, and more! Not only is it witty, salient, and downright fun, the examples and diagrams are constructive and illustrate many complex concepts simply and with no obfuscation. I would recommend this book for either a lisp beginner or someone with experience in other languages but not lisp. The hilarious cartoon illustrations are just icing on the cake!

Amazing. I have a great fun reading and fallowing the examples. The illustrations are insanely funny and the games presented provide excellent examples. My favorite parts starts with introduction of functional programming. But other parts such a as one devoted to loop are also awesome,and I'm known to dislike loop but with periodic table at hand I will probably change my mind.

As a little nitpicking I must point that author have a habit of writing very long functions which sometimes span 30 lines and those hurt my eyes.

Eleven reviews so far, and all of them 5 star. Well, I was trying to decide between 3 and 4 stars and settled on 4. This book is fun, no question about it. And it's mostly teaching me about Lisp. If it were as good at teaching Lisp as it is as trying to have fun with teaching Lisp, then it would be peerless. The problem is, that's just not true. I've been working as a professional programmer my whole adult life, and I've used a variety of programming languages, and even worked as a reviewer on several different books on different programming languages. And I'm struggling to get through some of the code examples in this book. It's not that he's not explaining any of the examples as he goes along, focused on developing the games that form the book's fun. But he's not explaining them ENOUGH. And some of them are sufficiently opaque that it has taken me quite a while to understand them. An experienced programmer picking up a beginning book on a new language shouldn't be finding himself wanting to look at other sources to try to help him understand what he's learning in the book at hand. The book at hand should be making itself clear enough on its own. Right now, I'm struggling with the example at the top of page 123. When I use what is admittedly another Lisp interpreter than the one recommended in the book to try to load this example, it fails, unable to load the EXT package. Ok, there's probably some way to load it, or maybe this is the thing he talked about earlier in the chapter when he mentioned that some of the features in this chapter's code examples were unique to CLisp (only he doesn't bother to say what they are). I also looked for "package" in the index: nothing. And he didn't give us much information about CLisp either. Do I have to type in the entire code example by hand into the CLisp REPL? Would it work then? Is there no way to load it into CLisp from a file? Maybe there is, but I can't find any help on this issue in the book. I won't toss this book aside, I'll keep slogging my way through it. But I wish I didn't have to slog my way. It shouldn't be necessary.

This books is for those who learn best by doing. I can be described as a loop of the following things: being presented some new concepts, typing in code that uses those concepts (and builds on previous ones), then seeing how it runs; repeat. The author does not dodge or gloss over the less friendly parts of Lisp, which is a plus in my opinion. The text games that remind me of old mainframe and early BASIC "home computer" things from BYTE back in the day.

This book manages to set a good pace of new ideas interspersed with game-based code examples, punctuated by the odd cartoons. When you are done, you'll have enough depth to be able to express many ideas in Lisp, and enough breadth to be able to explore other parts of Lisp in depth on your own.

It is a good start to learning Common Lisp, warts and all.

I agree with the general trend of reviews here. I just wanted to make a quick comment about buying options.

I purchased mine from No Starch directly. I did so to get early access to the eBook, which came free with paper book purchase. No Starch is still offering the ebook free with paper deal; however, I would not suggest purchasing from them. I had no problems. They were actually great. That said they aren't as good as buying paper from Amazon and the ebook from O'Reilly. The paper is the same, but O'Reilly's ebook management system is superior and more wildly supported (ex Stanza integration).

I've found that the price of splitting the purchase is within the margin of price fluctuation.

Having seen the overwhelmingly positive reviews for this book and the goofiness it exuded I had reasonably high expectations when I decided to order it.

Unfortunately, having spent an afternoon and a half with it I have to say that I am thoroughly unimpressed. My initial, though it now appears unfounded impression was that this book is targeted at people with a desire to learn how to program. Just reading the first three chapters was enough to completely dispel this illusion.

That in itself would represent no problem at all if the book lived up to its promise of teaching the reader how to program in LISP. Having read SICP I can quite confidently state that this book stumbles on what should have been a rather easy task. While the problems that SICP would throw at you were sometimes hard, the solutions it offered were regularly simple and elegant. On the other hand, the initial problems in this book are relatively simple, but the solutions feel totally ad hoc and oftentimes convoluted as well. There is a serious lack of didactycism here.

The thing that really sank this book for me was the perpetual and monomaniacal praise to LISP. It seems like every fifth paragraph is a dithyramb to a particular feature of LISP not to be found in most other contemporary programming languages. Sorry, but I don't think that any language, even LISP is that good.

Finally, the comics: they're quite a bit funny, but to fully appreciate them one should already know a thing or two about programming and functional programming in particular. The bad side to them is that their value is mostly confined to entertainment: on very few occasions do they actually usefully illustrate the currently discussed ideas.

As a comic book I could perhaps rate this with 5 stars (I'm still to read them all), but as a textbook on programming I can't in all honesty bring myself to rate it with more than 2 stars.

LAND OF LISP is for any computer collection strong in games programming, and covers the basics of the Lisp programming language. From understanding Lisp's quirks and using macros to creating your own web server and writing games, this is a pick for any programmer who wants to make the most of the Lisp gaming language.

I bought this book because of it's website with cartoons, expecting it to be fun. Unfortunately, the cartoons are only incidental to the book and play no major part in explaining the content. Actually, having read a few chapters on my Kindle, I feel a little disappointed, after all the hype. I wouldn't say the book is that well written. There just seems to be verbatim explanation of the code: where's the fun there?
The good side of the book is that the author chooses an accumlative project. Each mini-project (chapter) feeds into the larger project. The culmination: a game of some sort. The fun is seeing how the game is implemented, with mathematical structures behind it. The author in the process shows the reader the basics of lisp.
All in all, because the text is drably written and because there is no extensive use of cartoons as part of the learning process as insinuated by the Land of Lisp website (landoflisp.com) I would give this book 3 stars.