Timo Greifenberg

A comparison of mechanisms for integrating handwritten and generated code for object-oriented programming languages

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.

Integration of Handwritten and Generated Object-Oriented Code

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.

Architectural Consistency Checking in Plugin-Based Software Systems

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.

Mastering the future: Agile model-based system design for BMW’s electrified next generation platform

Future mobility systems are becoming more complex. Existing processes for hardware component oriented development reach a limit for highly integrated systems. High quality cannot be efficiently ensured any longer at shorter development cycles and reduced budgets.

On the Need for Artifact Models in Model-Driven Systems Engineering Projects

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.

Energieeffiziente Städte – Herausforderungen und Lösungen aus Sicht des Software Engineerings

Circa 40 % der weltweiten CO2-Emmissionen lassen sich auf Gebaude und deren Betrieb zuruckfuhren, weshalb deren energieeffizienter Betrieb eine wichtige Grose im Kampf gegen den Klimawandel darstellt. Die Beurteilung der Energieeffizienz setzt dabei adaquate Sensorik, gute Spezifikationstechniken fur Zielvorgaben und Moglichkeiten zur aktiven Einflussnahme voraus. Durch die Umsetzung dieser Anforderungen werden moderne Gebaude zu komplexen, cyberphysischen Systemen und durch die zusatzliche Nutzung erneuerbarer Energien steht die Smart City von morgen vor vollig neuen Herausforderungen. Komplexe Erzeuger- und Verbrauchersituationen zwischen einzelnen Gebauden aber auch ganzen Stadtquartieren fuhren zu einer Dezentralisierung des Energiemarktes und zu einem stark vernetzten IT Okosystem. Dieser Beitrag beschreibt die Herausforderungen an diese Entwicklungen aus Sicht des Software Engineerings. Der Fokus liegt hierbei auf Konzepten, Methoden und Losungen des Software Engineerings, die es erlauben die komplexen Vernetzungssituationen effizient und mit dem notwendigen Abstraktionsgrad zu beschreiben.