Durant ces dernières années, nous avons assisté à une forte émergence de nouvelles technologies et environnements informatiques tels que le cloud computing, l'informatique ubiquitaire ou les réseaux de capteurs. Ces environnements ont permis d'élaborer de nouveaux types d'applications avec une forte valeur ajoutée pour les usagés. Néanmoins, ils ont aussi soulevés de nombreux défis liés notamment à la conception, au déploiement et à la gestion de cycle de vie des applications. Ceci est dû à la nature même de ces environnements distribués, caractérisés par une grande flexibilité, un dynamisme accru et une forte hétérogénéité des ressources. L'objectif principal de cette thèse est de fournir une solution générique, réutilisable et extensible pour l'auto-gestion de ces applications. Nous nous sommes concentrés sur la fourniture d'un support logiciel permettant de gérer à l'exécution les architectures et leur cycle de vie, notamment pour les applications à base de composants s'exécutant dans des environnements dynamiques, distributes et à grande échelle. De façon à atteindre cet objectif, nous proposons une solution synergique - le framework Cube - combin- ant des techniques issues de domaines de recherche adjacents tels que l'auto-organisation, la satisfaction de contraintes, l'auto-adaptation et la reflexion fondée sur les modèles architecturaux. Dans notre solution, un ensemble de gestionnaires autonomiques décentralisés s'auto-organise de façon à construire et gérer une application cible en s'appuyant sur une description partagée des buts de l'application. Cette description formelle, appelé Archetype, prend la forme d'un graphe orienté exprim- ant les différents éléments de l'architecture et un ensemble de contraintes. Un prototype du framework Cube a été implanté dans le domaine particulier de la médiation. Des expériences ont été conduites dans le cadre de deux projets de recherché nationaux: Self-XL et Medical. Les résultats obtenus démontrent la validité de notre approche pour créer, réparer et adapter des applications à base de composants s'exécutant dans des environnements distribués, dynamiques et hétérogènes.

Les domaines de recherche actuels, tels que l'informatique ubiquitaire et l'informatique en nuage (cloud computing), considèrent que ces environnements d'exécution sont en changement continue. Les applications dynamiques ; où les composants peuvent être ajoutés, supprimés pendant l'exécution, permettent a un logiciel de s'adapter et de s'ajuster à l'évolution des environnements, et de tenir compte de l'évolution du logiciel. Malheureusement, les applications dynamiques soulèvent des questions de conception et de développement qui n'ont pas encore été pleinement explorées. <br> Dans cette thèse, nous montrons que le dynamisme est une préoccupation transversale qui rompt avec un grand nombre d'hypothèses que les développeurs d'applications classiques sont autorisés à prendre. Le dynamisme affecte profondément la conception et développement de logiciels. S'il n'est pas manipulé correctement, le dynamisme peut " silencieusement " corrompre l'application. De plus, l'écriture d'applications dynamiques est complexe et sujette à erreur. Et compte tenu du niveau de complexité et de l'impact du dynamisme sur le processus du développement, le logiciel ne peut pas devenir dynamique sans (de large) modification et le dynamisme ne peut pas être totalement transparent (bien que beaucoup de celui-ci peut souvent être externalisées ou automatisées). <br> Ce travail a pour but d'offrir à l'architecte logiciel le contrôle sur le niveau, la nature et la granularité du dynamisme qui est nécessaire dans les applications dynamiques. Cela permet aux architectes et aux développeurs de choisir les zones de l'application où les efforts de programmation des composants dynamiques seront investis, en évitant le coût et la complexité de rendre tous les composants dynamiques. L'idée est de permettre aux architectes de déterminer l'équilibre entre les efforts à fournir et le niveau de dynamisme requis pour les besoins de l'application.

In recent years, many distributed systems have evolved to cope with the convergence of their domain and computer networks. As an example, Internet telephony has drastically change the face of the telecommuni- cations domain in the last decade by introducing many new services based on Web services and databases. Distributed systems that provide advanced services must be efficient to be able to treat a large number of users and must be robust to face various attacks targeting the service itself or the underlying platform. However, building efficient and robust distributed systems requires an intimate knowledge of the relevant protocols and a substantial understanding of low-level system and network programming, which can be a challenge for many programmers. Nevertheless, the development process of distributed systems still remains rudimentary and requires a high level of low-level expertise. In this thesis, we show that domain-specific languages (DSLs) can successfully reduce the level of ex- pertise required to build efficient and robust distributed systems, making service programming in the reach of average developers. We present three contributions in this area. Our first contribution targets the creation of telephony services based on the SIP protocol. We have defined a domain-specific virtual machine for SIP and a DSL named SPL, providing the programmer with high-level notations and abstractions dedi- cated to telephony service development. The robustness of SPL has been a key factor in expediting service deployment. A variety of services have been written in SPL, demonstrating the usability and ease of pro- gramming of the language. Our second contribution is Zebu, a DSL-based approach for the development of network application protocol-handling layers. We have demonstrated, through various experiments, that this approach is a reliable alternative to manual development in the context of protocol-handling layers. Zebu generated code has good performance and has a significantly lower memory footprint than compa- rable existing manually encoded solutions, while guaranteeing the robustness and performance properties. The third contribution of this thesis is z2z, a generative approach to gateway construction that enables com- munication between devices that use incompatible protocols. Z2z includes a compiler that checks essential correctness properties, and a runtime system that hides low-level details from the gateway programmer. We have used z2z to automatically generate gateways between various incompatible protocols. The generated gateways run with a low runtime memory footprint, with essentially no runtime overhead.

