Product Description
...it has a fresh view on the language and the examples in the later chapters are usable in your day-to-day work as a programmer.If you're interested in Lisp as it relates to Python or Perl, and want to learn through doing rather than watching, Practical Common Lisp is an excellent entry point.

— Chris McAvoy, Chicago Python Users Group

Lisp is often thought of as an academic language, but it need not be. This is the first book that introduces Lisp as a language for the real world.

Practical Common Lisp presents a thorough introduction to Common Lisp, providing you with an overall understanding of the language features and how they work. Over a third of the book is devoted to practical examples such as the core of a spam filter and a web application for browsing MP3s and streaming them via the Shoutcast protocol to any standard MP3 client software (e.g., iTunes, XMMS, or WinAmp). In other "practical" chapters, author Peter Seibel demonstrates how to build a simple but flexible in-memory database, how to parse binary files, and how to build a unit test framework in 26 lines of code.

Customer Reviews (59)

Wonderful Introduction
I've found that I can gauge the usefulness of a book (on Amazon) by looking at the poor reviews first, to see the most severe criticism. I've read the poor reviews of Seibel's book, PCL, and have concluded that those reviewers haven't taken the book for what it is.

I've been a professional IT guy for over a decade and have used three different languages over the years. I've been playing with CL for several years, and have been through the standard texts (W&H, Wilensky, Touretzky, Graham). I can't therefore evaluate PCL from the standpoint of a complete beginner, but as someone who already knows something about CL.

PCL isn't a textbook, it isn't a tutor, and it isn't a reference. It's a guided tour by a lover, and as with all guided tours, reflects the biases and prejudices of the guide. This has both positive and negative implications.

In chapter 1, Seibel writes, "This book is for you if you're curious about Common Lisp, regardless of whether you're already convinced you want to use it or if you just want to know what all the fuss is about." This is a warning that the book isn't for the student or the practitioner, but for the curious -- note that Seibel intends to scratch an itch, rather than to lecture.

Seibel goes on to say, "If you've learned some Lisp already but have had trouble making the leap from academic exercises to real programs ..." This is where I was coming from, and in this respect PCL delivers. He continues "If you're a hard-nosed pragmatist who wants to know what advantages Common Lisp has over languages such as Perl, Python, Java, C, or C#, this book should give you some ideas." Again, PCL delivers. "Or maybe you don't even care about using Lisp ... but are annoyed by some Lisper telling you that's because you just don't 'get it'." PCL gives practical examples demonstrating the strengths of CL.

The word PRACTICAL in the book's title should clue the reader that PCL isn't a structured introduction to CL, but a guided tour with emphasis on the USES of the language and just enough theory to have it make sense.

I gave PCL five stars, I really should only have given it four because it's not sufficient by itself to learn CL -- but it most certainly meets the requirements of the curious to learn what the fuss is about. If the reader's curiosity turns into a desire to become proficient, PCL certainly gives him enough to make sense of a real text and/or reference.

Excellent Introduction to Common LIsp
I had been looking for a functional language with closure and object orientation. I wanted the object orientation a little more general than the message passing approach of c++, java, etc.

Well, common lisp has it all and I am finding it fun to use. The word "Practical" in the title is accurate, because Peter Seibel explains some of the issues with the different implementations of common lisp. He also explains how to make your lisp programs portable.

As a result of reading and working through some of the examples, I now only use common lisp for my more complex projects.

Great Book
First, these are my credentials as a reviewer. I have read this entire book (some parts more than once). I have completed modestly large freelance projects using php, actionscript, python and c. I do not have a formal background in computer science (I have a degree in Art). I learn by practice and by reading books.

Thinking of this book, here's what comes to mind, -one of the most enjoyable learning experiences I have had. It communicates itself with effectiveness, originality and a careful attention to detail.

When I first began using this book, I was skeptical of it. Chapter 3 introduces Common Lisp with a 'Practical', a step-by-step build-up of a small Lisp program. The next few chapters explain syntax, functions, variables and macros.

I was skeptical because, at the time, I understood little of Chapter 3 and it seemed to me that the following chapters (syntax, functions, variables, etc.) should have preceded Chapter 3. There are no end-of-chapter directives and only the 'Practical' chapters include significant tasks for cementing concepts. What does it mean?

It becomes evident that this organization is a good thing. It forces the reader to engage the book with a fresh approach. After reading a few chapters following Chapter 3, a necessary re-read of Chapter 3 yields great understanding. It sets the reader into a rhythm of reading... reading some parts once for creative enjoyment and once again for critical comprehension.

This is an important aspect of this book and my appreciation of it. The author does not try to anticipate and satisfy the expectations of the reader (a linear presentation of mixed code/explanation). Instead, like an artist, the author presents his method and changes the reader's perspectives to match his own.

The organization also adds something to the long-term usability of the book. Mini-programs and behavior test-cases are mostly reserved for the 'Practical' chapters. The other chapters are not cluttered with these things and are devoted to single topics. 'For example there is a chapter devoted to numbers. Another chapter is about the 'format' function, Common Lisp's equivalent of printf. The material in these chapters is patiently and thoroughly presented.

This is one of my favorite books. After reading it I was able to write a Common Lisp program that uses classes, packages and macros.

