Software Books

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.

I was really expecting something out of this title after reading the previous Designing the Obvious: A Common Sense Approach to Web Application Design but the book turned out to be a little disappointment. It contains 31 short chapters that put the principles of the previous book in to use. Some of the topics discussed like signing in, forms and so on can give you a few really nice ideas to be used in a project.

The point is that these few topics could have been published as online articles as they hardly have enough to say to put together a whole book. If the book would've been published a couple of years ago the "not so interesting" topics could have also been worth printing. The language is easy and really fast to read so you can quickly skim the book through and then concentrate on the interesting topics with more thought.

This title clearly falls in to the box of average things...

Robert Hoekman Jr. second book, Designing the Moment, focuses on improving the online user experience. His approach is a practical one: design interfaces that respect users and allow them to feel in control.

Robert's goal is to inspire the web professional to "improve the moment" for users. His storytelling method of explaining strategies makes the 220 page book a quick and fun read. The book contains 30 stories, based on his own experiences of real-world applications and the step-by-step approach taken toward resolving design interaction issues.

The stories are concise, and offer a critique of each phase as changes are made to interfaces. Robert has a "think out loud" method which allows the reader to better understand the decision making process. Question steps along the way and don't hesitate to make decisions you might change in the future. Designing interfaces is an iterative process.

Designing the Moment assumes the reader has knowledge of web design and development; it does not provide the specific code to implement the recommendations. As Robert mentions in the book, "This book is meant as a conversation starter. It's meant to get you thinking".

The book is divided into seven parts:
Part 1: Getting Oriented - give a good first impression to the user
Part 2: Learning - make it easier for users to find their way around
Part 3: Searching - improve the search interface
Part 4: Diving In - great tips on improving forms and video controls
Part 5: Participating - focus on social media
Part 6: Managing Information - how to manage lots of information
Part 7: Moving On - the sign out process

My favorite story in the book is in Chapter 7, where Robert discusses the simplicity of clear labels. Make it easy for users to to use applications. Provide users with simple, easy to understand labels and instructions. On forms or applications, rather than displaying an error message that the user didn't enter information in a valid format, add informative text on the form or application form field that describes what is acceptable.

Designing the Moment is a wonderful resource for information architects, usability experts, interaction designers and developers. I highly recommend it!

Since I'm starting to pay more attention to user-interface concepts and design, I felt this book was required reading for me... Designing the Moment: Web Interface Design Concepts in Action by Robert Hoekman, Jr. Besides offering a number of excellent concepts, he does so in a manner not often seen in other books. He tells you what he was thinking and how he got to that decision point. That's the kind of insight I need to improve my skills.

Contents:
Part 1 - Getting Oriented: Designing the First Impression; Showing Your Personality; Zen and the Art of Navigation; All Links Are Not Created Equal; Getting Your Head Out of the Tag Cloud
Part 2 - Learning: Surfacing the Trigger Words; Labeling the Interface; Beyond Words and Onto Video
Part 3 - Searching: Making Suggestions; Getting Through the Results; Refining Your Search
Part 4 - Diving In: Standardizing Playback Controls; Nailing Form Layout; Conquering the Wizard; Going the Extra Mile with Inline Validation; Simplifying Long Forms; Getting Them Signed In; Counting Characters
Part 5 - Participating: Building Profiles; Editing; Making Social Connections; Designing the Obvious Blog; Inviting Discussion; Getting a Good Rating
Part 6 - Managing Information: Making RSS Meaningful; Tagging It; Getting Reorganized with Drag-and-Drop; Managing Interruptions with System Notifications
Part 7 - Moving On: Signing Off; Dusting Off Dusty Users; Letting Them Go
Conclusion: The Keys to Great Design

Hoekman is well-known for design concepts, and I tend to like what he comes up with. The difference here over other books is that he starts off with a request or issue to solve, and then takes you through his mental process that got him to the resulting solution. For instance, All Links Are Not Created Equal... The need was to create a list of links for a call-center intranet page. The idea was to somehow communicate the current issues affecting the users, in chronological order, maximum five links. I would take the normal route (which is where he started) of just putting the last five links out there. But to communicate chronological order, that wouldn't work. Then he placed numbers in front of each link (1 to 5). OK, but still "flat" as he termed it. He started trying to incorporate a concept he learned about called "ambient signifiers", or ways to communicate information based on the way it's displayed. This led him to drop the numbers and use decreasing font sizes to show order and importance. Much better, but he still wanted more. He then stumbled on an "aging" technique whereby he would not only decrease the font size, but also lighten the text color the further down you went. This combination communicated both importance and age, and was exactly the solution he was looking for. Notice that he didn't go into it with a preconceived "spec" as to how it would work. But through his mental conversation, you see both how he got there and why he made the designs that he did.

I'm perfectly happy admitting I don't know it all when it comes to design concepts. But what I don't like is to read "do it this way because I said so" material that doesn't explain why. Hoekman makes that rare jump beyond "why" and reveals the imperfections and dead-ends before you get there. As such, this is one of the most valuable design books I've read.

I haven't read Hoekman's first book yet (but plan to now). I took this book on a 4 hour train ride last weekend and devoured it. It was like sitting with a friend and chatting. I dog-eared a lot of pages, each with a different client in mind and couldn't wait to get back and make some suggestions. I know at least one reviewer said this is old hat...Not for me it wasn't. I started as a print designer and moved into web out of necessity. I mostly do simple html sites. But more and more clients are needing to expand and I'm needing to know how to help them do that. I feel better equipped thanks to reading "Designing the Moment". I particularly loved Part V: Participating.

Sheila Hoffman
http://www.hoffmangraphics.com

