Les systèmes auto adaptatifs sont des systèmes logiciels capables d'observer leur environnement de travail (par des sondes), raisonner et prendre des décisions sur la façon de s'adapter aux changements environnementaux (par un moteur de raisonnement), et modifier leur structure interne pour prendre les adaptations en compte. Ces systèmes peuvent fournir une aide précieuse dans un grand nombre d'activités humaines. Cependant, ils ne fourniront entièrement leurs promesses que si les ingénieurs peuvent s'assurer que les décisions et les adaptations sont correctes sur toutes les situations. Ceci exige des techniques robustes pour valider que les mécanismes de raisonnement et d'adaptation dans de tels systèmes sont corrects. Dans cette thèse j'adresse la validation des moteurs de raisonnement et des mécanismes d'adaptation par programmation orientée aspect. Les moteurs de raisonnement sont des éléments logiciels responsables de raisonner sur un grand nombre de facteurs afin de décider comment adapter un système face à des variations dans l'environnement. Il est primordial d'assurer que les décisions prises par ces moteurs sont correctes pour chaque changement d'environnement possible. Une décision erronée peut mener vers une adaptation défectueuse qui peut empêcher le système de fonctionner correctement. Cependant, valider que les moteurs de raisonnement prennent la bonne décision entraine des défis dus au grand nombre de changements environnementaux possibles. Dans cette thèse je présente multi dimesional covering arrays (MDCA) pour échantillonner les conditions environnementales qui peuvent affecter la prise des décisions. MDCA vise spécifiquement les environnements qui peuvent déclencher des décisions complexes en intégrant explicitement la notion de l'histoire dans l'échantillon d'environnement. La programmation orientée aspect (AOP) fourni les moyens aux ingénieurs d'augmenter ou remplacer la structure ou le comportement du système, ces propriétés font d'AOP un bon mécanisme d'adaptation. Cependant, en utilisant l'AOP il est difficile de (i) prévoir des interactions entre différents aspects et le système de base, (ii) contrôler les endroits où les aspects se tisseront, (iii) assurer que les aspects s'exécuteront sans risque pour l'évolution (des aspects ou du système de base). Ces difficultés entravent la validation et l'adoption de l'AOP en général. Dans cette thèse je présente un framework pour la spécification d'interactions dans des programmes orientée aspects (ABIS), qui permet aux ingénieurs de contrôler les interactions entre les aspects et le système de base en spécifiant les endroits où aspects sont autorisés à se tisser. ABIS permet aux ingénieurs de réduire le temps nécessaire pour diagnostiquer et corriger des problèmes dus aux aspects défectu

La qualité de service temporelle permet à l'utilisateur d'une application à composants d'estimer les propriétés extra-fonctionnelles l'application. Afin d'obtenir une estimation précise de la qualité, les informations de qualité de service temporelle doivent être présentes durant le processus de développement de l'application, de la spécification jusqu'à l'implantation. La contribution de cette thèse est la définition d'un processus de gestion de la qualité de service temporelle pendant le développement d'une application à composants. Nous nous intéressons dans un premier temps à l'introduction des informations temporelles lors de la spécification de l'application. Nous utilisons une approche à base de motifs pour intégrer le temps dans la spécification de l'application. Dans un second temps, nous fournissons un moniteur de qualité de service temporelle à partir de la spécification. Le moniteur s'assure, pendant l'exécution, que l'application respecte la qualité de service temporelle requise par la spécification. Finalement, nous décrivons notre outil /Thot/ implantant le processus de gestion de la qualité de service temporelle et nous l'utilisons sur un cas d'application.

L'Ingénierie Dirigée par les Modèles est une approche pour la construction de systèmes fondées sur l'utilisation de modèles. Malgré une recherche très active sur les technologies d'IDM et leur application, il existe relativement peu de travaux sur la réutilisation et la composition fiable des éléments qui manipulent des modèles. Cette thèse présente une approche fondée sur les idées et formalismes du domaine des systèmes de types, pour définir des notions claires de modèles et de types de modèles, ainsi qu'une relation pour la substituabilité des types de modèles. Ces principes du typage de modèles ont été validés par leur application dans le langage de méta-modèlisation Kermeta. De plus, la thèse revisite le problème de l'extensibilité des langages sous l'angle de l'ingénierie dirigée par les modèles, et elle détaille comment les types de modèles en résolvent certains aspects.