great to work thru with allegro express
bought this about 4 years ago, got about half way thru, and then got too busy. Also, either I'd missed it, or Allegro didn't have a free 'express' edition then.I have more time now and so starting from the beginning once more, and was very glad to find Lisp in a Box which seems to bundle Allegro Express here : [...]
As I've read in other comments about Lisp in general, I feel what I did learn helped me to program better in the languages I was actually working with.

A great introduction to Lisp
This book is a great way to get to know lisp. It doesn't assume you know anything, but it moves along quickly. This isn't lisp for idiots. This is lisp for people who like to think, but don't know lisp (yet). I highly recommend this book. ... Read more

Product Description

Paradigms of AI Programming is the first text to teach advanced Common Lisp techniques in the context of building major AI systems. By reconstructing authentic, complex AI programs using state-of-the-art Common Lisp, the book teaches students and professionals how to build and debug robust practical programs, while demonstrating superior programming style and important AI concepts. The author strongly emphasizes the practical performance issues involved in writing real working programs of significant size.Chapters on troubleshooting and efficiency are included, along with a discussion of the fundamentals of object-oriented programming and a description of the main CLOS functions. This volume is an excellent text for a course on AI programming, a useful supplement for general AI courses and an indispensable reference for the professional programmer.

Customer Reviews (8)

Amazing book about designing programs
Don't let the title of the book fool you: Yes, it presents all its code in Common Lisp and yes, the domain it discusses mostly is Artificial Intelligence, but PAIP (as it's affectionately called by fans) is a book about the general process of designing programs and implementing them. It's just a by-product that along the way you will learn Common Lisp (which is a very interesting language) and will get familiar with some very interesting problems in the fields of AI, code optimization, search, compilation and OOP/

Peter Norvig is a masterful programmer and writer. His code is excellently thought-out and designed, and shines with originality and clarity at every snippet you read. Every chapter has interesting insights and great code in it. Reading through this book from cover to cover is a behemoth task, but even starting small is great. Norvig even includes several exercises *with solutions* for each chapter, which really helps understanding the material.

In short, PAIP is one of the best books about programming and computer science I have ever read. It is highly recommended.

One of the Best
"Paradigms of Artificial Intelligence Programming" is one of the best books of computer science that I have ever read.I put it up there in the pantheon with "Structure and Interpretation of Computer Programs".I have found more useful and mind expanding material in these case studies than I have in many other books on computer science. I highly recommend this book to anyone, even if they have never used Lisp.

Norvig's Corollary to Greenspun's Tenth Law of Programming
This book has been called "The best book on programming ever written".I'd have to agree--it is certainly the best that I've ever read.

William Zinsser said, "The essence of writing is rewriting" and the same can be said for writing computer programs.Norvig's book presents this process--how the limitations of a program are overcome by revision and rewriting.What sets Norvig apart as a writer is that, amazingly enough, he can write about debugging (the most dreaded part of computer programming) and make it a fascinating read!

Lisp has been getting a higher profile lately because of essayists like Paul Graham and Philip Greenspun; in particular,Greenspun's Tenth Rule of Programming which states: "Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." So, should this book be read as an exhortation to return to Lisp as the preferred programming language?

Paradoxically, I think not.One third of the way through the book, Norvig shows us how to implement Prolog in Lisp.From then on out, most of the AI techniques he presents either directly use Prolog instead of Lisp (such as his excellent discussion of natural language processing using Prolog) or use Prolog as a base to build on (such as his discussions on knowledge representation).

From this we can abstract what I'd like to call Norvig's Corollary to Greenspun's Tenth Law of Programming: "Any sufficiently complicated LISP program is going to contain a slow implementation of half of Prolog".I'm leaving out the "ad hoc", "bug-ridden" part of Greenspuns's law, because Norvig's programs are neither.But it is quite remarkable the degree to which, once having absorbed Prolog, Norvig uses Prolog as the basis for further development, rather than Lisp.

Is this a book about Prolog then?Again, no.What is the take-away message?It is this: as our world becomes more and more complex, and as the problems which programmers are facing become more and more complex, we have to program at a higher and higher level.

Norvig does not stop at just embedding Prolog in Lisp.He also shows us how to embed scheme as well.Excellent discussion on the mysterious call/cc function and on continuations.

In a capsule review, it is impossible to really give an overview of a 1,000 page book like this one. But the scope and heft of the volume really needs to be commented on: the programs presented in this book are like basis vectors, the totality of which nearly span the space of programming itself. In no way should this be considered "just an AI book" or "justa LISP book".This book transcends language, time, and subject matter.It is a programmer's book for the ages.

An Excellent Reference on WHY to write good Lisp
This book is equally excellent regardless of whether you wish to regard it as:

a) A historical study of Artificial Intelligence, with USABLE examples of code, or

b) A book presenting techniques for programming in Common Lisp.

As a reference about Common Lisp, it is certainly lacking, but this is no great problem when both the Common Lisp HyperSpec and Steele's book are readily available in electronic form.It provides something more important: SIGNIFICANT examples, and significant discussions on WHY you would use various Lisp idioms, and, fairly often, discussions on HOW pieces of Common Lisp are likely to be implemented.Its discussion of an implementation of the LOOP macro, for instance, provides a very different point of view than the "references" to LOOP.(Contrast too with Graham's books, which largely deprecate the use of LOOP.)

From an AI perspective, it is also very good, providing WORKING SAMPLES for a whole lot of the historically significant AI problems, including Search, PLANNER, symbolic computation, and the likes.

It would be interesting to see parallel works from the following sorts of perspectives:

