Depuis plusieurs années, l'évolution naturelle des applications vers la distribution a mis en évidence le besoin d'informations autre que celles uniquement nécessaires aux traitements. C'est ainsi qu'au fil du temps, les concepteurs et développeurs ont dû intégrer à leurs applications des tâches d'acquisition de l'environnement d'exécution permettant ainsi aux applications dans un premier temps de prendre en compte le contexte, puis de devenir « sensibles au contexte » et d'adapter leurs traitements en conséquence puis, dans un second temps, d'évoluer par reconfigurations dynamiques de manière à répondre au mieux aux sollicitations.<br /><br />Le contexte peut se diviser en trois couches. La première appelée « type de contexte » permet de réaliser l'acquisition du contexte, la deuxième, appelée « moyens de mise en œuvre de la gestion du contexte » est chargée de la gestion du contexte, enfin, la troisième couche offre les mécanismes permettant l'adaptation au contexte.<br /><br />Le premier chapitre de ce mémoire est intitulé « Processus de réingénierie » porte principalement sur la première phase d'acquisition des informations contextuelles et plus particulièrement sur les applications totalement (réingénierie) ou partiellement existantes comme les COTS.<br />Dans un premier temps, l'objectif est de réaliser une analyse des informations produites par des modules logiciels afin de prendre en compte mais également de fabriquer (si nécessaire) automatiquement à l'aide de connecteurs - lorsque c'est possible - des informations contextuelles de plus haut niveau. Dans un second temps, je me suis intéressé à l'intégration de Composants sur Etagères (ou COTS Products). L'objectif est ici une analyse des assemblages de COTS sélectionnés afin de s'assurer de la faisabilité du déploiement, et donc de la réalisation de l'application. Nous nous situons ici également dans le domaine de l'acquisition des informations contextuelles dans le sens où nous ne gérons que la phase d'acquisition du contexte et de production d'informations permettant des prises de décisions concernant la possibilité d'assemblage des COTS Products. <br /><br />Le deuxième chapitre intitulé « Outils d'adaptation permettant la prise en compte du contexte » est transversal aux trois couches précédemment présentées. Un modèle de plate-forme de supervision réflexive (Kalinahia) y est présenté afin de proposer les services nécessaires à la gestion du contexte. Un modèle de composant supervisable (Osagaia) ainsi qu'un modèle de connecteur (Korrontea) y est également présenté. Ces deux modèles offrent les mécanismes d'adaptation, de migration et de composition nécessaires à l'adaptation de l'application. <br /><br />Le troisième chapitre intitulé « Contexte et Qualité de service » présente comment la notion de qualité de service, intimement liée à celle de contexte, est intégrée dans nos travaux. En effet, fournir la qualité de service adéquate à un utilisateur ou, plus généralement à une application, demande d'avoir une connaissance à la fois du contexte de l'application mais aussi du contexte de l'utilisateur. Aussi, je propose un modèle formel de la qualité de service selon les deux critères intrinsèques (fonctionnalité) et contextuels (dans et sous quelles conditions).<br /><br />Enfin, le quatrième chapitre « Représentation des applications et de leur qualité de service » a pour objectif de proposer une modélisation d'applications sensibles au contexte ayant pour but d'assurer une qualité de service aux utilisateurs. L'approche formelle utilise des graphes orientés et prend en considération la qualité de service. Les différents graphes proposés vont du niveau conceptuel au niveau d'implantation permettant de générer directement les graphes d'implantation et de déploiement qui seront ensuite utilisés par la plateforme Kalinahia pour la reconfiguration dynamique de l'application. <br />L'objectif étant d'assurer une qualité de service acceptable (la meilleure étant un problème NP-Complet), le contexte de qualité est également pris en compte tout au long de la démarche et surtout lors des étapes de reconfiguration puisque c'est une modification du contexte qui déclenchera la modification du déploiement de l'application. L'objectif est de continuer à assurer une qualité de service « acceptable » malgré le contexte mouvant en provoquant des reconfigurations dynamiques de l'application.

