Related Work

Generative Programming Good source for information on Generative Programming.

Bayfront Technologies This site is among several that show generation is real and commercial. The CAPE translator has been used to generate ROM code for various protocols (e.g., Digital Subscriber Line and fiber optic protocols), business applications for process models, general communications protocols (e.g., ethernet), etc. This is one of the best, most mature and most practical generation efforts. Two decades of building problem domains will do that. It is rumored that CAPE was used to bring a DSL chip to market in a stunningly short time, before any of the chip competitors could.

CAPE is based on the DRACO generation system. The site includes copious documentation, a demonstration of CAPE, and commercial information on the product. This is a good place to learn about what can be done with generation.

GenVoca and Related Work This approach to generation uses larger components than Draco or AOG. These components are conceptually slices across a set of related, coordinated classes and methods. These layers are assemble based on a "type equation" that specifies the layers and their ordering. Each layer encapsulates a set of constraints that make the classes and methods fit together within each individual layer and make sets of separate layers plug together and work in concert.

GenVoca is to Draco (or AOG) as a prefab house is to a custom designed house. GenVoca prunes the search space by eliminating some design variations so that sets of layers can plug together. This is a reasonable approach for many domains where the price of efficiency loss is not high and the need for high levels of customization is not great.

Semantic Designs This work shows the power of reusing generative knowledge in the form of source-to-source program transformations and metaprograms across a broad spectrum of software engineering. The foundation of the work is a commercial, scalable program transformation system called the DMS Software Reengineering Toolkit. The scaling is along a number of axes, including compound notational systems operating at multiple levels of abstraction ("the Draco paradigm"), procedural escapes, highly tuned infrastructure (cache-aligned nodes) and parallel implementation on SMP systems using an in-house language, PARLANSE^TM, enabling the handling of million-line applications.

Commercial applications of DMS include code analysis (clone detection and test coverage tools, detection of dead code), code generation (mapping a factory control DSL into "Ladder Logic", using a strong propositional code optimizer), modification (preprocessor simplification) and large-scale porting (translation of JOVIAL to C). Future applications are intended to include problem-domain oriented reverse engineering by abstraction with human guidance. An interesting property of DMS is that much of it is constructed using itself and the various methods listed above.

SciComp SciComp's tools generate code from systems of equations using finite
difference, Monte Carlo, and similar methods. This technology is related to AOG in several ways. First via the DSLs. SciComp's equation-based DSL and AOG's Image Algebra both share the benefits of mathematical equation languages. Specifically, the equations can be easily manipulated (e.g., for the purpose of optimization) without the difficulties introduced by operational constructs such as programming control structures. Secondly, both systems generate optimized control structures -- AOG by algorithmically assembling and merging the control elements introduced by individual DSL operators and operands, SciComp's system by merging equations into a network of algorithm templates (chosen from alternative algorithms appropriate to the domain) and then custom designing data structures and applying optimizing operator and control structure transformations.

SciComp's system has applicability to a rich set of problem domains (such as various types of wave modeling). A commercial version of the system, SciFinance^TM, is used by investment banks to automatically generate a wide variety of codes for pricing derivative securities.

Kids and Kestrel Logistics Scheduler This work started with the Kids generator which was used to generate highly optimized search algorithms by using deep domain knowledge. It eventually evolved into systems for synthesizing highly optimized logistics schedulers that also use deep knowledge of the domain of logistics and scheduling. This is an example of where the "time to market" is reduced orders of magnitude via generation and in addition, the schedules produced by the schedule generator are better than human produced schedules by two orders of magnitude. See Smith for documents.

Domain Knowledge is King. Or alternatively, its the domain, stupid. If any more proof were really needed, these efforts say it AGAIN --

Domain knowledge is orders of magnitude more important than the programming languages, development systems and yes, even the human programmer -- IF ONE HAS THE DOMAIN KNOWLEDGE CODIFIED INTO A GENERATOR.

With conventional programming languages (e.g., Java, C#, C, etc.), nothing has ever been more important than the skill and knowledge of the human programmer. But with a domain specific (DS) generation system that is mature and really exploits the domain knowledge, this is no longer true. Unfortunately, such DS knowledge takes many years to acquire and formalize, which is why there are so few examples on this list.

Related Technologies

Stratego This is a domain-specific language for the specification of program transformation systems. It contains a mechanism for specification of patterns, rewrite rules, and strategies. It is interesting in that it separates the specification of strategies -- methods for traversing an AST and applying the rules -- from the specification of rules themselves. Stratego also supports the definition of generic traversal schemas such as topdown and bottomup starting from basic traversal combinators such as all and one. Traversal schemas are used in the building of strategies. These Stratego strategies call specific rules or other strategies to achieve their translation goals.

Aspect Oriented Programming (AOP) This work focuses on allowing specifications of separate "aspects" of a program. These aspects are, in a sense, orthogonal to the operational code of the target system but yet in the end are distributed throughout the target code. The notion is to isolate or separate the conceptually distinct aspects in the specification of the program even though they must eventually be woven (integrated) into the fabric of the operational code of the program. Even though the AOP technology is different from AOG in terms of languages, technologies and mechanisms, at some high level of conceptualization they have similar goals -- factoring the specification into more understandable pieces and generating operating programs from compositions of those pieces.

Reuse and Software Engineering Sites

	Reuse News Good source for information on the reuse, generation, and related material. Many links to reuse and generator oriented sites.
	Software Engineering Notes
	SEWorld
	IEEE Software Magazine

Conferences of Interest

International Conference on Software Reuse (ICSR)

Workshop on Generative Programming 2002 (GP2002)

Generative and Component-based Software Engineering (GCSE)

Generators and Components (GCSE/SAIG'02, GCSE'01)

Workshop on Institutionalization of Reuse (WISR)

Symposium on Software Reusability (SSR1999, SSR2001)

Automated Software Engineering (ASE)

International Conference on Software Engineering (ICSE)

International Conference on Software Maintenance (ICSM)