Keywords: Model transformation, CPN, Verification
Astract: Model-Driven Engineering (MDE) places models in the center of the software lifecycle. Model transformations play a vital role in this context whereas several model transformation languages and types of model transformations are available. This diploma theseis only addressed the issue of the model-to-model transformation (M2M). All this languages or approaches have the problem that they are not easy to understand respectively irreproducible. This makes them hard to debug and to analyse. This problem excites from the execution of the transformation in the form of a black-box which hides the operational sematic.
Therefore there are only marginal informations about the transformation process. A comprehensive analysis is important because errors in model transformations can appear on various points for instance on the source and target metamodel, source and target model and on the transformation logic. All this has a direct consequence to the correctness of the transformation and all following steps in the software lifecycle. The main problem of the MDE is currently the so far only unsatisfying answered question of analysing model transformations.
This diploma thesis pickes up the described problems in the analysis of model transformations and tries on the basis of transformation nets to go into detail of the veri cation. The transformation net formalism is based on coloured petri nets which offer a set of analysis methods. This thesis explores if the mentioned analysis methodes can be applied after the reduction of transformation nets to coloured petri nets and in which kind transformation net speci fics have an impact on this process. Beyond that this thesis investigates the support of widespread and already in industrial environment used tools for coloured petri nets. As a final step the already existing "Transformations On Petri Nets In Color" prototype for transformation nets gets extended to support analytical properties for model transformations.

Keywords: model versioning, model-driven development, collaboration, conflict resolution
Astract: The advances in software development lead to ever increasing complexity of software systems.
Therewith rises the demand for technologies and techniques to shield the developers from that system complexity. For decades researchers and practioners have created abstractions to that end. Early programming languages shielded the programmers from the complexity of programming with machine code. Continuously, new programming languages and environments emerged and still emerge. At the moment, model-driven development, the next abstraction level, is on the rise, leveraging models to central artefacts of software development.
Nowadays, software is developed in teams. Models provide the advantage to be additionally used as an inter-expert language, hence facilitating communication. Consequently, a model is often edited by multiple persons. Version control provides collaborative support on a technical level by enabling concurrent work. In version control, mechanisms are refined to improve software development in teams. Current versioning tools, however, mainly provide support for code-centric software engineering. Versioning of models still faces major challenges. Models may not be as easily divided into parts and partitioned for several developers to work on as source code is. Due to parallel development, the versioning of models is especially prone to conflicts. The resolution of conflict situations is a precarious and preferably collaborative process. Progress in model-driven development research seems to be restricted to the technical level, while social aspects like human behaviour and cooperation are often neglected. This is surprising, since software developers spend more than 60% of their time with collaborative activities, including meetings and other communication, coordination of tasks, and collaboratively executing these tasks. Well working collaboration in a team leads to an overall better outcome. It is therefore important to actively shape collaboration to gain the huge potential benefits achieved through efficient teamwork.
This thesis provides a general survey on possibilities to improve the model-driven development process in regard to collaborative aspects. We therefore analyse means and methods of collaboration in theory and practice, both in software engineering and various other fields. We highlight the importance of attaching a greater value to collaboration in research and in practice. Since collaboration is especially finical in conflict situations, we provide a specific example for enhanced collaboration in conflict resolution in model versioning.

Keywords:
Astract: Model-Driven Engineering places models as first-class artifacts throughout the software lifecycle requiring the availability of proper transformation languages. Although numerous approaches are available, they lack convenient facilities for supporting debugging and understanding of the transformation logic. This is because execution engines operate on a low level of abstraction, hide the operational semantics of a transformation, scatter metamodels, models, transformation logic, and trace information across different artifacts, and provide limited verification support. To tackle these problems, we propose a Domain-Specific Language (DSL) on top of Colored Petri Nets (CPNs)-called Transformation Nets-for the execution and debugging of model transformations on a high level of abstraction. This formalism makes the afore hidden operational semantics explicit by providing a runtime model in terms of places, transitions and tokens, integrating all artifacts involved into a homogenous view. Moreover, the formal underpinnings of CPNs enable comprehensive verification of model transformations.

Keywords:

Keywords:
Astract: In optimistic versioning, multiple developers are allowed to modify an artifact at the same time. On the one hand this approach increases productivity as the development process is never stalled due to locks on an artifact. On the other hand conflicts may arise when it comes to merging the different modifications into one consolidated version. In general, the resolution of such conflicts is not only cumbersome, but also error-prone. Especially if the artifacts under version control are models, little support is provided by standard versioning systems. In this paper we present the enhanced versioning process of the model versioning system AMOR. We show how AMOR is configured in order to obtain a precise conflict report which allows the recommendation of automatically executable resolution patterns. The user of AMOR chooses either one of the recommendations or performs manual resolution. The manual resolution may be in collaboration with other developers and allows to infer new resolution patterns which may be applied in similar situations.