Software Books

This book is clearly a "must have" for anyone developing with VFE. Despite spending a fair amount of time on the VFE Tech Support Conference, attending 2 VFE DevCons, etc., I have found this book to be invaluable. In particular, I like the narratives on the Instantiation of the Application object and Form, along with the discussion of various key properties and methods of the major classes. To the extent that one spends time actually studying these narratives, properties, and methods in conjunction with stepping thru the code, I feel this will reap rewards in the form of better productivity and higher quality applications. For those who aspire to get some depth of understanding of this framework, this book is for you.

This book is great for both new users of the VFE framework and experienced users alike. Not only does it provide step-by-step guidelines for building your apps with the VFE framework, but it also contains numerous tips and tricks for experienced developers. A required reference for all VFP/VFE developers!

This book is a "must have" reference for all Visual Foxpro programmers who use Visual FoxExpress. The information in this book will save many hours of development time. I highly recommend it.

I have read this book twice and will probably read it again. Everytime I read it I gain a little more insight into this great foundation and n-tier development. I especially like the explanation of the step-through logic in Chapter 10 and the explanation of each method in the various objects.

I think that if you buy Visual FoxExpress and buy this book, you will reduce your learning curve by several months.

This book is a crucial part of my reference library. Although Visual FoxExpress comes with good documentation and a sample application, it lacks the step by step walkthrough with explanations on the thoughts behind the concepts. This book fills in the blanks very nicely and helps the reader to gain a better understanding of not just the "how" but also the "why". The authors do not hesitate to inject their own observances and opinions about working this powerful framework. This makes it an interesting read as well as a good reference.

I ordered this book to serve as a reference for my symfony work. It has been an excellent reference guide to symfony, though it is not meant to be a "Introduction to.." or "Getting Started" book. I highly recommend if you work or have a solid background in symfony and need a handy desktop reference manual.

This book is really the definitive guide. It covers everything you need to know to build a web 2.0 application with symfony. It is written by the people behind symfony, so the book is extremely detailed and has a great format that makes it easy to understand. Well done.

The books contains all the information you can find in the online manual on the website of the symfony project.
If you know this before (and I did), the book has the same quality like the online manual, in my opinion a very good one.

I'm a freelancer that was in search of a framework that would allow me to expeditiously develop applications for my clients, without sacrificing reliability. After researching several PHP-based MVC frameworks, I landed on symnfony due to its comprehensive set of features, strong OOP support, PHP5 utilization, and (very importantly) the great documentation. Yes, this book is available in web format online - but I'm very glad I made the purchase so I could learn the framework as I traveled, and it's much easier to use as a reference (I have it sprawled across my desk as I type this review). If you're looking for a great framework, I'm convinced symfony is it. And if you're looking to learn symfony, and have a resource as you build your skills, this book is what you'll need. The only caviat is, if you have no Object-Oriented programming experience, I would recommend you pick up "Objects, Patterns, & Practice" by Apress before learning symfony.

Well written and understandable for such a large chunk of software. You can be the judge yourself, of course, by reading it online before you buy the hard copy. I'd definitely recommend having the real thing if you're just starting with symfony though.. you can't dogear or bookmark the online version.

I'm not an expert in either Interface Design or Programming Methodology, and I've only read a little bit in these areas. As I read this book, I found myself thinking: "You mean this approach isn't standard practice already?"

After reading Ellen and Alan's description of how a UI Designer and a Developer should interact with each other, it just seems so obvious that everyone should work this way. User needs should affect architecture, and technology constrains design--how hard can it be to understand that? But the implications--design and development are iterative, and ongoing user testing is critical to the iterative process--could change the way some people think about programming projects. (The old Specify, Design, Program, Test, Release process seems somewhat naive in retrospect.)

The book has a kind of fun and lively feel to it. It's clear that the authors were having fun telling their various stories, and were excited about illustrating their points. The writing is casual, which made it amazingly easy to read.

On the other hand, once the informal style sold me on the overall approach, I almost immediately wanted a more rigorous treatment. I'd have loved an Appendix that summarized the formats of the various documents, for instance, and perhaps one that reviews the process flow diagram used at the beginning of the later chapters. (As a former academic, I found myself wondering as well about the independence and completeness of the Design Guidelines, too, but that's my quirk. It's probably not an issue most readers would care about.)

I think this book could become one of those that inspires a sort of religious commitment to its vision, and that that would probably be a very good thing.

First let me tell you this is an interaction design (or user interface design) book, since the title of the book doesn't do this job well.

