Petra Brosch

An Example Is Worth a Thousand Words: Composite Operation Modeling By-Example

Predefined composite operations are handy for efficient modeling, e.g., for the automatic execution of refactorings, and for the introduction of patterns in existing models. Some modeling environments provide an initial set of basic refactoring operations, but hardly offer any extension points for the user. Even if extension points exist, the introduction of new composite operations requires programming skills and deep knowledge of the respective metamodel. In this paper, we introduce a method for specifying composite operations within the users modeling language and environment of choice. The user models the composite operation by-example, which enables the semi-automatic derivation of a generic composite operation specification. This specification may be used in various modeling scenarios, like model refactoring and model versioning. We implemented the approach in the Operation Recorder and performed an evaluation by defining multiple complex refactorings for UML diagrams.

An introduction to model versioning

With the emergence of model-driven engineering (MDE), software models are considered as central artifacts in the software engineering process, going beyond their traditional use as sketches. In MDE, models rather act as the single source of information for automatically generating executable software. This shift poses several new research challenges. One of these challenges constitutes model versioning, which targets at enabling efficient team-based development of models. This compelling challenge induced a very active research community, who yielded remarkable methods and techniques ranging from model differencing to merging of models. In this tutorial, we give an introduction to the foundations of model versioning, the underlying technologies for processing models and their evolution, as well as the state of the art in model versioning. Thereby, we aim at equipping students and researchers alike that are new to this domain with enough information for commencing to contribute to this challenging research area.

A posteriori operation detection in evolving software models

Highlights ► Detection of applications of composite operations in evolving software models. ► Automatic generation of detection rules from executable operation specifications. ► Real-world study showing that 70% of all applied composite operations can be detected. ► Performance analysis showing that detection algorithm scales well for large models.

Dynamic travel time provision for road networks

The application domain of intelligent transportation is plagued by a shortage of data sources that adequately assess traffic situations. Typically, to provide routing and navigation solutions map attributes in the form of static weights as derived from road categories and speed limits used for road networks. With the advent of Floating Car Data (FCD) and specifically the GPS-based tracking data component, a means was found to derive accurate and up-to-date travel times, i.e., qualitative traffic information. FCD is a by-product in fleet management applications and given a minimum number and uniform distribution of vehicles, this data can be used for accurate traffic assessment and also prediction. This work showcases a system that facilitates the collection of FCD, produces dynamic travel time information, and provides value-added services based on the dynamic travel times. The essential components that will be discussed are a Web-services-based data collection approach, sophisticated map-matching algorithms, a data management architecture and an online visualization platform.

We can work it out: Collaborative Conflict Resolution in Model Versioning

For the versioning of code a pantheon of version control system (VCS) solutions has been realized and is successfully applied in practice. Nevertheless, when it comes to merging two different versions of one artifact, the resolution of conflicts poses a major challenge. In standard systems, the developer who performs the later commit is sole in charge of this often time-consuming, error-prone task. This commit carries the inherent danger of losing the modifications of the other developer. Recently, collaborative merge approaches for code versioning systems have been proposed to minimize this risk. In this paper we propose to apply similar techniques in the context of model versioning where the challenge of merging two versions is even more formidable due to their graph-structure and their rich semantics. In particular, modeling is used in the early phases of the software development, where a collaborative merge is beneficial to elaborate a consolidated understanding of a domain.

Guided Merging of Sequence Diagrams

The employment of optimistic model versioning systems allows multiple developers of a team to work independently on their local copies of a software model. The merging process towards one consolidated version can be error-prone and time-consuming when performed without any tool support. Recently, several sophisticated approaches for model merging have been presented. However, even for multi-view modeling languages like UML, which distribute the information on the modeled system over different views, these views are merged independently of each other. Hence, inconsistencies are likely to be introduced into the merged model. We suggest to solve this problem by exploiting information stored in one view as constraint for the computation of a consolidated version of another view. More specifically, we demonstrate how state machines can guide the integration of parallel changes performed on a sequence diagram. We give a concise formal description of this problem and suggest a translation to the satisfiability problem of propositional logic.

Colex: a web-based collaborative conflict lexicon

While graphical modeling languages gained recognition as being a promising successor of third-generation programming languages, their widespread employment is still decelerated by the absence of adequate version control management for modeling artifacts. Even worse, the expected behavior and quality requirements for upcoming model versioning systems are only vaguely stated and understood. When it comes to defining, detecting, and resolving conflicts, no consolidated categorization and no common benchmark exist which impedes a uniform comparison of current approaches. With this paper, we invite the model versioning community to conjointly accomplish a consolidated body of knowledge which documents various types of conflicts, their detectability, as well as applicable resolution strategies. Therefore, we present Colex, an open, web-based, collaborative conflict lexicon. As a starting point, we provide a causal categorization of conflicts and---according to these categories---a set of versioning examples.

Towards scenario-based testing of UML diagrams

In model-driven engineering, models are not primarily developed for documentation and requirement specification purposes, but promoted to first-class artifacts, from which executable code is generated. As a consequence, typical development activities like testing must be performed on the model level. In this paper, we propose to use overlapping information inherent in multiple views of models for automatic testing. Using a prototype based on the model checker Spin we show the feasibility of this approach and identify future challenges.

The operation recorder: specifying model refactorings by-example

Predefined composite operations are handy for efficient software modeling, e.g., for the automatic execution of refactorings, and for the introduction of patterns in existing models. Some modeling environments provide an initial set of basic refactoring operations, but hardly offer any extension points for the user. Even if extension points exist, the introduction of new composite operations requires programming skills and deep knowledge of the respective metamodel. In our demonstration we present the Operation Recorder, a tool for specifying composite operations, like refactorings, within the users modeling language and environment of choice. The user models the composite operation by-example, which enables the semi-automatic derivation of a generic composite operation specification. This specification may be used in further modeling scenarios, like model refactoring and model versioning. We demonstrate our tool by creating two refactoring specifications for UML class diagrams and UML state machine diagrams.

Conflicts as first-class entities: a UML profile for model versioning

The urgent demand for optimistic version control support for software models induced active research within the modeling community. Recently, several approaches have been proposed addressing the task of detecting conflicts when merging two concurrently changed versions of a model. In this context, the holistic representation and supportive visualization of detected merge conflicts pose a challenge. In this paper, we present a modeling language independent conflict model comprising all necessary information to profoundly represent merge conflicts. From this conflict model, we leverage the dynamic extension power of UML profiles by introducing a dedicated conflict profile to visually assist modelers in resolving merge conflicts of UML models. As a result, modelers may resolve conflicts in the concrete graphical syntax conducting their familiar UML editors without tool extensions.