Le développement des applications distribuées, amenées de plus en plus à s'exécuter sur des machines aux caractéristiques hétérogènes, tend à se complexifier. Le modèle à composants apporte une réponse à ce problème en favorisant la réutilisabilité du code. Par ailleurs, les services techniques, offerts par les plates-formes à composants, allègent le code source et améliorent la qualité de service. Cependant, ces services techniques, conçus pour une exécution statique sur des machines serveurs, ne s'adaptent pas à d'autres contextes d'exécution. Leur développement sous forme d'objet notoire empêche leur adaptation. De plus, l'ensemble des services techniques fournis par la plate-forme à composants est figé. La première contribution de cette thèse consiste à définir un modèle de conception et de développement des services techniques basé sur le modèle à composants Fractal. Ce processus aboutit à la définition de personnalités d'un service (P1S) répondant chacune à un contexte d'utilisation, ainsi qu'à une redéfinition de l'assemblage formé par l'application et ses services techniques. Notre seconde contribution est un service de gestion de l'adaptation des services techniques qui permet de détecter les changements d'environnement d'exécution grâce à un moniteur, de localiser les services techniques et d'identifier la personnalité la plus adaptée au nouvel environnement grâce à un annuaire dédié aux services techniques. La faisabilité de nos propositions a été validée à travers la conception et l'implantation d'un service transactionnel multi-personnalités ainsi que l'implantation du système de gestion de l'adaptation.

L'approche "services Web" étend le rôle du Web d'un simple support d'information vers un intergiciel d'applications B2B. Un des concepts intéressants qu'offre cette technologie est la possibilité de définir un nouveau service par composition de services Web existants. Dans cette thèse nous nous intéressons à assurer des compositions fiables de services Web. Pour ce faire, nous proposons un modèle qui (i) enrichit la description des services Web pour mieux exprimer leurs propriétés transactionnelles et qui (ii) étend et fusionne les systèmes de workflow et les modèles transactionnels avancés (MTA).<br />Nous proposons trois approches, basées sur ce modèle, pour assurer des compositions fiables. Contrairement aux MTA, la première approche part des spécifications des concepteurs pour déterminer les mécanismes transactionnels permettant d'assurer des exécutions correctes.<br />La deuxième approche procède par ré-ingénierie du service composé (SC). Elle permet d'améliorer les mécanismes de recouvrement d'un SC après analyse de ses traces d'exécutions.<br />La troisième approche repose sur le concept de "patron transactionnel", un nouveau concept que nous introduisons. Un "patron transactionnel"est un patron qui combine la flexibilité des workflows et la fiabilité des MTA. Nous définissons un SC en connectant des patrons transactionnels.<br />Nous utilisons un ensemble de règles de cohérence pour assurer que le SC défini est fiable. La contribution majeure de notre proposition est qu'elle a pu fusionner la flexibilité des systèmes de workflow et la fiabilité des MTA. Ainsi elle permet d'assurer des exécutions correctes<br />selon les critères spécifiés par les concepteurs.

L'augmentation en taille et en complexité des systèmes réactifs font que leur vérification est de plus en plus difficile à comprendre et à appréhender. Dans cette thèse, une approche est proposée pour spécifier et vérifier compositionnellement certains de ces systèmes.<br /><br />Cette approche est basée sur un principe de décomposition supportant un raffinement compositionnel au niveau des composants et au niveau de leur produit synchronisé~: une méthode est présentée pour vérifier le raffinement d'un système à composants à partir du raffinement de ses composants.<br /><br />Les propriétés LTL sont préservées par le raffinement compositionnel présenté ici. De plus, certaines propriétés -- comme les invariants et les propriétés LTL de sûreté -- peuvent être vérifiées compositionnellement durant la phase de vérification du raffinement.<br /><br />Un outil, nommé SynCo, implante cette approche de vérification compositionnelle. Les différents aspects de ce travail sont illustrés par plusieurs exemples~: un robot industriel, un système d'essuyage et un porte-monnaie électronique.

Notre thèse se situe dans le domaine des méthodes formelles appliquées aux systèmes réactifs. Nous modélisons et traitons ces systèmes, en continuelle interaction avec leur environnement, grâce au langage<br />synchrone Lustre.<br /><br />D'abord, sur la base d'un travail précurseur, nous établissons pour Lustre une méthode de preuve inductive des propriétés de sûreté. Cette méthode est optimisée, afin de prendre en compte au mieux la dynamique des systèmes. Elle est implémentée dans un outil de preuve, Gloups.<br /><br />Ensuite, suivant le modèle de la méthode B, nous définissons un calcul de raffinement pour Lustre. Ce calcul est à la fois adapté à Lustre et exprimé en ce langage. Les obligations de preuve qui assurent la<br />correction du raffinement peuvent être traitées par Gloups. Pour faciliter le développement, un autre outil, Flush, génère automatiquement les obligations pour Gloups.<br /><br />Ainsi, nous utilisons Lustre à la fois comme langage de programmation et comme cadre formel d'un développement maîtrisé. L'intérêt de ce<br />procédé réside dans la simplicité du langage et dans son adaptation aux systèmes réactifs : en ce domaine, notre méthode de raffinement est suffisamment expressive, sans être inutilement compliquée. Des exemples viennent démontrer l'intérêt de la méthode.

