I tried more than one book to start learning CL, this one puts together the language principles with really well chosen code examples. The result is that I read it in a shot, with an increasing interest and never being intimidated.

After it I approached again the P. Graham's books and I finally found them really enjoyable.

The only critique I think is worth to be reported is about the software working environment. I tried lispbox on windows, but it is outdated, it is ok to try the companion source code downloaded from internet, but nothing more.
To start doing anything more serious I finally moved to linux, sbcl, emacs-cvs, and slime-cvs, it has been a pain. A few paragraphs on this topic would have been really helpful.

Anyway, it is a great reading! My gate to the Lisp world as a code writer instead of as a book reader.

This book is the best "learn a programming language" book I've read. It is a very readable book, with excellent pacing and a good mix of theory and practice. I have found this book to be very good for teaching myself Common Lisp, and highly recommend it to anyone who wishes to do the same.

I am a PhD student in Economics, and started using Common Lisp as the numerical programs I ran became more sophisticated (contrary to popular myths, the speed of modern CL implementations is in the same league as C and Fortran).

This book is an excellent and detailed introduction into the language, it assumes no prior knowledge of Lisp and provides the reader with excellent foundations to build on. I especially like that Seibel doesn't only enumerate the language constructs, but explains which ones are preferable in certain situations and puts a lot of things into perspective.

The book is available online, if you like it, I suggest that you get a hardcopy, it is a worthwhile investment.

I was a bit skeptical about this book, but decided to take a look anyway while I was learning Lisp. It turns out that it was the book where I always went when I wanted to understand some concept and see how it's used in practice.

It also helped me see that Lisp is indeed a great language! I will definetely start using Lisp from now on.

I do recommend this book to anyone willing to start learning Lisp.
However, this is not an advanced book -- it's purpose is to help you get into the Lisp way of thinking and get you ready to start working on real projects. Later you can get others, like Sonya Keene's Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS, and paul Graham's wonderful On LISP: Advanced Techniques for Common LISP.

This book is absolutely fantastic. It got me started on lisp in a very easy to follow, *practical* manner. I was impressed with Peter's writing style and choice of examples, particularly the example on writing a 'unit test library' so to speak. The power of macros becomes (IMHO) axiomatic once you see this chapter. It's short (12 pages?), the code is short (26 lines?) but *powerful*. Throughout the book, he demonstrates how to make certain examples more powerful yet more concise through the use of macros and other lisp features. After that I would recommend ANSI Common LISP which is my favorite CS book of all time right now (read: more technical, theoretical, etc. than PCL).

I first used Lisp back in my college days in the 80s. I really never saw a practical use for the language then. This is the first book I've read that really shows how useful Lisp can be in a variety of situations. I basically understand the major features now and why they are the way they are. I'm going to start using Lisp now more and more where I can fit it in. This book was really well-written compared to most computer books. Everything from the examples to the exposition really make a lot of sense.

I graduate college with an Electrical Engineering Degree, but took many Computer Science classes. I went into software, instead of hardware, as a career choice. I have used Perl, Java, C, VB 3-6, C# and other languages in my day to day job over 8 years. My only experience with LISP is hearing about it, while in college, and possibly the use of EMACS when doing Unix systems programming in C. While trying to locate good beginning courses for a co-worker, I came across MIT's online 6.001 class, using LISP. This rekindled my interest in learning LISP. The book for this course really didn't answer the "why should I learn LISP?" question. This book does.

After intending to purchase the textbook for that course here at Amazon and actually ordering it, I found this book. I wound up ordering this book and canceling the other (since it was online). If you are very low on funds, you can also find the text of this book online. I prefer a hard copy of the book for easier reference. This book takes me through not just learning LISP, but why certain features are unique and/or important. It is truly a great book for learning LISP.

If you go to any forum or other support site for CL and you ask about the best book for a beginner to start with, more than likely you'll be referred to this book. It is an excellent guide now only to Lisp, but to good Lisp programming style. It gives you practical help, but isn't afraid to give mathematical examples to show the power that awaits those that persevere in the brave old world of Lisp.

I, like many others, find it easy to recommend this book to any Common Lisp beginners. You won't be disappointed.

The book is written in a very logical way featuring practical and easy to follow examples. It makes a convincing argument that there is still a place under the sun for Common Lisp. Author also explains the basics of how compilers and interpreters work. Its a must read for everyone willing to become a well-rounded programmer.

I've used a bunch of different Lisp books in my efforts to get to the point where I could actually do something useful with the language. This book is the best I've seen for that, period.