- The same sorts of AI problems solved using functional languages (e.g. - ML, Haskell), to allow contrasting the use of those more modern languages.Being more "purely functional" has merits; such languages commonly lack macros, which is something of a disadvantage.

- The use of CL to grapple with some other sorts of applications, notably random access to data [e.g. - databases] and rendition of output in HTML/SGML/XML [e.g. - web server].

Not advanced, but good and vast
The strength of this book is its combination of breadth and completeness: there is working code (well beyond the toy stage) of a large number of different AI systems that cover a large subset of what is commonly considered AI.

The programming itself is rather basic, and very straightforward.In many places an advanced programmer would have avoided a global variable, unified code through the use of higher-order functions, had functions communicate through a shared local environment, created a lazy list, you name it.

The author avoids most of these more advanced approaches in order to present the ideas behind the approaches without being sidetracked into programming technique issues, and that is the correct choice for this book.Even as it is, there is already the duplicity of teaching Common Lisp and teaching AI programming.

That being said, the code in general is not bad at all, even though I wouldn't want my students to learn CL programming from it.The author has simply bent down to the level of, a good C programmer, and worked from there.His main intention being to teach AI programming approaches, he has spent much less time to raise the programming level of his audience.

Knowing the author's level of Lisp programming, I can't wait to see a book by his hand on how to use abstraction as an organising principle in programming. ... Read more

Customer Reviews (6)

THE book on object-oriented programming in Common Lisp
Sonya Keene is one of the very best technical writers in the entire computer industry, and she was one of the inner circle of experts who designed and standardized the Common Lisp Object System.This book is crystal clear, accurate, and comprehensive.