Cette thèse porte sur les environnements permettant aux formateurs de développer des simulations pédagogiques. La première partie présente un état de l'art de ces environnements, au regard des différentes tâches identifiées par le modèle MARS (Modèle, Associations, Représentation, Scénario). Elle montre notamment l'intérêt d'une séparation nette entre la simulation proprement dite et le contrôle pédagogique, ce qui permet d'utiliser différentes approches pédagogiques sur une simulation. Cette étude théorique est complétée par une expérimentation que nous avons menée avec des enseignants, dans le cadre du projet européen ARIADNE, sur l'outil OASIS créé par l'équipe ARCADE sur la base du modèle MARS. Ces travaux montrent que les outils existants facilitent les tâches de l'auteur, mais que la distance cognitive entre ses abstractions et les abstractions proposées par les outils est encore trop grande. Partant de ce constat, l'idéal (utopique) serait d'offrir un outil adaptable au domaine particulier de l'auteur. Adoptant un point de vue génie logiciel, nous proposons dans la deuxième partie de cette thèse une solution permettant à un développeur de construire rapidement des outils adaptés. Cette solution s'appuie sur des techniques de réutilisation basées sur les architectures, les frameworks et les patrons. Nous présentons un framework que nous avons développé sur la base du modèle MARS. Nous avons utilisé ce framework pour construire une version d'OASIS, ainsi que l'outil FENIX dédié à la réalisation de simulations basées sur des modèles mathématiques simples. La troisième partie concerne la mise en œuvre effective de la séparation entre simulation et contrôle pédagogique préconisée plus haut. Nous proposons ARGOS, une architecture de communication entre simulations et outils de contrôle pédagogique. Un sous-ensemble d'ARGOS a servi à l'élaboration d'un prototype pour le contrôle pédagogique de simulations à distance.

Cette thèse s'intéresse à la déclinaison matérielle des concepts logiciels d'intergiciel et d'architecture logicielle à base de composants, conteneurs et connecteurs dans les réseaux de portes programmables in situ (Field-Programmable Gate Array - FPGA). Le domaine d'applications ciblé est la radio définie logiciellement (Software Defined Radio (SDR)) conforme au standard Software Communications Architecture) (SCA). Avec le SCA, les applications radio sont décomposées en composants fonctionnels, qui sont déployés sur des plateformes radios hétérogènes et distribuées. Ces composants fournissent et requièrent des interfaces logicielles abstraites décrites sous forme de signatures d'opérations dans le langage de modélisation unifié appelé Unified Modeling language (UML) et/ou le langage de définition d'interface (Interface Definition Language - IDL) de l'intergiciel CORBA (Common Object Request Broker Architecture) standardisé par un consortium industriel appelé Object Management Group (OMG). Les besoins de portabilité et de réutilisation de ces composants requièrent que leurs interfaces abstraites définies au niveau système soient indépendantes d'une implémentation logicielle ou matérielle et puissent être indifféremment traduites dans un langage de programmation logiciel tel que C/C++, un langage système tel que SystemC au niveau transaction (Transaction Level Modeling - TLM), ou un langage de description matériel tel que VHDL ou SystemC au niveau registre (Register Transfer Level - (RTL)). Le besoin d'interopérabilité de ces composants requière des communications transparentes quelques soient leur implémentation logicielle ou matérielle et leur distribution. Ces premiers besoins ont été adressés en formalisant des règles de mise en correspondance entre des composants abstraits en OMG IDL3 ou UML2, des composants matériels à base de signaux en VHDL ou SystemC RTL, et des composants systèmes en SystemC TLM. Le deuxième besoin a été adressé en prototypant un intergiciel matériel utilisant de façon transparente le mapping mémoire et deux protocoles messages: CORBA General Inter-Object Request Broker Protocol (GIOP) et SCA Modem Hardware Abstraction Layer (MHAL).