L'ingénierie des modèles considère les modèles comme des entités de première classe pour le développement logiciel. Les processus dirigés par les modèles se doivent d'être capables de prendre en compte le savoir-faire d'experts, généralement exprimé en termes de patrons, qu'ils soient d'analyse, de conception ou d'architecture. Choisir le bon patron et assurer sa bonne intégration au sein d'une modélisation constitue des freins à l'utilisation systématique des bonnes pratiques de conception. Afin d'alléger ces tâches, nous proposons une approche basée sur l'inspection automatique des modèles. De la même manière qu'il existe des revues de code visant à vérifier l'absence de mauvaises pratiques de codage dans un programme, nous avons outillé une activité de revue de conception identifiant, expliquant et corrigeant les mauvaises pratiques de conception dans un modèle. Un patron abîmé est comparable à un patron de conception, ses contextualisations résolvant les mêmes types de problèmes, mais avec une architecture différente et certainement améliorable. Des expérimentations ont été menées afin de collecter des patrons abîmés, nous amenant à proposer un catalogue de mauvaises pratiques, complémentaire au catalogue du GoF. La détection des contextualisations de patrons abîmés dans un modèle UML est apparentée à un morphisme de graphe étendu. Les graphes UML ayant des sommets typés, la détection s'appuie sur des particularités structurelles locales et globales permettant de résoudre ce problème NP-Complet par des filtrages successifs. Cet algorithme est ainsi capable de détecter toutes les contextualisations possibles d'un patron abîmé, en gérant de plus les arcs interdits et facultatifs. La sémantique d'un fragment de modèle est donnée par son intention et celle-ci est validée par le concepteur. L'intention des fragments détectés et les bénéfices d'un remplacement par le patron adéquat sont déduits par des requêtes sur une ontologie conçue à cet effet. La transformation des fragments en contextualisations de patrons de conception est réalisée grâce à des restructurations de modèles déduites automatiquement des différences structurelles entre un patron abîmé et un patron de conception.

Présentation de travaux sur la création d'environnements collaboratifs synchrones réutilisables pour télé-TPs.

Cette thèse propose une approche pour intégrer l'utilisation des propriétés temporisées stochastiques dans un processus continu de design fondé sur des modèles à l'exécution. La spécification temporelle de services est un aspect important des architectures à base de composants, par exemple dans des réseaux distribués volatiles de nœuds informatiques. L'approche models@runtime facilite la gestion de ces architectures en maintenant des modèles abstraits des archi- tectures synchronisés avec la structure physique de la plate-forme d'exécution distribuée. Pour les systèmes auto-adaptatifs, la prédiction de délais et de débit d'un assemblage de composants est primordial pour prendre la décision d'adaptation et accepter les évolutions qui sont conformes aux spécifications temporelles. Dans ce but, nous définissons une extension du métamodèle fondée sur les réseaux de Petri stochastiques comme un modèle temporisé interne pour la prédiction. Nous concevons une bibliothèque de patrons pour faciliter la spécification et la prédiction des propriétés temporisées classiques de modèles à l'exécution et rendre la synchronisation des comportements et des changements structurels plus facile. D'autre part, nous appliquons l'approche de la modélisation par aspects pour tisser les modèles temporisés internes dans les modèles temporisés de comportement du composant et du système. Notre moteur de prédiction est suffisament rapide pour effectuer la prédiction à l'exécution dans un cadre réaliste et valider des modèles à l'exécution.

