Generative Software Engineering

Summary of Most Relevant Topic Papers

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.

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 therefore examined various aspects of generation. For instance, in [Rum12] [Rum11] [Rum16] [Rum17] (see also MBSE website) we define the language family UML/P (a simplified and semantically sound derivative of the UML) which is designed specifically for product and test code generation from class diagrams, object diagrams, statechart and sequence diagrams as shown in this figure:

We developed several generators, e.g., a flexible, modular and reusable generator for the UML/P [Sch12], a generator for generating simulation components out of the architectural analysis and design language MontiArc [Hab16] (used for the cloud as well as cyber-physical systems (CPS), such as cars or robotics [HRR12], see MontiArc) or the generator MontiGem [AMN+20a] for enterprise information systems or assistive systems. All of them are based on the MontiCore language workbench [KRV10] [GKR+06] [GKR+08] [HKR21]. 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 sub-languages and generation techniques in various applied 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).

Working with generated and handwritten code leads to challenges related with continuous repetitive generation (the generation gap problem). In [GKR+06] [GHK+15] [GHK+15a] 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 [Wei12] [HRW15] [Hoe18]. 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 DSLs [HHR+15] [AHRW17] [Hoe18] (see Evolution & Transformation of Models).

[HNRW16] presents how to generate extensible and statically type-safe visitors fitting to the abstract syntax (meta-model) of a language. Both abstract syntax classes and visitor infrastructure are now fully generated from MontiCore. In [NRR16], we discuss the use of symbols for ensuring the validity of composed models and therefore also of finally generated source code. [GMR+16] discusses product lines of template-based code generators introducing variability into the generation process. Integrating all these findings, we propose a compositional approach for engineering reusable language components in [HLN+15] and [HLN+15a], which is meanwhile also fully integrated into MontiCore.

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].

Key Statements

  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.

