Horst Kargl

Lifting metamodels to ontologies: a step to the semantic integration of modeling languages

The use of different modeling languages in software development makes their integration a must. Most existing integration approaches are metamodel-based with these metamodels representing both an abstract syntax of the corresponding modeling language and also a data structure for storing models. This implementation specific focus, however, does not make explicit certain language concepts, which can complicate integration tasks. Hence, we propose a process which semi-automatically lifts metamodels into ontologies by making implicit concepts in the metamodel explicit in the ontology. Thus, a shift of focus from the implementation of a certain modeling language towards the explicit reification of the concepts covered by this language is made. This allows matching on a solely conceptual level, which helps to achieve better results in terms of mappings that can in turn be a basis for deriving implementation specific transformation code.

Towards Model Transformation Generation By-Example

With the advent of model-driven engineering (MDE) several model transformation approaches and languages have been developed in the previous 5 years. Most of these existing approaches are metamodel-based with metamodels representing both an abstract syntax of the corresponding modeling language and also a data structure for storing models. However, this implementation specific focus makes it difficult for modelers to develop model transformations, because metamodels do not necessarily define all language concepts explicitly which are available for notation purposes. Therefore, we propose a by-example approach for defining inter-model mappings representing semantic correspondences between concrete domain models, which is more user-friendly, then directly specifying model transformation rules or mappings based on the abstract syntax. The inter-model mappings between domain models can be used to generate model transformation rules, by-example, taking into account the already defined mapping between abstract and concrete syntax elements. With this approach the users knowledge about the notation of the modeling language is sufficient for the definition of model transformations regarding semantic correspondences. Hence, no detailed knowledge about the metamodel and the model transformation language is required

A Framework for Building Mapping Operators Resolving Structural Heterogeneities

Seamless exchange of models among different modeling tools increasingly becomes a crucial prerequisite for the success of modeldriven engineering. Current best practices use model transformation languages to realize necessary mappings between concepts of the metamodels defining the modeling languages supported by different tools. Existing model transformation languages, however, lack appropriate abstraction mechanisms for resolving recurring kinds of structural heterogeneities one has to primarily cope with when creating such mappings.

Conflicts as first-class entities: a UML profile for model versioning

The urgent demand for optimistic version control support for software models induced active research within the modeling community. Recently, several approaches have been proposed addressing the task of detecting conflicts when merging two concurrently changed versions of a model. In this context, the holistic representation and supportive visualization of detected merge conflicts pose a challenge. In this paper, we present a modeling language independent conflict model comprising all necessary information to profoundly represent merge conflicts. From this conflict model, we leverage the dynamic extension power of UML profiles by introducing a dedicated conflict profile to visually assist modelers in resolving merge conflicts of UML models. As a result, modelers may resolve conflicts in the concrete graphical syntax conducting their familiar UML editors without tool extensions.

SmartMatcher -- How Examples and a Dedicated Mapping Language can Improve the Quality of Automatic Matching Approaches

Information integration has a long history in computer science. It has started with the integration of database schemas in the early eighties. With the rise of the semantic Web and the emerging abundance of ontologies, the need for an automated integration increased further. A lot of automated matching approaches and tools have been proposed so far. The typical output of such tools is a simple one-to-one alignment mostly based on schema information, e.g., similar names and structures of schema elements. However, these alignments cannot cope with schema heterogeneities, hence, these problems must be resolved manually. Furthermore, there is no automated evaluation of the quality of the alignments based on the instance level, because the matching approaches are not bound to a specific integration scenario, e.g., transformation or merge. In this work we propose the SmartMatching approach, which can be seen as an orthogonal extension to existing matching approaches for increasing the quality of the automatically produced alignments for the transformation scenario. This is achieved by using an executable mapping language for bridging schema heterogeneities and by using instance models to evaluate the quality of the alignments in an iterative and feedback-driven process inspired by machine learning approaches.

On Realizing a Framework for Self-tuning Mappings

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.