Aujourd'hui, les environnements ubiquitaires font partie de notre vie quotidienne. À la maison, au travail, dans les voitures, dans les hôtels, les supermarchés et autres espaces publiques, nous rencontrons des technologies qui visent à rendre notre vie plus simple et plus facile d'une façon transparente. Durant ces dernières années, le potentiel de ces environnements a été de plus en plus exploité, notamment avec l'avènement et l'utilisation généralisée des smartphones. Ce type de dispositifs permet l'exécution d'applications qui ont la capacité de s'adapter parfaitement à l'état courant de l'environnement. De telles applications, appelées "applications sensibles au contexte", bénéficient de l'information du contexte et des services qui sont présents dans leur environnement pour améliorer et changer automatiquement leur comportement. Toutefois, ces adaptations nécessitent une intégration d'informations qui doit être effectuée en tenant compte de l'hétérogénéité en termes de dispositifs, de plateformes d'exécution, et de protocoles de communication ainsi que la mobilité des applications de sorte que les différentes responsabilités de l'adaptation peuvent être distribuées. Pour faire face à ces défis, et compte tenu des limitations des solutions existantes, nous fournissons deux contributions majeures dans cette dissertation. Tout d'abord nous introduisons l'intergiciel SPACES comme une solution d'intégration des informations contextuelles et ensuite nous définissons le paradigme de "boucles de contrôle ubiquitaires" pour adapter les applications sensibles au contexte. En particulier, dans SPACES, nous définissons un méta-modèle inspiré du style architectural REST (REpresentational State Transfer) pour favoriser l'échange des informations contextuelles en tant que ressources, ce qui représente le fondement de notre approche. Ensuite, nous définissons les connecteurs SPACES pour modulariser les différents concepts et préoccupations identifiés par le méta-modèle. Ces connecteurs sont conçus en utilisant les principes de la programmation orientée composant et ils sont incorporés dans le modèle Service Component Architecture (SCA) pour être utilisés dans différents types d'applications, et ainsi indépendamment des applications sensibles au contexte. Grâce à la définition de SPACES, nous sommes en mesure d'élaborer la seconde contribution de la dissertation--i.e., les boucles de contrôle ubiquitaires. Inspiré par les concepts de l'informatique autonome, les boucles de contrôle offre la flexibilité nécessaire pour intégrer de nouveaux participants dans le processus d'adaptation (par exemple, des applications sensibles au contexte, des services et des systèmes existants) tout en fournissant un support pour la mobilité et l'intégration de nouveaux mécanismes de communication en cas de besoin. Dans le noyau des boucles de contrôle ubiquitaires--i.e., la prise de décision-- nous employons des techniques de programmation par contraintes pour optimiser la configuration courante de l'application en intégrant des critères qui garantissent une meilleure expérience à l'utilisateur final, tels que les coûts associés à l'adaptation, les ressources consommées ou encore la qualité de service offerte par la nouvelle configuration. Enfin, nous validons notre proposition avec trois études de cas: Tout d'abord une politique de Caching or Off-Loading, dans laquelle le comportement de l'application est modifiée lors de l'exécution, ensuite TRACK.ME, une plateforme pour effectuer des expérimentations scientifiques et enfin DIGIHOME, une plateforme pour la création des maisons intelligentes. Ces scénarios démontrent la pertinence de notre approche lorsque différents types de dispositifs, des protocoles et des technologies de mise en œuvre sont impliqués dans le processus d'adaptation.

Le logiciel est devenu omniprésent dans nos vies de sorte qu'on le retrouve dans plusieurs domaines de la vie courante. Cependant cette omniprésence, n'est pas sans conséquences. Les bogues de logiciel peuvent causer de vrais désastres, économiques, écologiques voire sanitaires. Vu la forte omniprésente du logiciel dans nos vies, le fonctionnement de nos sociétés dépend fortement de sa qualité. La programmation par contrat a pour but de produire des logiciels fiables, c'est-à-dire corrects et robustes. En effet, ce paradigme de programmation vise à introduire des assertions qui sont des spécifications de services. Ces spécifications représentent une forme de contrat. Les contrats définissent les responsabilités entre le client et le fournisseur. Le respect des contrats permet de garantir que le logiciel ne fait ni plus ni moins que ce que l'on attend de lui qu'il fasse. Le test unitaire est un test qui permet de s'assurer du bon fonctionnement d'une partie précise d'un logiciel. C'est un test dont la vérification se fait en exécutant une petite unité de code. En somme, un test unitaire est un code qui exécute de manière indirecte le code d'une classe pour vérifier que le code fonctionne bien. L'outil Génération de Squelettes des Contrats de classes et des tests unitaires (GACTUS) permet la génération automatique de squelettes de contrats de classes et celles des classes des tests unitaires d'un projet Java. La génération automatique du code source permet d'obtenir un code uniforme. GACTUS est un plug-in pour l'environnement de développement Eclipse écrit en Java. L'objectif principal de GACTUS est de faciliter la réalisation de logiciel de qualité grâce à la génération automatique des squelettes de contrats de classe et celui des tests unitaires et aussi d'accroître la productivité des développeurs. Pour faciliter son utilisation, GACTUS dispose d'une interface graphique permettant de guider l'utilisateur.

