Here are the main publications associated with the research subjects presented above.
-
Hugo Richard, Eric Cariou, and Jean-Philippe Babau, Weaving executable
models and code for software development, The 22nd European Conference on Modelling Foundations
and Applications (ECMFA 2026), Journal of Object Technology, 25(3), June 2026
[paper]
[abstract]
[BibTeX]
One of the initial objectives of MDE is to obtain a complete software application from models through
code generation. A standard such as fUML (Semantics of a Foundational Subset for Executable UML
Models) enables to add abstract code on UML and DSL (Domain-Specific Language) models, allowing
models to contain the entire definition of an application, from its architecture to its business
algorithms. However, this approach raises the issue of the ability to reuse existing code written
in a traditional programming language and of its adoption by software engineers. In this paper,
we propose an intermediate vision where an application is composed of an executable model defining
its behavior and traditional code defining its business operations. We propose a generic solution
for weaving business operation signatures onto elements of an executable DSL (xDSL), allowing
these operations to be executed automatically during model interpretation. We apply our solution
to the implementation of a drone simulator software: a xDSL is used to define the simulation
architecture model and the simulation functions are implemented in Java. We show that the
approach facilitates the configuration and the setup of the simulator.
@article{richard-ecmfa26,
author = {Hugo Richard and Eric Cariou and Jean-Philippe Babau},
title = {Weaving executable models and code for software development},
note = {Proceedings of the 22nd European Conference on Modelling Foundations and
Applications {(ECMFA 2026)}},
journal = {Journal of Object Technology},
volume = {25},
number = {3},
pages = {29--42},
year = {2026},
month = {June},
}
- Eric Cariou, Léa Brunschwig, Olivier Le Goaer, and Franck
Barbier, A software development process based on UML state
machines, The 4th Edition of the International Conference on
Advanced Aspects of Software Engineering (ICAASE’20), November
2020
[paper]
[slides]
[abstract]
[BibTeX]
We propose a model-based software development
process based on UML state machines. State machines are
executable models and such models offer the advantage to capture
the behavior of a system at a high-level of abstraction. Besides,
the business parts of the system can be specified and weave onto
the executable models, applying a good separation of concerns.
While advanced standards such as fUML enable to define the
complete contents of an application at the model level, it leads
to too much complexity and prevents flexibility in the use of
existing code. For these reasons, we propose an intermediate and
pragmatic approach where a UML state machine is compiled
onto Java code for our lightweight execution engine PauWare.
The business parts of the application are then implemented in
standard Java.
@InProceedings{cariou-icaase20,
author = {Cariou, Eric and Brunschwig, L{\'e}a and Le Goaer, Olivier and
Barbier, Franck},
title = {{A software development process based on UML state
machines}},
booktitle = {{The 4th Edition of the International Conference on
Advanced Aspects of Software Engineering (ICAASE’20)}},
publisher = {IEEE},
year = {2020},
}
- Franck Barbier and Eric
Cariou, Executable Modeling for Reactive Programming,
Model-Driven Engineering and Software Development. MODELSWARD 2018,
volume 991 of CCIS, Springer, February 2019
[paper]
[abstract]
[BibTeX]
After thirty years, it is reasonably time to critically look at Model
Driven Software Development (MDSD). Who may nowadays claim that MDSD
has been massively adopted by the software industry? Who may show numbers
demonstrating that MDSD allowed/allows massive cost savings in daily software
development, but, above all, software maintenance? This paper aims at investigating
executable modeling as a balanced articulation between programming and
modeling. Models at run-time embody the promising generation of executable
models, provided that their usages are thought and intended to cost-effective software
development. To envisage this not-yet-come success, this paper emphasizes
expectations from the software industry about “reactive programming”.
Practically, executable modeling standards like the SCXML W3C standard or the
BPMN OMG standard are relevant supports for reactive programming, but
success conditions still need to be defined.
@InProceedings{barbier-modelsward19,
author = {Franck Barbier and Eric Cariou},
title = {{Executable Modeling for Reactive Programming}},
booktitle = {{Model-Driven Engineering and Software Development (MODELSWARD
2018)}},
year = {2019},
volume = {991},
series = {CCIS},
publisher = {Springer}
}
- Eric Cariou, Olivier Le Goaer, Léa Brunschwig and Franck Barbier, A
generic solution for weaving business code into executable models, 4th International Workshop
on Executable Modeling at MoDELS (EXE 2018), CEUR Workshop Proceedings, vol. 2245, October 2018
[paper] [slides]
[abstract]
[BibTeX]
The separation of concerns is a fundamental principle that allows
to build a software with separate parts, thereby improving their
maintainability and evolutivity. Executable models are good potential
representatives of this principle since they capture the behavior
of a software-intensive system, that is, when, why and how calling
business operations, while the latter are specified apart. EMF is the
de facto framework used to create an executable DSL (xDSL) but a
solution to weave business operations into it is still missing. This
is compounded by the fact that such business operations can be
tied to specific technological platforms that stand outside the EMF
world (e.g. Android SDK). To that purpose, in this paper we describe
a solution for managing business operations both at design-time
(creation of executable models with EMF) and at run-time (operation
calls from the deployed execution engine). This solution is
generic enough to be integrated into any Java-based environment
and for any xDSL.
@InProceedings{cariou-exe18,
author = {Cariou, Eric and Le Goaer, Olivier and Brunschwig, L{\'e}a and
Barbier, Franck},
title = {{A generic solution for weaving business code into executable
models}},
booktitle = {{The 4th International Workshop on Executable Modeling at MODELS
(EXE 2018)}},
year = {2018},
volume = {2245},
publisher = {CEUR Workshop Proceedings}
}
- Eric Cariou, Olivier Le Goaer, and Franck
Barbier, On the Executable Nature of Models, 2nd
International Workshop on Executable Modeling at MoDELS (EXE 2016), CEUR Workshop Proceedings, vol.
1760,
October 2016
[paper]
[slides]
[abstract]
[BibTeX]
Within the model-driven engineering field, the con-
cept of “i-DSML” (interpreted Domain Specific Modeling Language)
refers to executable models which are interpreted through
an engine. While several works discussed the key ingredients of
an i-DSML, few of them answered the original question: What
is the class of models that are executable by nature and those
that are not? This paper attempts to provide some answers by
proposing two discriminating criteria: The possibility of defining
execution steps and the reification of the behavior of the running
system into the executed model. On this basis, we reconsider some
well-known DSML and notice a paradoxical situation with UML
diagrams.
@InProceedings{exe16-bibtex,
author = {Eric Cariou, Olivier Le Goaer, L\'ea Brunschwig and Franck
Barbier},
title = {{On the Executable Nature of Models}},
booktitle = {Proceedings of the Workshop at MoDELS 20016},
year = {2016},
volume = {1760},
publisher = {CEUR Workshop Proceedings},
}
- Franck Barbier, Eric Cariou, Olivier Le
Goaer, and Samson Pierre, Software Adaptation: Classification and
a Case Study with State Chart XML, IEEE Software, 32(5), Sept. Oct. 2015
[info]
[abstract]
[BibTeX]
Software adaptation has become prominent owing to the proliferation of
software in everyday devices. In particular, computing with the
Internet of Things requires adaptability. Traditional software
maintenance, which involves long, energy-consuming cycles, is no
longer satisfactory. Adaptation is a lightweight software evolution
that provides more transparent maintenance for users. This article
classifies types of adaptation and describes an implementation of it.
@Article{barbier-software15,
author = {Franck Barbier and Eric Cariou and Olivier Le Goaer and Samson
Pierre},
title = {{Software Adaptation: Classification and a Case Study with State Chart
XML}},
journal = {Software},
year = {2015},
volume = {32},
number = {5},
publisher = {IEEE},
pages = {68-76},
month = {Sept. Oct.}
}
- Samson Pierre, Eric Cariou, Olivier Le
Goaer, and Franck Barbier, A Family-based Framework for i-DSML
Adaptation, 10th European Conference on Modelling Foundations and
Applications (ECMFA 2014), volume 8569 of LNCS, Springer, July
2014
[paper]
[abstract]
[BibTeX]
One of the main goals of Model-Driven Engineering (MDE)
is the manipulation of models as software artifacts. Model execution is in
particular a means to substitute models for code. Precisely, if models of a
dedicated Domain-Specic Modeling Language (DSML) are interpreted
through an execution engine, then this DSML is called interpreted-DSML
(i-DSML for short). The possibility of extending i-DSML to adapt models
directly during their execution, allows the building of adaptable i-DSML.
In this article, we demonstrate that specializing adaptable i-DSML leads
to the potential definition of accurate adaptation policies. Domain-specicities
are the key factors to identify adaptations that really make sense.
In effect, we introduce the concept of family as a mean to encapsulate
adaptation operations that are attached to a particular domain. Families
can be specialized with the special purpose of defining a hierarchy of
adaptation contexts.
@InProceedings{pierre-ecmfa14,
author = {Samson Pierre and Eric Cariou and Olivier Le Goaer and Franck
Barbier},
title = {{A Family-based Framework for i-DSML Adaptation}},
booktitle = {10th European Conference on Modelling Foundations and Applications
(ECMFA 2014)},
pages = {164--179},
year = {2014},
volume = {8569},
series = {LNCS},
publisher = {Springer}
}
- Eric Cariou, Olivier Le Goaer, Franck
Barbier, and Samson Pierre, Characterization of Adaptable
Interpreted-DSML, 9th European Conference on Modelling Foundations
and Applications (ECMFA 2013), volume 7949 of Lecture Notes in
Computer Science, pp 37-53, Springer, July 2013
[paper]
[abstract]
[BibTeX]
One of the main goals of model-driven engineering (MDE)
is the manipulation of models as exclusive software artifacts. Model execution
is in particular a means to substitute models for code. More
precisely, as models of a dedicated domain-specific modeling language
(DSML) are interpreted through an execution engine, such a DSML is
called interpreted-DSML (i-DSML for short). On another way, MDE is a
promising discipline for building adaptable systems based on models at
runtime. When the model is directly executed, the system becomes the
model: This is the model that is adapted. In this paper, we propose a
characterization of adaptable i-DSML where a single model is executed
and directly adapted at runtime. If model execution only modifies the dynamical
elements of the model, we show that the adaptation can modify
each part of the model and that the execution and adaptation semantics
can be changed at runtime.
@InProceedings{cariou-ecmfa13,
author = {Eric Cariou and Olivier Le Goaer and Franck Barbier and Samson
Pierre},
title = {{Characterization of Adaptable Interpreted-DSML}},
booktitle = {9th European Conference on Modelling Foundations and Applications
(ECMFA 2013)},
pages = {37--53},
year = {2013},
volume = {7949},
series = {LNCS},
publisher = {Springer},
}
- Eric Cariou, Franck Barbier, and Olivier
Le Goaer, Model Execution Adaptation?, 7th International
Workshop on Models@run.time (MRT 2012) at MoDELS 2012, ACM Digital
Library, October 2012
[paper]
[abstract]
[BibTeX]
One of the main goals of model-driven engineering (MDE) is the
manipulation of models as exclusive software artifacts. Model
execution is in particular a means to substitute models for code. On
another way, MDE is a promising discipline for building adaptable
systems thanks to models at runtime. When the model is directly
executed, the system becomes the model, then, this is the model that
is adapted. In this paper, we investigate the adaptation of the model
itself in the context of model execution. We present a first
experimentation where we study the constraints on a model to be able
to determine if it is consistent (that is, adapted) with an
execution environment, possibly including fail-stop modes. Then,
we state some perspectives and open issues about model execution
adaptation.
@InProceedings{cariou-mrt12,
author = {Eric Cariou and Olivier {Le Goaer} and Franck Barbier},
title = {{Model Execution Adaptation?}},
booktitle = {7th International Workshop on Models@run.time (MRT 2012) at
MoDELS 2012},
year = {2012},
publisher = {ACM Digital Library},
}
Tools and examples presented in the OCL'09 workshop and ECMFA'11
papers are available here.
- Meriem Lahrouni, Eric Cariou, and
Abdelaziz El Fazziki, A Black-Box and Contract-Based Verification
of Model Transformations, The International Arab Journal of
Information Technology (IAJIT), 16(4), July 2019
[paper]
[abstract]
[BibTeX]
The main goal of Model-Driven Engineering (MDE) is to manipulate productive models to build
software. In this
context, model transformation is a common way to automatically manipulate models. It is then
required to ensure that
transformation has been correctly processed. In this paper, we propose a contract-based method to
verify that a target model
is a valid result of a source model with respect to the transformation specification. The
verification is made in a black-box
mode, independently of the implementation and the execution of the transformation. The method
allows the contract to be
written in any constraint language. In association with this method, we have implemented a tool
that partially generates
contracts written in OCL and manages their evaluation for both endogenous and exogenous
transformations.
@Article{lahrouni-iajit19,
author = {Meriem Lahrouni and Eric Cariou and Abdelaziz El Fazziki},
title = {{A Black-Box and Contract-Based Verification
of Model Transformations}},
journal = {The International Arab Journal of Information Technology
(IAJIT)},
year = {2019},
volume = {16},
number = {4},
month = {July}
}
- Eric Cariou, Olivier Le Goaer, Franck
Barbier, Samson Pierre, and Mohamed Graiet, Adaptation d’exécution
de modèles par contrats (in french), Technique et Science Informatiques,
numéro spécial "ingénierie du logiciel", Lavoisier, 34(6), 2015
[article]
[résumé]
[abstract]
[BibTeX]
Dans le contexte de l’ingénierie des modèles, l’exécution de modèles est un des moyens principaux pour
supprimer le fossé entre le code, c’est-à-dire le système développé, et le modèle. Pour adapter une
exécution de modèles, nous proposons de directement adapter le modèle en cours d’exécution. Cela
oblige à rajouter des éléments nécessaires à l’adaptation dans le modèle mais évite d’avoir un second
modèle dédié à l’adaptation comme c’est le cas pour les méthodes de type models@run.time. Cet article
présente une approche d’adaptation directe d’exécution de modèle par contrats. Si des conditions du
contrat ne sont pas respectées, une action d’adaptation doit être entreprise. L’approche est illustrée
par un i-DSML (interpreted Domain Specific Modeling Language) de machines à états et un exemple de
signalisation ferroviaire avec comme problématique de s’assurer qu’un modèle est adapté à un
environnement d’exécution donné.
In the model-driven engineering field, model execution is one of the main ways to fill the gap between
the code (i.e. the developed system) and the model. For adapting a model execution, we propose to
directly adapt the model under execution. This requires to add onto the model requisite elements for
the adaptation but this avoids to have a second model dedicated to the adaptation as for
models@run.time. This paper proposes a contract-based approach for directly adapting a model
execution. If some conditions of the contract are not respected, an adaptation action has to be
undertaken. The approach is illustrated through a state machine i-DSML (interpreted Domain Specific
Modeling Language) and an example of a railway signaling based on the ability to ensure that a model
is adapted with a given execution environment.
@Article{cariou-tsi15,
author = {Eric Cariou and Olivier Le Goaer and Franck Barbier and Samson Pierre and
Mohamed Graiet},
title = {{Adaptation d’ex\'ecution de mod\`eles par contrats}},
journal = {Technique et Science Informatiques, num\'ero sp\'ecial "ing\'enierie du
logiciel"},
year = {2015},
volume = {34},
number = {6},
publisher = {Lavoisier},
pages = {703-730},
}
-
Eric Cariou, Cyril
Ballagny, Alexandre Feugas, and Franck Barbier, Contracts for
Model Execution Verification, Seventh European Conference on
Modelling Foundations and Applications (ECMFA 2011), volume 6698 of
Lecture Notes in Computer Science, pp 3-18, Springer, June
2011
[paper]
[abstract]
[BibTeX]
One of the main goals of model-driven engineering is the manipulation
of models as exclusive software artifacts. Model execution is in
particular a means to substitute models for code. We focus in this
paper on verifying model executions. We use a contract-based approach
to specify an execution semantics for a meta-model. We show that an
execution semantics is a seamless extension of a rigorous meta-model
specification and is composed of complementary levels, from static
element definition to dynamic elements, execution specifications as
well. We use model transformation contracts for controlling the
dynamic consistent evolution of a model during its execution. As an
illustration, we apply our approach to UML state machines using OCL as
the contract expression language.
@InProceedings{cariou-ecmfa11,
author = {Eric Cariou and Cyril Ballagny and Alexandre Feugas and Franck
Barbier},
title = {{Contracts for Model Execution Verification}},
booktitle = {Seventh European Conference on Modelling Foundations and
Applications (ECMFA 2011)},
pages = {3--18},
year = {2011},
volume = {6698},
series = {LNCS},
publisher = {Springer},
}
- Eric Cariou, Nicolas
Belloir, Franck Barbier, and Nidal Djemam, OCL contracts for the
verification of model transformations, the Workshop The Pragmatics
of OCL and Other Textual Specification Languages at MoDELS 2009,
Electronic Communications of the EASST, vol. 24, October 2009
[paper]
[slides]
[abstract]
[BibTeX]
A model-driven engineering process relies on a set of transformations
which are usually sequentially executed, starting from an abstract
level to produce code or a detailed implementation
specification. These transformations may be entirely automated or may
require manual intervention by designers. In this paper, we propose a
method to verify that a transformation result is correct with respect
to the transformation specification. This method both includes
automated transformations and manual interventions. For that, we focus
on transformation contracts written in OCL. This leads to making the
proposed method independent of modeling and transformation
tools. These contracts are partially or fully generated through a
dedicated tool.
@InProceedings{cariou-ocl09,
author = {Cariou, Eric and Belloir, Nicolas and Barbier, Franck and Djemam,
Nidal},
title = {{OCL Contracts for the Verification of Model Transformations}},
booktitle = {the Workshop The Pragmatics of OCL and Other Textual Specification
Languages at MoDELS 2009},
year = {2009},
volume = {24},
publisher = {Electronic Communications of the EASST},
}
-
Eric Cariou, Raphaël Marvie, Lionel
Seinturier, and Laurence Duchien OCL for the Specification of
Model Transformation Contracts, Workshop OCL
and Model Driven Engineering of the Seventh International
Conference on UML Modeling Languages and Applications (UML
2004), October 12, 2004 Lisbon, Portugual
[paper]
[abstract]
[BibTeX]
A major challenge of the OMG Model-Driven Architecture (MDA)
initiative is to be able to define and execute transformations of
models. Such transformations may be defined in several ways and with
various motivations. Our motivation is to specify model
transformations independently of any transformation technology. To
achieve this goal, we propose to define transformation contracts. We
argue that model transformation contracts are an essential basis for
the MDA, they can be used for specification, validation and test of
transformations. This paper focuses on the specification of model
transformation contracts. We investigate the way to define them using
standard UML and OCL features. In addition to presenting the approach
and some experimental results, this paper discusses the relevance and
limits of standard OCL to define transformation contracts.
@Misc{cariou-ocl-mde-uml2004,
author = {Eric Cariou and Rapha\"el Marvie and Lionel Seinturier and
Laurence Duchien},
title = {{OCL for the Specification of Model Transformation Contracts}},
howpublished = {Workshop OCL and Model Driven Engineering of the Seventh
International Conference on UML Modeling Languages and Applications (UML 2004)},
year = {2004},
}
-
Nour Alhouda Aboud, Eric Cariou, Eric
Gouardères and Philippe Aniorté. Semantic Mappings between
Service, Component and Agent Models (short paper), 15th
International ACM SIGSOFT Symposium on Component Based Software
Engineering (CBSE 2012), ACM Digital Library, June 2012
[paper]
[abstract]
[BibTeX]
[Additionnal information]
Regarding the design and the development of distributed applications,
service, component and agent oriented approaches
provide their own interests and characteristics. Most of current
applications are designed according to a single approach
but it would be interesting to use these approaches simultaneously
to provide a more efficient paradigm for developing
distributed applications. Our goal is to integrate these three
approaches by focusing on the concepts of service and interaction
as key points, notably regarding cooperation between
agents and components. The service is the business abstraction
of a component or agent and it represents a pivot to
support its interactions. We presented previously our service,
component and agent models for this purpose. In this
paper, we establish the semantic mapping rules between the
concepts of each of these domains to be able to move on
from one model to another.
@InProceedings{aboud-cbse12,
author = {Aboud, Nour Alhouda and Cariou, Eric and Gouard\`{e}res, Eric and
Aniort{\'e}, Philippe},
title = {{Semantic mappings between service, component and agent models}},
booktitle = {the 15th ACM SIGSOFT symposium on Component Based Software Engineering
(CBSE 2012)},
year = {2012},
pages = {29--34},
publisher = {ACM Digital Library},
}
-
Nour Alhouda Aboud, Eric
Cariou, Eric Gouardères and Philippe
Aniorté. Correspondances sémantiques entre des modèles de
services, de composants et d'agents, (in french), 6ème Conférence
Francophone sur les Architectures Logicielles (CAL 2012), May 2012
[article]
[résumé]
[BibTeX]
Pour le développement d'applications distribuées, les approches
orientées services, composants ou agents offrent chacune des intérêts
et des caractéristiques propres qu'il serait intéressant de pouvoir
utiliser conjointement. Notre but est d'intégrer ces trois approches
en se focalisant sur les concepts de service et d'interaction, points
clé notamment de la coopération entre des agents et des composants :
le service représente l'abstraction métier d'un composant ou d'un
agent et permet de les faire interagir. Précédemment, nous avions
présenté nos modèles de services, d'agents et de composants dans ce
but. Dans cet article, nous établissons les correspondances
sémantiques entre les concepts de chacun de ces domaines afin de
pouvoir passer d'un modèle à un autre.
@InProceedings{aboud-cal12,
author = {Nour Alhouda Aboud and Eric Cariou and Eric Gouard{\`e}res},
title = {{Correspondances sémantiques entre des modèles de services, de
composants et d'agents}},
booktitle = {6\`eme Conf\'erence Francophone sur les Architectures Logicielles
(CAL 2012)},
year = {2012},
}
-
Nour Alhouda Aboud, Eric
Cariou, Eric Gouardères and Philippe
Aniorté, Service-Oriented Integration of Component and Agent
Models, special session on Architectures, Concepts and
Technologies for Service Oriented Computing (ACT4SOC) of the 6th
International Conference on Software and Data Technologies (ICSOFT
2011), SciTePress Digital Library, July 2011
[paper]
[abstract]
[BibTeX]
Multiagent systems and component-based systems are two mature
approaches; each one owns strengths and weaknesses points. Our goal is
to integrate these two approaches by reaching a high level of
connectivity between them to overcome their shortages. The concept of
service plays a key role in their interoperability. Indeed, the
relations between these three domains are manifold. From a service
perspective, agents and components are considered as service providers
or consumers while services can be seen as their functional
abstractions. Therefore, the concept of service as the interaction
point between agents and component is the base of our integration
approach. We will define a specification process composed of several
models. They are dedicated to specify an application through several
aspects: abstract services, components, agents and mix of them. In
this paper, we present a global view of this process and three of its
models: service, agent and component ones.
@InProceedings{aboud-icsoft11,
author= {Nour Alhouda Aboud and Eric Cariou and Eric Gouard{\`e}res and Philippe
Aniort{\'e}},
title = {{Service-oriented Integration of Component and Agent Models}},
booktitle = {Special session on Architectures, Concepts and Technologies for
Service Oriented Computing (ACT4SOC) of the 6th International Conference on Software and Data
Technologies (ICSOFT 2011)},
publisher = {SciTePress Digital Library},
year = {2011},
pages = {327--336},
}
-
Eric Cariou, and Antoine
Beugnard, Ingénierie des Composants : Concepts, Techniques et Outils,
edited by Mourad Oussalah, chapitre 10 : Les Composants de
Communication (in french), pp. 281 - 329, Vuibert, 2005
[résumé]
[BibTeX]
Ce chapitre présente une catégorie de composants dédiés à la
communication et donc à l'élaboration d'applications réparties. Il
montre l'intérêt qu'il y a à considérer la communication comme une
abstraction architecturale de haut niveau et donne quelques exemples
de composants de communication. Nous montrons comment à l'aide
d'UML1.4 nous spécifions ces composants. Puis nous décrivons un
processus de raffinement (par transformations de modèles) qui conduit
à la réalisation de variantes de mise en oeuvre de ces composants. Ces
variantes, fonctionnellement équivalentes, diffèrent par les choix de
conceptions réalisés au cours du raffinement et permettent, par
« substitution de composant », de faire évoluer les propriétés non
fonctionnelles d'applications réparties.
@InBook{cariou-composants-2005,
author = {Eric Cariou and Antoine Beugnard},
editor = {Mourad Oussalah},
title = {{Ing\'enierie des Composants : Concepts, Techniques et
Outils}},
chapter = {10 : Les Composants de Communication},
publisher = {Vuibert},
year = {2005},
}
-
Eric Cariou, Contribution à un Processus de Réification
d'Abstractions de Communication (in french), PhD thesis, Université de
Rennes 1, école doctorale Matisse, June 2003
[thesis]
[slides]
[résumé]
[abstract]
[BibTeX]
Lors de la conception et du développement d'applications distribuées,
la communication et les interactions entre les composants répartis
représentent un point crucial. La spécification d'abstractions
d'interaction entre ces composants est donc un élément primordial lors
de la définition de l'architecture d'une application. Si bien souvent
des abstractions d'interaction de haut niveau sont définies au niveau
de la spécification, à celui de l'implémentation il est par contre
plus courant de ne trouver que des abstractions bien plus simples
(comme des appels de procédure à distance ou de la diffusion
d'événements). Pendant le raffinement qui mène à l'implémentation, ces
abstractions de haut niveau ont été diluées, dispersées à travers les
spécifications et implémentations des composants de
l'application.
Nous proposons un processus de réification
d'abstractions de communication ou d'interaction sous forme de
composants logiciels. Ce processus permet de conserver l'unité et la
cohérence d'une abstraction d'interaction pendant tout le cycle de
développement d'une application. Que l'on soit à un niveau de
conception abstraite, de conception d'implémentation, d'implémentation
ou de déploiement, l'abstraction réifiée et manipulée est toujours la
même. Ces composants logiciels sont aussi appelés médiums pour les
différencier des autres composants d'une application.
Le
processus est composé de plusieurs éléments. Le premier est une
méthodologie de spécification de médiums en UML. Cette spécification
est réalisée à un niveau abstrait, indépendamment de toute
implémentation. Dans la terminologie du MDA (Model-Driven
Architecture) de l'OMG, il s'agit d'une spécification de niveau PIM
(Platform Independent Model). Cette spécification est le contrat du
médium qui doit ensuite être respecté quel que soit le niveau de
manipulation considéré. Le deuxième élément est une architecture de
déploiement de médiums qui offre la flexibilité nécessaire pour
implémenter a priori n'importe quelle abstraction d'interaction.
Enfin, le troisième élément est un processus de raffinement qui permet
de transformer une spécification abstraite de médium en une ou
plusieurs spécifications d'implémentation prenant en compte
l'architecture de déploiement et différents choix de conception ou
d'implémentation. Dans la terminologie du MDA, le processus de
raffinement sert à transformer une spécification de niveau PIM en une
ou plusieurs spécifications de niveau PSM (Platform Specific Model).
During the development of distributed applications, communications and
interactions among remote components are a key-point. The
specification of interaction or communication abstractions among these
components is thus a major task during the definition of an
application architecture. If high-level abstractions are very often
defined at the specification level, yet, it is common to find only
much simpler abstractions at the implementation level (such as remote
procedure calls or event broadcasting). During the refinement process,
i.e. from specification to implementation, these high-level
interaction abstractions are lost and split among the component
specifications and implementations.
We propose a process of
reification of interaction or communication abstractions into software
components. The process allows the consistency and the unity of an
interaction abstraction to be maintained, from abstract specification
to implementation. The abstraction manipulated remains unchanged
throughout the software process, from abstract specification to
implementation and deployment through specification
implementation. These components are also called mediums in order to
differentiate them from standard software components of an
application.
The process is composed of three parts. The
first one is a medium specification methodology in UML, at an abstract
level, independently of any implementation. In the MDA (Model-Driven
Architecture, defined by the OMG) terminology, this specification is
done at PIM (Platform Independent Model) level. This specification is
the medium contract that has to be fulfilled at all the levels of the
software development process. The second part is a medium deployment
architecture that provides the necessary flexibility to implement, in
principle, any kind of communication or interaction abstraction. The
last part is a refinement process, enabling the transformation of an
abstract specification into one or several implementation
specifications, conforming to our deployment architecture and to the
design or implementation choices. In the MDA terminology, the process
enables the transformation of a PIM specification into one or several
PSM (Platform Specific Model) specifications.
@PhdThesis{phd-cariou-2003,
author = {Eric Cariou},
title = {{Contribution \`a un Processus de R\'eification d'Abstractions de
Communication}},
school = {Universit\'e de Rennes 1, \'ecole doctorale Matisse},
year = {2003},
month = {June},
}
-
Eric Cariou, and Antoine Beugnard, The
Specification of UML Collaborations as Interactions Components,
at the Fifth International Conference on the Unified Modeling Language
(UML 2002), September 30 - October 4, 2002, Dresden, Germany, volume
2460 of Lecture Notes in Computer Science, Springer Verlag
[paper]
[slides]
[abstract]
[BibTeX]
One of the touchstones of Object-Oriented Design is that the
management of complexity is seldom located within any single
object. It should instead be an emerging property of the
collaborations within a society of objects, each one of these being as
simple as possible. These collaborations can easily be specified using
UML collaboration diagrams. We propose to reify UML collaborations as
interaction components. This allows the easy handling and reusing of
interaction abstractions among components at both specification and
implementation levels. This paper focuses on the specification of
these components. We propose criteria to define the type and the
`frontier of an interaction abstraction. We present a UML
collaboration specification methodology that deals with the
constraints of component specification.
@InProceedings{cariou-uml2002,
author = {Eric Cariou and Antoine Beugnard},
title = {{The Specification of UML Collaborations as Interaction
Components}},
booktitle = {{The Fifth International Conference on the Unified Modeling
Language (UML 2002)}},
pages = {352--367},
year = {2002},
volume = {2640},
series = {LNCS},
publisher = {Springer},
}
-
Eric Cariou, Antoine Beugnard, and Jean-Marc
Jézéquel, An Architecture and a Process for
Implementing Distributed Collaborations, at The 6th IEEE
International Enterprise Distributed Object Computing Conference
(EDOC 2002), IEEE Computer Society, September 2002
[paper]
[slides]
[abstract]
[BibTeX]
Collaborations (between objects) are increasingly being recognized as
fundamental building blocks to structure object-oriented design, and
they have made their way into UML. But very often the first class
aspect of a design level collaboration is lost during the detailed
design process, making it difficult to keep good traceability between
the design and the implementation. The problem is not simple, because
for any given collaboration abstraction, there might be several
possible design solutions depending on the many non-functional forces
impacting a given application. We propose a process and an
architecture in which the notion of collaboration is preserved from
analysis to design and implementation, while allowing the designer to
change his mind about which particular design trade-off is selected in
order to face changing non-functional requirements during
maintenance. We illustrate our approach with a case study inspired by
the real example of a large French railway company attempting to adapt
a flight reservation system to its own context.
@InProceedings{cariou-edoc2002,
author = {Eric Cariou and Antoine Beugnard and Jean-Marc J\'ez\'equel},
title = {{An Architecture and a Process for Implementing Distributed
Collaborations}},
booktitle = {The 6th IEEE International Enterprise Distributed Object Computing
Conference (EDOC 2002)},
year = {2002},
publisher = {IEEE Computer Society},
}