Menu

• Contact
• Enseignement
• Recherche
• Publications
  • Sélection par thème
  • Liste complète
  • Profil Google scholar

• English version

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

Maître de conférences au département informatique de l'UFR Sciences et Techniques de l'Université de Bretagne Occidentale
Membre du Lab-STICC UMR 6285, équipe P4S

Positions précédentes :
2004-2022 : maître de conférences au département informatique de l'université de Pau et des Pays de l'Adour, collège STEE Pau, membre du LIUPPA, responsable équipe GL
2003-2004 : post-doctorant dans l'équipe GOAL du LIFL
1999-2003 : doctorant au département Informatique de l'ENST Bretagne et dans l'équipe Triskell de l'Irisa

Enseignement

Enseignements – université de Brest

• Responsable de l'UE Conception d'Applications, licence informatique, 3^ème année
• Reponsable de l'UE Réseaux IP : IHM, licence informatique, 3^ème année
• Responsable de l'UE Systèmes d'Information, master ILIADE & TIIL-A, 1^ère année
• Responsable de l'UE "Projet S8 : développement de logiciel", master TIIL-A, 1^ère année
• Responsable de la partie Ingénierie des modèles de l'UE Programmation Générative, master TIIL-A, 2^ème année
• Participation à l'UE Java 2, licence informatique, 3^ème année
• Participation à l'UE Java 1, licence informatique, 2^ème année

Anciens enseignements – université de Pau

Responsable des cours, université de Pau :

• Architecture des ordinateurs, licence informatique, 2^ème année
• Introduction au génie logiciel, licence informatique, 3^ème année
• Systèmes distribués, licence informatique, 3^ème année
• Spécification des systèmes distribués, master Technologies de l'Internet, 1^ère année
• Développement Web avancé, master Technologies de l'Internet, 1^ère année
• Ingénierie des modèles, master technologies de l'Internet, 2^ème année

Enseignements extérieurs, en collaboration avec l'université de Pau :

• Ecole supérieure Sup'Technology, Casablanca, Maroc : Ingénierie des modèles, co-tutelle Master Technologies de l'Internet
• Université Gaston Berger, Saint-Louis, Sénégal : module de systèmes distribués, DESS 2ITIC
• Université M'hamed Bougara, Boumerdès, Algérie : programmation Java des clients/serveurs, licence professionnelle Technologies Web, 3^ème année

Autres :

• Institut Supérieur d'Informatique et de Mathématiques, Monastir, Tunisie : ingénierie des modèles, master Informatique, 1^ère année

Recherche

Mes travaux de recherche se placent dans le domaine du génie logiciel et plus précisement sur les thématiques suivantes : Ingénierie dirigée par les modèles (IDM) : Tissage d'opérations métier sur des modèles exécutables Adaptation d'exécution de modèles Vérification par contrats de transformations et d'exécution de modèles Architecture logicielle : Intégration des approches composants et agents par des services Composants de communication

Nuage de mots basé sur les titres des articles sélectionnés cités ci-dessous

Tissage d'opérations métier sur des modèles exécutables. En IDM, un modèle exécutable définit le comportement d'un système logiciel. Le modèle exécuté est le même que celui qui a été défini pendant la phase de spécification, supprimant ainsi le fossé entre la conception et l'implémentation. Nos travaux s'intéressent à la définition de ces modèles exécutables et plus particulièrement à comment tisser sur ces modèles des opérations métier implémentées dans des langages de programmation standard (Java par exemple).
[Principales publications et outils]

Adaptation d'exécution de modèles. L'IDM a montré son intérêt pour l'adaptation logicielle grâce au models@runtime dont le principe est d'avoir à l'exécution un modèle qui reflète l'état du système en cours d'exécution et de raisonner sur la nécessité d'adaptation du système à partir de ce modèle. Dans un contexte d'exécution de modèles, le modèle exécuté devient par principe le système. Dans ce cas, l'idée est d'adapter directement le modèle exécuté. La thèse de Samson Pierre (2012-2015) a étudié cette adaptation d'exécution de modèles.
[Principales publications]

Vérification par contrats en IDM. Lors de mon post-doctorat au LIFL, j'ai défini le concept de contrat de transformation de modèles. A mon arrivée à l'université de Pau, j'ai repris ces travaux sur les contrats en développant un outillage pour aider à l'implémentation de ces contrats pour la plateforme EMF. Ils ont été également adaptés pour vérifier l'exécution de modèles. Ces travaux se sont poursuivis dans le cadre de la thèse de Meriem Lahrouni (2012-2018) à la Faculté des Sciences Semlalia de Marrakech, Maroc.
[Principales publications et outils]

Intégration des approches composants et agents. Je co-encadre la thèse de Nour Aboud (2008-2012) dont le but est d'intégrer les approches composants et agents via des services. L'idée générale est de pouvoir définir des applications simultanément par des composants et des agents interopérants et de pouvoir faire utiliser les caractéristiques d'une approche aux éléments de l'autre approche (agents dans des structures composites de type composants, interactions de haut niveau des agents utilisables par des composants, ...). Les services servent de pivot d'interopérabilité entre les composants et agents.
[Principales publications]

Composants de communication. En Juin 2003, j'ai soutenu à l'Université de Rennes 1 et à l'ENST Bretagne une thèse intitulée Contribution à un Processus de Réification d'Abstractions de Communication. Dans cette thèse, j'ai défini un processus permettant de manipuler une abstraction de communication sous forme de composant logiciel (un composant de communication ou médium) de sa spécification abstraite jusqu'à son ou ses implémentations. Pendant tout le cycle de développement du logiciel, l'abstraction de communication réifiée et manipulée reste la même. L'intérêt de ces composants de communication est de pouvoir réutiliser facilement des abstractions de communication et d'en définir des variantes d'implémentation substituables.
[Principales publications]

Publications

Liste complète de mes publications

Profil Google scholar

Sélection par thème

Tissage d'opérations métier sur des modèles exécutables

• 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},
  }
  • Outil associé : PauWare Code Generator pour générer le code Java pour la libraire PauWare à partir d'une machine à états UML.
  • Tutoriel à ICAASE'20 avec des exemples d'utilisation de PauWare et du générateur de code.
  
  
• 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}
  }
  
  
  
  • Outil associé : Xmodeling studio pour tisser des opérations métiers lors de la définition d'un DSL exécutable avec l'environnement EMF.
  
  
• 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},
  }
  
  
  
  

Adaptation d'exécution de modèles

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

En complément, la thèse de doctorat de Samson Pierre à l'Université de Pau et des Pays de l'Adour (novembre 2015) : Adaptation logicielle pour et par les i-DSML.

Contrats pour l'Ingénierie des Modèles

Les outils et exemples présentés dans les articles du workshop OCL'09 et d'ECMFA'11 sont disponibles ici.

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

Intégration des approches composants et agents par des services

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

En complément, la thèse de doctorat de Nour Aboud à l'Université de Pau et des Pays de l'Adour (décembre 2012) : Service-Oriented Integration of Component and Organizational MultiAgent Models.

Composants de Communication

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