This is one of the gentlest introductions to Common Lisp that I have run across. I have read most of the introductory books and this beats them hands down. Consider this highly recommended if your trying to get up to speed on the language that makes you think different.

This is a good book. After the first few chapter of getting to know Lisp, he has some real world examples of using lisp (4-5 projects?) Very "Practical". It doesn't hover around subjective issues like the massive (LOOP ... ) macro, thats for flame-boards =D. He likes it, he uses it and shows you the power.

I have two objections to this book:- it's shoddily written and edited, and it is far too verbose (actually I have three, but I'll get to the third at the end).

First objection: Shoddy writing and editing. As others have commented it's badly organized and wanders all over the place. There are too many examples to detail here, so I'll focus only on one. How to get software that allows the reader to try out the examples.

In the opening chapter (actually Ch 2 since Ch 1 is really more of a preface than an opening chapter) the author says "We'll use the easy-to-install Lisp in a Box", but doesn't say anything about what this thing "Lisp in a Box" actually is, despite immediately footnoting some obscure issue relating to IDE's and emacs. And this is in a chapter titled "A tour of the REPL" - 'what on earth is the "REPL", I thought this was about Lisp?' says the curious newbie.

The mysterious "Lisp in a Box" then gets a section of its own a few pages later titled "Getting Up and Running with Lisp in a Box" which says that instructions on how to get this beast are contained in Ch. 32. I breifly ignore the subsequent trivia about emacs buckyboard keystroke combinations and turn to Ch. 32.

Not there. Not a single mention. In fact the magical "Lisp in a Box" is not mentioned at all in the book after p 38. and only gets 10 mentions in the entire book (including table of contents and index).

A brief google turns up a website, so yep I can download something. Let's review the "... up and running" bit first so I know what I'm getting myself into. I turn back and read the rest of the section. Nothing. Just more stuff about emacs. Nothing "up and running" about it at all, in that section or anywhere else in the book.

So here I am, I've been given the name of some semi-mythical package that I should obtain in order to follow the book. I've had to find the thing by my own independent means, and now I'm given absolutely nothing about what I should do next, just about 100 words on how C-h,t will bring up the emacs tutorial.

Now I'm not saying that this book should be something like "Learn CL in 21 days", but really ... the author nominated this package, made a cross reference to some chapter at the end of the book, and in no way delivered on that promise. Sloppy editing and instead I wade through paragraph after paragraph of non-information until I finally realize (at page 38) that the author has no intention of telling me anything more about this item "Linux in a Box" that he has felt so vital that it is raised in the second sentence of his opening chapter.

The whole book is in the same vein. Time and time again, points are raised, referred to and dropped.

Second objection: It's verbose (see above). In over 500 pages very little actually gets discussed, but we get a lot of admittedly very articulate, charming prose about not very much. It seems to take forever sometimes to explain some things. There is no way you could actually ever use this as a desk reference. Trying to find that one thing that you don't quite get would take forever. (The index is poor as well and seems to be machine generated as it's full of irrelevent stuff.) Some terseness would be greatly appreciated.

Third objection: Shockingly bad pedagogy.

The author doesn't create a solid conceptual understanding of the language before jumping into hard core esoterica. The table of contents gives it away:- 3 chapters on very basic elements (Syntax, Functions, Variables), then we skip control structure (the real hurdle in learning lisp) and get straight onto macros (of all things) for 2 chapters.

To compound this the book then drifts on for another 20 odd chapters of pretty tedious examples, which focus more on implementation issues ("this is how to implement an mp3 database...") than the language itself.

Now the author is a charming guy (I've seen a lecture of his on YouTube which is quite reasonable in itself, but it's over an hour where he mostly hangs it on Java rather than discuss lisp in any depth so don't bother), and he writes well (I'm giving it a second star for charm.) But I expect a lot more from a programming book.

If you're looking to hack out some-n-dirty lisp to implement bog-standard answers to modern applications, this book is fine.

If you also want to get a few ego-strokes as to how you're using the ultimate-language-of-all-time-that-puts-you-right-in-the-uber-hacker-space then this is your baby.

If you want to really learn lisp, try Peter Norvig.

LISP is alive, and Peter brings us the gospel.

I bumped back in LISP after reading "Hackers and Painters" by Paul Graham. The great guy certainly is a nostalgic of the ViaWeb days in which he developed in LISP an entire multi-site e-commerce web hosting application, but helped me to understand the power that still can be unleashed by the good ol' language.

Then, Peter arrived, giving a fresh flavour to everything, using the book to take you from the basics up to do things that could not be even conceived in Paul's golden days, as an MP3 Shoutcast-compatible server.

Peter has left his job as a Java programmer to go LISP nuts. I am tempted to do the same, but I'll finish the book first, at least :-)

The only lisp I ever knew was scheme and I'd long meant to dig into Common Lisp, so I finally got around to it. I am not sorry that this book was my introduction. Let me start off by saying that there are two kind of people in the world - the kind that like to read a tech book straight through and then start doing and the kind of people that like to do while reading the book (ok, so maybe there's a few more kinds of people...). I am of the first sort and the organization of this book was perfect - I don't know that I've read a book better suited to the way I like to learn a language. It is targetted to an experienced programmer, but one w/out any experience in LISP. I think it'd be a tough book for a complete newcomer to programming to start working with.

