"Développement d'applications à grande échelle par composition de métamodèles"
Composing Domain-Specific Metamodels for Large-Scale Software Engineering

Université de Grenoble, Grenoble, France
December 2005

Model Driven Software Engineering (MDSE) is a Software Engineering approach that addresses the ever increasing complexity of software development and maintenance through a unified conceptual framework in which the whole software life cycle is seen as a process of model production, refinement and integration.

This thesis contributes to this MDSE trend. We focus mainly on the issues raised by the complexity and diversity of the domains of expertise involved in large size software applications, and we propose to address these issues in an MDSE perspective.

A domain is an expertise area, potentially shared by many different software applications. The knowledge and know-how in a domain are major assets. This expertise can be formalized and reused when captured by a Domain Specific Language (DSL).

We propose an approach in which the target system is described by different models, written in different DSL. In this approach, composing these different models allows for modeling complex application covering simultaneously different domains.

Our approach is an original contribution in that each DSL is specified by a meta model precise enough to build, in a semi automatic way, a domain virtual machine; it is this virtual machine that interprets the domain models. Then, it is possible to compose these meta models to define new and more complex domains. Meta model composition increases modularity and reuse, and allows building domain with much larger functional scope than possible with traditional approaches.


"Inconsistency Management in Model-Driven Engineering - An Approach using Description Logics"

Vrije Universiteit Brussel, Brussel, Belgium
September 2005

Model-driven engineering (MDE) is an approach to software development where the primary focus is on models, as opposed to source code. Models are built representing different views on a software system. Models can be refined, evolved into a new version, and can be used to generate executable code. The ultimate goal is to raise the level of abstraction, and to develop and evolve complex software systems by manipulating models only. The manipulation of models is achieved by means of model transformation. Because model-driven engineering is still in its infancy, there is a need for sophisticated formalisms, techniques and associated tools supporting model development, evolution and transformation. The main concern of the research presented in this dissertation, is the definition, detection and resolution of model inconsistencies. We focus on two aspects of these activities: defining and resolving inconsistencies, and a feasibility study of Description Logics (DLs) as a formalism for supporting these activities.

Since the Unified Modeling Language (UML) is the generally accepted object-oriented modelling language, it ought to play an essential role in MDE. A software design is typically specified as a collection of different UML diagrams. Because different aspects of the software system are covered by different UML diagrams, there is an inherent risk that the overall specification of the system is inconsistent. Also model transformations, such as (arbitrary) model evolutions, can transform a model into an inconsistent state. Unfortunately, currentday UML CASE tools provide poor support for managing inconsistencies between (evolving) UML models.

Inconsistency management is a complex process consisting of different activities. It is a well-studied process that is also well-known within software engineering. However, in the UML context, little research has been done taking into account a wide range of inconsistencies over different kinds of UML diagrams. Inconsistency management in the UML context, is quite complicated due to several reasons. The most obvious reasons are the missing formal semantics for the UML and the UML being a general purpose language that can be applied to several application domains and in several software development processes.

To be able to define the occurrence of UML model inconsistencies precisely and unambiguously, there is first of all a need to formalise the UML’s abstract syntax and concepts.
A first contribution is to formalise an important fragment of the abstract syntax. The studied UML fragment allows the specification of the static structure of an application and
the specification of behaviour of individual objects and the possible interactions betwe as a process, also includes the activity of resolving inconsistencies. Different resolution
strategies are known in literature. The resolution of inconsistencies gives rise to some particular challenges. We give an overview of these challenges in the context of our classified

From the formalisation of a fragment of the UML abstract syntax, from our classification of inconsistencies, from the definition of different inconsistencies and from the different resolution strategies, we distil a set of key criteria. The requirements for each of these criteria can be used to evaluate a formalism and tool support supporting the detection and resolution of inconsistencies.

Through the second focus of this dissertation, we discovered that Description Logics (DLs) and DL systems are suited (or can be made suited) for the detection and resolution of inconsistencies on a fairly high-level of model abstraction.

DL is a two-variable fragment of first-order predicate logic, defining a family of logic languages, offering a classification task based on the subconcept-superconcept relationship. DLs are very suited for reasoning about hierarchies and about the satisfiability of knowledge bases. Different DL systems are developed and can be used to validate this formalism for the purpose of inconsistency detection and resolution.

