Erik Burger

View-centric engineering with synchronized heterogeneous models

Model-Driven Engineering provides an abstract representation of systems through the use of models and views. For complex systems, however, finding a single model and a single view to represent all relevant information of the system is infeasible. Specialized models for specific subsystems, domains or abstractions are more concise and thus more efficient than monolithic models. Furthermore, different tasks and concerns often require different views on the same model. Sustaining the consistency between different views and models is hard, especially if new models and views are dynamically added. In this paper, we present an approach that supports flexible views that may involve multiple models conforming to different metamodels. The approach is based on Orthographic Software Modeling and synchronizes individual instances using model transformations. These transformations are generated from view type definitions, metamodel correspondence rules and invariants, which are defined in a domain-specific language. We illustrate our approach with an application that combines component-based architectures with object-oriented source code and class diagrams.

View-based model-driven software development with ModelJoin

Fragmentation of information across instances of different metamodels poses a significant problem for software developers and leads to a major increase in effort of transformation development. Moreover, compositions of metamodels tend to be incomplete, imprecise, and erroneous, making it impossible to present it to users or use it directly as input for applications. Customized views satisfy information needs by focusing on a particular concern, and filtering out information that is not relevant to this concern. For a broad establishment of view-based approaches, an automated solution to deal with separate metamodels and the high complexity of model transformations is necessary. In this paper, we present the ModelJoin approach for the rapid creation of views. Using a human-readable textual DSL, developers can define custom views declaratively without having to write model transformations or define a bridging metamodel. Instead, a metamodel generator and higher-order transformations create annotated target metamodels and the appropriate transformations on-the-fly. The resulting views, which are based on these metamodels, contain joined instances and can effectively express concerns unforseen during metamodel design. We have applied the ModelJoin approach and validated the textual DSL in a case study using the Palladio Component Model.

Flexible views for view-based model-driven development

Model-driven development processes suffer from growing complexity, which leads to information spread across heterogeneous metamodels as well as drift and erosion between architecture and implementation. In this paper, we present a view-based modeling approach based on Orthographic Software Modeling (OSM), and introduce flexible views as a concept for the creation of custom, user-specific views. The envisioned benefit of the approach is to improve software quality, to increase consistency between the various modeling artifacts in model-driven software development, and to reduce the complexity for software developers.

Change-Driven Consistency for Component Code, Architectural Models, and Contracts

During the development of component-based software systems, it is often impractical or even impossible to include all development information into the source code. Instead, specialized languages are used to describe components and systems on different levels of abstraction or from different viewpoints: Component-based architecture models and contracts, for example, can be used to describe the system on a high level of abstraction, and to formally specify component constraints. Because models, contracts, and code contain redundant information, inconsistencies can occur if they are modified independently. Keeping this information consistent manually can require considerable effort, and can lead to costly errors, for example, when security-relevant components are verified against inconsistent contracts. In this paper, we present an approach for keeping component- based architecture models and contracts specified in the Java Modeling Language (JML) consistent with Java source code. We use change-driven incremental transformations and the Vitruvius framework to automate the consistency preservation where this is possible. Using two case studies, we demonstrate how to detect and propagate changes and refactoring operations to keep models and contracts consistent with the source code.

Change propagation and bidirectionality in internal transformation DSLs

Despite good results in several industrial projects, model-driven engineering (MDE) has not been widely adopted in industry. Although MDE has existed for more than a decade now, the lack of tool support is still one of the major problems, according to studies by Staron and Mohaghegi (Staron, in: Model driven engineering languages and systems, Springer, Berlin, 2006; Mohagheghi et al. in Empir Softw Eng 18(1):89–116, 2013). Internal languages offer a solution to this problem for model transformations, which are a key part of MDE. Developers can use existing tools of host languages to create model transformations in a familiar environment. These internal languages, however, typically lack key features such as change propagation or bidirectional transformations. In our opinion, one reason is that existing formalisms for these properties are not well suited for textual languages. In this paper, we present a new formalism describing incremental, bidirectional model synchronizations using synchronization blocks. We prove the ability of this formalism to detect and repair inconsistencies and show its hippocraticness. We use this formalism to create a single internal model transformation language for unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of up to multiple orders of magnitude compared to classical batch transformations.

