Timo Kehrer

Henshin: A Usability-Focused Framework for EMF Model Transformation Development

Improved usability of tools is a fundamental prerequisite for a more widespread industrial adoption of Model-Driven Engineering. We present the current state of Henshin, a model transformation language and framework based on algebraic graph transformations. Our demonstration focuses on Henshin’s novel usability-oriented features, specifically: (i) a textual syntax, complementing the existing graphical one by improved support for rapid transformation development, (ii) extended static validation, including checks for correct integration with general-purpose-language code, (iii) advanced refactoring support, in particular, for splitting large transformation programs, (iv) editing utilities for facilitating recurring tasks in model transformation development. We demonstrate the usefulness of these features using a running example.

SiPL -- A Delta-Based Modeling Framework for Software Product Line Engineering

Model-based development has become a widely-used approach to implement software, e.g. for embedded systems. Models replace source code as primary executable artifacts in these cases. Software product line technologies for these domains must be able to generate models as instances of an SPL. This need is addressed among others by an implementation technology for SPLs known as delta modeling. Current approaches to delta modeling require deltas to be written manually using delta languages, and they offer only very limited support for creating and testing a network of deltas. This paper presents a new approach to delta modeling and a supporting tool suite: the abstract notion of a delta is refined to be a consistency-preserving edit script which is generated by comparing two models. The rich structure of edit scripts allows us to detect conflicts and further relations between deltas statically and to implement restructurings in delta sets such as the merging of two deltas. We illustrate the tooling using a case study.

Shadow Symbolic Execution with Java PathFinder

Regression testing ensures that a software system when it evolves still performs correctly and that the changes introduce no unintended side-effects. However, the creation of regression test cases that show divergent behavior needs a lot of effort. A solutionis the idea of shadow symbolic execution, originally implemented based on KLEE for programs written in C, which takes a unified version of the old and the new program and performs symbolic execution guided by concrete values to explore the changed behavior. In this work, we apply the idea of shadow symbolic execution to Java programs and, hence, provide an extension of the Java PathFinder (JPF) project to perform shadow symbolic execution on Java bytecode. The extension has been applied on several subjects from the JPF test classes where it successfully generated test inputs that expose divergences relevant for regression testing.

Incrementally slicing editable submodels

Model slicers are tools which provide two services: (a) finding parts of interest in a model and (b) displaying these parts somehow or extract these parts as a new, autonomous model, which is referred to as slice or sub-model. This paper focuses on the creation of editable slices, which can be processed by model editors, analysis tools, model management tools etc. Slices are useful if, e.g., only a part of a large model shall be analyzed, compared or processed by time-consuming algorithms, or if sub-models shall be modified independently. We present a new generic incremental slicer which can slice models of arbitrary type and which creates slices which are consistent in the sense that they are editable by standard editors. It is built on top of a model differencing framework and does not require additional configuration data beyond those available in the differencing framework. The slicer can incrementally extend or reduce an existing slice if model elements shall be added or removed, even if the slice has been edited meanwhile. We demonstrate the usefulness of our slicer in several scenarios using a large UML model. A screencast of the demonstrated scenarios is provided at http://pi.informatik.uni-siegen.de/projects/SiLift/ase2017.

A tool environment for quality assurance of delta-oriented model-based SPLs

With the advent of model-driven engineering, software product line (SPL) technologies must be able to generate models as instances of a model-based SPL (MBSPL). Delta modeling is a variability mechanism which can be easily adopted for MBSPLs. The idea is to generate products by applying one or several deltas onto a core model. Hence, the main task during SPL implementation is to develop a set of deltas and to maintain several kinds of interrelations, e.g. dependencies and conflicts, in order to be able to generate all products of a MBSPL upon request. The resulting network of deltas is often complex and hard to maintain without appropriate tool support. This paper presents a tool environment for quality assurance in delta-oriented MBSPLs supporting the identification and elimination of design flaws in a network of deltas based on the principles of quality metrics and refactoring. We build upon previous work on the integration of model versioning tools with delta-oriented development of MBSPLs. Our solution is agnostic of the modeling language and may be easily extended by additional quality metrics and refactorings. We illustrate our approach using a delta-oriented MBSPL from the automation domain.

Automatic Inference of Rule-Based Specifications of Complex In-place Model Transformations

Optimal support for continuous evolution in model-based software development requires tool environments to be customisable to domain-specific modelling languages. An important aspect is the set of change operations available to modify models. In-place model transformations are well-suited for that purpose. However, the specification of transformation rules requires a deep understanding of the language meta-model, limiting it to expert tool developers and language designers. This is at odds with the aim of domain-specific visual modelling environments, which should be customisable by domain experts.

ReVision: a tool for history-based model repair recommendations

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 toolname 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/.

A Formal Framework for Incremental Model Slicing

Program slicing is a technique which can determine the simplest program possible that maintains the meaning of the original program w.r.t. a slicing criterion. The concept of slicing has been transferred to models, in particular to statecharts. In addition to the classical use cases of slicing adopted from the field of program understanding, model slicing is also motivated by specifying submodels of interest to be further processed more efficiently, thus dealing with scalability issues when working with very large models. Slices are often updated throughout specific software development tasks. Such a slice update can be performed by creating the new slice from scratch or by incrementally updating the existing slice. In this paper, we present a formal framework for defining model slicers that support incremental slice updates. This framework abstracts from the behavior of concrete slicers as well as from the concrete model modification approach. It forms a guideline for defining incremental model slicers independent of the underlying slicer’s semantics. Incremental slice updates are shown to be equivalent to non-incremental ones. Furthermore, we present a framework instantiation based on the concept of edit scripts defining application sequences of model transformation rules. We implemented two concrete model slicers for this instantiation based on the Eclipse Modeling Framework.

Inferring visual contracts from Java programs

Visual contracts model the operation of components or services by pre- and post-conditions formalised as graph transformation rules. They provide a precise intuitive notation to support testing, understanding and analysis of software. Their detailed specification of internal data states and transformations, referred to as deep behavioural modelling, is an error-prone activity. In this paper we propose a dynamic approach to reverse engineering visual contracts from Java based on tracing the execution of Java operations. The resulting contracts give an accurate description of the observed object transformations, their effects and preconditions in terms of object structures, parameter and attribute values, and their generalised specification by universally quantified (multi) objects, patterns, and invariants. While this paper focusses on the fundamental technique rather than a particular application, we explore potential uses in our evaluation, including in program understanding, review of test reports and debugging.

Supporting semi-automatic co-evolution of architecture and fault tree models

Abstract During the whole life-cycle of software-intensive systems in safety-critical domains, system models must consistently co-evolve with quality evaluation models like fault trees. However, performing these co-evolution steps is a cumbersome and often manual task. To understand this problem in detail, we have analyzed the evolution and mined common changes of architecture and fault tree models for a set of evolution scenarios of a part of a factory automation system called Pick and Place Unit. On the other hand, we designed a set of intra- and inter-model transformation rules which fully cover the evolution scenarios of the case study and which offer the potential to semi-automate the co-evolution process. In particular, we validated these rules with respect to completeness and evaluated them by a comparison to typical visual editor operations. Our results show a significant reduction of the amount of required user interactions in order to realize the co-evolution.