The comparison of versions and variants of models is a well-known challenge in model-driven software engineering. In the context of low-code platforms, models are rarely text-only and the modelers are not necessarily familiar with programming. Therefore, presenting the comparison results in an understandable way and on a suitable level of abstraction is a challenging problem vital, e.g., for enabling asynchronous collaborative low-code development. This paper describes an approach for calculating and displaying differences between versions or variants of models in A12, a low-code platform for enterprise applications that employs different types of models to represent data and its presentation. The differencing infrastructure is built of reusable modules to avoid redundancies of its commonalities across different A12 model types. Despite that, it can be applied for calculating and displaying differences of data conforming to models in low-code applications. The approach has been developed for A12, but the concepts behind it are supposed to be transferable to other low-code platforms.

AbstractThe usage of models within model-driven software development aims at facilitating complexity management of the system under development and closing the gap between the problem and the solution domain. Utilizing model-driven software development (MDD) tools for agile development can also increase the complexity within a project. The huge number of different artifacts and relations, their different kinds, and the high degree of automation hinder the understanding, maintenance, and evolution within MDD projects. A systematic approach to understand and manage MDD projects with a focus on its artifacts and corresponding relations is necessary to handle the complexity. The artifact-based analysis presented in this paper is such an approach. This paper gives an overview of different contributions of the artifact-based analysis but focuses on a specific kind of analysis: architecture consistency checking of model-driven development projects. By applying this kind of analyses, differences between the desired architecture and the actual architecture of the project at a specific point in time can be revealed.

Efficient testing is a crucial prerequisite to engineer reliable automotive software successfully. However, manually deriving test cases from ambiguous textual requirements is costly and error‐prone. Model‐based software engineering captures requirements in structured, comprehensible, and formal models, which enables early consistency checking and verification. Moreover, these models serve as an indispensable basis for automated test case derivation. To facilitate automated test case derivation for automotive software engineering, we conducted a survey with testing experts of the BMW Group and conceived a method to extend the BMW Group's specification method for requirements, design, and test methodology by model‐based test case derivation. Our method is realized for a variant of systems modeling language activity diagrams tailored toward testing automotive software and a model transformation to derive executable test cases. Hereby, we can address many of the surveyed practitioners' challenges and ultimately facilitate quality assurance for automotive software.

Software is the most crucial innovation driver for cyber-physical systems and validating its correct behavior is crucial to many application domains from automated vehicles to medical systems, smart homes, and smart cities. Typical for these systems is that software errors can cause severe ramifications and can be very costly to fix. Consequently, facilitating a priori software validation and verification is of crucial importance for cyber-physical system development. We hence present a model-based method which facilitates test creation, test maintenance, and improved test coverage in automotive software engineering. To this end, we translate specification models used in the BMW Group's SMArDT engineering methodology into activity diagrams, apply optimizations, and ultimately generate test cases. We realize these transformations using the MontiCore language workbench and report on ongoing evaluation at the BMW Group. First results indicate that model-based test case creation can provide great benefits to all stakeholders, once the initial learning efforts have been mastered.

Testing is crucial to successfully engineering reliable automotive software. The manual derivation of test cases from ambiguous textual requirements is costly and error-prone. Model-based development can reduce the test case derivation effort by capturing requirements in structured models from which test cases can be generated with reduced effort. To facilitate the automated test case derivation at BMW, we conducted an anonymous survey among its testing practitioners and conceived a model-based improvement of the testing activities. The new model-based test case derivation extends BMW's SMArDT method with automated generation of tests, which addresses many of the practitioners' challenges uncovered through our study. This ultimately can facilitate quality assurance for automotive software.

Model-driven development has shown to facilitate systems engineering. It employs automated transformation of heterogeneous models into source code artifacts for software products, their testing, and deployment. To this effect, model-driven processes comprise several activities, including parsing, model checking, generating, compiling, testing, and packaging. During this, a multitude of artifacts of different kinds are involved that are related to each other in various ways. The complexity and number of these relations aggravates development, maintenance, and evolution of model-driven systems engineering (MDSE). For future MDSE challenges, such as the development of collaborative cyber-physical systems for automated driving or Industry 4.0, the understanding of these relations must scale with the participating domains, stakeholders, and modeling techniques. We motivate the need for understanding these relations between artifacts of MDSE processes, sketch a vision of formalizing these using artifact models, and present challenges towards it.

Model-driven development has shown to facilitate systems engineering. It employs automated transformation of heterogeneous models into source code artifacts for software products, their testing, and deployment. To this effect, model-driven processes comprise several activities, including parsing, model checking, generating, compiling, testing, and packaging. During this, a multitude of artifacts of different kinds are involved that are related to each other in various ways. The complexity and number of these relations aggravates development, maintenance, and evolution of model-driven systems engineering (MDSE). For future MDSE challenges, such as the development of collaborative cyber-physical systems for automated driving or Industry 4.0, the understanding of these relations must scale with the participating domains, stakeholders, and modeling techniques. We motivate the need for understanding these relations between artifacts of MDSE processes, sketch a vision of formalizing these, and present challenges towards it.

: Visualizing information enables humans to capture, understand, and analyze them in an efficient way. Tools providing such visualization possibilities are omnipresent in software development processes and still subject to current research. While visualization is widely tried in classical software development, the application to MDD is much less common, but still desperately needed. In this paper we outline an integrated and pervasive visualization approach for artifacts and software engineering tools as well as their static and dynamic dependencies by employing, extending, and combining well established visualization approaches to the MDD domain.

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete software system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integration of both forms of code is needed.In this paper, we provide an overview of mechanisms for integrating handwritten and generated object-oriented code. To compare these mechanisms, we define and apply a set of criteria. The results are intended to help model-driven development (MDD) tool developers in choosing an appropriate integration mechanism. In this extended version, we additionally discuss essential integration aspects including the protection of generated code and elaborate on how to use action languages to extend generated code.