Les systèmes distribués modernes à large-échelle évoluent dans des contextes variables soumis à de nombreux aléas auxquels ils doivent s'adapter dynamiquement. Dans ce cadre, l'informatique autonome se propose de réduire les interventions humaines lentes et coûteuses, en leur préférant l'auto-gestion. Elle repose avant tout sur une description adéquate de ses composants, de leurs interactions et des différents aspects ou topologies qu'il peut adopter. Diverses approches de modélisation ont étés proposées dans la littérature, se concentrant en général sur certains du système dynamique et ne permettent ainsi pas de répondre à chacune des problématiques inhérentes à l'auto-gestion. Cette thèse traite de la modélisation basée graphes des systèmes dynamiques et de son adéquation pour la mise en œuvre des quatre propriétés fondamentales de l'informatique. Elle propose quatre principales contributions théoriques et appliquées. La première est une méthodologie pour la construction et la caractérisation générative de transformations correctes par construction dont l'application préserve nécessairement la correction du système. La seconde contribution consiste en une extension des systèmes de réécriture de graphe permettant de représenter, mettre à jour, évaluer et paramétrer les caractéristiques d'un système aisément et efficacement. Une étude expérimentale extensive révèle un net gain d'efficacité vis à vis de méthodes classiques. Les deux dernières contributions s'articulent autour de l'élaboration de deux modules de gestions visant : (1) des requêtes de traitement d'événements complexes et (2) tout système Machine-à-Machine se conformant au standard ETSI M2M. / Modern, large-scale systems are deployed in changing environments. They must dynamically adapt to context changes. In this scope, autonomic computing aims at reducing slow and costly human interventions, by building self-managed systems. Self-adaptability of a system is primarily based on a suitable description of its components, their interactions and the various states it can adopt. Various modeling approaches have been elaborated. They usually focus on some aspects or properties of dynamic systems and do not tackle each of self-management's requirements. This manuscript deals with graph-based representations of dynamic systems and their suitability for the implementation of autonomic computing's four fundamental properties : self-optimization, self-protection, self-healing and self-configuring. This thesis offers four principal theoretical and applied contributions. The first one is a methodology for the construction and generative characterization of transformations correct by construction whose application necessarily preserves a system's correctness. The second one consists in an extension of graph rewriting systems allowing to easily and efficiently represent, update, evaluate and configure a system's characteristics. An experimental study reveals a significant efficiency gain with regard to classical methods. The two lasts contribution are articulated around the design of two autonomic managers driving: (1) complex events processing requests and (2) any Machine-to-Machine system complying to the ETSI M2M2 standard.

Les architectures logicielles ont un rôle important dans le développement de systèmes à logiciel prépondérant afin de permettre la satisfaction tant des exigences fonctionnelles que des exigences extra-fonctionnelles. En particulier, les architectures logicielles dynamiques ont émergé pour faire face aux caractéristiques des systèmes contemporains qui opèrent dans des environnements dynamiques et par conséquent susceptibles de changer en temps d’exécution. Les langages de description architecturale (ADLs) sont utilisés pour représenter les architectures logicielles en produisant des modèles qui peuvent être utilisés pendant la conception ainsi que l’exécution. Cependant, la plupart des ADLs existants sont limités sur plusieurs facettes : (i) ils ne décrivent que les aspects structurels, topologiques de l’architecture ; (ii) ils ne fournissent pas un support adéquat pour représenter les aspects comportementaux de l’architecture ; (iii) ils ne permettent pas de décrire des aspects avancés de la dynamique de l’architecture ; (iv) ils sont limités en ce qui concerne la vérification automatisée des propriétés et des contraintes architecturales ; et (v) ils sont déconnectés du niveau d’implémentation et entraînent souvent des incohérences entre l’architecture et l’implémentation. Pour faire face à ces problèmes, cette thèse propose un framework formel pour les architectures logicielles dynamiques. Ce framework comprend : (i) .-ADL, un langage formel pour décrire des architectures logicielles dynamiques sous les perspectives structurelles et comportementales ; (ii) la spécification des opérations de reconfiguration dynamique programmée ; (iii) la génération automatique de code source à partir des descriptions architecturales ; et (iv) une approche basée sur la vérification statistique pour exprimer et vérifier formellement des propriétés des architectures logicielles dynamiques. Les contributions principales apportées par le framework proposé sont quatre. Premièrement, le langage .-ADL a été doté de primitives de niveau architectural pour décrire des reconfigurations dynamiques programmées. Deuxièmement, les descriptions architecturales dans .-ADL sont transformées vers le code source d’implémentation dans le langage de programmation Go, en contribuant à minimiser les dérives architecturales. Troisièmement, une nouvelle logique appelée DynBLTL est utilisée pour exprimer formellement des propriétés dans les architectures logicielles dynamiques. Quatrièmement, un outil basé sur SMC a été développé pour automatiser la vérification des propriétés architecturales en cherchant à réduire l’effort, les ressources computationnelles, et le temps pour réaliser cette tâche. Dans ce travail, deux systèmes basés sur réseaux de capteurs sans fil sont utilisés pour valider les éléments du framework. / Software architectures play a significant role in the development of software-intensive systems in order to allow satisfying both functional and non-functional requirements. In particular, dynamic software architectures have emerged to address characteristics of the contemporary systems that operate on dynamic environments and consequently subjected to changes at runtime. Architecture description languages (ADLs) are used to represent software architectures, producing models that can be used at design time and/or runtime. However, most existing ADLs have limitations in several facets: (i) they are focused on structural, topological aspects of the architecture; (ii) they do not provide an adequate support for representing behavioral aspects of the architecture; (iii) they do not allow describing advanced aspects regarding the dynamics of the architecture; (iv) they are limited with respect to the automated verification of architectural properties and constraints; and (v) they are disconnected from the implementation level, thus entailing inconsistencies between architecture and implementation. In order to tackle these problems, this thesis proposes formally founded framework for dynamic software architectures. Such a framework comprises: (i) .-ADL, a formal language for describing software architectures under both structural and behavioral viewpoints; (ii) the specification of programmed dynamic reconfiguration operations; (iii) the automated generation of source code from architecture descriptions; and (iv) an approach based on statistical model checking (SMC) to formally express and verify properties in dynamic software architectures. The main contributions brought by the proposed framework are fourfold. First, the .-ADL language was endowed with architectural-level primitives for describing programmed dynamic reconfigurations. Second, architecture descriptions in .-ADL are translated towards implementation source code in the Go programming language, thereby contributing to minimize architectural drifts. Third, a novel logic, called DynBLTL, is used to formally express properties in dynamic software architectures. Fourth, a toolchain relying on SMC was built to automate the verification of architectural properties while striving to reduce effort, computational resources, and time for performing such a task. In this work, two wireless sensor network-based systems are used to validate the framework elements.

