Keywords: schema matching, information integration, schema mapping, smartmatcher
Astract: In software projects most of the data is saved in a structured way to simplify the usage of it. These data structures are persisted in relational or XML (Extensible Markup Language) databases. In case of new software releases these data structures have to be modified to save new data or adapted data. The usage of a new technology often implies changes in the data structures as well. If changes are made on the data structure, in most of the cases the old data must be migrated to the new data structure to avoid data loss. This process, called information integration, is a time intensive job, and must be done by experts, who create the mapping rules manually and have to take care of the data structure limitations. With schema matching this process can be solved more efficient by schema matching tools build automatically the mapping rules which can be used to transform the data into a new data structure.
SmartMatcher is a schema matching tool prototype, which has been developed at the Vienna University of Technology. This prototype generates mappings out of a source and target schema with their corresponding training instances. The latest release of the SmartMatcher contains a new internal data structure, which should allow more complex mapping operations in future. The effect of this new data structure regard-ing the quality of mappings has been evaluated in this work.
Furthermore, a new feature has been integrated which allows to import existing mappings. With this fea-ture the SmartMatcher will be able to use results from other matching tools to im-prove them. In the past the SmartMatcher was limited to one training instance per schema. Thus, a further feature was implemented, called Multiple Samples. This allows more training instances to be used by the SmartMatcher, and improves the user experience by providing a better clarity of the training instances.

Keywords: versioning, conflict resolution, model versioning
Astract: In modern software development, models are used for documentation and particularly for source code generation. Thus, syntax errors and inconsistencies within a model directly affect the generated source code.
If only one developer is working on a model, it is easier to ensure the consistency of the model, because of tools provided by the development environment. If several developers are working collaboratively on one model, which is the more realistic case, a version control system (VCS) has to be used. Unfortunately, conventional textbased approaches for versioning are not sufficient for versioning models.
Concerning conflict resolution two major drawbacks exist when using conventional VCSs.
The first drawback concerns conflicts which arise between two versions of models when several developers are concurrently changing the same model elements. These conflicts must be resolved manually by the developer, because there is currently no tool support for merging conflicting models. Errors caused by the manual merge of the model versions have negative impact on the quality of the generated source code. The second drawback stems from lost information which is generated during conflict resolution and which may be of use in future conflicting situations. However, this information is currently not saved in VCS and so it gets lost. Thus, generated knowledge concerning conflict resolution cannot be reused and the usage of design guidelines for developing future models cannot be provided.
Therefore, prior decisions of developers for conflict resolution cannot be reused and the usage of design guidelines for developing models cannot be verified.
The approach introduced in this thesis facilitates the description of resolution strategies for syntactic and static semantic conflicts, which allows a semiautomatic resolution of conflicts. To describe syntactic conflicts and their resolutions, a model based, descriptive language is introduced. To resolve static semantic conflicts, graph transformation and patterns expressed in the Object Constraint Language(OCL) are employed.
Because of the model based approach for describing resolution strategies, simple and flexible adaptations of the strategies are possible. The common structure of the resolution patterns facilitates the recording of the developer's decisions. Analysis of the recorded decisions provides further information which may support the developer finding the appropriate resolution strategy for a conflict and verifying the usage of design guidelines. Finally, the increased quality of the merged model versions reduces errors within the generated source code.

Keywords: webml, legacy, web application, reverse engineering
Astract: In the last decade the adoption of web applications instead of desktop applications has grown rapidly. Also the patterns and technologies for developing and running web applications have changed a lot over time. The World Wide Web has evolved from a collection of linked static documents to a space of countless dynamic, data centric applications. One of the oldest and most popular languages for developing dynamic web applications is PHP. Although nowadays there are proved techniques for developing web applications in PHP, many older PHP web applications are written without the notion of applying welldefined design patterns. Those web applications are hard to understand, maintain, extend as well as hard to migrate to new web platforms.
Nowadays many web applications are developed using Model Driven Engineering (MDE) techniques where software systems are described as models and code artifacts are generated out of these models. But often the requirement is not to develop a completely new web application but to capture the functionality of an existing legacy application. As it usually takes a lot of time for humans to understand the source code, it can be helpful to have a tool that analyzes the source artifacts and transforms them into a model on a higher level of abstraction. This process is called reverse engineering.
The requirements for such a tool to work is the existence of well-known patterns in the source code, which is typically found in Model-View-Controller (MVC) web applications.
In this thesis a reverse engineering process from a legacy PHP web shop application into a model of the Web Modeling Language (WebML), based on static code analysis, is presented. First of all the requirements for the source code are analyzed in order to apply an automatic reverse engineering process on it. The source application is refactored to fulfill these requirements, which leads to a MVC version of the example application. The refactored application is the source for the next step, a code to model transformation into an intermediate model of the MVC web application.
The last step is a model to model transformation from the the MVC model into a WebML model.
The result is a WebML model that shows the most important structural and behavioral aspects of the example application. The benefit of such a model is that that it provides a realistic documentation of the current state of the application. Whenever the application changes, the process can be repeated so the documentation never gets outdated. It helps humans to understand the connections between different parts of the application and can be used to support refactoring activities or the migration to another platform.

Keywords:
Astract: The vision of Model-Driven Engineering places models as first-class artifacts throughout the software lifecycle. An essential prerequisite is the availability of proper transformation languages allowing not only code generation but also augmentation, migration or translation of models themselves. Current approaches, however, lack convenient facilities for debugging and ensuring the understanding of the transformation process. To tackle these problems, we propose a novel formalism for the development of model transformations which is based on Colored Petri Nets. This allows first, for an explicit, process-oriented execution model of a transformation, thereby overcoming the impedance mismatch between the specification and execution of model transformations, being the prerequisite for convenient debugging. Second, by providing a homogenous representation of all artifacts involved in a transformation, including metamodels, models and the actual transformation logic itself, understandability of model transformations is enhanced.

Keywords:
Astract: Realizing information exchange is a frequently recurring challenge in nearly every domain of computer science. Although languages, formalisms, and storage formats may differ in various engineering areas, the common task is bridging schema heterogeneities in order to transform their instances. Hence, a generic solution for realizing information exchange is needed. Conventional techniques often fail, because alignments found by matching tools cannot be executed automatically by transformation tools. In this paper we present the Smart Matching approach, a successful combination of matching techniques and transformation techniques, extended with self-tuning capabilities. With the Smart Matching approach, complete and correct executable mappings are found in a test-driven manner.