An empirical study on the perception of metamodel quality

Despite the crucial importance of metamodeling for Model-Driven Engineering (MDE), there is still little discussion about the quality of metamodel design and its consequences in model-driven development processes. Presumably, the quality of metamodel design strongly affects the models and transformations that conform to these metamodels. However, so far surprisingly few work has been done to validate the characterization of metamodel quality. A proper characterization is essential to automate quality improvements for metamodels such as metamodel refactorings. In this paper, we present an empirical study to sharpen the understanding of the perception of metamodel quality. In the study, 24 participants created metamodels of two different domains and evaluated the metamodels in a peer review process according to an evaluation sheet. The results show that the perceived quality was mainly driven by the metamodels completeness, correctness and modularity while other quality attributes could be neglected.

Using internal domain-specific languages to inherit tool support and modularity for model transformations

Model-driven engineering (MDE) has proved to be a useful approach to cope with today’s ever-growing complexity in the development of software systems; nevertheless, it is not widely applied in industry. As suggested by multiple studies, tool support is a major factor for this lack of adoption. In particular, the development of model transformations lacks good tool support. Additionally, modularization techniques are inevitable for the development of larger model transformations to keep them maintainable. Existing tools for MDE, in particular model transformation approaches, are often developed by small teams and cannot keep up with advanced tool support for mainstream general-purpose programming languages, such as IntelliJ or Visual Studio. Internal DSLs are a promising solution to these problems. In this paper, we investigate the impact of design decisions of an internal DSL to the reuse of tool support and modularization concepts from the host language. We validate our findings in terms of understandability, applicability, tool support, and extensibility using three case studies from academia, a model-driven engineering platform, and the industrial automation domain where we apply an implementation of an internal model transformation language on the .NET platform. The results confirm the value of inherited modularity and tool support while conciseness and understandability are still competitive.

Flexible views for rapid model-driven development

Model-driven development processes that use severalmetamodels suffer from information spread across heterogeneous instances. Models can be managed with specialized partial views that aggregate the information from heterogeneous instances and offer the approprate kind of abstraction for developers. The creation and maintenance of such views requires, however, high manual effort. In this paper, we present the usage of flexible views in the Vitruvius approach for view-centric engineering. Flexible views serve as custom, user-specific views which can be defined at development time using a textual domain-specific language. Developers can rapidly create specialized views instead of manually creating the appropriate metamodels and transformations, which is a time-consuming and error-prone task. The envisioned benefit of this approach is to improve software quality, to increase consistency between the various modeling artefacts in modeldriven software development, and to reduce the complexity for software developers.

A feature-based survey of model view approaches

When dealing with complex systems, information is very often fragmented across many different models expressed within a variety of (modeling) languages. To provide the relevant information in an appropriate way to different kinds of stakeholders, (parts of) such models have to be combined and potentially revamped by focusing on concerns of particular interest for them. Thus, mechanisms to define and compute views over models are highly needed. Several approaches have already been proposed to provide (semi)automated support for dealing with such model views. This paper provides a detailed overview of the current state of the art in this area. To achieve this, we relied on our own experiences of designing and applying such solutions in order to conduct a literature review on this topic. As a result, we discuss the main capabilities of existing approaches and propose a corresponding research agenda. We notably contribute a feature model describing what we believe to be the most important characteristics of the support for views on models. We expect this work to be helpful to both current and potential future users and developers of model view techniques, as well as to any person generally interested in model-based software and systems engineering.

Translatability and Translation of Updated Views in ModelJoin

The ModelJoin language offers the definition of views that combine information from heterogeneous models. These views are currently realised by unidirectional transformations. Thus, updates to the views are not translated back to the models. In this paper, we study the view-update problem for ModelJoin view definitions. We propose translation strategies for view updates, and show that generated model constraints can be used to decide whether updated views can be translated. We provide a transformation for deriving a set of OCL constraints to check for translatability. For untranslatable cases that can be made translatable with minor fixes to the view, we provide algorithms for automatic fixes. The constraints are evaluated in two case study examples. The evaluation shows the applicability of the translation strategies, and the algorithms for automatically checking and restoring the translatability. Most of the consistent update sequences could be translated, and all inconsistent updates could be identified.