<< back to topics

Generative Software Engineering

Summary of Selected Papers

In Agile Model-Based Software Engineering, we clarify that generating software is crucial to successfully integrated modeling in development processed. Modeling will only become an integral to industrial software engineering, if automated derivation of executable code and smooth integration with handwritten code become commonplace.

We therefore examined various aspects of code generation. For instance, in [Rum12], [Rum11], [Rum16], and [Rum17] we define the language family UML/P (a reduced and semantically sound derivate of the UML) which is designed specifically for product and test code generation from class diagrams, object diagrams, Statecharts, and sequence diagrams as shown in the following figure.

In [Sch12], we developed a flexible, modular and reusable code generator for the UML/P based on the MontiCore language workbench ([KRV10], [GKR+06a]). With MontiCore, we can easily define extensions of languages as well as new language combinations. Thus, we can reuse the defined UML/P sublanguages and generation techniques in various projects.

Our architectural analysis and design language MontiArc is also based on this generation technology. As described in [HRR12] it can be used for the cloud systems, as well as cyber-physical systems, such as cars or robotics. MontiArc also has been applied to various projects.

Tooling and especially generators will only be successful in practical projects, if they have an appropriate impact on the development process, i.e., development processes need to be adapted or completely reshaped according to the availability of a generator. In [KRV06], we discuss additional roles necessary in a model-based software development project (while other roles either vanish or their workload can greatly be reduced).

The generation gap problem is addressed in [GKR+06b]. There, we discuss mechanisms to keep generated and handwritten code separated, while integrating them in the product and enabling the repetitive generation (which is much more valuable than one-shot generation).

For various purposes, including preparation of a model for generation, it is helpful to define model transformations. We can create transformation languages in concrete syntax, that reuse the underlying language concepts. In [Wei12] we show how this looks like. Even more important we describe how to systematically derive a transformation language in concrete syntax. Since then we have applied this technique successfully for several UML sub-languages and domain-specific languages.

Sometimes executability can be a disadvantageous characteristics for a modeling language, especially when people start modeling concrete algorithms instead of abstract properties. We therefore discuss needs and advantages of executable modeling with UML in agile projects in [Rum04c], how to apply UML for testing in [Rum03] as well as the advantages and perils of using modeling languages for programming in [Rum02].


Summary

  1. Generation of code and tests is a core capability for model-based software engineering (MBSE).
  2. Generators depend on the source modeling language, a precise clarification of semantic variants and the target infrastructure, including frameworks that are generated against.
  3. A generator consists of a transformation engine (model source to code) and a runtime environment.
  4. A domain specific generator can add a high amount of functionality to the target that was not "modeled" in the source.
  5. Agile projects require generators to be incremental, compositional and therefore quick. Thus, big monolithic tools (storing all in one model) cannot be used in agile projects.
  6. The MontiCore language workbench provides infrastructure for generative software development.

Related Topics


Selected Related Publications



<< list of all topics list of all publications >>