Ce travail s'inscrit dans un contexte où la taille et la complexité des logiciels augmentent alors que les contraintes de temps de développement, de qualité, de maintenance et d'évolution sont toujours plus fortes. Pour répondre à cette tendance, l'ingénierie dirigée par les modèles constitue une évolution prometteuse des techniques de génie logiciel. Les idées de l'ingénierie dirigée par les modèles sont, d'une part de rendre les modèles productifs, et d'autre part d'automatiser certaines étapes du développement grâce à des transformations de modèles. Une des conditions pour que l'ingénierie dirigée par les modèles tienne ses promesses, en terme de productivité et de qualité, est d'assurer, tout d'abord, la correction des modèles, et ensuite, la correction des transformations utilisées. La contribution de ce travail s'articule autour de ces deux axes et constitue un premier pas vers la fiabilisation des processus de dévelopement dirigés pas les modèles. Le premier axe de ce travail vise à améliorer les possibilités de validation des modèles en proposant une plateforme pour la définition de langages de modélisation. En fonction des expériences et du domaine considéré, les modèles utilisés dans l'ingénierie dirigée par les modèles sont exprimés dans divers langages de modélisation. Comme tout langage, un langage de modélisation est constitué de plusieurs éléments de spécification : une syntaxe abstraite (ou méta-modèle), une sémantique et des contraintes syntaxiques et sémantiques. Pour assurer la précision et la cohérence d'un tel langage, il faut d'une part spécifier sans ambiguïtés chaque élément, et d'autre part assurer la bonne intégration des différents éléments entre eux. Or, les pratiques actuelles de l'ingénierie dirigée par les modèles utilisent des formalismes hétérogènes et parfois difficiles à exploiter (le langage naturel par exemple) pour la spécification de ces éléments. Afin d'améliorer la définition des langages de modélisation, nous proposons l'utilisation d'un coeur sémantique unique et précis. Ce coeur sémantique se présente sous la forme d'un langage appelé Kermeta. Au coeur de la plateforme d'ingénierie dirigée par les modèles développée par l'équipe Triskell, le langage Kermeta a été utilisé dans des contextes variés dont la transformation de modèles, la modélisation orientée-aspects et l'analyse d'exigences logicielles. L'utilisation de Kermeta pour ces applications a permis de valider le langage et de mettre en évidence ses avantages par rapport aux techniques existantes. Le second axe de ce travail concerne la validation des transformations de modèles. Celles-ci sont utilisées pour automatiser les phases du processus de développement qui peuvent l'être. Qu'il s'agisse de raffinement, de composition, de refactoring ou encore de génération de code, la qualité des transformations de modèles est primordiale pour assurer la qualité des logiciels développés. Il suffit en effet qu'une seule transformation utilisée soit erronée pour que l'ensemble du processus de développement soit fragilisé. Dans ce contexte, nous proposons une technique pour la sélection de modèles de test permettant la validation des programmes de transformation de modèles. Cette technique tire avantage du fait que toute transformation de modèles manipule des données dont la structure est décrite par un méta-modèle.

La séparation de préoccupations transverses permet au concepteur de logiciels d'avoir un meilleur contrôle sur les variations et les évolutions du logiciel. Dans le domaine de la programmation, cette idée a été popularisée par le langage AspectJ, mais aujourd'hui, la communauté aspect s'intéresse aussi à opérer cette séparation plus tôt dans le cycle de développement: dès les phases d'analyse/conception et même d'expression des besoins. Dans cette optique, cette thèse propose une technique permettant de tisser des comportements décrits sous forme de scénarios dans un modèle de base de scénarios. Le processus de tissage se décompose en deux phases. Tout d'abord, une phase de détection permettant d'identifier des parties particulières d'un modèle de base où un aspect doit être tissé, puis une phase de composition permettant de construire le modèle voulu. Ces deux phases sont détaillées dans cette thèse. En particulier, nous proposons plusieurs sémantiques de détection dans des scénarios finis. Certaines de ces sémantiques favorisent le tissage d'aspects multiples. Nous proposons également un algorithme de détection dans des scénarios infinis, fondé sur l'analyse statique de la sémantique des scénarios (qui est dynamique), ce qui revient à proposer un tissage statique d'aspects dynamiques. Pour fusionner des scénarios, nous proposons plusieurs opérateurs de composition, définis formellement, permettant d'obtenir des résultats cohérents. Finalement, nous décrivons l'implantation du tisseur de scénarios proposé dans l'environnement Kermeta, et nous montrons son utilité à travers des cas d'application.

