Keywords: RIA, e-Learning, UML, Visualization, Diagrams, Class Diagrams, Modeling, Metamodeling, Model Engineering, Web
Astract: The ability of software engineers to develop clear and comprehensive models according to a specific problem domain has become an essential factor for the success of software projects. The trend of Model Driven Software Engineering (MDSE) even increases this factor.
Universities have to qualitatively educate their students in this field to prepare them for those challenges.
At the Vienna university of Technology (VUT), the course "Object Oriented Modeling" teaches the basics of modeling and the Unified Modeling Language (UML). Due to the high number of students, various e-Learning elements have already been established, mainly for teaching the theory behind UML.
The goal of this thesis was to develop a web-based modeling tool, that is integrated into the e-Learning platform of the VUT using Rich Internet Application technologies. Thus, students can solve practical modeling exercises comfortably and directly using the e-Learning platform. Therefore, a generic approach shall be used by utilizing metamodeling: Visualization and manipulation of two-dimensional diagrams is based on certain patterns. A framework was created, that allows for creating complete diagram editors with drag-and-drop functionality, by specifying the structure of the diagram elements (abstract syntax) and the visual notation elements (concrete syntax). This enables to easily create various UML editors and to align the notation elements with those of the course. Within this thesis, three editors (class diagram, state diagram, and sequence diagram) have been created with the aid of the framework and integrated into the e-Learning platform.

Keywords: UML, UML 2.0, Unified Modeling Language, modeling
Astract: In 2005 the Object Management Group (OMG) adopted the UML 2.0, a new version of the Unified Modeling Language which is said to be more compact, understandable and coherent.
The main criticism of the UML 1.x is its extensive and complex format which inhibits learners from quickly utilizing the functions the program offers.1 This thesis dealt with the question of whether the UML 2.0 has become more effective an efficient. This question can be addressed through the creation of a software project in which all UML 2.0 diagrams are used.
The theoretical part contains a historical description of the UML as well as the diagram types. Ultimately, the objective is to create diagrams which enables the reader to quickly comprehend the operations of the UML 2.0. The description of the software project is also included in the theoretical part. The software project is about the combining of single software systems of an enterprise into one. The objective of the enterprise is to work with one single system instead of using several systems.
Within the practical part a set of criteria was prepared which critically questioned the different aspects of the diagrams.

Keywords:
Astract: Model integration is one of the core components for the realization of model-driven engineering. In particular, the seamless exchange of models among different modeling tools is of special importance. This exchange is achieved by the means of model transformations. However, the manual definition of model transformations is an error prone and cumbersome task. So matching techniques, originally intended for database schema integration, have been reused. The result is unsatisfactory as current matching approaches typically produce only one-toone alignments which are inappropriate for many integration problems. As a consequence, a detailed review and a manual post-processing step is often necessary. To tackle these problems, we propose the self-tuning framework SmartMatcher for improving automatically generated transformations. Our approach combines the power of an executable mapping language for bridging structural heterogeneities with the strength of an instance based quality evaluation model. In an iterative, feedback-driven process a mapping between two schemas is constructed and repeatedly enhanced.

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.