Les thèmes de recherche présentés s'articulent autour des architectures et des protocoles de communication et de coordination pour les logiciels distribués coopératifs. Dans le cas de la communication, nous avons étudié un contexte d'interaction synchrone point-à-point, et dans le cas de la coordination, différents types et modes d'interaction sont considérés : synchrones / asynchrones, point-à-points ou multi-points, par échange de messages ou par invocation de méthodes à distance. Nos contributions ont concerné la spécification, la modélisation, la conception, la validation, l'implémentation et l'expérimentation. L'adoption d'une démarche orientée modèle formel constitue une caractéristique partagée par les différents résultats de cette recherche. Cette démarche, orientée modèle, appliquée aux problèmes de conception et de validation des systèmes à architecture multi-composants peut être considérée comme un fil conducteur dont dérive l'ensemble de nos travaux. L'étude du comportement des composants d'une architecture, qui peut se définir comme l'ensemble des règles qui décrivent la dynamique de leurs interactions, a constitué nos travaux de recherche initiaux. Les travaux ultérieurs se sont ouverts pour couvrir les problèmes relatifs à la coordination d'ensembles de composants, laquelle inclut, en particulier, l'intégration et la distribution de ces composants sous différentes contraintes architecturales : interdépendance, dynamisme et distribution. Enfin, la gestion de la dynamique de l'architecture et de ses interactions distribuées ainsi que son application pour le support des activités génériques de coopération ont été deux axes majeurs dans les problèmes traités. L'édition en groupe a constitué pour nous une catégorie spécifique d'activité coopérative. La télé-ingénierie et la télé-formation ont constitué nos domaines d'expérimentation principaux.

Nos travaux se situent dans le cadre des architectures logicielles dynamiques en tant qu'outil pour l'adaptation des applications à base de services Web, l'objectif étant de proposer des mécanismes d'aide à la gestion de la QdS. Nous proposons une approche de modélisation par le biais d'éléments architecturaux étendant la vue de déploiement d'UML. A partir de la définition de règles de base, issues des techniques de réécriture de graphes, des actions de reconfiguration architecturale sont introduites. Un premier scénario applicatif traite le processus de revue coopérative adapté au cas spécifique d'un système de gestion de conférences. Un deuxième scénario traite le cas d'un magasin en ligne. Nous proposons une classification des cas de dysfonctionnement pour la gestion de la QdS, classification que nous formalisons par le biais d'une ontologie. Notre dernière proposition concerne une architecture de gestion de la QdS, modélisée et validée au moyen de l'outil UML Tau G2.