Selected Topic-Specific Publications

  1. [HKR21]
    K. Hölldobler, O. Kautz, B. Rumpe:
    Aachener Informatik-Berichte, Software Engineering, Band 48, ISBN 978-3-8440-8010-0, Shaker Verlag, May 2021.
  2. [AMN+20a]
    K. Adam, J. Michael, L. Netz, B. Rumpe, S. Varga:
    In: 40 Years EMISA: Digital Ecosystems of the Future: Methodology, Techniques and Applications (EMISA’19), Volume P-304, pp. 59-66, LNI, Gesellschaft für Informatik e.V., May 2020.
  3. [Hoe18]
    K. Hölldobler:
    Aachener Informatik-Berichte, Software Engineering, Band 36, ISBN 978-3-8440-6322-6, Shaker Verlag, Dec. 2018.
  4. [Rum17]
    B. Rumpe:
    Springer International, May 2017.
  5. [AHRW17]
    K. Adam, K. Hölldobler, B. Rumpe, A. Wortmann:
    In: International Conference on Robotic Computing (IRC’17), pp. 172-179, IEEE, Apr. 2017.
  6. [Hab16]
    A. Haber:
    Aachener Informatik-Berichte, Software Engineering, Band 24, Shaker Verlag, Sep. 2016.
  7. [HNRW16]
    R. Heim, P. Mir Seyed Nazari, B. Rumpe, A. Wortmann:
    In: Conference on Modelling Foundations and Applications (ECMFA), pp. 67-82, LNCS 9764, Springer, Jul. 2016.
  8. [Rum16]
    B. Rumpe:
    Springer International, Jul. 2016.
  9. [GMR+16]
    T. Greifenberg, K. Müller, A. Roth, B. Rumpe, C. Schulze, A. Wortmann:
    In: Modellierung 2016 Conference, Volume 254, pp. 141-156, LNI, Bonner Köllen Verlag, Mar. 2016.
  10. [NRR16]
    P. Mir Seyed Nazari, A. Roth, B. Rumpe:
    In: Modellierung 2016 Conference, Volume 254, pp. 133-140, LNI, Bonner Köllen Verlag, Mar. 2016.
  11. [HLN+15a]
    A. Haber, M. Look, P. Mir Seyed Nazari, A. Navarro Perez, B. Rumpe, S. Völkel, A. Wortmann:
    In: Model-Driven Engineering and Software Development, Volume 580, pp. 45-66, Communications in Computer and Information Science, Springer, 2015.
  12. [GHK+15a]
    T. Greifenberg, K. Hölldobler, C. Kolassa, M. Look, P. Mir Seyed Nazari, K. Müller, A. Navarro Perez, D. Plotnikov, D. Reiß, A. Roth, B. Rumpe, M. Schindler, A. Wortmann:
    In: Model-Driven Engineering and Software Development, Volume 580, pp. 112-132, Communications in Computer and Information Science, Springer, 2015.
  13. [HRW15]
    K. Hölldobler, B. Rumpe, I. Weisemöller:
    In: Conference on Model Driven Engineering Languages and Systems (MODELS’15), pp. 136-145, ACM/IEEE, 2015.
  14. [HHR+15]
    L. Hermerschmidt, K. Hölldobler, B. Rumpe, A. Wortmann:
    In: Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp’15), Volume 1463, pp. 18-23, CEUR Workshop Proceedings, 2015.
  15. [HLN+15]
    A. Haber, M. Look, P. Mir Seyed Nazari, A. Navarro Perez, B. Rumpe, S. Völkel, A. Wortmann:
    In: Model-Driven Engineering and Software Development Conference (MODELSWARD’15), pp. 19-31, SciTePress, 2015.
  16. [GHK+15]
    T. Greifenberg, K. Hölldobler, C. Kolassa, M. Look, P. Mir Seyed Nazari, K. Müller, A. Navarro Perez, D. Plotnikov, D. Reiß, A. Roth, B. Rumpe, M. Schindler, A. Wortmann:
    In: Model-Driven Engineering and Software Development Conference (MODELSWARD’15), pp. 74-85, SciTePress, 2015.
  17. [HRR12]
    A. Haber, J. O. Ringert, B. Rumpe:
    RWTH Aachen University, AIB-2012-03, Technical Report, Feb. 2012.
  18. [Wei12]
    I. Weisemöller:
    Aachener Informatik-Berichte, Software Engineering, Band 12, ISBN 978-3-8440-1191-3, Shaker Verlag, 2012.
  19. [Sch12]
    M. Schindler:
    Aachener Informatik-Berichte, Software Engineering, Band 11, ISBN 978-3-8440-0864-7, Shaker Verlag, 2012.
  20. [Rum11]
    B. Rumpe:
    Springer Berlin, Sep. 2011.
  21. [KRV10]
    H. Krahn, B. Rumpe, S. Völkel:
    In: International Journal on Software Tools for Technology Transfer (STTT), Volume 12(5), pp. 353-372, Springer, Sep. 2010.
  22. [GKR+08]
    H. Grönniger, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    In: 30th International Conference on Software Engineering (ICSE 2008), Leipzig, Germany, May 10-18, 2008, Companion Volume, pp. 925-926, 2008.
  23. [GKR+06]
    H. Grönniger, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    CFG-Fakultät, TU Braunschweig, 2006-04, Informatik-Bericht, Aug. 2006.
  24. [KRV06]
    H. Krahn, B. Rumpe, S. Völkel:
    In: Domain-Specific Modeling Workshop (DSM’06), pp. 150-158, Technical Report TR-37, Jyväskylä University, Finland, 2006.
  25. [Rum04c]
    B. Rumpe:
    In: Workshop on Radical Innovations of Software and Systems Engineering in the Future (RISSEF’02), pp. 297-309, LNCS 2941, Springer, Oct. 2004.
  26. [Rum03]
    B. Rumpe:
    In: Symposium on Formal Methods for Components and Objects (FMCO’02), pp. 380-402, LNCS 2852, Springer, Nov. 2003.
  27. [Rum02]
    B. Rumpe:
    In: Issues & Trends of Information Technology Management in Contemporary Associations, Seattle, T. Clark, J. Warmer (Eds.), pp. 697-701, Idea Group Publishing, London, 2002.