DLs are validated against our key criteria in three successive steps. First, we investigate to which extent it is possible to encode the fragment under study of the abstract syntax of the UML. We also answer the question if DLs can be used as a semantic domain for some possible semantics for UML diagrams. Second, we show how inconsistencies can be detected using this formalism. Finally, we investigate if it is possible to resolve inconsistencies using DLs and the capabilities of state-of-the-art DL systems.

Model transformations are considered to be the heart and soul of MDE. One particular kind of model transformation and evolution is model refactoring. Model refactorings restructure models as opposed to source code refactorings, which restructure source code and are well-known and well-studied. Model refactorings preserve behaviour. We show how some of the classified inconsistencies correspond to behaviour preserving properties that can be expressed between a UML model and its refactored version. A second idea about model refactorings introduced in this dissertation, is to use inconsistency detection and resolution techniques for supporting a software engineer in executing model refactorings.

Our ideas are illustrated and validated on a simplified, yet complex enough, set of models of an Automatic Teller Machine (ATM) simulation application using a prototype tool, called RACOoN. This tool is integrated in a commercial UML CASE tool using the latter’s built-in plugin mechanism.


"Adaptability of Model Transformation"

Universiteit Twente, Twente, Netherlands
August 2005

Model Driven Engineering (MDE) is an emerging approach for software development. This thesis focuses on one of the main research topics in MDE: transforming models. This topic may be studied from process and artifact perspectives. The artifact perspective involves transformation definitions and models. Transformation definitions written in transformation languages are software assets that may be considered as important as models of systems. Transformation definitions may be subject of design, implementation, reuse and evolution. In addition, they are affected by changes in their environment.An important quality factor of software is adaptability, which indicates the capabilities of software to be modified for a changing environment and as a response to changes in software requirements. Adaptability of model transformations is required in several cases motivated by various changes that may occur.

This thesis addresses three problems related to the adaptability property of model transformations:

  • identification and comparison of alternative transformations, 

  • definition of transformation languages capable of expressing transformations among models written in different languages,

  • and language support for reusable and adaptable transformations.

We claim that the identification of alternative transformations should be included as a step in an MDE process. This is motivated by the observation that multiple ways are usually available to transform a given source model to a target model. The resulting target models may be functionally equivalent but different in their quality properties such as adaptability and performance. Software engineers must be able to identify transformations that produce models with the required quality properties. For this purpose a formal technique is defined for describing the space of alternative transformations for a given source model. The technique provides operations for reduction of and selection from transformation spaces on the basis of the desired quality properties of the resulting target model.

The thesis presents a hybrid transformation language named MISTRAL capable of defining transformations between models expressed in different modeling languages. The transformation language is separated from the instantiation and generalization mechanisms, which are represented in the modeling space in which the transformation language operates. Transformation definitions are specified on the basis of intensions. The concept of intension is a generalization of the concepts of meta-model and domain model expressed in a modeling language. The transformation language MISTRAL is capable of working with more than one instanceOf relation and more than one model level in a single transformation definition. This overcomes a major drawback in current transformation languages that are often coupled with particular modeling languages. A prototype shows the feasibility of this approach.

Transformation definitions should be reusable and adaptable artifacts. The thesis studies requirements for a transformation language to provide adequate support for reusability and adaptability of transformation definitions. An evaluation of a set of representative languages against requirements is given. A light-weight approach is proposed for extending transformation languages with new features.

The techniques proposed in the thesis are applied in a case study on XML (eXtensible Markup Language) processing based on model transformations. Compared to current techniques, this approach improves the extensibility of XML applications.


Modelltransformationen als Mittel der modellbasierten Entwicklung von Software-Systemen
Model transformations as means for the model based development of software systems

Technische Universität München, Germany
February 2005

Today in software engineering model based development approaches are applied more and more. Within these approaches conceptual models with precisely defined semantics are used for the description of software systems. By the restriction of models to the essential characteristics of systems and the possibility to restrict the structure of models and model operations in a suitable manner, these approaches contribute essentially to the efficiency of the development process and to the quality of the created software products.

The manipulation of conceptual models usually takes place through suitable description techniques which allows one to build views onto a conceptual model. Techniques are developed within this thesis that allow one to integrate description techniques into a common conceptual model by transformations of the description techniques’ abstract syntaxes.

Conceptual models are often created at different levels of abstraction during a software development process. Ideally more concrete models can be derived (partially) automatically by refinement mappings. Therefore methods are developed that allow a consistent refinement and extension of conceptual models.