L'évolution des systèmes pendant leur vie opérationnelle est incontournable. Les systèmes sûrs de fonctionnement doivent évoluer pour s'adapter à des changements comme la confrontation à de nouveaux types de fautes ou la perte de ressources. L'ajout de cette dimension évolutive à la fiabilité conduit à la notion de résilience informatique. Parmi les différents aspects de la résilience, nous nous concentrons sur l'adaptativité. La sûreté de fonctionnement informatique est basée sur plusieurs moyens, dont la tolérance aux fautes à l'exécution, où l'on attache des mécanismes spécifiques (Fault Tolerance Mechanisms, FTMs) à l'application. A ce titre, l'adaptation des FTMs à l'exécution s'avère un défi pour développer des systèmes résilients. Dans la plupart des travaux de recherche existants, l'adaptation des FTMs à l'exécution est réalisée de manière préprogrammée ou se limite à faire varier quelques paramètres. Tous les FTMs envisageables doivent être connus dès le design du système et déployés et attachés à l'application dès le début. Pourtant, les changements ont des origines variées et, donc, vouloir équiper un système pour le pire scénario est impossible. Selon les observations pendant la vie opérationnelle, de nouveaux FTMs peuvent être développés hors-ligne, mais intégrés pendant l'exécution. On dénote cette capacité comme adaptation agile, par opposition à l'adaptation préprogrammée. Dans cette thèse, nous présentons une approche pour développer des systèmes sûrs de fonctionnement flexibles dont les FTMs peuvent s'adapter à l'exécution de manière agile par des modifications à grain fin pour minimiser l'impact sur l'architecture initiale. D'abord, nous proposons une classification d'un ensemble de FTMs existants basée sur des critères comme le modèle de faute, les caractéristiques de l'application et les ressources nécessaires. Ensuite, nous analysons ces FTMs et extrayons un schéma d'exécution générique identifiant leurs parties communes et leurs points de variabilité. Après, nous démontrons les bénéfices apportés par les outils et les concepts issus du domaine du génie logiciel, comme les intergiciels réflexifs à base de composants, pour développer une librairie de FTMs adaptatifs à grain fin. Nous évaluons l'agilité de l'approche et illustrons son utilité à travers deux exemples d'intégration : premièrement, dans un processus de développement dirigé par le design pour les systèmes ubiquitaires et, deuxièmement, dans un environnement pour le développement d'applications pour des réseaux de capteurs.

De toutes les étapes qui constituent le processus de maintenance, l'étape de compréhension d'une application avant son évolution, et l'étape de vérification de sa progression et de sa non régression aprés évolution sont de loin les plus coûteuses. Dans cette these, je présente une approche qui diminue les coûts associés a ces deux étapes, pour des applications conçues à l'aide de composants. Dans cette approche, les liens unissant les attributs qualité d'une application et les décisions architecturales sont documentés formellement. La définition de ces liens se fait a chaque étape du cycle de vie de l'application. J'ai développé un environnement d'assistance à l'évolution, qui exploite cette documentation, pour d'une part, garantir sa mise a jour et d'autre part, notifier au développeur les effets possibles sur les exigences qualité des changements architecturaux proposés. Cette documentation forme ainsi un contrat dit d'évolution. Il s'agit d'un accord entre l'architecte de l'application et le responsable de son évolution. Le premier doit expliciter ses décisions de conception, sous la forme d'un ensemble de contraintes, afin qu'elles puissent être respectées lors du développement et de l'évolution. Le second doit respecter ce contrat afin de bénéficier d'une garantie de préservation de la qualité initialement requise. Ceci permet, principalement, de réduire les coûts associés aux tests de non-régression sur l'aspect non-fonctionnel. Cette même documentation est utilisée pour tracer toutes les décisions architecturales tout au long du processus de développement d'un logiciel. Il est possible, ainsi, de vérifier, à une étape donnée du processus, la non-altération de toutes les décisions prises dans les étapes en amont. J'ai proposé un outil permettant de transformer vers une représentation unique, puis évaluer, les contraintes définies lors des différentes étapes. Cette traçabilité des décisions a pour objectif de rendre persistants les attributs qualité qui sont à l'origine de ces décisions, à travers toutes les étapes du cycle de vie d'un logiciel.