Generating software from abstract models is a prime activity in model-driven engineering. Adaptable and extendable code generators are important to address changing technologies as well as user needs. However, they are less established, as variability is often designed as configuration options of monolithic systems. Thus, code generation is often tied to a fixed set of features, hardly reusable in different contexts, and without means for configuration of variants. In this paper, we present an approach for developing product lines of template-based code generators. This approach applies concepts from feature-oriented programming to make variability explicit and manageable. Moreover, it relies on explicit variability regions (VR) in a code generator’s templates, refinements of VRs, and the aggregation of templates and refinements into reusable layers. A concrete product is defined by selecting one or multiple layers. If necessary, additional layers required due to VR refinements are automatically selected.

Code generation from models is a core activity in model-driven development (MDD). For complex systems it is usually impossible to generate the entire software system from models alone. Thus, MDD requires mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects with many model and code artifacts, where a sound integration for generated and handwritten code is necessary. We provide an overview of mechanisms for integrating generated and handwritten code for object-oriented languages. In addition to that, we define and apply criteria to compare these mechanisms. The results are intended to help MDD tool developers in choosing an appropriate integration mechanism.

Manually ensuring that the implementation of a software system is consistent with the software architecture is a laborious and error-prone task. Thus, a variety of approaches towards automated consistency checking have been developed to counteract architecture erosion. However, these approaches lack means to define and check architectural restrictions concerning plugin dependencies, which is required for plugin-based software systems. In this paper, we propose a domain-specific language called Dependency Constraint Language (DepCoL) to facilitate the definition of constraints concerning plugin dependencies. Using DepCoL, it is possible to define constraints affecting groups of plugins, reducing the required specification effort, to formulate constraints for specific plugins only and to refine constraints. Moreover, we provide an Eclipse plugin, which checks whether the software system under development is consistent with the modeled constraints. This enables a seamless integration into the development process to effortless check consistency during development of the software system. In this way, developers are informed about dependency violations immediately and this supports developers in counteracting architecture erosion.

Integrating existing heterogeneous data models for buildings, neighbourhoods and periphery devices into a common data model that can be used by all participants, such as users, services or sensors is a cumbersome task. Usually new extended standards emerge or ontologies are used to define mappings between concrete data models. Within the COOPERaTE project a neighbourhood information model (NIM) has been developed to address interoperability and allow for various kinds of data to be stored and exchanged. The implementation of the NIM follows a meta model based approach, allowing for runtime extension and for easily integrating heterogeneous data models via a mapping DSL and code generation of adaptation components.

In many development projects models are core artifacts used to generate concrete implementations from them. However, for many systems it is impossible or not useful to generate the complete soft- ware system from models alone. Hence, developers need mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects, where model and code artifacts are essential. Thus, a sound approach for the integra- tion of both forms of code is needed. In this paper, we provide an overview of mechanisms for integrating handwritten and generated object-oriented code. To compare these mech- anisms, we define and apply a set of criteria. The results are intended to help model-driven development (MDD) tool developers in choosing an appropriate integration mechanism. In this extended version, we addi- tionally discuss essential integration aspects including the protection of generated code and elaborate on how to use action languages to extend generated code.

Circa 40 % der weltweiten CO2-Emmissionen lassen sich auf Gebäude und deren Betrieb zurückführen, weshalb deren energieeffizienter Betrieb eine wichtige Größe im Kampf gegen den Klimawandel darstellt. Die Beurteilung der Energieeffizienz setzt dabei adäquate Sensorik, gute Spezifikationstechniken für Zielvorgaben und Möglichkeiten zur aktiven Einflussnahme voraus. Durch die Umsetzung dieser Anforderungen werden moderne Gebäude zu komplexen, cyberphysischen Systemen und durch die zusätzliche Nutzung erneuerbarer Energien steht die Smart City von morgen vor völlig neuen Herausforderungen. Komplexe Erzeuger- und Verbrauchersituationen zwischen einzelnen Gebäuden aber auch ganzen Stadtquartieren führen zu einer Dezentralisierung des Energiemarktes und zu einem stark vernetzten IT Ökosystem. Dieser Beitrag beschreibt die Herausforderungen an diese Entwicklungen aus Sicht des Software Engineerings. Der Fokus liegt hierbei auf Konzepten, Methoden und Lösungen des Software Engineerings, die es erlauben die komplexen Vernetzungssituationen effizient und mit dem notwendigen Abstraktionsgrad zu beschreiben.

To keep a DSL clean, readable and reusable in different contexts, it is useful to define a separate tagging language. A tag model logically adds information to the tagged DSL model while technically keeping the artifacts separated. Using a generic tagging language leads to promiscuous tag models, whereas defining a target DSL-specific tag language has a high initial overhead. This paper presents a systematic approach to define a DSL-specific tag language and a corresponding schema language, combining the advantages of both worlds: (a) the tag language specifically fits to the DSL, (b) the artifacts are kept separated and enabling reuse with different tag decorations, (c) the tag language follows a defined type schema, and (d) systematic derivation considerably reduces the effort necessary to implement the tag language. An example shows that it can at least partially be realized by a generator and applied for any kind of DSL.