Further, an unambigeously defined development process offers developers the needed assistance for the specification and the creation of a software system. Therefore a framework for the definition of flexible development processes is built which defines development steps as transformations of the model of artifacts created during the development process.

The structure of correct models is defined by metamodels. Since object-oriented metamodels can be mapped very easily to a tool support, these kinds of metamodels are very widespread in software engineering. In order to be able to implement the presented concepts on model driven development processes the "Bidirectional Object-Oriented Transformation Language" (BOTL) is introduced as a mechanism for the transformation of object-oriented models. The Language comprises formal semantics and offers a number of verification techniques that allow to verify whether a transformation specification is executable and whether it will create syntactically correct models or not.

The use of BOTL for the realization of a model based development approach is presented and the application of the different techniques is shown exemplary on the basis of the requirements engineering methodology KOGITO.

The viability of the presented approaches for model transformations is verified by a tool support that was developed within this thesis. The tool allows the graphical specification of BOTL transformations and their automated verification. Ultimately a transformation component is able to transform object oriented models of different technical formats like Java object structures or XMI according to a BOTL specification.

IRISA, INRIA, Rennes, France 
December 2004

not available 

External link

"Multi-path Development of User Interfaces"
Université Catholique de Louvain
Autumn 2004

In software engineering transformational development is a paradigm consisting in the progressive refinement of abstract models into concrete models, until program code. This thesis applies transformational development concepts to User Interfaces (UIs). It enlarges the paradigm of transformational development by defining a methodology allowing the realization of various types of development paths (e.g., forward engineering, reverse engineering, context of use adaptation) in order to realize multi-path development, we propose an ontology of concepts defining various viewpoints that can be maintained on a UI system. Viewpoints are hierarchically structured depending on their level of abstraction. They describe user tasks, classes of objects, presentational and behavioral aspects of UIs, context
of use, and a set of mappings between these representations. The underlying mathematical formalism of our ontology being a graph structure (directed, identified, labeled, constrained, and typed graphs), we transform one viewpoint into another by the application of conditional graph rewriting rules gathered in graph grammars. These enable us expressing a wide variety of transformational
heuristics so as to be able to express multiple development paths. Ontology and transformations may be stored in an XML format called UsiXML (User interface eXtensible Markup Language) allowing the dissemination, the capitalization, and the consolidation of UI specifications and transformation catalogs.

External Link


"Metamodel Driven Model Migration"
Vanderbilt University, Nashville, Tennessee, USA 
August 2003

not available 

External link


"Séparation des préoccupations et métamodélisation pour environments de manipulation d'architectures logicielles à base de composants"
Separation of Concerns and Metamodeling applied to Software Architecture Handling
(partial translation)

Université des Sciences et Technologies de Lille, Lille, France
December 2002

Software architectures are centric regarding software engineering processes. Architecture Description Languages (ADLs) represent the most suited mean to define such architectures. Nevertheless, those ADLs concepts are most often fixed and their use does not always match the various concerns of software engineering processes. Moreover, their syntaxic reduced means do not ease the collaboration of the various actors of a software engineering process. Our proposal (CODeX) provides a framework for ADL meta-modeling. A meta-model defines the architectural concepts required by a software engineering process. In order to structure such definitions and to improve the collaboration of the various actors, meta-models are defined following the sepration of software engineering processes' architectural concerns. This separation also defines the relationship between the various concepts of an ADL. Together with this framework, a set of tools relying on the meta-model of an ADL automatically generate the associated environment to define and manipulate software architectures. The later is designed around a reified representation of software architectures. This representation also follows the separation of concerns defined in the meta-model and provides each actor a dedicated view on a software architecture.
Metamodeling, Separation of Concerns, Architecture Description Languages, Software Components, Software Engineering Process.

(french version)
(partial english version)

Metamodel for Object-Oriented Database Management Systems
Polish Academy of Sciences, Warsaw, Poland
August 2002