Like many of you here, I write web apps. Some are written in the context (and confines) as hobbyist, others are for the job. I'm fortunate enough to have my passion and my career follow parallel disciplines. Unfortunately, it means when I'm stuck on something, its effecting me TWICE as bad as I can neither work nor play! I found this book quite by accident, digging through the digital stacks on web applications, and rocketed through it within a weekend - seriously, I winced every time I closed it, and could only think about when I could squeeze in some more time with it.

First and foremost: this book is not a "How To" in the strict sense of the phrase - it will not give you a primer on web application design from end-to-end. Which was great, I wasn't looking for someone to come around and up-end my own methodologies, my own principles, etc and tell me "this is how you do it." Instead, this book is a "this is how I do it" book: Mr. Hoekman will walk you through efforts he himself has made on behalf of his clients to better their web application experience. He describes and defines these zen-like 'moments' when the interface just 'works', and how he looks to create them whenever possible. The book is beautifully illustrated as these ideas take shape so you can see the progression. He really broadened my understanding of some core concepts on interface and how they are perceived by users that I have been overlooking, or simply ignoring as being irrelevant.

To re-state: you won't see a single line of HTML/Javascript/Perl/PHP/Ruby here! It's a wonderful departure from the tick-and-tack of the technical and I plan to keep it within arm's reach for those times when I need a mental 'reboot'.

I ordered his earlier book, Designing the Obvious, recently as well and can't wait. Robert: If I ever run into you in a Phoenix-area Starbucks I'll have to shake your hand ;)

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 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.

It's rare to find an advanced computer science textbook that's both so engaging and so informative. I've only read the first seven chapters so far, but when I sat down to write my first genetic algorithm (for real research use), the book had already prepared me well.

It's hard to imagine a better introductory textbook for this topic.

This book is a great introduction to genetic programming and should be a model for textbook authors in other fields. Knowing little about genetic programming to begin with, this book guides the reader through the various topics and problems associated with genetic programming in a very logical and understandable way. Highly recommended! I wish more technical books were like this!

I skimmed the Koza books (GP: I & II) and this one at the store. Using the layout, chapter names, and the introductory chapters as my guide, I decided to buy this book to introduce me to the current state of the art in GP. The strengths of this book are its textbook format and the informal exercises that are presented for the reader at the end of every chapter. There is also a great deal of compilation from other relevant gp works presented in a localized, intra-chapter basis. The book is thus highly digestable to a newcomer, and is a far less time-consuming way to learn about GP than through the "expert" papers on the web. Having now almost finished the book, I feel that I am ready and able to author and apply GP techniques in a wide variety of applications and languages, having spent less than 20 hours in study time. A terrific achievement by Banzhaf and company, highly recommended.

This book is good for getting a general view of genetic programming. Nevertheless, I think it neglects many details. For example, it is very hard to from the book how a simple selection strategy (tournament selection) works in practice.

I do not think this book is useful for someone intending to code a genetic programming algorithm.

We all know that kind of books where the author likes to show how much he knows making things intentionally complex....well...this is the opposite side of the spectrum.
The book is very complete and detailed yet easy to read, even after a day of work.
The first part of the book contains introductory information on background areas like probability, biology and computer science as a general discipline.
Getting into the topic, it clarifies some of the differences between evolutionary systems and genetic algorithms and shows how all this contributes to the theory of genetic programming and the evolution of computer programs.
It explains how things are done with different types of individuals (tree, linear, graph, etc) and gives valuable insight about the implementation process.
Although you may need other sources for formal treatment of some topics, this book is a very good acquisition.

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.

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.

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.

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.

I first lend this book from collage developer an have read with great enthusiasms and finally ordered my own copy of this book.
The book gives detailed information on how to developing software from scratch, taken you by hand and leading you de hole way step by step.
With the different way to present the information en with lot of illustrations its newer a boring read.

Anders Kjaer

[...]

Although I was initially put off by the non-serious cover and gimmicky premise, I decided to trust to O'Reilly and give this book a try. That turned out to be a great decision!

Be forewarned that the real title should be "Head First AGILE Software Development," so don't expect other methodologies, but it definitely delivers. Whether you're just beginning to take the plunge into agile development, or you've been sort of trying to do it for a while but don't have a real clear picture of your goal, this is a great book for you.

However, if you've been developing agilely for a while, then what you'll find here isn't much more than a refresher course or reminder of how you should be doing things.

I've been eyeballing the Head First books for a while, specifically the Java and Object-Oriented Analysis & Design. I don't program in Java and I think I understand OOP very well. Because of this, the Head First structure looks to offer a bit less structure - so a good "read as you can" book.

I got this title in a raffle. I'm glad I did. It whetted my appetite for more Head First. Not so much for the content (Which I will review further down) but because it's almost like reading a comic book. Easy, entertaining and something my busy dizzy mind could readily grasp in small chunks. I will probably get another Head First book in the future. Probably more than one.

As for the content of this book, it was well laid out and for someone new to the concepts of formal software design, it was nice to see all the little pieces come together. I did have a hard time with the Java specific environment, but I guess it would be a much larger book if they covered other systems. The steps were clear, some of them a smidge corny, but most of them logical.

After having read this, I was inspired to put it to use. That's when it hit me. I can't see this working unless the entire development group reads the book - or they were all newbies. Well I can see it, just not in the places I've worked.

The way this book is writen is just fantastic. Wonderful book to LEARN how to develop GOOD software.

Head First Software Development is another home run from the Head First series. I have bougth the HTML/CSS, Design Patterns, Object-Oriented Analysis & Design, and now this book. These "Brain-Friendly Guides" are such wonderful learning tools packed with great information, and so much fun to read. Keep them coming!