Le déploiement arrive en fin de cycle de vie du logiciel. Cette étape a pris une grande importance dans les entreprise ayant un grand nombre de machines à gérer : on parle alors de déploiement à grande échelle. Les entreprises souhaitent pouvoir automatiser cette étape, pour éviter d'avoir à répéter les mêmes étapes plusieurs fois. Cependant, elles souhaitent garder un certain contrôle sur les activités de déploiement, en imposant différentes contraintes (même version d'une application sur un groupe de machines, préférence pour des applications avec certaines caractéristiques, ordonnancement prioritaire, ...). Dans notre travail, nous définissons un méta-modèle de déploiement permettant d'automatiser le traitement des données liées au déploiement. Nous définissons aussi des stratégies de déploiement qui permettent aux entreprises de définir leur propres contraintes de déploiement, selon leurs besoins et leurs préférences.

Ce travail s'inscrit dans la continuité de l'étude du langage de description de systèmes AltaRica. Ce langage, développé au Labri, permet de modéliser des systèmes réels de manière hiérarchique. L'objectif de la thèse est d'introduire le temps quantitatif dans le but de concevoir des systèmes temps réel, c'est à dire des systèmes assujettis à des contraintes temporelles.<br />Deux extensions du langage sont proposées : une version temporisée et une hybride. Ces extensions respectent les caractéristiques du langage initial et conservent les aspects de hiérarchie, de synchronisation, de partage de variables et de priorité statique. En outre, afin d'améliorer les descriptions temps réel, de nouveaux opérateurs de modélisation, comme l'urgence et les priorités temporelles, ont été ajoutés. Nous obtenons ainsi un langage hiérarchique de haut niveau de modélisation de systèmes temps réel. <br />Une étude formelle complète a été menée sur la sémantique du langage, le pouvoir d'expression des langages AltaRica temps réel et des moyens de traductions automatiques vers des modèles classiques existants. Ces algorithmes reposent sur la notion de mise à plat de modèle, i.e. réécrire le modèle sans sous composant.<br />Enfin, le langage temporisé est implanté dans un prototype qui étant donné un modèle le met à plat puis le traduit en automate temporisé. Ainsi, certains systèmes réels ont pu être modélisés puis des propriétés ont été vérifiées à l'aide du model checker UPPAAL.

Dans notre travail nous nous sommes intéressés à la vérification<br /> automatique de propriétés comportementales d'applications réparties par des<br /> méthodes fondées sur les<br />modèles. En particulier, nous étudions le problème de<br />génération de modèles <br />à partir de programmes Java répartis et représentés par des systèmes de transitions<br />communiquants.<br /><br />Pour ce faire, nous définissons une sémantique comportementale de programmes ProActive, une<br />librairie Java pour la programmation parallèle, distribuée et<br />concurrente. À partir de cette sémantique nous construisons des modèles<br />comportementaux pour<br />des abstractions finies d'applications écrites dans ce langage. Ces<br />modèles sont basés sur la sémantique des algèbres de<br />processus et peuvent donc être construits de manière compositionnelle et<br />hiérarchique.<br />La construction de modèles finis n'est pas toujours possible. Pour<br />pouvoir traiter des problèmes prenant en compte des données, ainsi que<br />des problèmes concernant des topologies non bornées d'objets<br />répartis, nous définissons une nouvelle notion de modèleles<br />hiérarchiques, à base de systèmes de transitions paramétrés et de<br />réseau de synchronisation paramétrés. Moyennant des abstractions ces modèles permettent de<br />spécifier des applications possiblement infinies par des représentations<br />expressives, finies, et plus proche de la structure du code. <br />Par ailleurs, nous définissons un système de règles sémantiques<br />permettant de générer automatiquement ces modèles (finis ou<br />paramétrés) à partir d'une forme intermédiaire, obtenue par analyse statique,<br />des programmes analysés.<br />Les modèles ainsi générés sont exploitables directement ou après<br />instantiation par des outils de vérification.