Mes travaux concernent la modélisation opérationnelle des systèmes à informatique prépondérante, dans le double but de capitaliser les savoir-faire et d'automatiser les réalisations. La modélisation est l'utilisation d'une représentation, en lieu et place d'une chose du monde réel, dans un but cognitif. Un modèle se substitue à un système dans un contexte donné, à moindre coût, plus simplement, plus rapidement et sans les risques ou dangers inhérents à une manipulation du système réel. Une modélisation devient opérationnelle dès lors qu'une implantation informatique peut en être dérivée de manière systématique. L'ensemble de mes travaux a pour but in fine de réduire le fossé entre les processus métier et les techniques d'informatisation. Je m'intéresse à la fois à la formalisation des savoir-faire métier et informatique. Ma démarche scientifique mélange des aspects théoriques et des validations expérimentales. Elle procède par fertilisation croisée, en reposant tout à la fois sur l'analyse de l'état de l'art, la participation à des groupes de travail ou de normalisation, et à la confrontation avec des problématiques industrielles. Les idées que j'ai approfondies dans mes travaux ont émergées dans différentes communautés (telles celles des grammaires, des bases de données, de la gestion des documents, des méthodes formelles...). Je procède en considérant la modélisation comme une alternative à la programmation. C'est une posture certes un peu radicale – car la modélisation et la programmation peuvent très bien se complémenter – mais je l'ai choisi afin d'amener les techniques de modélisation à leur extrême. Mes principales contributions portent sur : - Des avancées méthodologiques, dans le domaine de la modélisation objet avec UML et aussi dans l'intégration entre l'ingénierie dirigée par les modèles et les méthodes agiles. Ces contributions ont été validées dans des contextes industriels, en collaboration avec Rational Software et ObjeXion Software. - Des contributions pour la capitalisation du savoir-faire de modélisation des systèmes de commande et contrôle. Ces travaux à la frontière entre l'informatique et l'automatique, ont été réalisés en partenariat avec l'Ifremer et Nipson Printing System. - Des contributions pour la modélisation opérationnelle des systèmes d'information Web. Ces contributions s'inscrivent dans le cadre d'un transfert de technologie, sous la forme d'une création d'entreprise innovante : ObjeXion Software. - Des contributions pour l'application de la modélisation à l'ingénierie des langages. Ces travaux regroupés dans le projet open-source Kermeta porté par l'INRIA, font l'objet d'un déploiement industriel dans le cœur de la plateforme RNTL OpenEmbeDD.

Avec l'ingénierie des modèles on cherche à résoudre le problème de l'évolution des grands systèmes informatiques. En effet, ces systèmes doivent s'adapter à l'évolution des besoins et des technologies, et cette évolution est de plus en plus rapide par rapport à celle du domaine métier. On souhaite donc réutiliser l'expertise de ce domaine indépendamment des technologies sur lesquelles on s'appuie, grâce à des techniques de manipulation de modèles. La contribution présentée dans ce manuscrit est une architecture de manipulation de modèles indépendante d'un quelconque métamodèle. Cette architecture favorise la réutilisation des techniques reconnues de génie logiciel orienté objet pour le développement de transformations de modèles. La sémantique de l'interface d'accès aux modèles est spécifiée par une implémentation de référence en langage fonctionnel. Notre approche est fondée sur une interface de niveau mof (Meta-Object Facility) pour la manipulation de modèles. Le langage associé permet de manipuler des éléments de modèle directement, car la structure du métamodèle étend dynamiquement l'ensemble des types accessibles au programme de transformation. D'un point de vue méthodologique, on montre que les transformations de modèles synthétisent l'expertise d'implantation d'un domaine métier vers une technologie donnée ; il est donc utile de modéliser les transformations les plus complexes pour les développer en appliquant récursivement les techniques de génie logiciel et d'ingénierie des modèles. La mise en pratique illustre ce point et montre le fonctionnement de l'architecture de manipulation de modèles avec des transformations pour l'introduction de design patterns et la restructuration de modèles uml (Unified Modeling Language).