Thèse numérisée par la Direction des bibliothèques de l'Université de Montréal.

Les applications ubiquitaires évoluent dans des environnements plus hétérogènes et plus dynamiques que ceux des systèmes distribués traditionnels. La criticité des domaines applicatifs impliqués et la vocation non intrusive de l'informatique ubiquitaire exigent de garantir la robustesse des applications avant et pendant leur déploiement en situation réelle. Les solutions proposant de gérer la dynamicité des environnements ubiquitaires offrent des canevas de programmation dont la généricité ne permet pas de garantir la fiabilité des applications développées. D'autres solutions permettent davantage de vérifications en assurant, par exemple, l'intégrité des communications. Cependant, ces vérifications, telles que proposées dans ces solutions, empêchent la prise en compte de la dynamicité, indispensable à la mise en oeuvre d'applications ubiquitaires. Dans cette thèse, nous proposons un canevas logiciel visant à concevoir, développer, vérifier et tester les applications ubiquitaires avant leur déploiement en environnements réels. Notre approche repose sur des spécifications haut niveau des applications cibles. Chaque spécification, écrites dans le langage DIASPEC, est analysée, vérifiée et compilée par le compilateur DIASPEC qui génère un canevas logiciel dédié, incluant un canevas de programmation et un canevas de simulation. Les canevas de programmation générés fournissent du support pour la programmation d'applications ubiquitaires. Ils garantissent l'intégrité des communications tout en permettant la gestion de la dynamicité des environnements ubiquitaires. Les canevas de simulation générés fournissent du support pour le test des applications ainsi développées. Les contributions de cette thèse sont les suivantes ; Nous proposons l'approche DIAGEN qui permet, à partir de spécifications d'architectures logicielles ubiquitaires, de générer du support de programmation et un ensemble de vérifications dédiés au développement d'applications ubiquitaires. Ces spécifications reposent sur un langage déclaratif, appelé DIASPEC, qui permet de décrire les types de services composant les applications ubiquitaires cibles. Le compilateur DIASPEC vérifie la cohérence des spécifications et génère, à partir de celles-ci, des canevas de programmation dédiés. Les canevas de programmation générés garantissent l'intégrité des communications d'applications dynamiques. Nous avons développé DIASIM, un simulateur pour tester à l'exécution, le comportement des applications développées avec l'approche DIAGEN. DIASIM permet de tester les applications sans les modifier et d'intégrer incrémentalement des services réels dans les scénarios de simulation. Nous avons montré que l'approche DIAGEN permet davantage de vérifications statiques tout en gérant la dynamicité des environnements ubiquitaires et en permettant une plus grande concision des applications développées. Nous avons analysé les canevas de programmation générés pour la gestion de réunion, l'immotique et la téléphonie. / Ubiquitous systems have to cope with more heterogeneous and more dynamic environments than traditional distributed systems. The criticity of application domains related to ubiquitous computing requires to ensure the robustness of applications before their deployment in actual situations. Some approaches handle the dynamicity of ubiquitous environments but propose generic programming frameworks. This genericity is a major obstacle for producing robust applications. Other approaches enable more verifications that ensure, for example, communication integrity. However, as performed by these approaches, these verifications are not compatible with managing constant changes of ubiquitous environments. This thesis proposes a declarative approach to generate software frameworks for ubiquitous computing. Our approach relies on high-level specifications of target applications. These specifications, written in the DIASPEC language, are analyzed, checked and compiled by the DIASPEC compiler which generates dedicated software frameworks, including programming frameworks and simulation frameworks. The generated programming frameworks provide programming support for developing ubiquitous applications while the generated simulation frameworks provide testing support for these applications. Programming frameworks ensure communication integrity while handling the dynamicity of ubiquitous environments. Furthermore, they are generated on top of a generic middleware; the layered architecture of this middleware allows ubiquitous applications to be independent of underlying technologies. The contributions of this thesis are as follows; We present the DIAGEN approach which proposes to generate, from specifications of ubiquitous software architectures, programming support and verifications dedicated to the development of ubiquitous applications. These specifications are written in a declarative language, called DIASPEC, which allows to describe all service types composing the target ubiquitous applications. The DIASPEC compiler checks the specification consistency and generates dedicated programming frameworks. These programming frameworks ensure communication integrity of dynamic applications. The underlying middleware has a layered architecture, making programming frameworks independent of software buses. Thus, applications are portable without modification. We present the DIASIM simulator that tests, at run time, the behavior of applications developed with DIAGEN. DIASIM allows to test applications without modification and to incrementally integrate actual services in simulation scenarios. We show that DIAGEN applications are more concise than existing approaches while enabling more verifications and handling the dynamicity of ubiquitous environments.