Le déploiement est une phase qui prend de plus en plus d'importance dans le cycle de vie du logiciel. Il prend le relais après la phase de développement et couvre les étapes restantes du cycle de vie : de l'installation jusqu'à la désinstallation du logiciel en assurant sa maintenance corrective et évolutive . Cette maintenance est nécessaire pour prendre en compte de nouvelles conditions, non envisagées et difficiles à prédire dans la phase de développement. Depuis plusieurs années, le développement du logiciel s'oriente vers un nouveau paradigme permettant de simplifier la maintenance. Ce paradigme a pour objectif la construction d'applications en intégrant des briques logicielles bien définies et "autonomes", appelées composants. La notion classique de développement d'applications en écrivant du code a été remplacée par l'assemblage de composants préfabriqués. En général, pour introduire les modifications nécessaires, l'application doit être arrêtée, modifiée, recompilée puis démarrée à nouveau. Cependant, ce processus classique de maintenance ne peut pas être appliqué à certaines catégories d'applications, pour lesquelles l'interruption complète de service ne peut pas être tolérée. Ces applications, qualifiées de "non-stop", doivent être adaptées d'une manière dynamique avec le minimum de perturbation. Dans cette thèse, nous proposons une approche réflexive permettant de supporter la reconfiguration dynamique des applications à base de composants. Cette approche est mise en œuvre sous forme du système DYVA. Le rôle de ce système est de prendre en charge la responsabilité de reconfiguration, et de permettre aux développeurs de se concentrer sur la logique applicative. Notre objectif majeur est de proposer une solution de reconfiguration générale, basée sur des abstractions et séparée des applications à reconfigurer. Ceci permet de développer des applications propres, qui focalisent sur la logique métier. La séparation favorise aussi l'évolution et facilite la maintenance, aussi bien des applications que du système de reconfiguration. Pour assurer l'ouverture et la réutilisabilité de notre système, nous l'avons basé sur un modèle de composants abstrait. Ce modèle incarne l'image de l'application à reconfigurer et permet de traiter d'une manière homogène, des applications issues de modèles de composants différents. Notre approche favorise aussi l'auto-reconfiguration qui reflète la capacité du système de reconfiguration à prendre des décisions de reconfiguration cohérentes, et à matérialiser ces décisions sans l'intervention d'un acteur humain.

Les problèmes d'ordonnancement constituent une classe importante des problèmes d'optimisation combinatoire. La plupart des travaux dans ce domaine considèrent des problèmes statiques pour lesquels toutes les données (activités, ressources, contraintes) sont connues à l'avance. En réalité, ce type de problèmes est très souvent soumis aux aléas (matières premières livrées en retard, arrivées de nouvelles commandes, pannes de machines, etc.). Aussi, l'ordonnancement se déroule rarement comme prévu. On a alors affaire à un problème d'ordonnancement dit dynamique. Dans cette thèse, nous considérons un problème d'ordonnancement très général, appelé RCPSP (Resource Constrained Project Scheduling Problem), et proposons un système permettant de résoudre le cas dynamique. Bien que beaucoup de travaux concernent le RCPSP statique, seules quelques méthodes sont proposées pour le cas dynamique. De plus ces méthodes ne sont pas satisfaisantes. La méthode que nous proposons applique au RCPSP une des techniques utilisées pour résoudre les problèmes de satisfaction de contraintes dynamiques : les explications. Une explication est un ensemble de contraintes (un sous-ensemble du système de contraintes courant) qui justifie le résultat de la recherche (déduction de nouvelles contraintes, contradiction aboutissant à un échec, etc.). Ces explications sont une trace explicite du comportement de la propagation. Elles permettent de défaire efficacement les effets passés d'une contrainte et ainsi d'ajouter et retirer dynamiquement des contraintes. Nous avons ainsi développé une recherche arborescente (inspirée d'une recherche arborescente de la littérature) qui en chaque noeud propage les contraintes temporelles et de ressources (en utilisant les techniques de core-times, task-interval et resource-histogram) tout en conservant des explications. Nous utilisons de plus une notion de distance (écart entre la fin d'une activité et le début d'une autre) permettant d'exprimer toutes les contraintes temporelles dans un cadre unique. Notre système est ainsi capable de résoudre de manière efficace (i.e. sans repartir à zéro et dans un temps raisonnable) des instances de RCPSP dynamiques (i.e. ajouts/retraits de contraintes de précédence, ajouts/retraits d'activités et de ressources). De plus, notre système étant très générique, il permet de traiter des extensions du RCPSP dynamique (précédences/disjonctions/chevauchements généralises, et variation des disponibilités des ressources).

Cette thèse propose de généraliser l'utilisation de la transformation de programmes, pour la construction d'un lien efficace entre les parties fonctionnelle et non-fonctionnelle (ou technique) d'un système logiciel. Dans ce cadre, nous avons développé un système de transformation (Jabyce), avec pour objectifs la possibilité d'implanter tous les transformateurs de programmes possibles, leur encapsulation pour systématiser leur réutilisation, et la possibilité de les composer arbitrairement et efficacement. Pour cela, Jabyce a deux caractéristiques : les transformateurs sont conçus sous la forme de composants logiciels dans un modèle de composant général (Fractal), et les programmes transformés sont représentés par des séquences d'interactions au lieu de graphes d'objets (représentation classique). Une extension de la catégorisation classique des systèmes de transformation de programme nous permet une comparaison exhaustive de Jabyce aux autres systèmes existants, qui montre que, grâce à ses caractéristiques, Jabyce facilite significativement la conception de transformateurs complexes, et offre les mécanismes de composition de transformateurs les plus efficaces et les plus flexibles. Jabyce a été validé expérimentalement dans le cadre de la construction d'un environnement de persistance transparente d'objets Java, et celle d'une Machine Virtuelle Java modulaire basée sur la compilation statique. Un autre apport original de ce travail est l'introduction de la problématique du traitement des erreurs dans les systèmes de transformation de programmes, et la conception d'un système de traitement d'erreur adapté à Jabyce.