Table of Contents

Part I Code generation fundamentals

Chapter 1 Overview

1.1 A generation case study

Step 1: generating the database access layer — Step 2: generating the user interface — Step 3: building the client interface — Step 4: building unit tests — Step 5: integrating a technical change — Step 6: integrating a design change — Step 7: building an RPC layer — Step 8: building documentation — Case study conclusions

1.2 Benefits of code generation for engineers1

1.3 Benefits of code generation for managers

1.4 The code generation process

Assessing the need — Laying down the infrastructure — Documenting it — Deploying it — Maintaining it

1.5 The buy/build decision

1.6 Code generation at its best

1.7 Top ten code-generation rules

1.8 Generators you are using today

1.9 Summary

Chapter 2 Code generation basics

2.1 The various forms of active code generation

Code munging — The inline-code expander — Mixed-code generation — Partial-class generation — Tier or layer generation — Full-domain language

2.2 Code generation workflow

Editing generated code

2.3 Code generation concerns

Nobody on my team will accept a generator — Engineers will ignore the ?do not edit? comments — If the generator can?t build it, the feature will take weeks to build

2.4 Code generation skills

Using text templates — Writing regular expressions — Parsing XML — File and directory handling — Command-line handling

2.5 Choosing a language for your code generator

Comparing code generator languages — Using Ruby to write code generators

2.6 Summary

Chapter 3 Code generation tools

3.1 Building generators with Ruby

3.2 Parsing XML with Rexml

Using Rexml

3.3 ERb: a great tool for templates

Installing and using ERb — ERb templates — Building ASP, JSP, etc. with ERb

3.4 Building the language parser toolkit

Inside the Tokenizers — Inside the LanguageScanners — Language parsing tools

3.5 Summary

Chapter 4 Building simple generators

4.1 The code munger generator type

Uses and example code — Developing the generator

4.2 The inline-code expansion generator model Uses and examples

Developing the generator

4.3 The mixed-code generator model

Uses and examples — Developing the generator

4.4 The partial-class generator mode

Uses and examples — Developing the generator

4.5 The tier generator model

Uses and examples — Developing the generator

4.6 Generating for various languages

C — C++ — C# — Java — Perl — SQL

4.7 Summary96

Part II Code generation solutions

Chapter 5 Generating user interfaces

5.1 The big picture

Why generate the user interface? — Integration with existing tools and other generators

5.2 Designing a good interface

5.3 Workflow comparison

5.4 A case study: generating JSP

Why generate JSPs? — The role of the generator — The high-level architecture — A table definition file — A form definition file — Processing flow — Designing the generator

5.5 Technique: generating Swing dialog boxes

Generator requirements — Architectural recommendation — Processing flow

5.6 Technique: generating MFC dialog boxes

Generator requirements — Recommended tier generator architecture — Processing flow — Recommended mixed-code generation architecture — Processing flow

5.7 Design tips

5.8 Tools for generating UIs

5.9 Summary

Chapter 6 Generating documentation

6.1 The importance of structured comments

6.2 The big picture

6.3 A case study: augmented SQL code

Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the SQL generator — Performing system tests

6.4 Understanding the JavaDoc and the Doclet API

6.5 Finding a tool to do it for you

6.6 Summary

Chapter 7 Generating unit tests

7.1 The big picture

7.2 Preparing for common concerns

Unit tests won?t be maintained — It?s too hard to make unit tests — Unit tests will limit our flexibility — The interface isn?t ready yet — Unit tests are not worth the time — Adding unit tests to a legacy system is painful — Unit tests can only prove the existence of errors

7.3 A case study: augmented C code

Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the unit test generator — Finding tools for test cases

7.4 Technique: the ordered test generator

Roles of the generator — Laying out the generator architecture — Processing flow

7.5 Technique: the test data generator

Roles of the generator — Laying out the generator architecture — Processing flow — Using the test data generator and the sequential test generator together

7.6 Technique: the test robot generator

Roles of the generator — Laying out the generator architecture — Processing flow — Generators for robots

7.7 Finding a tool to do it for you

7.8 Design tips

7.9 Summary

Chapter 8 Embedding SQL with generators

8.1 PerlSQL

8.2 Preparing for common concerns

We are creating a new language — Debugging will be a pain — With Perl you could do this within the language

