Generative and component approaches have the potential to revolutionize software development in a similar way as automation and components revolutionized manufacturing. Generative Programming (developing programs that synthesize other programs), Component Engineering (raising the level of modularization and analysis in application design), and Domain-Specific Languages (elevating program specifications to compact domain-specific notations that are easier to write and maintain) are key technologies for automating program development.
GPCE arose as a joint conference, merging the prior conference on Generative and Component-Based Software Engineering (GCSE) and the Workshop on Semantics, Applications, and Implementation of Program Generation (SAIG). The goal of GPCE is to provide a meeting place for researchers and practitioners interested in cutting edge approaches to software development. The conference aims to foster further cross-fertilization between the software engineering research community on the one hand, and the programming languages community on the other, in addition to supporting the original research goals of both the GCSE and the SAIG communities.
This special issue features a selection of the best papers of the 2004 and 2005 editions of the conference, which appeared as Volumes 3286 and 3676 of Lectures Notes in Computer Science published by Springer-Verlag. Out of the 52 papers presented at the two conferences, the authors of 10 papers were invited to submit a revised article for this special issue. Of these submissions four articles were eventually selected for publication.
In Multi-stage Programming with Functors and Monads, Jacques Carette and Oleg Kiselyov use MetaOCaml's safe code generation features to generically define a family of Gaussian elimination algorithms and use OCaml's advanced module system to modularize generators and ensure compositionality of aspects.
In Statically Safe Program Generation with SafeGen, Shan Shan Huang, David Zook, and Yannis Smaragdakis present the SafeGen meta-programming language for writing statically safe generators of Java programs. A SafeGen generator program that passes the static semantic checks is guaranteed to generate only well-formed Java programs. SafeGen combines traditional type checking with calls to a theorem prover to check well-formedness properties of generators.
In A Type System for Reflective Program Generators, Christof Lutteroth, Dirk Draheim, and Gerald Weber present the Genoupe language, which integrates code generation features into the C# language. Programmers can use compile-time reflection to instantiate generator-level code blocks in their C# program. The Genoupe compiler checks generators and guarantees they produce compilable code.
In A Language for Generic Programming in the Large, Jeremy Siek and Andrew Lumsdaine present the design and implementation of G, a programming language with concepts for organizing constraints on generics. The language has been designed to enable modular type checking and separate compilation in order to enable short development cycles, even with large libraries. The design is illustrated with implementations of the C++ Standard Template Library and Boost Graph Library.