Code Generation in Action, ISBN 1-930110-97-9, by Jack Herrington

Reviewed by: Yanick Dufresne, January 2004, send e-mail
Published by: Manning Publications, go to the web site
Requires: N/A
MSRP: US$44.95 (print), $22.50 (ebook)

Programming is fun. It's all about solving interesting problems and inventing new algorithms. It's about getting computers to do new things, to do them better, to do them faster. Or so the story goes. In reality, in most large software projects, a sizeable portion of programmers' time is spent implementing the infrastructure around the juicy bits - the more mundane task of creating what is usually referred to as "the plumbing". Much of this plumbing usually revolves around database access code, test code, reports from data sets, forms, and other repetitive aspects of larger software applications.

It's somewhat surprising how programmers tend to resist delegating those tasks to the computer itself. After all, don't computers specialize in handling repetitive, boring tasks? Code Generation comes to the rescue. Code generation is any process designed to create source code, typically from some metadata. This metadata might be a database schema, in the case of data access code for instance, or it can even be the code itself, using embedded markup to generate the repetitive portions.

Code Generation in Action endeavors to introduce programmers to the varied techniques used in generating source code. The book is divided into two main parts. First, fundamental principles of code generation are explained, and various generator types explored. The second part of the book, titled Code Generation Solutions presents a handful of cases studies in each of eight categories of problems, and provides different techniques for solving each generation problem.

The overall layout of the first part is very effective. Each section builds on the previous one in a natural flow. Several generator types of increasing complexity are explained in detail and sample implementations are provided and annotated. The code annotations are particularly handy, despite some slightly annoying editorial mistakes; some variable names in the code don't match the text describing what they do, for instance. Hopefully, those will get fixed in the second edition.

One initial surprise was the author's choice of language for the generators themselves. The sample generators in the book target several different languages with which most programmers will be sufficiently familiar to easily grasp the intent. However, the generators themselves are all written in Ruby, a relative newcomer to the world of scripting languages. I was initially wondering why author Jack Herrington hadn't chosen Perl or Python. Herrington anticipated this question and covers it fairly well in chapter 2. I wasn't familiar with Ruby before reading this book and I must admit I was a quick convert. The expressiveness of its syntax makes it an elegant solution for most any scripting need. For the reader's convenience, chapter 3 includes a small crash course, and appendix A offers a more meaty introduction. The Web is also a plentiful source of documentation and tutorials on using Ruby. At any rate, the Ruby coverage of the book should be quite sufficient for understanding the code samples, and I'm willing to bet you'll be curious enough to fire up your web browser and kick the Ruby wheels yourself.

Part 2 of the book is meant to expose the reader to more realistic case studies and offers several solutions for each problem. The first sections cover each generator and technique in depth. As the book progresses, the problems become somewhat repetitive. The text starts to address the particularity of each problem and glances over aspects already covered in previous sections. Despite the author's efforts to keep it lively, it does get a little monotonous towards the end. Regardless, Part 1 and much of Part 2 amply justify the purchase price, and you can easily look up any particular problem in Part 2 when the need arises.

A few recurring topics throughout the book are worth mentioning. The importance of unit testing human-created as well as machine-generated source code can't be overstressed. Herrington offers sound advice on implementing unit testing strategies, including - you guessed it - unit test generators. There's also a handy regular expressions primer in the Appendix. As is now pretty standard procedure, the source code of all examples is available online.

All in all, this is a great read and should provide you with a good reference. If you're involved in code generation or if you're simply curious about the subject, this book should be on your shopping list. Recommended.

Letters to the Editor are welcome and occasionally abused in public. Send e-mail to:





© Copyright 2000-2006 All rights reserved. legal notice
home | previous reviews | forums | about us | search | store | subscribe


Forums Search Home Previous Reviews About Us Store Subscribe