Browse Books

Reviewer: Fernando Berzal

Code generation (CG) is the result of applying the old "work smarter, not harder" adage to software development. Even though wizards have used passive code generation for a long time, the adoption of active code generation has not yet become mainstream. Active code generators are responsible for the maintenance of the source code of (part of) your application: you do not modify the generator output; you tweak and refine its input, in order to produce your desired output, in a model-driven way. In fact, model-driven software development initiatives, such as the Object Management Group's (OMG's) Model Driven Architecture (MDA), make heavy use of code generators to raise the abstraction level in software development. This book reveals the fundamentals behind the design and implementation of code generators, instead of the particulars of existing commercial products. Reading it, you will learn how to build different kinds of generators, and many of their potential applications in common software development tasks, from database access layers to user interfaces. Basically, code generators can take source code or abstract definition files as input. JavaDoc-like documentation tools, and utilities to embed structured query language (SQL) into your source code, belong to the first category. They can save you a lot of time when used appropriately in repetitive tasks. The second category of code generation tools, those that take abstract definition files as input, are essential for model-driven software development, since they can be readily modified to target different programming platforms. The book does an excellent job of presenting the potential benefits of CG, and showing readers how to smooth CG adoption. Not only does it vividly illustrate the improvements CG can induce in source code consistency and maintainability (with a bit of hype, to be honest), but it also addresses the concerns other people may express when introducing code generation into an organization. Although the hypothetical case study at the beginning of the book smells like snake oil to all of us who know that there are no silver bullets, the author acknowledges that application generators are ongoing projects that require constant maintenance (and, hence, hidden costs he does not mention). The book also addresses the skills and tools you will need to make the most out of code generation. Herrington puts a special emphasis on the use of text templates, regular expressions, and language parsing tools. He also discusses the importance of testing code generators (a test utility is included), and the suitability of handwriting the code in the first place, in order to fully understand your framework before generating any code. As all of the books in Manning's "In Action" series are, this book is example-driven. You will find plenty of examples demonstrating the potential of code generation in a wide variety of development tasks. You will find almost anything, from simple pretty printers, header file generators, and small systems, to automatically building the glue code between subsystems, to complete tier generators that build a part of your applications. Obviously, EJBs are ideal for code generation, since they involve a lot of mechanical and repetitive work. CG is particularly suited for generating database access code, be it Java Database Connectivity (JDBC), ADO .NET, Perl database interface module (DBI), or PHP: hypertext preprocessor (PHP) extension and application repository (PEAR). As the author states, "If you generate only one section of code in your application, it should be the database code." Less repetitious tasks, however, are not as easily amenable to code generation. For instance, user interface development requires a higher level of sophistication, which is not present in the book examples. This might need a whole book of its own, actually. In any case, this book presents evidence of the likely benefits of code generation, even in this area, which requires modeling the users' workflow, breaking down the interface into different interaction models, and identifying exception cases that might need to be hand-coded (login forms, for instance). Some may argue that the author's selection of tools might not be appropriate for every developer. He has chosen Ruby, an object-oriented scripting language, to develop all of the examples in his book. The rationale to justify this decision is certainly biased, and does not offer concluding facts. However, the truth is that the examples throughout the book show how Ruby can be used for developing compact code snippets that clearly convey the author's intentions. This makes Ruby ideal for this book, even though it might not be the best option in a production environment. In the worst case, this book can also teach you a new programming language. After that, you can apply what you learn about code generation in your language of choice. An appendix provides the information you may need. Online Computing Reviews Service