<< back to topics

Agile Model Based Software Engineering

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

Agility and modeling in the same project? Today, too many developers and project managers think that the use of models in software development leads to a heavy-weight, tedious development process. They believe that sooner or later, the models are usually outdated, are not being co-evolved, are buggy and no longer helpful. On the contrary, 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.

One of our research hypotheses was initiated in [Rum04c] and can be phrased like this: "Using an executable, yet abstract and multi-view modeling language for modeling, designing and programming still allows to use an agile development process."

The figure below illustrates that one or more domain specific modeling languages (DSML) are used as a central notation in the development process. DSMLs or the UML serve as a central notation for the software development. A DSML can be used for programming, testing and modeling.

We found that modeling will be used in development projects much more, when the 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 interesting

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 the UML language, but also identified a number of challenges. We therefore started our research agenda to solve these challenges in order to make MBSE truly successful in the 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.

In [Rum03] we discussed how modeling of tests helps to increase reuse and efficiency. In [GKR+06b], for example, we concentrate on the integration of models and ordinary programming code.

Cover of book 1 Cover of
book 2 Cover of book 1 English Cover of book 2 English

In [Rum12], [Rum11], [Rum16], and [Rum17] (online versions available here), 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.

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, can be found in [Rum12], [Rum11], [Rum17], and [Rum16]. Forms of language integration, e.g., using object diagrams in the OCL to describe desired or unwanted object structures, are presented there as well.

In the last decade, we implemented a language workbench called MontiCore which is initially described in [GKR+06a]. On top of that, we realized most of the language components of the UML/P in [Sch12]. This includes a precise definition of the textual languages, type checks, checks for other context conditions within and between UML sub-languages and a framework for the implementation of code generators.

Specific Concepts assisting Agile Development

Agile development processes require quite a lot of specific activities, techniques and concepts. Links to further research can be found below. Some of this research, e.g., includes a general discussion of how to manage and evolve models [LRS+10] or a precise definition for model composition as well as model languages [HKR+09]. Compositionality is particularly important and must be designed carefully as it allows the tools to analyze and generate incrementally, thus being much more agile than today's modeling tools. We also discussed in detail what refactoring means and how refactoring looks like in the various modeling and programming languages [PR03]. The UML/P is implemented in such a way that models can be specified free of redundancies even in 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. [KRV06] discusses the additional roles and activities necessary in a DSL-based software development project.

We assume that the use of models at runtime will become a pretty agile and efficient development technique. It allows developers to delay 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 adaptivity.


Summary:

  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, such 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.

Further Topics:


Selected(!) Publications:



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