Software is an everyday companion in today’s technology society that need to be evolved and maintained over long time periods. To manage the complexity of software projects, it has always been an effort to increase the level of abstraction during software development. Model-Driven Engineering (MDE) has shown to be a suitable method to raise abstraction levels during software development. Models are primary development artifacts in MDE that describe complex software systems from different viewpoints.

In MDE software projects, models are heavily edited through all stages of the development process. During this editing process, the models can become inconsistent due to uncertainties in the software design or various editing mistakes. While most inconsistencies can be tolerated temporarily, they need to be resolved eventually. The resolution of an inconsistency affecting a model’s design is typically a creative process that requires a developer’s expertise. Model repair recommendation tools can guide the developer through this process and propose a ranked list of repairs to resolve the inconsistency. However, such tools will only be accepted in practice if the list of recommendations is plausible and understandable to a developer. Current approaches mainly focus on exhaustive search strategies to generate improved versions of an inconsistent model. Such resolutions might not be understandable to developers, may not reflect the original intentions of an editing process, or just undo former work. Moreover, those tools typically resolve multiple inconsistencies at a time, which might lead to an incomprehensible composition of repair proposals.

This thesis proposes a history-based approach for model repair recommendations. The approach focuses on the detection and complementation of incomplete edit steps, which can be located in the editing history of a model. Edit steps are defined by consistency-preserving edit operations (CPEOs), which formally capture complex and error-prone modifications of a specific modeling language. A recognized incomplete edit step can either be undone or extended to a full execution of a CPEO. The final inconsistency resolution depends on the developer’s approval. The proposed recommendation approach is fully implemented and supported by our interactive repair tool called ReVision. The tool also includes configuration support to generate CPEOs by a semi-automated process.

The approach is evaluated using histories of real-world models obtained from popular open-source modeling projects hosted in the Eclipse Git repository. Our experimental results confirm our hypothesis that most of the inconsistencies, namely 93.4%, can be resolved by complementing incomplete edits. 92.6% of the generated repair proposals are relevant in the sense that their effect can be observed in the models’ histories. 94.9% of the relevant repair proposals are ranked at the topmost position. Our empirical results show that the presented history-based model recommendation approach allows developers to repair model inconsistencies efficiently and effectively.

This work reports recent research results on history-based model repair recommendations in Model-Driven Engineering (MDE), originally published in Reference [Oh21]. Models in MDE are primary development artifacts that are heavily edited in all software development stages and can become temporarily inconsistent during editing. Model repair tools can support developers by proposing a list of the most promising repairs. Such repair recommendations will only be accepted in practice if the generated proposals are plausible and understandable and the set as a whole is manageable.

Our interactive repair tool ReVision [Oh18], aims at generating repair proposals for inconsistencies introduced by past incomplete edit steps. Such an incomplete edit step is either undone or extended to the full execution of a consistency-preserving edit operation. We evaluate our approach using histories of real-world models from popular open-source modeling projects. Our experimental results confirm our hypothesis that most of the inconsistencies can be resolved by complementing incomplete edits. In fact, 92.2% of the proposed complementations could be observed in the model history.

Models in Model-driven Engineering are primary development artifacts that are heavily edited in all stages of software development and that can become temporarily inconsistent during editing. In general, there are many alternatives to resolve an inconsistency, and which one is the most suitable depends on a variety of factors. As also proposed by recent approaches to model repair, it is reasonable to leave the actual choice and approval of a repair alternative to the discretion of the developer. Model repair tools can support developers by proposing a list of the most promising repairs. Such repair recommendations will be only accepted in practice if the generated proposals are plausible and understandable, and if the set as a whole is manageable. Current approaches, which mostly focus on exhaustive search strategies, exploring all possible model repairs without considering the intention of historic changes, fail in meeting these requirements.

In this article, we present a new approach to generate repair proposals that aims at inconsistencies that have been introduced by past incomplete edit steps that can be located in the version history of a model. Such an incomplete edit step is either undone or it is extended to a full execution of a consistency-preserving edit operation. The history-based analysis of inconsistencies as well as the generation of repair recommendations are fully automated, and all interactive selection steps are supported by our repair tool called ReVision. We evaluate our approach using histories of real-world models obtained from popular open-source modeling projects hosted in the Eclipse Git repository, including the evolution of the entire UML meta-model. Our experimental results confirm our hypothesis that most of the inconsistencies, namely, 93.4%, can be resolved by complementing incomplete edits. 92.6% of the generated repair proposals are relevant in the sense that their effect can be observed in the models’ histories. 94.9% of the relevant repair proposals are ranked at the topmost position.

Models in Model-Driven Engineering are heavily edited in all stages of software development and can become temporarily inconsistent. In general, there are many alternatives to fix an inconsistency, the actual choice is left to the discretion of the developer. Model repair tools should support developers by proposing a short list of repair alternatives. Such recommendations will be only accepted in practice if the generated proposals are plausible and understandable. Current approaches, which mostly focus on fully automatic, non-interactive model repairs, fail in meeting these requirements. This paper proposes a new approach to generate repair proposals for inconsistencies that were introduced by incomplete editing processes which can be located in the version history of a model. Such an incomplete editing process is extended to a full execution of a consistency-preserving edit operation. We demonstrate our repair tool ReVision using a simplified multi-view UML model of a video on demand system, a screencast is provided at http://pi.informatik.uni-siegen.de/projects/SiLift/icse2018/.

In software development, models are used for system analysis and design. In model-driven software development, models are primary artifacts and the formal basis for the system implementation. A model is an abstraction layer which conceals the technical target platform. This increases the reusability of the developed components.However, this requires the definition of a formal syntax and semantics for the modeling language. Models are usually expressed from various viewpoints, e.g. the data structure and a user interaction. A multi-view modeling environment can be used to build complex system models. A viewpoint can also be constructed by slicing a specific part of the model. This can be helpful in distributing and processing large models across a development team. However, a developer can inadvertently introduce inconsistencies between different views. Ensuring the correctness of a model is a key task of the development process. Therefore, the developers need fully-fledged tool support to deal with inconsistencies. This work presents an approach to the repair of inconsistencies in a distributed multi-view modeling environment. The introduced tool determines repairs based on user-defined edit rules. To understand the cause of an inconsistency, the repair algorithm considers the modifications which have introduced the inconsistency.