L'ingénierie dirigée par les modèles est une approche du génie logiciel qui utilise des modèles comme artefacts de première importance, à partir desquels la validation, le code, les tests et la documentation sont dérivés. Les modèles peuvent être généralistes (e.g.; UML), propres à un domaine (e.g.; les systèmes temps réels), ou même spécifiques au métier d'une compagnie. La mesure est une activité d'ingénierie qui permet d'obtenir une information quantitative sur les processus d'ingénierie ou les systèmes en cours de développement. La mesure des modèles tôt dans le cycle de développement permet aux architectes et aux managers d'estimer les coûts, d'identifier les risques et les défauts, de valider des propriétés et de suivre une démarche d'assurance qualité dès le début du développement. Malheureusement, il est coûteux de développer un outil de mesure ad hoc pour chaque type de modèles manipulés. Nous proposons une approche indépendante du métamodèle pour définir des métriques de modèles. Les métriques sont spécifiées à un haut niveau d'abstraction, de manière plus rigoureuse qu'avec le langage naturel, de manière plus concise qu'avec un langage de programmation et débarrassées des préoccupations d'implémentation. Ensuite, à partir de cette spécification déclarative des métriques, un outil peut générer le composant de mesure, directement intégré dans un environnement de modélisation. La contribution globale de cette approche est de donner une implémentation des métriques de modèles, intégrée, fondée sur des modèles, et à un coût moindre.

Software is becoming a pervasive presence in our lives, powering computing systems in the home, in businesses, and in safety-critical settings. In response, languages are being defined with support for new domains and complex computational abstractions. The need for formal techniques to help better understand the languages we use, correctly design new language abstractions, and reason about the behavior and correctness of programs is now more urgent then ever. In this dissertation we focus on research in programming language semantics and program analysis, aimed at building and reasoning about programming languages and applications. In language semantics, we first show how to use formal techniques during language design, presenting definitional techniques for object-oriented languages with concurrency features, including the Beta language and a paradigmatic language called KOOL. Since reuse is important, we then present a module system for K, a formalism for language definition that takes advantage of the strengths of rewriting logic and term rewriting techniques. Although currently specific to K, parts of this module system are also aimed at other formalisms, with the goal of providing a reuse mechanism for different forms of modular semantics in the future. Finally, since performance is also important, we show techniques for improving the executable and analysis performance of rewriting logic semantics definitions, specifically focused on decisions around the representation of program values and configurations used in semantics definitions. The work on performance, with a discussion of analysis performance, provides a good bridge to the second major topic, program analysis. We present a new technique aimed at annotation-driven static analysis called policy frameworks. A policy framework consists of analysis domains, an analysis generic front-end, an analysis-generic abstract language semantics, and an abstract analysis semantics that defines the semantics of the domain and the annotation language. After illustrating the technique using SILF, a simple imperative language, we then describe a policy framework for C. To provide a real example of using this framework, we have defined a units of measurement policy for C. This policy allows both type and code annotations to be added to standard C programs, which are then used to generate modular analysis tasks checked using the CPF semantics in Maude.

Ce mémoire présente mes travaux de recherche de 1988 à 2001, travaux effectués d'abord à l'INRIA Rocquencourt au sein du projet Algo (1988 à 1992), puis à l'INRIA Lorraine et au LORIA dans les projets Euréca (1993 à 1997), PolKA (1998 à 2000), et Spaces (2001). Au niveau thématique, on peut distinguer grosso modo trois phases : une première période allant de 1988 à 1992 où j'ai surtout travaillé sur l'analyse d'algorithmes et la génération aléatoire, une seconde période de 1993 à 1997 où je me suis investi dans le calcul formel et les algorithmes sous-jacents, enfin une troisième période depuis 1998 où je me suis intéressé aux problèmes d'arithmétique exacte en précision arbitraire.