Agile Model-Based Software Engineering

Summary of Most Relevant Topic Papers

Today, many developers and project managers assume that the use of models in software development leads to heavy-weight, tedious development processes. On the one hand, they believe that sooner or later, models are outdated, are not being co-evolved with software changes, contain bugs, and are no longer helpful. On the other hand, agility means to concentrate on the program as a core artifact without much extra documentation. Agility enables efficient evolution, correction and extension. As such, it seems to conflict with modeling.

We believe, and have shown, that using an executable, abstract and multi-view modeling language for modeling, designing, and programming still allows to use an agile development process (see the research hypotheses in [Rum04c]). Such modeling languages, often consisting of one or more DSLs, are used as a central notation in the development process. DSLs or the UML serve as a central notation for software development. A DSL can be used for programming, testing, modeling, analysis, transformation and documentation.

We found that modeling will be used in development projects much more, when its benefits become evident early. This means constructive generation or synthesis of code from the models needs to be among the first steps of a model-based development process. All other interesting techniques, such as test synthesis or high level analysis techniques seem to come second. As a consequence, executability of modeling languages is a desired feature.

Execution of UML and DSLs

The question, whether UML should be executable, is discussed in [Rum02]. We found this a promising approach for larger subsets of UML, but also identified a number of challenges. We therefore started our research agenda to solve these challenges in order to make model-based software engineering (MBSE) truly successful when employed for agile software development. We explored in detail, how UML fits for that purpose. Not only the deficiencies of existing UML tools but also the UML language itself need to be adapted to fit the needs of an agile software development process, e.g., in [Rum03] we discuss how modeling of tests helps to increase reuse and efficiency and in [GKR+06] the integration of models and ordinary programming code.


Moreover, in [Rum12], [Rum11], [Rum16], and [Rum17], which are also online available, the UML/P, a variant of the UML especially designed for programming, refactoring and evolution, is defined. The UML/P embodies class, object, sequence diagrams, Statecharts, and OCL in combination with Java to model code as well as tests as sketched in the following figure. Moreover, these publications include a detailed discussions on how to use the UML/P for code generation, testing and on how to refactor structural models such as class diagrams, as well as behavioral models such as Statecharts. Additionally, forms of language integration, e.g., using object diagrams within OCL to describe desired or unwanted object structures, are presented there as well.

In the last decade, we implemented a language workbench called MontiCore (see MontiCore - Language Workbench for DSLs) that was first described in [GKR+06] and [GKR+08]. The MontiCore handbook [HKR21] explains technical details as well as the principal guidelines for its use and also offers a core layer of reusable language components. On top of MontiCore, we realized most of the language components of the UML/P [Sch12]. This work includes a precise definition of textual languages, type checks, checks for context conditions within and between UML sub-languages and a framework for the implementation of code generators.

MontiCore also serves as demonstration tool of the annual Software Language Engineering course at RWTH and serves as basis for the mechanisms to teach agile modeling adressed in [RRSW17].

Specific Concepts Assisting Agile Development

Agile development processes require quite a lot of specific activities, techniques and concepts. Our research includes a general discussion of how to manage and evolve models [LRSS10] and a precise definition for model and modeling language composition [HKR+09]. Compositionality is particularly important and must be designed carefully as it allows for incremental analyses and code generation, thus being much more agile than today’s modeling tools. We also discussed in detail what refactoring means and how it looks like in various modeling and programming languages [PR03]. UML/P is implemented to support modeling without redundancies even on different levels of abstraction, which enhances refactoring and evolution techniques on models. To better understand the effect of an evolved design, we discuss the need for semantic differencing in [MRR10].

When models are the central notation, model quality becomes an important issue. Therefore, we have described a set of general requirements for model quality in [FHR08]. We distinguished between internal and external quality. External quality refers to the correctness and completeness of a model with respect to the original that it describes, while internal quality refers to the model presentation and thus plays the same role as coding guidelines for programming languages.

We also know that, even when using the UML/P, there is additional effort necessary to adapt the tooling infrastructure to the project specific needs. This becomes more pressing, when a domain specific language is specifically designed for a project. We discuss the additional roles and activities necessary in a DSL-based software development project in [KRV06]. However, it may be that not all of the participants in a project need to be physically at the same place and fully available anymore [JWCR18].

We expect that the use of models at runtime will soon become an agile and efficient development technique. It allows developers to defer design decisions to runtime adaptation and configuration of systems. However, reliability then becomes an issue. In [CEG+14] we have therefore discussed how to improve reliability while retaining adaptability. In [KMA+16] we have also introduced a classification of forms of reuse of modelled software components.

Key Statements

  1. Model-based development becomes interesting, when the model language is the central notation and thus replacing the programming language.
  2. Tooling for MBSE must include code and test generation as well as type and context condition checking already on models. These techniques must be quick and thus modular and incremental.
  3. Agile concepts, especially as refactoring, evolution, and automatic testing can be established with UML/P.
  4. Executable UML/P is an extension of UML with Java, implemented using the MontiCore language workbench.

