Project-Team-Triskell:Model-Driven Engineering

Project-Team : triskell

Section: New Results

Model-Driven Engineering

Weaving Executability into Object-Oriented Meta-Languages

Participants: Pierre-Alain Muller, Franck Fleurey, Jean-Marc Jézéquel.

Nowadays, object-oriented meta-languages such as MOF (Meta-Object Facility) are increasingly used to specify domain-specific languages in the model-driven engineering community. However, these meta-languages focus on structural specifications and have no built-in support for specifications of operational semantics. In [34] we explore the idea of using aspect-oriented modeling to add precise action specifications with static type checking and genericity at the meta level, and examine related issues and possible solutions. We believe that such a combination would bring significant benefits to the community, such as the specification, simulation and testing of operational semantics of metamodels. We present requirements for such statically-typed meta-languages and rationales for the aforementioned benefits.

Model Transformations

Participants: Jean-Marc Jézéquel, Pierre-Alain Muller, Franck Fleurey, Zoé Drey, Damien Pollet, Didier Vojtisek, Jim Steel.

Model engineering attempts to solve how we can evolve complex software systems. Indeed, those systems must follow the evolution of new requirements and technologies, and this evolution is faster and faster compared to the business domain evolution. We thus propose to reuse the domain expertise independently of any underlying technology, through model transformation techniques [35].

Domain specific languages for model transformation have recently generated significant interest in the model-driven engineering community. A number of approaches have been presented to model transformation, from graph-transformation-based techniques, to rule-based languages, to imperative languages. Each of these offer comparative advantages for different classes of model transformation problems.

One such approach is Tefkat, an implementation of a language designed specifically for the transformation of MOF models using patterns and rules. The language adopts a declarative paradigm, wherein users may concern themselves solely with the relations between the models rather than needing to deal explicitly with issues such as order of rule execution and pattern searching/traversal of input models. In [30], the language and its implementation are demonstrated using a provided example and highlight a number of language features used in solving the problem, a simple object-to-relational mapping.

Another approach is presented in [14] as an architecture for manipulating models which is independent of any specific metamodel. During development of model transformations, this architecture supports proven techniques of object-oriented software engineering. A reference implementation in functional programming specifies the semantics of the interface for accessing models.

This approach is based on a MOF-level interface for model manipulation. The associated programming language supports direct manipulation of model elements, because the metamodel structure dynamically extends the set of types available to the model transformation program. From a methodological point of view, we show that model transformations capture the implementation expertise for a business domain to a given technology ; it is therefore useful to model and develop complex transformations using sound software engineering and model engineering techniques. We illustrate this in practice using transformations for refactoring UML models.

Thus, while the adopted QVT specification has normalized some scheme of model transformation language; several different model transformation language paradigms are likely to co-exist in the near future, ranging from imperative to declarative (including hybrid). It remains nevertheless questionable how model transformation specific languages compare to more general purpose languages, in terms of applicability, scalability and robustness. [20] is a general overview of the different model transformation techniques, including concept and terminology presentation. In [35] we report on our specific experience in applying an executable meta-language such as Kermeta to the model transformation field.

Model Typing for Improving Reuse in Model-Driven Engineering

Participants: Jim Steel, Jean-Marc Jézéquel.

Where object-oriented languages deal with objects as described by classes, model-driven development uses models, as graphs of interconnected objects, described by metamodels. A number of new modeling languages have been and continue to be developed for this model-based paradigm, both for model transformation and for general programming using models. Many of these use single-object approaches to typing, derived from solutions found in object-oriented systems, while others use metamodels as model types, but without a clear notion of polymorphism. Both of these approaches lead to brittle and overly restrictive reuse characteristics.

The contribution presented in [40] presents a simple extension to object-oriented typing to better cater for a model-oriented context, including a simple strategy for typing models as a collection of interconnected objects. Using a simple example it is shown how this extended approach permits more flexible reuse, while preserving type safety.

Going forward, the presence of a well-founded type system for models will allow developers to reason about how various model-driven engineering artifacts interconnect, from models and metamodels to model transformations and programs, to repository and modelling tools.

Code Generation from UML Models with Semantic Variation Points

Participants: Franck Chauvel, Jean-Marc Jézéquel.

UML semantic variation points provide intentional degrees of freedom for the interpretation of the metamodel semantics. The interest of semantic variation points is that UML now becomes a family of languages sharing lot of commonalities and some variabilities that one can customize for a given application domain. This works [26] propose to reify the various semantic variation points of UML 2.0 statecharts into models of their own to avoid hardcoding the semantic choices in the tools. We do the same for various implementation choices. Then, along the line of the OMG's Model Driven Architecture, these semantic and implementation models are processed along with a source UML model (that can be seen as a PIM) to provide a target UML model (a PSM) where all semantic and implementation choice are made explicit. This target model can in turn serve as a basis for a consistent use of code generation, simulation, model-checking or test generation tools.

Bridges between Models and Text/Hypertext

Participants: Jim Steel, Pierre-Alain Muller, Jean-Marc Jézéquel.

In [36] we use HUTN as a bridge between ModelWare and GrammarWare, to generate parsers and editors for DSLs defined under the shape of metamodels. We describe the problems that we have encountered with the ambiguities of the current HUTN specification and discuss how this specification may be fixed to be usable with grammar-driven tools.

[21] is about platform independent Web application modeling and development in the context of model-driven engineering. Web applications are represented via three independent but related models (business, hypertext and presentation). A kind of action language (based on OCL and Java) is used all over these models to write methods and actions, specify constraints and express conditions.