The book is divided into 2 sections, the first (slightly more than half) is the language reference and the second is the practical part. The language part was the perfect model for me, it works you from basic to advanced. Beginning from the very beginning it gives you suggestions on the environment in which to work with LISP and where and what would be good to install. It moves to through all the basics, syntax, functions, variables then spends a little bit of time on macros (a very key and subtle feature), moves onto numbers and strings, collections and lists (spends some time really covering these to give a true understanding), and then pushes on to I/O, OO in LISP and then a good look at FORMAT, exception handling and loops.

These were not cursory overviews of language features, but were in depth coverage. As such, it is inevitable that in trying to show you how things work they need to use some more advanced constructs that they have not yet covered. They, however, tell you that you don't know about this feature yet and explain just enough about what it's doing that it's no impediment to understanding the example. They are very thorough and concious when this happens. The alternative, confining yourself to only what you've covered traps many writers into showing only trivial examples that are unable fully display particular concepts.

There are a couple practical examples in this first section that demonstrate ideas covered up to that point. The examples themselves are excellent, showing how programs are built up and refactored. It is a really clear view of the expressiveness that LISP allows.

The second half of the book is dedicated to putting things together in a diverse set of projects. The first, kind of standalone is the Spam Filter. The rest are parts of the elements needed to create a streaming music library from parsing binary files, extended to reading ID3 tags of mp3's, to working with AllegroServe (a lisp web server), you build a database of music, learn how to build a shoutcast server and tie it all together with an online mp3 browser.

There's a good amount of coverage on working with the web, generating html and the like. These practical topics are not the lightweight fairly trivial examples that you most often see in books, these are in depth and very diverse examples of what you can do with LISP. To me this is the advantage the book gets by its organization, by first letting you learn all the basics of the language, they can show you how a real program is developed using the full expressiveness of LISP.

I gave this book five stars because of the great way it was organized, the in depth coverage of it's features and it's friendly and readable writing style. It did have some flaws, sometimes it didn't give examples on some topics that might have been more easily explained through a little show and tell, a couple minor typos caused a little bit of confusion. But these are minor nits that don't detract from the overall goodness of the book. If you are interested in learning LISP, I can whole heartedly recommend this book.

This was my first book on Lisp. What is great about this book is that if you are an experienced developer such as myself, but never exposed to Lisp, this book quickly exposes the power of lisp. Which was fantastic and is what this book does best. It did however leave me with more questions than answers which lead me to other books on the subject. Good effort but I wanted so much more.

Practical Common Lisp is a fantastic book for those who know some programming language, and ideally, even a little common lisp. It's a whirlwind tour of CL (Common Lisp) functionality, and some great practical examples. The greatest thing about this book is that it covers truly practical applications, and it does cover everything used in the applications. There is truth to the criticism that some aspects of lisp are presented before they are explained, but it doesn't hurt the learning, IMO. If you care to find out for yourself, do a web search on the title - the full text is available online. I bought my print copy after just a few chapters - it was well worth it. There are precious few good lisp texts, but this is certainly in the top five.

Peter Siebel's PRACTICAL COMMON LISP is an introduction to this underappreciated language with the goal of showing through examples how the language can be powerfully used in modern applications. He gives a series of projects, starting with a simple database, which culminate in an MP3 Shoutcast server. Instead of a dry systematic primer, he introduces each facet of the language as it is needed. Before even introducing common datatypes, he walks you through useful code, allowing the reader to become captivated by Lisp's style before he even knows much about it. In line with Apress' slogan "Books for Professionals by Professionals", Siebel's book assumes that one already has considerable experience in software development. Therefore, the reader will not find an explanation of how to install a Lisp environment, nor are common development terms defined. One excellent consequence of this approach is that the author occasionally compares Lisp features to other languages such as C or Python, allowing one to see how Lisp has its own philosophy.

