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.

Keywords:
Astract: 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 user´s 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.

Keywords:
Astract: The standardized QVT Relations language, one cornerstone of Model-Driven Architecture (MDA), has not yet gained widespread use in practice, not least due to missing tool support in general and inadequate debugging support in particular. Transformation engines interpreting QVT Relations operate on a low level of abstraction, hide the operational semantics of a transformation and scatter metamodels, models, QVT code, and traces across different artifacts. We propose a model-based debugger representing QVT Relations on bases of TROPIC, a model transformation framework which utilizes a variant of Colored Petri Nets (CPNs) providing an explicit runtime model and a homogenous view on all artifacts of a transformation.