Louis M. Rose

Model migration with epsilon flock

In their recent book, Mens and Demeyer state that Model-Driven Engineering introduces additional challenges for controlling and managing software evolution. Today, tools exist for generating model editors and for managing models with transformation, validation, merging and weaving. There is limited support, however, for model migration - a development activity in which instance models are updated in response to metamodel evolution. In this paper, we describe Epsilon Flock, a model-to-model transformation language tailored for model migration that contributes a novel algorithm for relating source and target model elements. To demonstrate its conciseness, we compare Flock to other approaches.

The Epsilon Generation Language

We present the Epsilon Generation Language (EGL), a model-to-text (M2T) transformation language that is a component in a model management tool chain. The distinctive features of EGL are described, in particular its novel design which inherits a number of language concepts and logical features from a base model navigation and modification language. The value of being able to use a M2T language as part of an extensible model management tool chain is outlined in a case study, and EGL is compared to other M2T languages.

A research roadmap towards achieving scalability in model driven engineering

As Model-Driven Engineering (MDE) is increasingly applied to larger and more complex systems, the current generation of modelling and model management technologies are being pushed to their limits in terms of capacity and efficiency. Additional research and development is imperative in order to enable MDE to remain relevant with industrial practice and to continue delivering its widely recognised productivity, quality, and maintainability benefits. Achieving scalability in modelling and MDE involves being able to construct large models and domain-specific languages in a systematic manner, enabling teams of modellers to construct and refine large models in a collaborative manner, advancing the state of the art in model querying and transformations tools so that they can cope with large models (of the scale of millions of model elements), and providing an infrastructure for efficient storage, indexing and retrieval of large models. This paper attempts to provide a research roadmap for these aspects of scalability in MDE and outline directions for work in this emerging research area.

Taming EMF and GMF using model transformation

EMF and GMF are powerful frameworks for implementing tool support for modelling languages in Eclipse. However, with power comes complexity; implementing a graphical editor for a modelling language using EMF and GMF requires developers to hand craft and maintain several low-level interconnected models through a loosely-guided, labour-intensive and error-prone process. In this paper we demonstrate how the application of model transformation techniques can help with taming the complexity of GMF and EMF and deliver significant productivity, quality, and maintainability benefits. We also present EuGENia, an open-source tool that implements the proposed approach, illustrate its functionality through an example, and report on the communitys response to the tool.

The Design of a Conceptual Framework and Technical Infrastructure for Model Management Language Engineering

Model management is the discipline of managing artefacts used in Model-Driven Engineering (MDE). A model management framework defines and implements the operations (such as transformation or code generation) required to manipulate MDE artefacts. Modern approaches to model management generally implement these operations via domain-specific languages (DSLs). This paper presents and compares the principles behind three approaches to implementing DSLs for model management and identifies some of the key differences between DSL engineering in general and for model management. It then shows how theory relates to practice by illustrating how DSL design and implementation approaches have been used in practice to build working languages from the Epsilon model management framework. A set of questions for guiding the development of new model management DSLs is summarised, and data on development costs for the different approaches is presented.

A comparison of model migration tools

Modelling languages and thus their metamodels are subject to change. When a metamodel evolves, existing models may no longer conform to the evolved metamodel. To avoid rebuilding them from scratch, existing models must be migrated to conform to the evolved metamodel. Manually migrating existing models is tedious and errorprone. To alleviate this, several tools have been proposed to build a migration strategy that automates the migration of existing models. Little is known about the advantages and disadvantages of the tools in different situations. In this paper, we thus compare a representative sample of migration tools - AML, COPE, Ecore2Ecore and Epsilon Flock - using common migration examples. The criteria used in the comparison aim to support users in selecting the most appropriate tool for their situation.

Update Transformations in the Small with the Epsilon Wizard Language

We present the Epsilon Wizard Language (EWL), a tool-supported language for specifying and executing automated update transformations in the small based on existing model elements and input from the user. We discuss on EWL’s requirements and relevant design decisions, as well as the infrastructure upon which the language has been developed. We also provide concrete working examples to demonstrate how EWL can be used to automate the process of constructing and refactoring models.

Graph and model transformation tools for model migration

We describe the results of the Transformation Tool Contest 2010 workshop, in which nine graph and model transformation tools were compared for specifying model migration. The model migration problem—migration of UML activity diagrams from version 1.4 to version 2.2—is non-trivial and practically relevant. The solutions have been compared with respect to several criteria: correctness, conciseness, understandability, appropriateness, maturity and support for extensions to the core migration task. We describe in detail the comparison method, and discuss the strengths and weaknesses of the solutions with a special focus on the differences between graph and model transformation for model migration. The comparison results demonstrate tool and language features that strongly impact the efficacy of solutions, such as support for retyping of model elements. The results are used to motivate an agenda for future model migration research (including suggestions for areas in which the tools need to be further improved).

EUnit: a unit testing framework for model management tasks

Validating and transforming models are essential steps in model-driven engineering. These tasks are often implemented as operations in general purpose programming languages or task-specific model management languages. Just like other software artefacts, these tasks must be tested to reduce the risk of defects. Testing model management tasks requires testers to select and manage the relevant combinations of input models, tasks and expected outputs. This is complicated by the fact that many technologies may be used in the same system, each with their own integration challenges. In addition, advanced test oracles are required: tests may need to compare entire models or directory trees. To tackle these issues, we propose creating an integrated unit testing framework for model management operations. We have developed the EUnit unit testing framework to validate our approach. EUnit tests specify how models and tasks are to be combined, while staying decoupled from the specific technologies used.

Raising the level of abstraction in the development of GMF-based graphical model editors

The Eclipse Graphical Modeling Framework (GMF) provides substantial infrastructure and tooling for developing diagram-based editors for modelling languages atop the Eclipse platform. It is widely accepted that implementing a visual editor using the built-in GMF facilities is a particularly complex and error-prone task and requires a steep learning curve. We present an approach that raises the level of abstraction at which a visual editor is specified. The approach uses annotations at the metamodel level. Annotations are used for producing the required low-level intermediate GMF models necessary for generating an editor via model-to-model transformations.