Siebel's tone is no-nonsense, but there are parts of the book where his explanation of Lisp features is simply too straightforward. For example, the overview of how Lisp deals with pathnames is too hastily written and confusing. In spite of some complaints, however, I stil think Siebel's book serves the learner well. I got from no knowledge of Lisp to a good level of comfort in just a few weeks thanks mainly to this introduction. However, I should mention that for the hobbyist who can't immediately apply what he as learned to some real project, the lack of systematic exercises is a problem. I'd certainly recommend PRACTICAL COMMON LISP to anyone curious about the language, but the hobbyist should supplement it with Paul Graham's ANSI Common LISP.

This is one of the worst books on computer programming I've ever seen. It's badly written and badly organized. I will echo what others have already said about the author presenting material BEFORE he has covered the prerequisite material.

Another problem is that the author constantly starts off a paragraph or chapter with an irrelevant topic and then makes his point afterwards. For example in Chapter 21, Programming in the Large: packages and symbols, he says:

"In chapter 4 I discussed how the Lisp reader translates textual names into objects to be passed to the evaluator...blah,blah,blah.... That, however, isn't the topic of this chapter."

Well then why the hell did you start off the chapter with something that the chapter ISN'T about. Don't you think it would be good to start the chapter by saying what the chapter IS about?

There is just so much throat clearing and rambling, it's hard to wade through it all.

Another example is Chapter 8 on macros. He starts the chapter with a strange little allegory:

"Once upon a time long ago, there was a company..." and on and on for something like 500 words! For what? The point of the allegory escapes me. It really doesn't illuminate anything about macros.

Yes, I know this is not a well written review, but I'm not asking people to pay money to read it and I didn't work on it for more than year.

I'm giving it 2 stars for TRYING to present practical applicatons of lisp.

This book serves as a very good introduction to Common Lisp.

It contains some of the best explanations I've seen of Common Lisp's loop macro, format directives, and condition system. These alone were well worth the price of the book, as it's very hard to find good information about these elsewhere.

My one complaint is, with the notable exception of the Unit test framework chapter early on, the "Practical" chapters don't capture the incremental development style of Lisp very well. Most of the latter chapters involve typing out pages and pages worth of code at the end of which everything magically just works.

This is fine and all, but it neglects Lisp's major advantage over less dynamic languages like C and Java: the ability to build up larger systems piece by piece, experimenting with bits of functionality in the toplevel as one goes along.

Understandably, it's more difficult to capture this style of programming in book form, but it would have been nice if Peter would have alluded to it a few more times in some of the larger examples.

I'm also somewhat puzzled as to why he chose to introduce his HTML Generation library at the very end of the book, when it had already been in use for four chapters. I believe the book flows better if you read chapters 31 and 32 prior to chapter 26.

Still, studying the compiled version of Peter's HTML generation language was absolutely fascinating for me - one of those "aha" moments.

A very good read overall. I'd also recommend Paul Graham's ANSI Common Lisp for getting the feel of Lisp programming.

Most of the 5 star comments are from people who are already familiar with Lisp.

For a beginner, the book isn't organized very well. The code snippets use concepts that have not been introduced yet.

He would do it in Lisp.

This book is good, because unlike most books on Lisp, it is about actually doing something mortals will comprehend. Not being a PhD in mathematics, I never saw much of the point in proofing esoteric theories in a strange language. But than I got this book and a book on Scheme, and I at least saw a bit of what it is about and I liked it.

Lisp is a language of ideas. It is worth it to look into it. Personally, I like Scheme much better. But Scheme and Lisp evolve togethor. You really must spend some time and learn Lisp even if you never proof esoteric theories and are just a humble coder.

Best lisp book I've read. Covers the language clearly, and filled with practical examples from the beginning.

This book seems to have been written under a lot of time pressure. It is badly organized. You cannot enter code and run it as you read because the code requires ideas and code that are not presented until later in the book. For example defmethod if introduced before defclass.
You see examples like
(defmethod withdraw((account bank-account) amount)....)

But defclass and the class bank-account is not defined until the next chapter!

This happens again and again. Topics are introduced before the prerequiste topics are covered.

Seibel also has a tendency to throw in details that are distracting and interrupt the flow of the material.

For example in the chapter on classes he describes defclass and make-instance and then he throws in a long and technical paragraph on print-object.

