On the Power of Models

Unclear requirements are still the top reason why IT projects fail.

Thus, even if the implementation and verification of requirements are optimized, using techniques such as Mutation Testing [1], Metamorphic Testing [2] or optimized test case definitions [3] that have already been discussed in previous articles on this blog, the following challenges lead to inefficiencies in or even discontinuance of IT projects. Usually, this challenge is due to the following three barriers of creating requirements:

1. Natural language is usually too imprecise to be automatically mapped to software code
2. Technical language is usually too complex for stakeholders to understand
3. Changes in requirements lead to inconsistencies between different requirements

To overcome these barriers, models are used more and more in practice to provide a bridge between natural and technical language. The formal description of requirements used to create models also helps finding inconsistencies and leverage automation.

In this article, we give a basic introduction to what models are, the power of models in every software project, and how this power can be leveraged in practice by integrating models with software code.

What is a model?

In its very basic form, a model is “a simplification of reality”. In software engineering, models are usually used to formally describe particular aspects of a system in a machine-readable manner.

Such models are usually created via modelling tools, such as Genmymodel [4] or Enterprise Architect [5]. The visual interface of such tools allow the user-friendly definition of common concepts. Machine-readable models are then automatically derived based on these visually created concepts. The formalization of models, using modelling languages such as UML [6] or SysML [7], allows a uniformed interpretation of models and increased efficiency during creation, by reusing modelling concepts whose syntax and semantics are predefined by the corresponding language.

The power of models

The visual interface of modelling tools, combined with the formalisms required by modelling languages, allow to tackle common bridges of defining requirements in the following way:

1. Modelled aspects can be easily and correctly transferred to code by developers.
2. They can be easily understood and discussed, also by non-techs, using visual representations
3. Inconsistencies that arise over time (e.g. due to changing requirements) can be easily and automatically detected by regularly running consistency rules on created models (such rules are usually predefined for various modelling languages, and supported by most modern modelling tools).

However, the real power of models is unleashed when persisting them in a machine-readable format, such as XMI (a standard for xml-based files containing models), and reusing them to leverage automation across the whole software development cycle. Some advantages and application scenarios are highlighted in the next section of this article.

Integration of models and software code

As mentioned previously, most of the power (and benefit) of models lies in the automation potential that can be achieved when integrating the requirements that are formalized in models in a machine-readable way with code that is used to implement particular software.

There are several approaches to achieve this, using different levels of compability and potential for automation:

• Independent evolution of models and code: By developing and maintaining models in parallel to software code, automation can be achieved by e.g. creating code from model representations, or deriving models from code to automatically visualize complex behaviour or execution traces. However, the consistency between models and code after adaptations of either a model or a code fragment must be ensured in order to have a valid mapping between models and code [8].
• Low-Code software development: In so-called low-code development platforms, such as GenerativeObjects [9] or Domino Volt [10], models are derived from visually defined workflows and used to create whole applications from them. No need to worry about the correct implementation of any of these aspects. The creation of applications is enabled by mapping visual elements to existing code blocks that are defined using General-Purpose Languages [11], or Domain-Specific Languages [12] that are explicitly developed for a particular low-code use case.
• No-Code software development: companies and tools, such as salesforce [13], scratch [16], appsheet [14], or bubble [15] promote the development of different kinds of software applications without the need of a single line of code (so-called no-code software development). The main advantage is usually listed as allowing anyone to create powerful software. Although the boundaries between low-code and no-code are a bit blurred, no-code is usually associated with the development of general-purpose applications with a large focus on user interfaces, whereas low-code is associated with automation of traditional development processes, while still providing a large degree of customization for developers [17].
• Digital Twins (DTs): The model-based creation and definition of so-called Digital Twins [18] allows to even go one step further than no-code, by (i) backpassing information from the running system to the development cycle, as well as (ii) sending models, e.g. from simulation or machine learning experiments, to the running software system. This usage opens the stage for a seemingly unlimited area of applications.