Really great book on CLOS
This is a great book. It shows everything about CLOS (except the metaobject protocol, which is just mentioned but not explained in detail). The explanations are very clear and the author does every possible thing to make you understand all details (a bit too much for me, but that's a matter of taste).

For anyone interested in OO programming in Common Lisp, this is an essential book.
Even if you are interested in OO programming in general, this book covers a different approach, so it is nice for a comparison (in CLOS, methods do not belong to classes, and there are lots of interesting tricks that you can do that are not possible in other languages).

Concise, clear and readable, an excellent introduction
Lisp is kinda hot again, Perl 6 will have multiple dispatch, Ruby's getting before and after methods, and Aspect Oriented Programming is still bubbling under in Java, so what better time to revisit the Common Lisp Object System and this slim volume from 1989? Unsurprisingly, objects in Lisp are implemented differently to the well-known object systems, even Smalltalk, so if you're into OO (and in particular AOP), check out CLOS.

And this book is an excellent way to get acquainted with the features of CLOS. While the introduction suggests non-Lispniks can benefit from reading this book, I would strongly suggest you can read Lisp to make sure you understand what's going on. It's a quick read (about 220 pages, excluding the appendices), the language is unfussy and clear, and the concepts are simply explained.

The hoary old shape example is used briefly (perhaps it wasn't as tired in 1989), but the two main examples used in the book is a simple locking mechanism for concurrency, and multiple inheritance based disk and tape stream classes. Both example do the job well of highlighting the unique flavour of CLOS. The metaobject protocol is touched upon only briefly, but there's more than enough of the standard object protocol described for you to be getting your money's worth.

Other introductory books do cover CLOS (Practical Common Lisp has a good chapter), but this is a very nice standalone volume devoted to CLOS only. Well worth reading, object (and Lisp) fans.

A good way to understand "why CLOS?"
This is a nice "tutorial style" walk through much of the functionality of CLOS.

It doesn't get into examples that are of _spectacular_ complexity, either in size or in difficulty of concept, but that strikes me as being just fine.The dialect of CLOS in use predates the final version that was released, so a few examples require a little modification to work with modern Lisp releases.

If you're looking to get into the sophistication of redefining your own metaobject protocols, the MOP book is surely more suitable.But for most of us who just need to figure out what CLOS is good for, this book provides a very nice presentation of that.

The cover says it all
You are going to get precisely what is advertised: a good guide to object-oriented programming in Common Lisp, no less, no more. ... Read more

Product Description
KEYBENEFIT: Teaching users new and more powerful ways of thinking aboutprograms, this two-in-one text contains a tutorial—full ofexamples—that explains all the essential concepts of Lisp programming,plus an up-to-date summary of ANSI Common Lisp, listing every operator inthe language. Informative and fun, it gives users everything they need to startwriting programs in Lisp both efficiently and effectively, and highlights suchinnovative Lisp features as automatic memory management, manifest typing,closures, and more.Dividing material into two parts,thetutorial half of the book covers subject-by-subject the essential core ofCommon Lisp, and sums up lessons of preceding chapters in two examples of realapplications: a backward-chainer, and an embedded language for object-orientedprogramming. Consisting of three appendices, the summary half of the book givessource code for a selection of widely used Common Lisp operators, withdefinitions that offer a comprehensive explanation of the language and providea rich source of real examples; summarizes some differences between ANSI CommonLisp and Common Lisp as it was originally defined in 1984; and contains aconcise description of every function, macro, and special operator in ANSICommon Lisp. The book concludes with a section of notes containingclarifications, references, and additional code.For computerprogrammers.Amazon.com Review
This book provides an excellent introduction to Common Lisp. In addition to chapters covering the basic language concepts, there are sections discussing the Common Lisp object system (CLOS) and speed considerations in Lisp. Three fair-sized examples of nontrivial Lisp projects are also included. The book's clear and engaging format explains complicated constructs simply. This format makes ANSI Common Lisp accessible to a general audience--even those who have never programmed before. The book also provides an excellent perspective on the value of using Lisp. ... Read more

Customer Reviews (30)

Outdated and confusing
This book is outdated and harder to understand than most programming books. I would recommend Practical Common LISP by Peter Siebel in place of this book. Practical Common Lisp

The example code in the book doesn't compile in modern Common LISP implementations and there are no comments whatsoever in the book. The author doesn't even acknowledge that comments exist in LISP.

A Lot of Fun!
I used this book 8 years ago for an AI Programming course.I remember going through each chapter and doing several exercises.I haven't used LISP in several years, but I still remember how much fun I had going through this book.Almost to much fun.I think that speaks very highly of this book.

The must have book for Lisp programmers
If you are interested in Lisp, you must get this book right after finishing Practical Common Lisp.

thought provoking
This is not an introduction to programming book.Instead it describes how an experienced programmer can use CL.As such, it is very dense.Descriptions of new operators are part of the text, rather than displayed in figures (there is a good reference at the back).This keeps the book small though.

Perhaps the most profound ideas in the book are bottom up programming (modify the language to add the commands you need), coding at the highest-level possible until the problem is well understood, and that code comments have cost:

"Good code, like good prose, comes from constant rewriting...Interlinear comments make programs stiff and diffuse, and so inhibit the evolution of what they describe"

As for downsides, I found the exercises for each chapter to be uneven.One asks us to create a function that returns a copy of a queue, later we're asked to detect car-circular lists, yikes.

Pragmatic
Paul Graham does a great job of reminding readers in practical ways that designing programs means examining trade-offs of performance, memory use, and simplicity.I appreciate any computer science book that not only introduces a language but also drives the reader toward developing a thought process that will make them implement great solutions in any programming language.

... Read more

Product Description
This is a comprehensive account of the semantics and the implementation of the whole Lisp family of languages, namely Lisp, Scheme and related dialects. It describes 11 interpreters and 2 compilers, including very recent techniques of interpretation and compilation. The book is in two parts. The first starts from a simple evaluation function and enriches it with multiple name spaces, continuations and side-effects with commented variants, while at the same time the language used to define these features is reduced to a simple lambda-calculus. Denotational semantics is then naturally introduced. The second part focuses more on implementation techniques and discusses precompilation for fast interpretation: threaded code or bytecode; compilation towards C. Some extensions are also described such as dynamic evaluation, reflection, macros and objects. This will become the new standard reference for people wanting to know more about the Lisp family of languages: how they work, how they are implemented, what their variants are and why such variants exist. The full code is supplied (and also available over the Net). A large bibliography is given as well as a considerable number of exercises. Thus it may also be used by students to accompany second courses on Lisp or Scheme. ... Read more

Customer Reviews (8)

How to implement LISP/Scheme language features and an intro to a compiler
This book is fantastic for filling the gap between a SICP-level understanding of how to write a Scheme (or LISP) compiler and actually getting the full language together. You know all of those "almost full R5RS" Scheme-to-{Java,.NET,JS} compilers? This book would help those authors fill in the last few pieces and actually implement the whole language.

Where this book falls short is as it approaches final code generation --- after you've generated the first working intermediate representation and want to start producing code you'd actually want to compiler. I recommend Appel's first book (Compiling with Continuations) for some tips on the basic optimization phases required in a functional compiler.

Excellent book
I don't have much experience with LISP and Scheme, but
I enjoy reading that book because the author gives a deep
insight into the inner workings and structure of compilers/
interpreters for the whole family of LISP languages and beyond.
It's a hard read (at least for me) - mostly because it contains
too much information and you need to follow the code sections
on almost every page (written in Scheme), but it deserves every
hour you'll dedicate to reading it.

Lisp in small pieces
Nikoluas Wirth once said "language design is compiler design". This book is truly remarkable in providing a look behind the (LISP ) scenery. Everyone who write LISP progams should red it to get an understanding of the implementation and hence cost of the language features. Great reading!!!

Great book on implementing Lisp-like languages
This book is excellent. It is clear but not superficial at all.

Queinnec explains from the basics of Lisp implementation (evaluation of S-expressions) to techniques for compiling into C. You will find very good advice on how to implement macros, continuations and higher-order functions. If you want to implement Lisp, Scheme or any other language actually, buy this book!

Besides being an excellent technical text, the book is also a great pleasure to read, because of Queinnec's writing style.

Also, there are exercises -- with answers! :-)

The future history of programming
I'm not a professional reviewer. But I program a lot, and for a living. After more than 15 years of experience in algorithm development and user interface design, to name some extremes, I get the feeling that "traditional" computer programming languages like C (C++, C#, Objective C) and Pascal (Modula, Oberon, ADA)
and even oldtimers as Cobol and Fortran tend to develop, or rather mature, into languages getting closer and closer to Lisp, Algol, and their ultimate offspring, Scheme.
This is not without reason.
But although the many qualities of Lisp have long since been known in academia, they need time and, more important, good reference material, to find their way into the real world.
Lisp programmers know the value of everything, but the cost of nothing, it is said. Christian Queinnec neatly fills the gap in our knowledge in a book that is a hard read because of the density of the content, but also a fun book because all the source is there (available through the Internet, of course) to experiment with.
You will not only gain insight into the workings of your Lisp system. You will gain insight into the basic elements of computer programming languages and their reason for being, their implementation, and the benefits and costs they will bring you.
All in all, one of the best books on Lisp I have ever almost, but not completely grokked.

I sincerely believe that tomorrow's programming languages, whether they be called C** or Delphi 2010, will be closer to current Lispthan to current C or Pascal, and a way to efficiently implement these languages is available here and now.

The book covers all standard material like direct interpretation, compilation towards a virtual machine using bytecodes, and compilation to C. New material is found in the chapter on macro's , a subject that has regained much interest of late. A broad variety of programming styles is used to illustrate all concepts.

There is only one drawback to the book. It won't teach you Lisp, or Scheme. That is, unless you already know it. ... Read more

Product Description
AutoCADet: A person who uses AutoCAD directly or indirectly to create or analyze graphic images and is in possession of one or more of the following traits: wants to learn; has an interest in improving the way AutoCAD works; is a visionary AutoCAD user; i

Customize AutoCAD to include productivity enhancements like new commands, combinations of existing commands or list processing scripts to store and manipulate data. This tutorial offers a complete introduction to the Visual LISP language, environment and editor. Advanced topics include data manipulation and programming dialog boxes. ... Read more

Customer Reviews (3)

Agree - a good intermediate lisp book.
I had learnt LISP by studying existing code and looking up what each command did in a reference manual.I found Bill's book gave me a better overview of lisp and tied what I already knew together.I now feel comfortable developing routines from the beginning without having to copy and modify somebody else's code.It also helped me make better use of the VLIDE.

This book expains things very well
Unlike many technical and programming books, the author of this book shows his love and dedication to programming, and sets down the ground rules with a little bit of history to help understand exactly what it is that you are doing. This book is so full of good information, you almost have to read it one paragraph at a time, yet it is so intriguing that it's hard to put down.

A great intermediate lisp book.
I found Bill Kramer's book to be very helpful in really understanding how the lisp language for AutoCad works.I would not say it is for the absolute beginner.It does not contain tons of non-useful, simple code to use as a tutorial.It does, however, contain a lot of truly useful functions and detailed explanations on how the code actually works.From the very start, it discusses how to use AutoCad's Visual Lisp Integrated Design Environment, one of the best tools for helping programmers write functions.This is something other books, inexplicably, leave till the end.I highly recommend this book to anyone.It is one of the better books out there. ... Read more

Product Description

Product Description
This third edition is a revised and expanded version of Winston and Horn's best-selling introduction to the Lisp programming language and to Lisp-based applications, many of which are possible as a result of advances in Artificial Intelligence technology. The Knowledge You NeedThe new edition retains the broad coverage of previous editions that has made this book popular both with beginners and with more advanced readers -- coverage ranging from the basics of the language to detailed examples showing Lisp in practice. Based on the CommonLisp standard, this book also introduces CommonLisp's object system, CLOS, and the productivity-promoting techniques enabled by object-oriented programming. Application examples drawn from expert systems, natural language interfaces, and symbolic mathematics are featured, and new applications dealing with probability bounds, project simulation, and visual object recognition are introduced.Special Features of this Edition *Based on extensive teaching experience *Explains key problem solving paradigms, such as search, forward chaining, and problem reduction *Discusses constraint propagation, backward chaining, and key ideas in Prolog *Emphasizes procedure and data abstraction, and other points of programming style and practice *Covers cliches, mapping, streams, delayed evaluation, and techniques for better and faster procedure definition 0201083191B04062001 ... Read more

Customer Reviews (14)

Good old book
From the very beginnings to advanced topics, this book will cover the Lisp language in a way newcomers will feel safe and at home. You'll certainly understand what Lisp is and what it is good for, perhaps for the first time. You'll learn this wonderful language without any difficulties from this book.
A piece of advice: I purchased an old used copy of this old book. I think this book is the best in its category: for a handful of dollars, you can purchase one of the best comprehensive books on Lisp ever written. Look for an used copy here at Amazon. Buy it and you'll never again receive so much for so little.

not delivered
They canceled delivery of this textbook. It was problematic. I did read some of someone else's copy and it seems a good textbook for lisp though, so maybe I'll buy it some other time.

A superb book on Lisp
I am a beginning Lisp programmer.So far, I have read several books and websites on Lisp, but this is the best.It covers all the fields necessary for effective Lisp programming.The explanation is crystal clear.For example, I have had problem in differentiating among "equal", "eql", "eq", and "=", but one paragraph in this book resolved this problem for me once for all.It contains a lot of exercise problems with appropriate levels of difficulty, which is optimum for self-teaching.I strongly recommend this book for all programmers learning Lisp.

Good Introductory textto LISP
I bought this book interested in AI applications; I already knew LISP when I read it and I find it one of the best books for introduction to LISP.The text and samples themselves teach you how to learn.

Finally after ANSI common and Practical Common I found Good BeGINNER LISP BOOK!
I have been through Gentle Introduction by Touretsky, ANSI Common by Graham, and Practical Common LISP ....all pissed me off. This book is what I have been waiting for, a BEGINNER BOOK, I am on chapter 3 and many of the concepts I have learned before are sinking in with this book.Lisp is fun and easy.I am using linux and vi editor with set: ai lisp option once I open vi.I load my definitions by launching clisp -i myfile.txt.There is a typo on p39 where the second both-ends definition should have LAST not REST.This made me blink until I realized it is a typo.Just above both-ends is defined correctly. It is obvious AFTER you see it let me tell you... lolThe only other thing that is bad is that the right page text has a nice 2 inch space away from the book binding so it is easy to read.The left page reversed this and put the 2 inches of space on the outside away from the binding, so the text is right up against the book binding.If this is reprinted they should fix that.....hard to read many practice problems on left page since the text on the left page curves so hard toward the book binding since this is a huge tome.
AWESOME BOOK!! COMMON LISP NEEDED IT!! ... Read more

Product Description
A highly accessible introduction to LISP, this is for inexperienced programmers and programmers new to LISP. A LISP "toolkit" in each chapter explains how to use Common LISP programming and debugging tools such as DESCRIBE, INSPECT, TRACE and STEP. ... Read more

Customer Reviews (11)

Still in Good quality
This is a recommended book for beginning lispers.
The book sent was in a very good condition even after being in the shelf for 20 years.

A must read for every Lisp newbie
When i decided to buy this book, i knew nearly nothing about Common Lisp other than some myths. As i went deeper in the book; i saw that many of those myths were nothing but only the muds thrown with an ill manner over Common Lisp because of jealousy. Touretzky introduces every concept in a quite pedagogic way giving no more than a newcomer can handle. At the end of each chapter he even treats some advanced topics like tail recursion, macros etc. The only absence in the book, as far as i see, is object oriented programming features - CLOS -and package system which are not critically necessary for a novice so do not expose a serious problem, i think. I strongly recommend this monumental book to everyone who is planning to learn Common Lisp.

Amazing introduction to Lisp
"A Gentle introduction to Symbolic Computing" as the name states is a great introduction to Lisp. It starts at the beginning with introducing the reader to the basic concepts of Lisp. Rather then the basic functions it starts with what a function is and how it behaves, the book moves into what a linked list is how it works and how to manipulate it (cons, car, cdr).

While many would rather jump in feet first and write a basic hello world program I personally prefer to understand the basics of what I'm doing and why it works. This book is excellent in that regard. My one problem with this book is that its out of print so you have to find a used copy. The alternative being that the Author/Publishers provide this book for free online, use Google.

Clear and concise
The book is useful even if you have programming experience in other languages. It explains important concepts (list, cells, symbols, variables etc) better than many other programming books do.

Highly recommended!

Very nice beginner's book on Lisp
This is a great book for those wanting to learn Lisp.
In the first part of the book, when describing functions, the author stays away from Lisp and any real programming notation, using diagrams to show some of the fundamental concepts -- which are explained in such a clear way that everything become so obvious! Later he switches to Lisp, telling you it's a "different notation for the same ideas".
The text is always clear, short and right to the point.
... Read more

Product Description
Stark goes beyond a discussion of the programming and theory behind the language LISP to present colorful applications, bits of history, computational philosophy, and consequences of LISP's exceptional power. Includes examples and exercises. ... Read more

Customer Reviews (1)

Lisp Programming
I am doing masters in computer science. This book is one of the book we are using for our class. I found the book is easy to understand and describes the subject well enough. I just started learning Lisp and after Istarted to reading the book I do not have any trouble to understand termsor etc. even if english is not my first language. The book has niceexamples related with Lisp programming and if there is a given more examplewill be a lot more useful for the students.It will be a lot better if thebook prices little cheaper. I believe book is out of print from thepublisher, so if the authors take the copyrights and put the book on theweb and let the students or teachers to print the book with acceptable costthat will be great. Thank you ... Read more

Product Description

Customer Reviews (23)

Overrated
This book lacks anything close to sufficient depth. Clojure is a deep language and Programming Clojure simply fails to do it justice. Most of the book reads like API documentation. The example code, mostly one liners, leave the reader feeling unsatisfied. What if I want to write a program that's more than five lines of code?

Stuart Halloway glosses over Clojure's fundamental language paradigms, like functional programming, recursion, and Java. While I suspect it would be near impossible to explain functional programming without devoting an entire book to it, Stuart Halloway doesn't even try, instead hoping that the reader will magically figure it out on his own.

The layout of the book is plain frustrating, leading me to wonder if Halloway actually wrote the chapters in the order that they're presented. More than once, Halloway uses the obnoxious literary device of referring to chapters after the current one. "We'll talk about this more in Chapter 18!" Just let me read the chapters in order, Stuart!

Save yourself some mental anguish and purchase The Joy of Clojure: Thinking the Clojure Way or Practical Clojure (Expert's Voice in Open Source) instead.

Excellent book for beginning to learn Clojure.
This book is a very good guide about the Clojure programming language. It is not a reference, so, you need to complement this book with another resources like the official API, the very good screencasts that are around the web, slides, etc. In general, a very good book about a very promising programming language.

Solid
I have three different categories for programming books I've read - those I don't need anymore, those that I want to keep but generally won't read again, and those that I want to keep on hand because I know I'll go back to them frequently. Usually "language tutorial" programming books like this one are in either of the first two categories, but "Programming Clojure" is staying close to my desk.

Halloway's enthusiasm for Clojure really shines, as his writing has an engaging personality that evangelizes the language without being irritating. The code samples are plentiful yet lean, so they're easy to digest even if you're just reading the book a few pages at a time (which is how I read it, while commuting). The curriculum is also fairly well-designed, this is one book you'll probably read from start to finish and then return to the sections that you want to spend more time with.

I applaud the team that put this book together for not rushing it, as errors of any kind, but in code samples especially, are incredibly distracting for readers trying to understand complex concepts. I don't remember finding too many spelling mistakes or code errors while reading this book, which you know is unusual if you read a lot of programming books. My one criticism is that the last chapter, "Clojure in the Wild", was well-intentioned but felt a little too quick. Rather than just cover a few popular libraries briefly, I'd love to see more time spent on guidance for structuring larger projects.

As of this review (May 2010), Clojure has continued to evolve in features that this book obviously couldn't have included, but it's still a worthwhile read if your goal is to learn the language. If you've read "Programming Clojure" and you plan to use the language, catching up on what's new is just a matter of reading a few blog posts (protocols, etc). This book is a solid introduction to the language - if Halloway updates this book for some future version of Clojure, I'll pay for it all over again.

Clojure - Language Elegance on the JVM
Clojure is the most elegant and effective language to cross my path in recent times. This book captures the essence of that elegance, while opening your eyes to the many defects common to mainstream practices in software engineering. Seasoned Java practitioners will feel right at home here, despite the functional hurdle, thanks to the elegant Java interoperability of this Lisp reloaded for the JVM. Highly recommended.

Great place to start
You really need some programming experience to follow this book. Still, if you are new to functional programming and Clojure, this is a good place to start. I have referenced the book constantly as I learn Clojure, and find the book extremely useful. ... Read more

Product Description
This tutorial is an elementary introduction to teach non-programmers how to customize their work environment; it can also be used as an introduction to programming basics. It includes numerous exercises and sample programs; the author also walks you through the actual source code of several GNU Emacs commands. A handy reference appendix is included.Emacs Lisp is a simple, complete, and powerful programming language. It is the building block of GNU Emacs, which is an integrated development environment with special features for scanning and parsing text as well as for handling multiple files, buffers, displays, windows, and sub-processors.This text will show you: * how to set variables and write function definitions * How to use "if" and "let" * How to write "while" loops and recursive loops * How to search for a word or expression * How to customize GNU Emacs for yourself, even when it is shared on a network. * How to debug programs * and much more.This revised third edition covers new features included in GNU Emacs version 21, while remaining compatible with earlier versions. ... Read more

Customer Reviews (1)

14th edition has all the indices that you need!
(This is a note about the 14th edition--20.7)

One of my favorite technical books from a documentation standpoint is Richard Stallman's superior GNU Emacs Manual. The tool is justly famous and the manual is one of the best written and best organized books I'd ever seen. I've had problems at times figuring out how Emacs works, but when I came across an older edition of this book at a used bookstore, I realized that I simply had to have this book. I've found almost everything I wanted to know from this book and gotten a sense of how everything works. The manual also leaves me with a sense of how wonderfully extensible and versatile the program is. The book contains a glossary, a key index, a command and function index and a concept index. Wow! This is every technical writer's dream! I can generally find the answer to any question within a few seconds when consulting this manual (the help that comes with the program....well, that's another story). Keeping true to the GNU philosophy, Stallman makes the book (as well as a LISP reference guide) available for free at the gnu site.

So the good news is that the book is expertly written and organized. What's the bad news? First, the 14th edition (20.7) book doesn't include a discussion of how to use major modes of Emacs (such as PSGML) or the very handy PCL-CVS. Also, because emacs and xemacs have followed different development paths, Stallman's book doesn't cover the NT-based xemacs implementation. Love or hate xemacs, you have to appreciate the attempt at a GUI, especially when it comes to configuring the program. The package update functionality of Xemacs, could use better documentation as well.

In summary: a masterpiece of documentation, but the manual is sorely in need of a section discussing major mode and emacs. ... Read more

Product Description
Developments in Lisp technology have been accelerated by a number of factors, including the increased interest in Artificial Intelligence and the emergence of Common Lisp.Advanced Lisp Technology is the fourth volume in the seriesAdvanced Information Processing Technology and it brings togther a group of highly respected Japanese researchers working the field of Lisp technology.
The book is split into four parts. The first examines Lisp systems design and implementation in parallel and distributed computing environments; the second looks at language features such as evaluation strategy for parallel symbolic computation; the third discusses memory management and garbage collection and the fourth part considers the programming environment. ... Read more

Product Description
A step-by-step guide to enhancing AutoCAD commands and creating your own. This text and accompanying CD-ROM teaches the professional and higher-level student how to customize AutoCAD software with the new programming language of Visual LISP. If you're looking for guidance on such things as porting over existing AutoLISP routines into Visual LISP, this is the book for you.Keywords: AutoCAD ProgrammingKeywords: Visual LISP ... Read more

Customer Reviews (5)

This book isn't for learning VisualLISP/AutoLISP
If the CD doesn't accompany the book, the book is worthless. The majority of this book is simply a guide to the API included on the CD. To make matters worse, I don't believe the CD contains the source code for the API, which basically makes it a black box. The author also puts some fairly strict restrictions on how the files on the CD or programs written with the book's API can be distributed.

This book isn't for someone who wants to learn VisualLISP or AutoLISP. I was very dissapointed in the book and felt that I wasted my money on it.

Not Very Useful
While I have always greatly respected the author, this book was a serious let-down.It continually focuses on using the author's custom functions to save time, but that completely circumvents the full learning process.You're learning how to use his custom toolset, not the language itself.It's a major handicap in my opinion.

Great book, the best book on visual lisp and autolisp
I have seen almoost all the books available on visual lisp and autolisp. I found this one the most useful. The accompanying software creates an elegant and more lisp-like abstraction on the top of visual lisp's VBA-like constructs. Very well designed api, and a thoroughly enjoyable book. Many thanks.

Jayanta

Visual Lisp : A guide to Artful Programming
The manual appears to be very good but without the use of the cd file containing all the functions, it's useless. The manual directs to run setup, which isn't there. Upon examination of the the four remaining files there is a list of the four files on cd, no setup and no apparrent way of doing it manually because there is no database of the functins. The manual also suggests downloading the latest version but the website is invalid. Trying to reach Phil Kreiker by email is also invalid. I tried Bill Krammer's, who wrote an intro to the book, websit and found an 800 # only got a lot of run-around. I see nearly a 50/50 split on the feedback on the book. ???Has anyone had this problem??.Amazon.com is still selling it, with the same errors. How good is this book if it is so poorly checked before publishing?
Tom Curtis
curtis@geeksnet.com

VERY INFORMATIVE
THE MOST HELPFUL GUIDE TO VISUAL LISP I'VE SEEN SO FAR. A REAL MUST HAVE VOLUME. ... Read more

Product Description
This tutorial an elementary introduction to teach non-programmers how to customize their work environment; it can also be used as an introduction to programming basics. It includes numerous exercises and sample programs; the author also walks you through the actual source code of several GNU Emacs commands. A handy reference appendix is included.

Emacs Lisp is a simple, complete, and powerful programming language. It is the building block of GNU Emacs, which is an integrated development environment with special features for scanning and parsing text as well as for handling multiple files, buffers, displays, windows, and sub-processors.This book will show you:

* how to set variables and write function definitions
* How to use "if" and "let"
* How to write "while" loops and recursive loops
* how to search for a word or expression
* how to customize GNU Emacs for yourself, even when it is shared on a network.
* how to debug programs
* and much more.

This revised second edition covers new features included in GNU Emacs version 21, while remaining compatible with earlier versions. ... Read more

Customer Reviews (4)

Fabulous Introduction
A very good introduction to using elisp. I have about a decade of experience programming and extending Emacs; I picked this up to consider giving it to my computer science students. I finally decided against it only because Successful Lisp is such an amazing book. No, really, I cannot recommend Successful Lisp highly enough.

This book is very good and focuses on the specifics of Emacs Lisp. If you are interested in extending that venerable editor, this is a good place to start. If you are interested in learning programming in Lisp (specifically Common Lisp), take a look at Successful Lisp.

Emacs the one true Editor
Emacs is the best editor, ever. Of course, you hear people say that, and than you try to use it and get confused by ALT-META-SHIFT this and META-META-CTRL-ALT that. Look! I will let you in on a secret. Emacs is completely ***programmable*** in it's own language: Emacs lisp. With a few wizardly strokes, you can change the behavior of emacs to behave like editor X you are used too.

Now, there are alot of features of Emacs that simply make it the most useful editor around. Most important, is it's ability to split the screen. I can not stress how useful it is, when working on code, to be able to work on a file from several frames at once. There is no other editor I know of that does it like Emacs does.

There are a number of packages available for Emacs, I never looked at even 10% of them all. I like Speedbar over Emacs native file system. CEDET and Semantic bovine are nice too. If you are a beginner, you will probably find those packages are all you will need, and mostly just search on Google to find out how to alter the editor behavior so you don't have to know all the shortcuts right away. After you know your way around you learn those shortcut keys later.

Emacs requires some patience if you are new to it but when you get it you will never want to go back to some inferior product.

This book is a good start to being an emacs power user
I was really excited to grab a copy of this book, and it didn't let me down.It's a gentle but thorough introduction to using elisp.I do a bit of programming in other languages, but had never tried elisp.Now I'm excited to dive in and start making emacs do (even more) work for me.

Great Intro to Programming
I originally got this book to learn a few "tricks" to help me use Emacs. I am not a programmer, and thought programming was mysterious and difficult.However, Robert Chassell is an incredible teacher.I never thought programming could be explained so well to such as rank beginner as myself.And he makes it all seem very easy and logical.Not at all scary.I wish he taught at my college. ... Read more

Product Description
A practical introduction to symbolic computing and denotational programming is offered in this book. The first part covers programming, and the second part addresses symbolic computing in such areas as game playing, language translation, and theorem proving. For each topic, there are example problems, with proposed solutions, followed by working programs using the techniques presented earlier in the text. Two programs using a denotational approach accompany each of the applications in symbolic computing, one in LISP and one in PROLOG. ... Read more

Customer Reviews (4)

Splendid!
Robert Mueller has the best, most understandable and down right well written book on this subject I have ever laid eyes on.This book helped me understand more about the subject without ever making it sound tedious ordull.Thank you Mr. Mueller.Admirable work.

Well written and straight to the point
This book is useful for those that need more information about LISP and Prolog, and for my class regarding the subject at OSU, it makes perfect sense

Symbolic Computing With Lisp and Prolog is a very useful.
I prefer Symbolic Computing With Lisp and Prolog much more than other books which I have read concerning the subject. It is quite informative, and even has a touch of humor from time to time.

Symbolic Computing With Lisp and Prolog is a very useful.
I prefer Symbolic Computing With Lisp and Prolog much more than other books which I have read concerning the subject. It is quite informative, and even has a touch of humor from time to time. ... Read more