Menu

• Contact
• Teaching (french)
• Research
• Publications
  • Selection by theme
  • Complete list
  • Google scholar profile

• Version française

Eric Cariou Université de Bretagne Occidentale UFR Sciences et Techniques Département Informatique 20 avenue Le Gorgeu CS 93837 29238 BREST CEDEX 3 France E-mail : Eric.Cariou@univ-brest.fr

Assistant professor at the computer science of "UFR Sciences et Techniques" of the Université de Bretagne Occidentale, France
Member of the Lab-STICC UMR 6285, team P4S

Former positions :
2004-2022 : assistant professor at the computer science department of the university of Pau, head of the Software Engineering team of the LIUPPA
2003-2004 : post-doctorate position in the GOAL team of LIFL
1999-2003 : PhD student at the computer science department of the ENST Bretagne and in the Triskell team of Irisa

Research

My research interests are in the software engineering field and more precisely on: Model-driven engineering (MDE): Weawing of business operations into executable models Model execution adaptation Verification by contracts for model transformation and execution Software architecture: Integration of component and agent approaches through services Communication components

Word cloud based on titles of the undermentioned selected papers

Weawing of business operations into executable models. Within MDE, an executable model defines the behavior of a software system. The executable model is the same as the one defined during the specification stage, thus eliminating the gap between design and implementation. Our work focuses on the definition of these executable models and more particularly on how to weave into these models business operations implemented in standard programming languages (Java for instance)
[Main publications and tools]

Model execution adaptation. MDE has shown its interest for software adaptation thanks to models@runtime which is based on the principle to have at runtime a model that reflects the state of the running system and to reason about the need of system adaptation from this model. In a context of model execution, the model becomes by principle the running system. In this case, the idea is to directly adapt the executed model. The PhD of Samson Pierre (2012-2015) aimed to study this adaptation of model execution.
[Main publications]

Verification by contracts in MDE. During my post-doctorate position at the LIFL, I defined the concept of model transformation contract. When I arrived at the University of Pau, I restarted working on these contracts by developing a tool to facilitate their implementation for the EMF platform. They were also adapted to verify model execution. This work has continuing with the PhD of Meriem Lahrouni (2012-2018) at the Faculty of Sciences Semlalia of Marrakech, Morocco.
[Main publications and tools]

Integration of component and agent approaches. I was co-advisor of the PhD of Nour Aboud (2008-2012) whose goal is to integrate component and agent approaches via services. The global idea is to define applications simultaneously with interoperating components and agents and to be able to use the characteristics of an approach for the elements of the other approach (agents in composite structures of components, agent high-level interactions used by components, ...). Services are used as pivot of interoperability between components and agents.
[Main publications]

Communication components. In June 2003, I defended at the University of Rennes 1 and at the ENST Bretagne my PhD thesis called Contribution to a Process of Communication Abstraction Reification. In this thesis, I propose a process enabling the manipulation of a communication abstraction under the form of a software component (a communication component or medium) from its abstract specification to its implementation(s). Throughout the whole software process, the reified communication abstraction remains the same. The interest of these communication components is to easily reuse communication abstractions and to define substitutable implementation variants of them.
[Main publications]

Publications

Complete list of my publications

Google scholar profile

Selection by theme

Weawing of business operations into executable models

• 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)}},
      year = {2020},
  }
  • Associated tool: PauWare Code Generator for generating the Java code for PauWare based on a UML state machine.
  • ICAASE'20 tutorial with examples for using PauWare and the code generator.
  
  
• 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}
  }
  
  
  
  • Associated tool: Xmodeling studio for weaving business operations when defining executable DSL in the EMF environment.
  
  
• 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},
  }
  
  
  
  

Model execution adaptation

• 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},
  }
  

In addition, the PhD thesis of Samson Pierre at the Université de Pau et des Pays de l'Adour (november 2015) : Adaptation logicielle pour et par les i-DSML (in french).

Contracts for Model-Driven Engineering

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, 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},
  }
  
  
  
  
• Eric Cariou, Raphaël Marvie, Lionel Seinturier, and Laurence Duchien, Model Transformation Contracts and their Specification in UML and OCL, technical report 2004-08, LIFL, April 2004
  [paper] [BibTeX]
  @TechReport{cariou-tech-2004,
      author = {Eric Cariou and Raph\"el Marvie and Lionel Seinturier and Laurence Duchien},
      title = {{Model Transformation Contracts and their Definition in UML and OCL}},
      institution = {LIFL},
      year = {2004},
      number = {2004-08},
  }
  
  
  
  

Integration of agent and component approaches through services

• 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é, 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},
  }
  
  
  

In addition, the PhD thesis of Nour Aboud at the Université de Pau et des Pays de l'Adour (december 2012) : Service-Oriented Integration of Component and Organizational MultiAgent Models.

Communication Components

• Eric Cariou, and Antoine Beugnard, Ingénierie des Composants : Concepts, Techniques et Outils, edited by Mourad Oussalah, chapitre 10 : Les Composants de Communication, 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, 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},
  }