It is very frustrating trying to learn Lisp from this book.

This book is a fantastic introduction to Common Lisp. Too many Lisp books you'll find are either a) incomplete (i.e. little to no discussion of macros or CLOS, two of the most powerful features of Lisp), or b) are written before 1990. Not so with Practical Common Lisp. The book opens up with an introduction to the language itself and then surveys major features of the language before going through a series of practical examples.

The book really shines in its treatment of macros. Before reading PCL, I'd had a rough idea of what macros were and why they were cool, but no idea how to write them. Peter Seibel manages to explain in two chapters what took Paul Graham most of a book (On Lisp) to discuss.

One of the later chapters describes Common Lisp's condition/restart system, which I had never heard of until reading this book. If you are unfamiliar with the condition/restart system, picture the try-throw-catch construct found in other languages, only with the ability to jump back to where the error was thrown and take a different code path. It is incredible that this system gets so little mention outside this book.

The practicals it includes are also very cool. Seibel builds a simple test suite in one of the early chapters that is amazingly featureful yet incredibly concise. He builds an astonishingly small in-memory database in one of the earlier chapters with pretty advanced features. Two practicals toward the end involve building an HTML generation system and then using macros to optimize the generation.

He includes a brief discussion of efficiency as well, describing how bottleneck functions can be tweaked for maximum efficiency and introduces some of the techinques that can bring Common Lisp applications to C-like efficiency.

I highly recommend this book to anyone looking to learn Common Lisp, or even just someone looking to see what all the hype is about. It provides a great survey of the language, lots of useful practicals, and is pretty handy as a reference as well.

Buy this book!

I don't remember how many times I have referred to that book when I gave advice to my fellow programmers. Long before the book came out I was reading its drafts online and admiring (and of course telling people to go and get some fresh ideas). Now, forget about your prejudices, fasten your seatbelts and get ready for a tour of Common Lisp applications for Internet, database, streaming server, etc. programming.

This is not the Lisp you may have seen in your typical class, here we are talking about real world applications: handling HTML, creating mini languages for Internet, creating an mp3 streaming server, building an SQL like language from scratch and learning the power of Lisp.

The author has also extensive Java experience and can provide great insights and comprasisons. In addition to that he is an active participant in various newsgroups related to Lisp, Java, Perl, etc.

This great book would be better if exercises were included at the end of the chapters but for that I prefer ANSI Common Lisp from Paul Graham and PAIP from Peter Norvig. If you have a %90 understanding of these three titles you'll be much more than an average programmer with a deep and broad vision.

Great if you're coming from another language ,
Lisp may really help you think different.
The crup side it that any descent Lisp implementation
starts with around 800$ which is just too much compared
with wonderfull tools for C/C++/Java/Python .
There is some free ones but they are unable to make exe
files (read useless for nonelispers LW personal,Allegro) or user-unfriendly CLisp and a cheap one ~250$ CormanLisp but
unstable and dated GUI.
Also Lisp doesn't plays well with mainstream languages .

Peter Seibel's writing style is a joy to read, and (unlike other commenters) I find his footnotes quite useful. Concepts are introduced in a natural and general intuitive ordering, and in general this is a great book for the first-time learner of Lisp.

Now -- WATCH OUT FOR THE INDEX! My first indication that the index of this book was not up to par was an especially useful footnote on page 58 mentioning READ-FROM-STRING, which I couldn't find later when I needed to use READ-FROM-STRING in the small Lisp program I'm writing. A little experimentation convinced me that nothing in the footnotes is listed in the index, and I started reading with a pencil in my hand.

Unfortunately, the index fails in more fundamental ways as well. It would have you believe that the "do" keyword is introduced on page 278, when in fact an entire subsection is devoted to "do" in pages 85-87. If you look up "comment" you'll find no mention of page 49, where comment conventions for block comments, line comments and so forth are described in concise and useful detail. The long list of special characters that stars the alphabet is inexplicably lacking some of the most common operators and directives, such as #', ,@ , ,@ and #. In fact, the only thing the index seems consistently to get right are words that appear in all capital letters in the body of the text.

It slows my reading considerably to constantly be adding pencilled entries to the index, but since it will probably save hours of irritated searching for information in the future, I'm persisting. Let's all hope this glaring flaw is corrected soon in a second edition. In the meantime, there's always the option of searching the full text, which is online on the gigamonkeys site, every time you would normally flip to the index.