A database metamodel is inherent to every DBMS. Appropriate constructs reflect the declarations of data-definition and data-manipulation languages, and are necessary to implement the internal DBMS mechanisms. Particularly, a metamodel definition provides a base for implementation of database’s schema repository. However in object-oriented DBMS these notions are often treated implicitly or (as in case of ODMG standard) suffer from rather ad-hoc approach to their definition. This work is intended to show the importance of providing an explicit database metamodel definition that is both simple and extensible. The main roles of database metamodel have been enumerated. Since different responsibilities of database metamodel together with inherent complexity of object data model can easily lead to unacceptably complicated metamodel definition, the radically simplified, “flattened” form of metamodel structure is proposed. Moreover, the proposed solution assumes the usage of generic means to manipulate database metadata instead of a large set of narrowly specialize operations assumed by the ODMG standard. The prototype implementation of metadata repository is provided to prove the feasibility of the simplified metadata structure. To show the importance of metamodel extensibility, the database schema-based mechanism to support the configuration management of ODBMS application has been implemented over the flattened metamodel structure. A number of additional remarks, concerning future extensions to a database metamodel as well as its capability to accept custom extensions in the context of current challenges for database management systems, have been presented.



"Contribution à la représentation de processus par des techniques de méta-modélisation"
Université de Nantes, Nantes, France 
Juin 2002

The concept of process is taking a significant place in the field of software engineering. The increasing complexity of information systems, the speed of technological evolution and the new working methods (outsourcing and subcontracting) are some reasons that explain this phenomen on. Process management is thus becoming a major stake for most companies. Our work is situated within this framework. The Sodifrance Company, the industrial partner of this thesis, is specialized in the management and the evolution of information systems. Know-how on the processes of maintenance and migration were acquired as projects were carried out. In order to collect and organize this knowledge we propose a formali sm dedicated to the description of this type of processes. It has been defined using meta-modeling techniques. Those radically evolved these last years since the adoption of the MOF by the OMG. This trend leads into the MDA, another proposal of the OMG, which proposes a new approac h to software engineering based on models. From these specifications, and the products developed at Sodifrance for model transformation and c ode generation, we designed a set of tools for the definition and the handling of process models. In particular, we developed mechanisms for operationalizing process models that were validated within an industrial project of applicative third party maintenance managed by Sodifrance . This work initiated some thoughts on the contributions of meta-modeling to the representation of processes. We mainly focused on the organi sation of process meta-models and their relations with meta-models dedicated to different fields. We also carried out some experiments on mak ing explicit the dynamic aspects of processes and the rules specifying their execution.

"Aspect-Oriented Domain-Specific Modeling: A Generative Approach using a Metaweaver Framework"
Université Vanderbilt University, Nashville, TN USA
May 2002

The Issues pertaining to separation of concerns have been the primary nexus between software engineering and programming language research. Several techniques for advanced separation of concerns have been proposed within the area of Aspect-Oriented Software Development (AOSD). These techniques have focused on the modularization of non-orthogonal concerns that exhibit crosscutting behavior. This dissertation is about advanced separation of concerns at the modeling level, and the construction of support tools that facilitate the elevation of crosscutting modeling concerns to first-class citizens.

A key objective of the research described in this dissertation is the application of Aspect-Oriented (AO) concepts at a higher level of abstraction. The principles of modularity espoused by AO offer a powerful technology for supporting the separation of crosscutting concerns in domain-specific modeling. Although there have been other efforts that explore AO at the design and analysis level, the work described in this dissertation represents one of the earliest occurrences in the literature of an actual aspect-oriented weaver that is focused on modeling issues, rather than topics that are applicable to traditional programming languages.

Another objective of the research presented in this dissertation pertains to the creation of new weavers using a metaweaver framework. Because the syntax and semantics of each modeling domain are unique, a different weaver is needed for each domain. A metaweaver framework has been created as an aid toward the construction of new domain-specific weavers. This framework utilizes several code generators that take metalevel specifications, described in a Domain-Specific Language (DSL), as input. The generators produce code that serves as a hook into the framework.

These two objectives provide a contribution toward the synergy of AOSD and Model-Integrated Computing (MIC). This union assists a modeler in capturing concerns that, heretofore, were very difficult, if not impossible, to modularize. A key benefit is the ability to explore numerous scenarios by considering crosscutting modeling concerns as aspects that can be rapidly inserted and removed from a model.



"A Metamodel-based Approach to Integrate Object-Oriented Graphical and Formal Specification Techniques"
University of Queensland, Brisbane, Australia
Novembre 2001

not available

External link



"Techniques de Modélisation et de Méta-modélisation"
Université de Nantes, Nantes, France
October 2000

not available 


Your PhDs is not there? Want to add/remove/change something? Use the MODIFICATION FORM