L'évolution des systèmes pendant leur vie opérationnelle est incontournable. Les systèmes sûrs de fonctionnement doivent évoluer pour s'adapter à des changements comme la confrontation à de nouveaux types de fautes ou la perte de ressources. L'ajout de cette dimension évolutive à la fiabilité conduit à la notion de résilience informatique. Parmi les différents aspects de la résilience, nous nous concentrons sur l'adaptativité. La sûreté de fonctionnement informatique est basée sur plusieurs moyens, dont la tolérance aux fautes à l'exécution, où l'on attache des mécanismes spécifiques (Fault Tolerance Mechanisms, FTMs) à l'application. A ce titre, l'adaptation des FTMs à l'exécution s'avère un défi pour développer des systèmes résilients. Dans la plupart des travaux de recherche existants, l'adaptation des FTMs à l'exécution est réalisée de manière préprogrammée ou se limite à faire varier quelques paramètres. Tous les FTMs envisageables doivent être connus dès le design du système et déployés et attachés à l'application dès le début. Pourtant, les changements ont des origines variées et, donc, vouloir équiper un système pour le pire scénario est impossible. Selon les observations pendant la vie opérationnelle, de nouveaux FTMs peuvent être développés hors-ligne, mais intégrés pendant l'exécution. On dénote cette capacité comme adaptation agile, par opposition à l'adaptation préprogrammée. Dans cette thèse, nous présentons une approche pour développer des systèmes sûrs de fonctionnement flexibles dont les FTMs peuvent s'adapter à l'exécution de manière agile par des modifications à grain fin pour minimiser l'impact sur l'architecture initiale. D'abord, nous proposons une classification d'un ensemble de FTMs existants basée sur des critères comme le modèle de faute, les caractéristiques de l'application et les ressources nécessaires. Ensuite, nous analysons ces FTMs et extrayons un schéma d'exécution générique identifiant leurs parties communes et leurs points de variabilité. Après, nous démontrons les bénéfices apportés par les outils et les concepts issus du domaine du génie logiciel, comme les intergiciels réflexifs à base de composants, pour développer une librairie de FTMs adaptatifs à grain fin. Nous évaluons l'agilité de l'approche et illustrons son utilité à travers deux exemples d'intégration : premièrement, dans un processus de développement dirigé par le design pour les systèmes ubiquitaires et, deuxièmement, dans un environnement pour le développement d'applications pour des réseaux de capteurs. / Evolution during service life is mandatory, particularly for long-lived systems. Dependable systems, which continuously deliver trustworthy services, must evolve to accommodate changes e.g., new fault tolerance requirements or variations in available resources. The addition of this evolutionary dimension to dependability leads to the notion of resilient computing. Among the various aspects of resilience, we focus on adaptivity. Dependability relies on fault tolerant computing at runtime, applications being augmented with fault tolerance mechanisms (FTMs). As such, on-line adaptation of FTMs is a key challenge towards resilience. In related work, on-line adaption of FTMs is most often performed in a preprogrammed manner or consists in tuning some parameters. Besides, FTMs are replaced monolithically. All the envisaged FTMs must be known at design time and deployed from the beginning. However, dynamics occurs along multiple dimensions and developing a system for the worst-case scenario is impossible. According to runtime observations, new FTMs can be developed off-line but integrated on-line. We denote this ability as agile adaption, as opposed to the preprogrammed one. In this thesis, we present an approach for developing flexible fault-tolerant systems in which FTMs can be adapted at runtime in an agile manner through fine-grained modifications for minimizing impact on the initial architecture. We first propose a classification of a set of existing FTMs based on criteria such as fault model, application characteristics and necessary resources. Next, we analyze these FTMs and extract a generic execution scheme which pinpoints the common parts and the variable features between them. Then, we demonstrate the use of state-of-the-art tools and concepts from the field of software engineering, such as component-based software engineering and reflective component-based middleware, for developing a library of fine-grained adaptive FTMs. We evaluate the agility of the approach and illustrate its usability throughout two examples of integration of the library: first, in a design-driven development process for applications in pervasive computing and, second, in a toolkit for developing applications for WSNs.