<< back to topics

Generative Software Engineering

A selection of papers from Bernhard Rumpe and the Software Engineering Group


In "Agile Model Based Software Engineering" we clarify that generating software is an important capability for a tooling infrastructure that successfully assists modeling in the development process. We believe that modeling will only become an integral part of the process in many industrial projects, if automatic derivation of executable code and smooth integration with handwritten code is a standard feature of its tooling.

We therefore examined various aspects of generation. E.g. in [Rum12], [Rum11], [Rum16], and [Rum17] we define the language family UML/P (a simplified 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.


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

Our architectural analysis and design language (AADL) MontiArc is also based on this generation technology. As described in [HRR12] it can be used for the Cloud as well as Cyber Physical Systems, such as cars or robotics.

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 are able to 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 sublanguages and DSMLs.

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.

Further Topics:


Selected(!) Publications:



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