This is one of the books that have great impact on me. I agree with the review written by Kevin Mullet (printed on the book's back cover) that the ideas presented in this book are a bit "dangerous". It is dangerous because they are not the common practice yet. If people want to follow these ideas, they need to have changes. Changes are always dangerous to many people.

Those "dangerous" ideas include:

- Build fewer features but build them well. (The current practice is to build as many features as possible so that marketers can list those features for promotion. Is a product easy to use? Everyone can claim that since there are no criteria for such a claim.)

- User interface design should drive the system architecture, not the other way around. (Modifying system architecture is always hard. If we want to support a certain interaction afterwards, the architecture will probably can't support cleanly, if at all.)

- Technology should be used for user needs, but not for technology's own sake. (Visual design should also be treated the same.)

Last but not least, this book shows that user interface design is actually science but not art. We don't need a graphic design degree to be an interaction designer.

As an IT project manager supporting web applications, sites and portals, this book summarizes the story of my life. Not just a must-read, but a godsend for application developers and UI designers -- two groups who traditionally don't always see eye-to-eye or face daunting communication challenges. Can't we all just get along? Yes! This book tells you how, using simple, easy-to-understand language and real-life examples. End users and customers will thank you for reading it.

I highly recommend this book as an invaluable resource for anyone currently in, or looking to enter, the instructional design field. The authors have successfully been able to present information, which can often be dry and complex, in a clear and easy to read format.

I have a read many books in this area and they have been a fantastic cure for insomnia. This on the other hand is a compelling read from start to finish. Many of the concepts presented will not be foreign to people that work in this field or in the area of product development. However the logical order and detailed examples work brilliantly to drive home the principles.

Publishers in this area should use this book as a bench mark for design and layout for its susinct and logical passage. Thank you very much Ellen and Allan for such a useful tool!

This book has many examples of good and bad web pages and also consumer products. What it covers is seemingly obvious, but apparently not realized by many. It shows how users and designers can work together for optimal result. It should be a required reading for anyone doing user-interface designs. It is good that they actually have a good free product, HUBBUB ... .that was created using this design philosophy.
I didn't give it a 5-star only because, to me, the section of their HUBBUB experience and the conclusion was too long and could have been made more concise. Also, it was disappointing to see their product not following their own design goals well enough, which seemed to make the book less effective.

This book is a great resource for when you're looking for that specific line of code. Its terrible to read from front to back, but its an excellent way to find exactly what you're looking for. Its so much code, it'll make your eyes bleed.

Director 8.5 is a monster application with huge range of functionality. Nyquist's "Bible" uses CD-ROM-based tutorials to carry you through the concepts with relative ease. The tutorials are part of one continuous complex project, taking the reader from the basics through media management, interactivity, project management and some pretty sophisticated Lingo programming. It is also organized to allow easy reference for specific issues. Having recently completed an 'Emedia & Design' programme I would have to say that Nyquist's book is probably the most valuable text in my library.

There is no better book with which to get involved in Director. I've read nearly all of them; nothing else comes CLOSE! Get IT! ENJOY IT! LOVE IT!

Este libro es realmente extraordinario para aprender a usar director, pues se ve desde el uso basico de cada herramienta aplicando los ejemplos que incluye el cd-rom.

Recomiendo este libro a quien nunca haya usado director antes, y para aquellos que habiendo usado, solo han aprendido por su cuenta sin referencias técnicas.

A well written book of the "Bible" series! Great examples and delivered in an understandable "lingo." This book is a must have for all Director developers regardless of your level or experience. There is a ton of useful information for everyone.

I just can't wait until I finish reading the entire book before I post this review because this is the best PowerBuilder book I have ever read. This book leads you through the steps on how to develop a distributed PowerBuilder applications. This is a must have and the only book you need to learn how to write DPB applications. Well done, Michael !!

This book cover all aspects of Powerbuilder Distributed components. It is clear, informative, well written and contain many examples. Although covering what is generally considered an advanced topic, this book should be understandable by Powerbuilder beginners. Most technical books covering a product are bad. This is a welcome exception. Overall an excellent book.

This book is very helpful in covering all of the details of building an Distributed PB Application. I recommend it for others to read for it is very helpful and informative.

If you are a Powerbuilder Guru, you must read this book, otherwise you'd take the risk to know less than your apprentices. If you are a novice, you must read it to become a Guru. Don't loose time with me, go to buy one!

Distributed Application Development with PowerBuilder 6 is dedicated to distributed application development in the PowerBuilder environment. It focuses on Distributed PowerBuilder. This text is packed with code samples to guide you every step of the way. Also included is a robust server framework I have used on real-world projects. A "must buy" for anyone preparing to go to the next level of PB development!

In writing The Elements of UML Style, Scott Ambler has done the software modeling community a great service. As a consultant and trainer of numerous corporate clients, I see many teams whose individuals understand the semantics of UML, but have yet to gel as a team with common practices and style. On these teams, communication and productivity often suffer when arguments erupt over why something is modeled the way it is and how my way is better. Teams need to agree on a set of common practices and style. The Elements of UML Style is a great starting point.

The Elements of UML Style is small, concise, intuitively organized, and well explained. It proceeds section by section through the various UML diagrams, in the order they are used on a project. These sections provide many tried and true common sense guidelines and some valuable, but less obvious guidelines aimed at creating well-formed models.

Is it necessary? Yes. This is the best compendium of UML modeling guidelines I have seen published. Projects would be foolish to start from scratch.

Is it sufficient? No. It is a starting point. Projects will want to adjust and go beyond what Ambler writes here. For example, The Elements of UML Style provides general guidelines that urge adopting common naming conventions (section 2.3). A corporation or project will want to nail down specific guidelines for their use case, class, and component names. Also, Ambler focuses on the diagrams of UML, but there is more to modeling than the diagrams. UML itself avoids topics such as what constitutes a well-formed use case specification, and so does Ambler's book. One would have to turn to other books or training, such as IconMedialab's Advanced Use Case Lab course for detailed guidelines in these areas.

Will I be an object modeler just by reading this book? No. This is not an intro book to modeling. Read Craig Larman's "Applying UML and Patterns" (for example) to learn how to object model. Instead, The Elements of UML Style brings together many of the nuggets that will help to become a better, more consistent, and easily understood modeler. I will be recommending this book to my clients.

This book has lots of excellent recommendations on style and presentation of UML diagrams. Ambler offers up 236 recommendations to questions such as: How often should I use stereotypes? Should we model keys into our DBMS? Should we require activation boxes on our sequence diagrams?

I have to recommend this little book to anyone beginning to use UML. More experienced object modelers will have developed their own modeling conventions, but they also will benefit from reading Ambler's articulate perspective. He is an accomplished modeler and an effective communicator.

Ambler covers style guidelines for all 9 UML 1.x diagrams. IMHO most of his suggestions are right-on, and his explanations are consise and accessible. I have been modeling OO systems for 10 years, and I don't agree with every recommendation Ambler makes, but I appreciate what he is offering in this book.

I especially like the fact that Ambler included an Appendix that lists all 236 guidelines in just a few pages. The book also has a high-quality bibliography of other modeling resources, and I was quite pleased that this short book also includes an Index for rapid access to terms.

Most development groups endorse the need for programming conventions and consistent naming standards. "The Elements of UML Style" is an extension of this philosophy to UML models, and every project will benefit from the ideas it presents.

There are two people I look to for information about UML: Martin Fowler (noteably: UML Distilled), and Scott Ambler.

With this book all the pieces are there. "UML Distilled" tells us how to use UML, "Agile Modeling" tells us how to use it in an agile way, and now "The Elements of UML Style" tells us how to use it so that the results look good and are understandable.

Physically, it's a nice book. Small and thin, it packs well, and will fit easily into the most overstuffed briefcase or backpack.

The format is good as well. Organized around the different diagrams, with extras for general guidelines and a quick overview of Agile Modeling, it covers related issues together in an easy to digest format. The guidelines themselves are short, concise, and well illustrated with examples.

I found it an easy book to read, being able to pick it up for a few minutes at a time without having to spend a lot of time to regain my context.

No matter how much you model, or what tools you use to do it, this little book will help make your diagrams better.

This is a great reference book for anyone wanting to improve their UML modeling skills. It won't teach you how to model, but it will teach you how to create UML diagrams which are much easier to read and to understand. Although Ambler preaches that "content is more important than representation", the reality is that if your diagrams look like crap then people think that your work is crap. This book describes a collection of very simple techniques, many of which could be considered modeling patterns, for making your UML diagrams look good.

The book contains both modeling tool diagrams and sketches, showing how you'd apply the various techniques with both your users at a whiteboard or developers at a workstation. The sketches are easy to read, which is pretty amazing considering the book is the size of paperback.

The second chapter is almost worth the price of the book itself because it overviews guidelines which could be used on any type of diagram, UML or not. Chapters 4, 5, and 10 are must reads for business analysts because they cover techniques to improve use case diagrams, class diagrams, and activity diagrams, the things you're most likely to show your end users. Making your diagrams understandable is an important step to communicating what you're doing, and maybe even getting funding for your project.

Other chapters focus on guidelines for technical diagrams. Modeling tool vendors should pick this book up and automate these guidelines. If they were to do that they would really improve the quality of their tools.

If you're serious about UML modeling, then this is a must have book. It's so cheap your company should even consider getting a copy for each analyst, architect, and designer that you have on staff.

I still remember the first time I read something written by Scott Ambler. It was an article about 9 years ago in Software Development magazine (actually it was probably the forerunner) about use cases. His style of writing is, was, and always will be so easy to read and comprehend. Perhaps that is why so many folks write to agree and/or disagree with his ideas: there's no AMBIguity there.

Scott's subscribes to and adheres to the KISS principle (Keep It Simple, Scott!). That is what makes it easy to understand and appreciate. In this book Scott has very capably tackled the easily misunderstood (and therefore often misapplied) ideas of the Unified Modeling Language (UML) and presented them in a manner than anyone can understand and apply in their work.

This book is small enough to fit in your pocket but is incredibly massive in applicability. It belongs on the desks of every developer (AND their manager!) working with UML. Whether applying UML in an XP environment or within the constraints of behemoth software development projects, a basic understanding of the UML is essential. This book will get your team there, quickly.

Research shows that the number one factor that contributes to project success (or failure) is the ability (or inability) to communicate well. That was one of the goals of the UML, a truly UNIFIED language in the arena of modeling. A key value in Agile Modeling (AM) is communication. Coupled with the AM principle of Know Your Models and the AM practice of Apply Modeling Standards, this book will assure that your project's modeling efforts shine.

I confirm all that has been said.

It is the first source I have found that explains building the linux kernel in a way that makes it easy to understand. While you might be able to find this information on the net, this makes it easy to get an overall view of what is going on.

It is easy to read, and has great references. Well worth the price.

This book is very well organized, and provides a good level of detail of the topic. I do recommend it.

I am an experienced embedded developer that just inherited an embedded Linux-based project already in progress. As there happens to be no one else at my company with any embedded Linux experience, I automatically became the de-facto Linux expert and I needed to come up to speed on a lot of topics very quickly. I found this book to be an excellent survey of the must-know topics for the embedded Linux developer. It also contains many references to the most definitive sources of information on the various topics. Highly recommended for coming up to speed on embedded Linux.

For those engineers who start their first embedded Linux project, this book is a must have. The book is not for those who want to understand how kernel runs but it gives you the most important concept and work flow to bring up the OS on your development board. The author also provides a useful further reading list in case you want to dig more. A very practical and clearly written book and I would recommend it to those who have solid experience in embedded development but just start to explore in Linux.

This book, the CALAO SYSTEM USB-A9260 card, an eeePC and a cross over cable is all that you need to study embedded system everywhere (even along the Seine river in Paris - yes I did it !).
The chapters about the U-BOOT bootloader, the BUSYBOX embeded Linux and an extra piece of information on the JFFS2 file system are welcome. If the cross-development environment chapter had been about BUILDROOT, this book would have been THE BOOK for the present embedded Linux based systems designers.

I have read (well, ok, read through or I would post more reviews) quite a few technical books about SQL Server. Where many books follow a very rigid path through a subject, quite often in a very feature driven manner (Here is this command, and you can do this. Next, this command) or process driven manner (First we do this, then we do this...).

This book is very different from that. The title includes the word "Expert" for good reason. This is a book that doesn't assume you know nothing and start from scratch, nor does it try to teach you every knob and switch on all of the SQL commands. It it more about going to the next level and becoming the expert at programming with SQL Server by covering several deep dive subjects that every person needs to make the transition from "Pro" to "Expert".

It has eleven chapters, each of them about a distinct facet of programming SQL Server, from the common stuff you need to do or use right (testing, errors, privilege, CLR, encryption, dynamic SQL and concurrency) to three chapters on really deep applied stuff (spatial data, temporal data, and graphs/trees). Each chapter has some very deep information, and a lot of code that could make you dizzy if you try to ingest it too fast. It is all explained nicely though, and if you take the time to understand the code you will be far better off for it.

I would not suggest this as a book for the casual "I would like to know a bit more about SQL" reader. It is more for the reader who is already good and wants to become a solid professional/expert SQL programmer who know the right way to do things. For that reader it should be on your required reading list.

This is really a great book. It covers specific topics really extensively and it is very easy to read. I was impressed because I was able to find great information about topics such as Encryption or Hierarchies that cannot be found very easily in other books. The examples are very descriptive but the most important thing is that the author will show you all possible solutions and will prove why the one he selected is the best. It is not a beginner's book but it is a fantastic book for advanced DBAs/Developers.

The author imparts a wealth of knowledge on the reader in a mere 445 pages. His style is direct, clear and doesn't waste any pages on trying to get you up to speed. He gives you just what you need and nothing else. I wish they were all like this.

By providing actual performance testing Adam Machanic doesn't just make expert claims for his methods. In fact, my favorite quote from the book: "The hallmark of a truly great developer, and what allows these qualities to shine through, is a thorough understanding of the importance of testing."

Having never worked with spatial data before, I found the coverage of the topic fascinating. Also, entire books have been written on tree's, hierarchies and graphs. Adam provides enough information in a single chapter for the developer to choose a strategy that works.

5 stars - easy

The book presents real-life SQL Server problems and shows you how to solve them. It is written in a friendly and story-like fashion. The amount of detail presented is just right - detailed enough to understand the topics yet simple enough not to feel overwhelmed by the amount of information presented.

In the first chapter, the author reviews coupling, cohesion, encapsulation and database role in the application development cycle.

Chapter 2 is extremely useful for testing and tuning queries. It teaches you all you need to know about SQL Profiler. Other topics include unit and functional testing and performance counters. The chapter also introduces the SQLQueryStress Performance Tool which is a free query performance and load testing tool designed by the author.

Chapter 3 covers the different types of errors and exceptions and also shows you how to write error handling code using new error-handling construct added in SQL Server 2005.

The chapter on Dynamic SQL, chapter 7, is a must read for every database developer as it teaches you how and when to use dynamic SQL to make your application both efficient and secure.

Other advanced topics covered in the book are encryption, SQLCLR security and designing systems for application concurrency.

Recommended for SQL Server professionals of all levels.

Frankly, I was expecting a very SQL Server 2005 specific book. Instead, what we have is a good general RDBMS book that happens to be using SQL Server 2005. Encryption, access control, testing, basic software engineering and exception handling are never touched in SQL programming books -- including my own! The spatial chapters were new to me. The little asides were also worth looking up. Good clean style, great job.

Final Cut Express has a bit of a learning curve to work through. I'm only half-way through this book, and its worth is already more that I paid for it. I'd already been through most of the online help, and also another FCE4 book that I had purchased, when I bought this one. It has provided many valuable insights that have made it possible for me to actually become productive with Final Cut Express.

This is a very useful book for anyone learning the program. Video editing, particularly titling and animation, can be detailed and laborious. The writer--an experienced editor--takes you through the process step-by-step in contrast to manuals that merely describe a program's functions.

The accompanying CD has hands-on lessons for every chapter, so the reader can actually experience what the writer describes. Invaluable. Final Cut, even the express version, offers many video capabilities for both amateur and professional. This book shortens the learning process and brings you up-to-speed quickly.

I purchased three books on editing Final Cut Express 4. This is the most helpful of the three. It was the only one that was helpful in setting up my iMac to work effectively with Final Cut Express 4.

Everything I needed to improve and speed up my learning curve on FCE. Highly recommended.

I've gotten each new edition of this book, even though there aren't a huge number of changes. It's just nice to see the updates he's made and draw from his rich knowledge and experience with Final Cut Pro/Final Cut Express/iMovie, and the new nuances he throws in with each edition.

You can already learn some key points to keep in mind about the latest version of FCE in the Excerpt from the front of the book available for viewing on Amazon. It's worth the price of the book right there!

Tom works so hard providing lucid and practical support on the Apple Support page for FCE, and no doubt uses that to enhance the next edition. You're going to be getting his free advice sooner or later, so you might as well throw a few bucks his way and give him some credit for all that you will benefit from his wisdom. I've bought several of the other FCE books over the years, but Tom is the best.

Ron Carlson

This is a great "how to" book loaded with examples of how to implement genetic algorithms. The two main points this book makes is that many seemingly different problems can be reformulated as problems of program induction and that the genetic programming paradigm described in this book provides a way to do that program induction. No prior knowledge of conventional genetic algorithms is assumed. Thus the first three chapters are introductory material. In particular, chapter three describes the conventional genetic algorithm and introduces certain terms common to the conventional genetic algorithm and genetic programming. If you are already familiar with genetic algorithms you can skip ahead.

Chapter 4 discusses the representation problem for the conventional genetic algorithm operating on fixed-length character strings and variations of the conventional genetic algorithm dealing with structures more complex and flexible than fixed-length character strings. Since this book assumes no prior knowledge of the LISP programming language, section 4.2 describes LISP and section 4.3 outlines the reasons behind the choice of LISP for the implementation of solutions in this book. Chapter 5 provides an informal overview of the genetic programming paradigm and chapter 6 provides a detailed description of the techniques of genetic programming. Some readers may prefer to rely on chapter 5 and hold off on reading the detailed discussion in chapter 6 until they have read chapter 7 and the later chapters that contain examples.

Chapter 7 provides a detailed description of how to apply genetic programming to four introductory examples thus laying the groundwork for all of the problems to be described later in the book. Chapter 8 discusses the amount of computer processing required by the genetic programming paradigm to solve certain problems. Chapter 9 shows that the results obtained from genetic programming are not the fruits of a random search. Chapters 10 through 21 illustrate how to use genetic programming to solve a wide variety of problems from varying disciplines and are defined by the table of contents. The examples in these 12 chapters make up the heart of the book.

The final eight chapters discuss aspects of genetic algorithms common to all implementations. Chapter 22 discusses the implementation of genetic programming on parallel computer architectures. Chapter 23 discusses the ruggedness of genetic programming with respect to noise, sampling, change, and damage. Chapter 24 discusses the role of extraneous variables and functions, and chapter 25 presents the results of some experiments relating to operational issues in genetic programming. Chapter 26 summarizes the five major steps in preparing to use genetic programming while chapter 27 compares genetic programming to other machine learning paradigms. Chapter 28 is an interesting one in which the spontaneous emergence of self-replicating and self-improving computer programs is discussed. Chapter 29 attempts to wrap up the book with a conclusion.

This book is best used for its examples and practical viewpoint. There are certain matters, such as how to program in LISP, for which you will need dedicated books since the amount of detail in this book is not enough. I do highly recommend this book as a uniquely practical one on how to implement genetic algorithms via computer programs. I haven't found another with so much practical information.

I became interested in Genetic Programming after hearing one of the professors at our university lecture on it to a small group of students and other professors. I asked what book might be a good starting point and he pointed me here and i'm glad he did.

This first volume in the Genetic Programming series of books by Koza is very well organized and clear in its explanations. I have not tried the techniques presented yet, but I have some good ideas on how to proceed. The author uses LISP as the language of choice in the book, but practically any modern language should be sufficient.

If you have any interest in Genetic Programming, I encourage you to at least pick up this first volume and read through it. This technology is still relatively new and the application of the techniques seems virtually limitless.

If you are someone who plans to study Genetic Programming, or are already doing so and feel kind of lost about it, then you must read this book. It starts from the very top and brings you through all the steps of Genetic Programmin with tons of very useful examples.

This book is great!

Yeah, its a big book...weighs a ton. However, only the first few chapters are concerned with the basic mechanisms of GP (should be familiar to anyone with a background in genetic algorithms or evolutionary computation). The rest of the book is chock full of examples on how to apply GP. These examples are essential and very welcome. I've found that I can usually find a solved problem in Koza that is similar to what I'm after, then I adapt it to my needs. This is a great reference, but don't be fooled into thinking this book is a tutorial. Think of it more as an exposition of GP with examples. For a tutorial, look somewhere else.

The book was very large but enjoyable and made the subject very clear and easy to understand. It explained the genetic programming algorithm very well and showed the results of many experiments to show applicability, limitations, and characteristics of the method.

There was some repetition in places, maybe because the author wanted to emphasize some points and also to remain understandable to persons who may read selected chapters or examples rather than from cover to cover, page by page.

Although the book states that Genetic Programming does not depend on the LISP language or features, it uses LISP as its exclusive language of choice. I would like to implement these generally very computationally intensive Genetic Programming Algorithms in a very fast and efficient way, which for me implies assembly language, and although the author gives good tips about making the algorithm run faster the implementation shown is all LISP and nothing else. I am also interested in using the algorithm to generate efficient, parsimonious, code. The author described the additional problems of parsimony, but gave no information on generation of fast code from S expressions. I will have to refer to some compiler books and my own experiments to go further in this area.

I look forward to experimenting with the subject and reading some of Dr. Koza's other books on the subject.