8.3 Workflow comparison

8.4 A case study: PerlSQL

Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the PerlSQL generator — Performing system tests

8.5 Finding SQL tools

8.6 Summary

Chapter 9 Handling data

9.1 Code generation versus a library

9.2 A case study: a simple CSV-reading example

Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the CSV reader generator — Performing system tests

9.3 Technique: data adapters

Roles of the generator — Laying out the generator architecture — Processing flow

9.4 Technique: binary file reader/writer

Roles of the generator — Laying out the generator architecture — Implementation recommendations — Processing flow

9.5 Finding tools to do it for you

9.6 Summary

Chapter 10 Creating database access generators

10.1 Benefits of database access generators

10.2 The big picture

Terminology — Integration with existing tools — Working with other generators

10.3 Preparing for common concerns

The code is going to be out of control — I?m going to be the only one who knows what?s going on — Our application semantics aren?t well defined yet — This is going to take all the joy out of coding — The database design is too complex to be generated — The generated SQL SELECT statements will be rubbish — The up-front development cost is too high — I don?t have all of the prerequisite skills — The information here is centered around web applications; what about client/server? — My application doesn?t use a database

10.4 Workflow comparison

10.5 A case study: EJB generation

The architecture of the EJB database access layer — EJB options — The schema — Roles of the generator — Laying out the generator architecture — Processing flow — The schema definition — The extensions definition file — Sample data definition — Implementation — Performing system tests — J2EE developer resources — Generators for J2EE

10.6 Technique: generating JDBC

Roles of the generator — Laying out the generator architecture — Processing flow — JDBC developer resources

10.7 Technique: generating database access layers for ASP

Roles of the generator — Laying out the generator architecture — Processing flow — ASP developer resources

10.8 Technique: generating database access layers for ASP.NET

Roles of the generator — Recommended architecture — Laying out the generator architecture — Processing flow — ASP.NET developer resources — Generators for .NET

10.9 Technique: Generating database access classes for Perl DBI

Roles of the generator — Laying out the generator architecture — Processing flow — Perl/DBI developer resources

10.10 Technique: generating database access classes for PHP

Roles of the generator — Laying out the generator architecture — Processing flow — Generators for PHP — PHP developer resources

10.11 Off-the-shelf: AndroMDA

Roles of the generator — Laying out the generator architecture — Developer resources

10.12 Off-the-shelf: XDoclet

Roles of the generator — Laying out the generator architecture

10.13 Design tips

10.14 Finding a tool to do it for you

10.15 Summary

Chapter 11 Generating web services layers

11.1 The big picture

Providing security and authentication — Why not use a library?

11.2 A case study: generating XML-RPC for Java

The XML-RPC message flow — Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the XML-RPC generator — Performing system tests — XML-RPC resources

11.3 Technique: generating SOAP

Roles of the generator — Laying out the generator architecture — Processing flow — SOAP resources

11.4 Design tips

11.5 Finding a tool to do it for you

11.6 Summary

Chapter 12 Generating business logic

12.1 A case study: generating Java business equations

Roles of the generator — Laying out the generator architecture — Processing flow — Building the code for the equation generator — Performing system tests

12.2 A case study: the report logic and interface generator

Roles of the generator — Laying out the generator architecture — Processing flow — A report logic and interface generator alternative — Report logic generation tools

12.3 Summary

Chapter 13 More generator ideas

13.1 Technique: maintaining header files

Roles of the generator — Laying out the generator architecture — Processing flow — Processing flow

13.2 Technique: creating DLL wrappers

Roles of the generator — Laying out the generator architecture — Processing flow

13.3 Technique: creating wrappers for external languages

Roles of the generator — Laying out the generator architecture — Processing flow

13.4 Technique: creating firewall configurations

Roles of the generator — Laying out the generator architecture — Processing flow

13.5 Technique: creating lookup functions

Roles of the generator — Laying out the generator architecture — Processing flow

13.6 Technique: creating macro lookup tables

Feeding code to the generator — Roles of the generator — Laying out the generator architecture — Processing flow

13.7 Summary

appendix a A brief introduction to Ruby
appendix b The simple system test framework
appendix c EJBGen code and templates
appendix d Integrating code generation into your IDE
appendix e Simple templating
appendix f Patterns for regular expressions
index