Keywords:

Keywords:
Astract: The usage of optimistic version control systems comes along with cumbersome and time-consuming conflict resolution in the case that the modifications of two developers are contradicting. For code as well as for any other artifact the resolution support moves hardly beyond the choices "keep mine", "keep theirs", "take all changes", or "abandon all changes". To ease the conflict resolution in the context of model versioning, we propose a recommender system which suggests automatically executable resolution patterns to the developer responsible for the conflict resolution. The lookup algorithm is based on a similarity-aware graph matching approach incorporating information from the metamodel of the used modeling language. This allows not only the retrieval of recommendations exactly matching the given conflict situation, but also the identification of similar conflict situations whose resolution patterns are adaptable to the current conflict.

Keywords:
Astract: Optimistic version control systems enable globally distributed teams of developers to work together asynchronously. Every developer works on a local copy and consequently, no developer is ever detracted from working by waiting for a resource. The price for this flexibility is payed at the moment when conflicting modifications must be integrated into one consolidated version. In this paper, we discuss conflicts and their need for resolution in the context of model versioning and provide the basic concepts necessary to build a model versioning system which guides modelers through the critical consolidation phase by recommending suitable patterns.

Keywords: model-driven, model versioning, conflict detection, refactorings
Astract: Within the last years, the popularity and appearance of model-driven software development (MDSD) has increased significantly.
The model-driven paradigm induces a shift from code-centric to model-centric development. Software models are considered as first class entites building the basis for generating an executable software.
Nowadays, MDSD is a widely accepted technology helping software developers to accelerate and simplify their work by raising the abstraction level of the software artefacts they create.
Large-scale software is usually produced by a high number of software developers, who are often working in parallel and spread all over the world. Therefore, the version management of software models is crucial for an effective, collaborative software development. One of the most important components of a versioning system for model artefacts is a precise difference and conflict detection, which is capable of identifying all operations executed by the developers and the eventually resulting conflicts that arise at merging independently changed models.
Without an appropriate difference and conflict detection system, software developers are forced to find occuring problems manually, which is a time consuming process. Especially complex operations, refactorings and language specific conflicts are hard to identify and can lead to serious malfunctions in the produced software if they remain undiscovered.
The main goal of this work is the development and implementation of an intelligent and adaptable conflict detection mechanism for models in the context of versioning. A framework will be presented which is able to precisly calculate the differences and detect conflicts in a generic way. Users may extend this system by providing language specific definitions which will be used to refine the functionality for specific modeling languages. In that way, the quality of the difference and conflict detection can be improved to minimize the need for manual interaction.

Keywords: QVT, Model, Model Transformation, Debugging, Visualization
Astract: Model transformations (MT) play a key role in the Model Driven Engineering (MDE) paradigm, leading to the standardization of the Query/View/Transformation (QVT) model transformation language by the Object Management Group (OMG). Until now, however, this language did not attract the same interest as the Unified Modeling Language (UML), because of the lack of adequate debugging facilities which are necessary regarding the following three problem areas: First, declarative languages like QVT Relations (QVT-R) hides the operational semantics of transformations. Only the information provided by the interpreter, as well as the tendered inputs and returned outputs are available for tracking the progress of transformations. Furthermore, the ordering of transformation application is hidden by the MT engines providing only a black-boxes view to the users. This can lead to the problem of impedance mismatches between design and runtime. These characteristics of QVT-R are assets for developing, but are handicaps for debugging. Second, QVT-R code is specified on higher abstraction level than its execution and state-of-the-art debugging. This deteriorates the ability to deduce causes from produced results. Third, the information content responsible for operating MTs is spread over several artifacts including the input model, a resulting target model and the QVT-R code. As a consequence, the reasons for a particular outcome are hard to be derived from the involved artifacts. This severely harms the ease of debugging.
Therefore, this master thesis tackles the mentioned problems by visualizing QVT-R as Transformations Nets, using the MT framework ``Transformations On Petri Nets In Color'' (TROPIC) based on Colored Petri Nets (CPN). This can be seen as explicit definition of operational semantics on a high abstraction level providing a white-box view for debugging QVT-R. This thesis proposes a procedure model formulated in a conceptual approach and in a prototypic implementation striving for bridging the existing gap between these two different paradigms by mapping the concepts of QVT Relations to such nets. In this thesis three particular contributions are provided: (i) a solution approach for unidirectional mappings producing target models from an existing source model, (ii) the support for model inheritance, (iii) and synchronization approaches for timely and version-based incremental changes.