Traceability-based change management in operational mappings

This paper describes an approach for the analysis of changes in model transformations in the Model Driven Architecture (MDA). Models should be amenable to changes in user requirements and technological platforms. Impact analysis of changes can be based on traceability of model elements. We propose a model for generating trace links between model elements and study scenarios for changes in source models and how to identify the impacted elements in the target model

Rewriting Constraint Models with Metamodels

An important challenge in constraint programming is to rewrite constraint models into executable programs calculat- ing the solutions. This phase of constraint processing may require translations between constraint programming lan- guages, transformations of constraint representations, model optimizations, and tuning of solving strategies. In this paper, we introduce a pivot metamodel describing the common fea- tures of constraint models including different kinds of con- straints, statements like conditionals and loops, and other first-class elements like object classes and predicates. This metamodel is general enough to cope with the constructions of many languages, from object-oriented modeling languages to logic languages, but it is independent from them. The rewriting operations manipulate metamodel instances apart from languages. As a consequence, the rewriting operations apply whatever languages are selected and they are able to manage model semantic information. A bridge is created between the metamodel space and languages using parsing techniques. Tools from the software engineering world can be useful to implement this framework

Towards a family of model transformation languages

Abstract. Many model transformation languages of different nature have been proposed during the last years, each one of them suitable for a certain kind of transformation task. However, a complex transformation problem may not fall into a single transformation category, making the solution written in the chosen transformation language suboptimal, as some concerns cannot be handled naturally. To tackle this issue, we propose to define a model transformation tool as a family of model transformation languages. Each member of the family is a simple language intended to deal with a particular kind of transformation task. In this paper we discuss the different issues involved, such as design decisions, interoperability among languages, and composability. We illustrate the paper with a transformation from UML and OCL to Java, in which languages for pattern matching, mapping, attribution and target-oriented transformations are used. Finally, the approach is validated with a proof-of-concept implementation

Toward the adaptation of component-based architectures by model transformation: behind smart user interfaces

Graphical user interfaces are not always developed for remaining static. There are GUIs with the need of implementing some variability mechanisms. Component-based GUIs are an ideal target for incorporating this kind of operations, because they can adapt their functionality at run-time when their structure is updated by adding or removing components or by modifying the relationships between them. Mashup user interfaces are a good example of this type of GUI, and they allow to combine services through the assembly of graphical components. We intend to adapt component based user interfaces for obtaining smart user interfaces. With this goal, our proposal attempts to adapt abstract component-based architectures by using model transformation. Our aim is to generate at run-time a dynamic model transformation, because the rules describing their behavior are not pre set but are selected from a repository depending on the context. The proposal describes an adaptation schema based on model transformation providing a solution to this dynamic transformation. Context information is processed to select at run-time a rule subset from a repository. Selected rules are used to generate, through a higher-order transformation, the dynamic model transformation. This approach has been tested through a case study which applies different repositories to the same architecture and context. Moreover, a web tool has been developed for validation and demonstration of its applicability. The novelty of our proposal arises from the adaptation schema that creates a non pre-set transformation, which enables the dynamic adaptation of component-based architectures

Rule-based modularization in model transformation languages illustrated with ATL

International audienc

User-defined Code generation from UML 2.0

This thesis explores ways to implement transformations from UML 2.0 to code in such a way that the generated code can be customized and extended in a compact and user-friendly way. As a solution to this problem I introduce a general transformation architecture. The architecture uses an intermediate meta-model in two parts and the transformations are split into manageable, reusable modules. An example scenario is implemented by two different approaches. Two different intermediate meta-models are implemented and in each case the general transformation architecture is adapted to the specific scenario. Finally I show examples of how the generated code can be customized by extending or replacing parts of the transformation architecture

Evaluation of Rule-based Modularization in Model Transformation Languages illustrated with ATL

This paper studies ways for modularizing transformation definitions in current rule-based model transformation languages. Two scenarios are shown in which the modular units are identified on the base of the relations between source and target metamodels and on the base of generic transformation functionality. Both scenarios justify modularization by requiring adaptability and reusability in transformation definitions. To enable representation and composition of the identified units, a transformation language must provide proper modular constructs and mechanisms for their integration. We evaluate several implementations of the scenarios by applying different transformation techniques: usage of explicit and implicit rule calls, and usage of rule inheritance. ATLAS Transformation Language (ATL) is used to illustrate these implementations. The experience with these scenarios shows that current languages provide a reasonably full set of modular constructs but may have problems in handling some composition tasks