Selected Topic-Specific Publications

  1. [HKR21]
    K. Hölldobler, O. Kautz, B. Rumpe:
    MontiCore Language Workbench and Library Handbook: Edition 2021.
    Aachener Informatik-Berichte, Software Engineering, Band 48, ISBN 978-3-8440-8010-0, Shaker Verlag, May 2021.
  2. [JWCR18]
    R. Jolak, A. Wortmann, M. Chaudron, B. Rumpe:
    Does Distance Still Matter? Revisiting Collaborative Distributed Software Design.
    In: IEEE Software Journal, Volume 35(6), pp. 40-47, 2018.
  3. [RRSW17]
    J. O. Ringert, B. Rumpe, C. Schulze, A. Wortmann:
    Teaching Agile Model-Driven Engineering for Cyber-Physical Systems.
    In: International Conference on Software Engineering: Software Engineering and Education Track (ICSE’17), pp. 127-136, IEEE, May 2017.
  4. [Rum17]
    B. Rumpe:
    Agile Modeling with UML: Code Generation, Testing, Refactoring.
    Springer International, May 2017.
  5. [Rum16]
    B. Rumpe:
    Modeling with UML: Language, Concepts, Methods.
    Springer International, Jul. 2016.
  6. [KMA+16]
    J. Kienzle, G. Mussbacher, O. Alam, M. Schöttle, N. Belloir, P. Collet, B. Combemale, J. Deantoni, J. Klein, B. Rumpe:
    VCU: The Three Dimensions of Reuse.
    In: Conference on Software Reuse (ICSR’16), Volume 9679, pp. 122-137, LNCS, Springer, Jun. 2016.
  7. [CEG+14]
    B. H. Cheng, K. I. Eder, M. Gogolla, L. Grunske, M. Litoiu, H. A. Müller, P. Pelliccione, A. Perini, N. A. Qureshi, B. Rumpe, D. Schneider, F. Trollmann, N. M. Villegas:
    Using Models at Runtime to Address Assurance for Self-Adaptive Systems.
    In: Models@run.time, N. Bencomo, R. France, B. H. Cheng, U. Aßmann (Eds.), pp. 101-136, LNCS 8378, ISBN 978-3-319-08914-0, Springer International Publishing, Switzerland, 2014.
  9. [Sch12]
    M. Schindler:
    Eine Werkzeuginfrastruktur zur agilen Entwicklung mit der UML/P.
    Aachener Informatik-Berichte, Software Engineering, Band 11, ISBN 978-3-8440-0864-7, Shaker Verlag, 2012.
  10. [Rum11]
    B. Rumpe:
    Modellierung mit UML, 2te Auflage.
    Springer Berlin, Sep. 2011.
  11. [LRSS10]
    T. Levendovszky, B. Rumpe, B. Schätz, J. Sprinkle:
    Model Evolution and Management.
    In: Model-Based Engineering of Embedded Real-Time Systems Workshop (MBEERTS’10), pp. 241-270, LNCS 6100, Springer, 2010.
  12. [MRR10]
    S. Maoz, J. O. Ringert, B. Rumpe:
    A Manifesto for Semantic Model Differencing.
    In: Proceedings Int. Workshop on Models and Evolution (ME’10), pp. 194-203, LNCS 6627, Springer, 2010.
  13. [HKR+09]
    C. Herrmann, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    Scaling-Up Model-Based-Development for Large Heterogeneous Systems with Compositional Modeling.
    In: Conference on Software Engineeering in Research and Practice (SERP’09), pp. 172-176, Jul. 2009.
  14. [FHR08]
    F. Fieber, M. Huhn, B. Rumpe:
    Modellqualität als Indikator für Softwarequalität: eine Taxonomie.
    In: Informatik-Spektrum, Band 31(5), pp. 408-424, Oktober. 2008.
  15. [GKR+08]
    H. Grönniger, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    MontiCore: A Framework for the Development of Textual Domain Specific Languages.
    In: 30th International Conference on Software Engineering (ICSE 2008), Leipzig, Germany, May 10-18, 2008, Companion Volume, pp. 925-926, 2008.
  16. [GKR+06]
    H. Grönniger, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    MontiCore 1.0: Ein Framework zur Erstellung und Verarbeitung domänspezifischer Sprachen.
    CFG-Fakultät, TU Braunschweig, 2006-04, Informatik-Bericht, Aug. 2006.
  17. [KRV06]
    H. Krahn, B. Rumpe, S. Völkel:
    Roles in Software Development using Domain Specific Modelling Languages.
    In: Domain-Specific Modeling Workshop (DSM’06), pp. 150-158, Technical Report TR-37, Jyväskylä University, Finland, 2006.
  18. [Rum04c]
    B. Rumpe:
    Agile Modeling with the UML.
    In: Workshop on Radical Innovations of Software and Systems Engineering in the Future (RISSEF’02), pp. 297-309, LNCS 2941, Springer, Oct. 2004.
  19. [Rum03]
    B. Rumpe:
    Model-Based Testing of Object-Oriented Systems.
    In: Symposium on Formal Methods for Components and Objects (FMCO’02), pp. 380-402, LNCS 2852, Springer, Nov. 2003.
  20. [PR03]
    J. Philipps, B. Rumpe:
    Refactoring of Programs and Specifications.
    In: Practical Foundations of Business and System Specifications, Kilov, H. and Baclavski, K. (Eds.), pp. 281-297, Kluwer Academic Publishers, 2003.
  21. [Rum02]
    B. Rumpe:
    Executable Modeling with UML - A Vision or a Nightmare?.
    In: Issues & Trends of Information Technology Management in Contemporary Associations, Seattle, T. Clark, J. Warmer (Eds.), pp. 697-701, Idea Group Publishing, London, 2002.