There have been any number of excellent books written on Lisp and its sister, Scheme. "The Little Lisper" and "Structure and Interpretation of Computer Programs" are two that come to mind. What most of them have in common is an emphasis on applying the powerful semantic features of Lisp to fundamental questions in computer science.

This book does show that side of Lisp. However, its most important feature is in showing an underexposed side of common Lisp - that of a potent and underutilized tool for real world programming applications.

File operations, XML and HTML output and web services are all covered. Constructs like the loop macro and package system are given extensive treatment. These were essential tools in the days when Lisp Machines roamed the earth. The unique power of the "defmacro" user defined macro facility is shown to good advantage.

I am giving the author five stars for a comprehensive *practical* treatment. This book demonstrates that Lisp is as capable as the current breed of "dynamic" languages for application programming - while possessing unique functional powers that have yet to be equaled.

When an author uses footnotes, that often means that he, or she, hasn't got the organization of the book right. Unfortunately, that is the case in this book. The author has a very easy, readable style, but the readers enjoyment of the text, and concentration, is constantly interrupted by the footnotes. They are excessive and intrusive. For example, half of page 45 is footnotes! Some of the footnotes are valuable, some are not,some seem to be related to the text, and others just seem to be random thoughts that the author wants to squeeze in. One or two of them actually seem to contradict the text they refer to. They make the text much harder to read and ruin an otherwise easy and fluent style. I'm suprised that the copy editor didn't spot and fix this problem!

Apart from this gripe about the style, this is the best book on Lisp that I have ever come across! I recommend it to anyone interested in learning the language. On the whole, it is clear, well-written (apart from the footnotes) and practical.

If you are trying to learn Lisp on your own, this is the book that you need.

This book takes the approach that examples are the best explanations and goes straight to the eye.
Lisp is a very vast subject, and it is presented (at last!) to the programmer, not for computer/sciences students and similar passers-by.

Leaving aside the practicality of learning Lisp, this book is really amazing. I've read a couple of books on Lisp and never really gotten it until now. Generally they present some abstract math concepts, show how they work in Lisp and leave it there. This book takes it to the next level, the practical level, as you see in the title.

Macros, slots, object orientation, data structures, and more, are all discussed in detail without 'leaving it to the reader' as the other books do.

Finally! A good book on Lisp.

I really like this book even if i'm not a Lisp fan.
This book gave me fresh view of lisp that realy helped me.

Few months ago my company got a new wealthy client,
the job was to maintain their in-house software ,
as the application was written in Lisp and i was the
only programmer with Lisp in my CV
(I's behind C/C++,Java,VB, php and before Pascal)
i got the project , promotion "Lead Programmer",
raise , and could hire help .
Sounds great ? Well it was untill i sow the code.
Actually i didn't used Lisp since the college days,
even than my largest one was less than 800 lines long.
Facing the code that i sopose to maintain was a:
"In what the hell is this written in ?"
Even after 8 months, and countless hours working
on the code i still can't answer that.
The whole program is a one big macro , when i
macroexpand it , got a code large enaphe to fill
Paul Grahams' On Lisp , book (around 400 pages)
and remain enaphe for 2 Doctoral thesis.
After unsuccessfull idea to rewrite the code in
C# , our calculation was that 4 men would do it
in something like 5 years , and hiring three Lispers
we decided to rewrite the code strictly from the comments
and documentation (geetting as much idea from original code as we could).
Thank you lord that it was such well documented and commented.
Now our program is still missing features ,it's buggy ,
it's slower , and thanks god for the brand new Dell boxes that
hide our unoptimization else we would be out of job .

Eight months ago i had a very high opinion of my skills
now i feel like a high School jr writing his first Hello World.
Lisp tested me and i failed .

If it wasn't this recession i would leave this project ,but good job are hard to find this days especially for one with lack of selfrespect as myself.

.

I wish you a happy Lisping
Stephen
You could never know how good you are if never done
Lisp before

This book is an outstanding introduction to Common Lisp and I would not hesitate to recommend it to anyone interested in becoming a better programmer. Few experienced programmers would deny the benefits of learning a new language, but with the proliferation of languages that are near clones of others, those benefits are not always significant or obvious.

Not so with Common Lisp! Within the first quarter of Practical Common Lisp a reader is introduced to interactive development, code as data, dynamic variable scope, several function calling conventions, syntactic abstraction, and much more. True to the book title, these are tools that are useful in almost every program and their use is demonstrated with practical examples.

Finally, a word of warning: once your programming toolbox contains such a wide selection of tools, it is very hard to limit yourself to the handful that most languages provide.