Les systèmes logiciels modernes sont caractérisés par leur complexité croissante et les fortes exigences en termes de continuité et de disponibilité des services. Face à cette problématique, des propositions telles que le génie logiciel à composants et l'approche contractuelle constituent des approches pertinentes pour faciliter la construction des systèmes et augmenter leur fiabilité. En outre, les aspects extrafonctionnels des systèmes à l'exécution doivent être constamment mieux gérés, et des techniques qui permettent aux systèmes logiciels de réagir à divers changements et maintenir des qualités satisfaisantes sont requises. La contribution de cette thèse est ainsi un modèle d'auto-adaptation dynamique pour des systèmes logiciels fondés sur ces deux approches. Notre proposition originale consiste à définir un modèle de négociation automatisé de contrats qui permet aux composants contractualisés de conduire eux-mêmes l'auto-adaptation. Le modèle identifie les différents éléments de base permettant aux composants d'effectuer l'adaptation des composants ou des contrats, et chaque processus de négociation exploite diverses informations fines contenues dans les contrats. Des politiques de négociation différentes sont aussi développées pour orienter et fournir plusieurs possibilités de déroulement de négociation. En particulier, un support compositionnel permet de conduire la négociation dans les hiérarchies de composants. Le modèle de négociation s'appuie sur les principes généraux de la plate-forme à composants hiérarchiques Fractal et du modèle de contrats ConFract, et son intégration est effectuée sur ces deux technologies. Les propositions sont illustrées sur des exemples extraits d'un cas d'étude et les premières expérimentations du modèle sont présentées.

Chaque année, les entreprises nord-américaines dépensent des milliards de dollars dans des projets en technologies de l'information. Plusieurs de ces projets ne connaitront pas de succès. L'échec n'est pas causé par un manque de ressources financières ou par une mauvaise utilisation des technologies. Une grande partie des projets échouent par manque d'expertise en gestion de projet. Malgré les apparences, la définition du succès en TI n'est pas facile et il n'existe pas de définitions universellement acceptées. Les projets en TI peuvent être classés dans trois grandes catégories : succès, échec et gageure (challenger). L'amélioration des processus de gestion et des processus de développement en génie logiciel ont permis d'augmenter le taux de succès des projets en TI tout en diminuant les coûts. Malgré ces progrès, le taux d'échec demeure élevé. La réalisation et l'implantation d'un projet TI amènent des changements qui doivent être gérés efficacement afin d'assurer l'atteinte de tous les bénéfices escomptés. Le rôle du gestionnaire de projet est de mobiliser et d'utiliser les ressources de l'entreprise afin d'atteindre un objectif spécifique : la livraison des artéfacts pour lesquels le projet a été mis en place. Un projet TI envoie des signes bien avant d'être en situation d'échec. Bien qu'il n'existe pas de liste exhaustive, plusieurs études ont identifié des facteurs critiques ayant un impact sur le taux de succès et/ou d'échec en TI. Ces facteurs peuvent être divisés en deux groupes. Dans le premier groupe, on retrouve les facteurs critiques de succès et, dans le second, les facteurs critiques d'échec. Plusieurs études identifient les facteurs critiques ayant un impact sur le succès d'un projet TI. Ces facteurs sont classés et pondérés par les chercheurs comme s'ils étaient indépendants les uns des autres. Parmi ces facteurs, la communication et coordination est identifiée comme un des facteurs critiques du succès par la littérature. Nous croyons que cette dernière peut être utilisée pour mesurer la tendance générale du projet. Ce facteur a possiblement des impacts importants sur les autres facteurs critiques, ce qui le rend intéressant et digne d'approfondissement. ______________________________________________________________________________

Notre objectif est de proposer une méthodologie pour le développement d'un intergiciel embarqué dans l'automobile offrant des services de communication aux applications. Le cadre d'utilisation de nos travaux est la conception de systèmes embarqués dans les véhicules. Ces applications requièrent un intergiciel capable de fournir des services standards de communication, qui cachent la localisation des participants aux échanges, qui masquent l'hétérogénéité des plates-formes de communication, et qui garantissent le respect des contraintes temporelles imposées sur les échanges et sur l'exécution des participants.<br />La méthodologie proposée vise la conception d'un intergiciel optimisé et pour cela aborde deux aspects : la spécification d'une architecture d'implémentation, et la construction d'une configuration faisable. L'architecture d'implémentation est optimisée dans le sens où l'intergiciel est adapté à l'environnement d'exécution (le système d'exploitation OSEK/VDX OS), et minimise son utilisation des ressources disponibles. Elle apporte une réponse, d'une part, au niveau de la spécification d'une architecture logicielle (construite à l'aide de design patterns), et, d'autre part, à la manière dont cette architecture est déployée sur une plate-forme concrète (sous la forme d'un ensemble de tâches). La procédure proposée pour la construction de la configuration de l'intergiciel calcule les caractéristiques temporelles faisables de l'intergiciel et des trames émises par les stations d'un réseau CAN. Elle prévoit aussi une étape pour le calcul d'une allocation de priorités faisable pour les tâches de l'application sur chaque station. L'optimalité de la configuration est atteinte en assurant le respect de toutes les contraintes temporelles imposées sur les échanges et sur l'exécution des tâches de l'application et de l'intergiciel.

Un système, décrit avec un grand nombre d'éléments fortement interdépendants, est complexe, difficile à comprendre et à maintenir. Ainsi, une application orientée objet est souvent complexe, car elle contient des centaines de classes avec de nombreuses dépendances plus ou moins explicites. Une même application, utilisant le paradigme composant, contiendrait un plus petit nombre d'éléments, faiblement couplés entre eux et avec des interdépendances clairement définies. Ceci est dû au fait que le paradigme composant fournit une bonne représentation de haut niveau des systèmes complexes. Ainsi, ce paradigme peut être utilisé comme "espace de projection" des systèmes orientés objets. Une telle projection peut faciliter l'étape de compréhension d'un système, un pré-requis nécessaire avant toute activité de maintenance et/ou d'évolution. De plus, il est possible d'utiliser cette représentation, comme un modèle pour effectuer une restructuration complète d'une application orientée objets opérationnelle vers une application équivalente à base de composants tout aussi opérationnelle. Ainsi, La nouvelle application bénéficiant ainsi, de toutes les bonnes propriétés associées au paradigme composants. L'objectif de ma thèse est de proposer une méthode semi-automatique pour identifier une architecture à base de composants dans une application orientée objets. Cette architecture doit, non seulement aider à la compréhension de l'application originale, mais aussi simplifier la projection de cette dernière dans un modèle concret de composant. L'identification d'une architecture à base de composants est réalisée en trois grandes étapes: i) obtention des données nécessaires au processus d'identification. Elles correspondent aux dépendances entre les classes et sont obtenues avec une analyse dynamique de l'application cible. ii) identification des composants. Trois méthodes ont été explorées. La première utilise un treillis de Galois, la seconde deux méta-heuristiques et la dernière une méta-heuristique multi-objective. iii) identification de l'architecture à base de composants de l'application cible. Cela est fait en identifiant les interfaces requises et fournis pour chaque composant. Afin de valider ce processus d'identification, ainsi que les différents choix faits durant son développement, j'ai réalisé différentes études de cas. Enfin, je montre la faisabilité de la projection de l'architecture à base de composants identifiée vers un modèle concret de composants. / A system is complex and particularly difficult to understand and to maintain when it is described with a large number of highly interdependent parties. An object-oriented application is often complex because it uses hundreds or thousands of classes with many different dependencies more or less explicit. The same application, using the component paradigm, contains a smaller number of loosely coupled parties, highly cohesive with clear inter-dependencies. Indeed, because the component paradigm provides a high-level representation, synthetic and well-organized structure of complex systems, it can provide a space of projection for object-oriented applications. Such projection facilitates the step of understanding a system prior to any activity of maintenance and/or evolution. In addition, it is possible to use this representation as a model to perform a complete restructuring of an operational object-oriented application into its equivalent operational component-based application. Thus, the new form of the application benefits from all the good properties associated with the component-oriented paradigm. The goal of my thesis is to propose a semi-automatic approach to identify a component-based architecture in an object-oriented application. This architecture should help in understanding the original application, but also simplifies the projection of the object-oriented application on a concrete component model. The identification of a component-based architecture is achieved in three main steps: i) obtaining data for the identification process. These data, which correspond to dependencies between classes, are obtained with a dynamic analysis of the target application. ii) identification of the components. Three methods were explored. The first uses the formal concept analysis, the second two meta-heuristics and the last a multiobjective meta-heuristic. iii) identification of the component-based architecture representing the target application. This is done by identifying the provided and required interfaces for each component. To validate this identification process, and the different choices made during its development, I realized several case studies. Finally, I show the feasibility of the projection of the identified component-based architecture on a specific component model.

De nombreux outils existent afin de faire face à la complexité des logiciels et des projets de développement logiciel. Leur utilisation est cependant à l'origine de tâches manuelles répétitives, sources d'erreurs et coûteuses en temps. L'automatisation de ces tâches permet de gagner en productivité. Mais la difficulté est de déterminer quand une automatisation de tâche manuelle répétitive doit être réutilisée, ainsi que de créer des automatisations réutilisables à travers leurs différents cas d'utilisation. Nous proposons donc une approche outillée pilotant la réutilisation des automatisations de tâches manuelles répétitives par les processus de développement logiciel, où un processus de développement logiciel décrit les étapes à réaliser pour mener à bien un projet de développement logiciel. Cette approche consiste à capitaliser sur un ensemble de processus et à réutiliser des processus de cet ensemble en fonction des exigences des projets, indépendamment du formalisme utilisé pour définir les processus. Des automatisations de tâches manuelles répétitives sont liées aux étapes des processus qu'elles automatisent. Ce lien permet de savoir quelles automatisations utiliser pour un projet donné et quand. Il permet également d'expliciter les différents cas d'utilisation de chaque automatisation. Cette information est utilisée afin de créer des automatisations réutilisables à travers leurs différents cas d'utilisation. L'approche ainsi que l'outillage associé ont été appliqués sur une famille de processus industriels de développement Java ainsi que sur une famille de processus consistant à définir et outiller un langage de modélisation.

Les logiciels actuels adoptent une méthodologie de développement dite "agile" pour mieux prendre en compte la nécessité de s'adapter constamment aux nouveaux besoins des utilisateurs. Les concepteurs et développeurs se rapprochent alors des futurs utilisateurs du logiciel en proposant des cycles courts d'itération, où le futur utilisateur fait un retour rapide sur l'incrément apporté au logiciel, et fait part de nouveaux besoins à prendre en compte dans les incréments à venir. Ces itérations peuvent être vues comme des évolutions, faisant suite à la définition d'un nouveau besoin de l'utilisateur, à un changement de l'en- vironnement d'exécution, ou encore à une remise en question de l'architecture du logiciel. Dans l'écosystème des architectures orientées services, la conception d'applications passe par la chorégraphie ou l'orchestration de services par des processus métiers. Concevoir ces applications consiste alors à mettre en relation les flots de contrôle et de données de ces services. La phase d'évolution devient une phase complexe, où une simple modification lo- calisée à une sous-partie d'un processus métier peut avoir des conséquences sur l'ensemble du système logiciel, causant par exemple son ralentissement lors de l'exécution. Du point de vue de la qualité de service (QoS), la maîtrise de la fiabilité du processus d'évolution pour maintenir la qualité de service d'un logiciel est alors critique. Il est donc nécessaire de pouvoir proposer des mécanismes d'évolution agiles et fiables permettant le maintien de la QoS lors de l'évolution d'applications à base de processus métiers. En d'autres termes, il s'agit de s'assurer qu'une évolution ne viole pas les contrats de QoS définis initialement. Cette garantie doit être établie en fonction du contrat soit lors de la conception soit lors de l'exécution. Dans ce dernier cas, le processus de vérification doit être minimal et localisé, afin de ne pas dégrader les performances du système logiciel. Pour cela, nous proposons de mettre en œuvre un cycle de développement agile, centré sur le maintien de la QoS lors de l'évolution. Il s'agit de prendre l'aspect évolutif du système, ceci dès l'étape de conception initiale, en identifiant les informations requises pour déter- miner si la QoS est correcte et si elle est non violée par une évolution. Ces informations étant détenues par plusieurs intervenants, il est également nécessaire d'établir les points d'interaction au cours du cycle de développement, au cours desquels les informations seront partagées de façon à ce que le logiciel qui en est issu reste syntaxiquement et sémantique- ment cohérent et que les contrats de QoS soient (re)vérifiés a minima. Les contributions de cette thèse sont donc mises en œuvre dans Blink, un cycle de développement pour l'évolu- tion, et Smile, un canevas de développement pour le maintien de la qualité de service lors de l'évolution d'applications orientées service définies à base de processus métiers. Tandis que le cycle de développement Blink vise à identifier les différents rôles présents dans l'équipe de développement et à expliciter leurs interactions, le canevas Smile propose la réalisation d'une boucle d'évolution. Cette boucle permet de concevoir, d'analyser et d'appliquer une évolution, en détectant les potentielles violations de contrat de QoS. Pour cela, l'analyse de l'évolution détermine son effet sur la QoS du logiciel, en établissant des relations de causalité entre les différentes variables, opérations, services et autres parties du système. Ainsi, en identifiant les éléments causalement affectés par l'évolution et en écartant ceux qui ne le sont pas, notre approche permet de limiter le nombre d'éléments à (re)vérifier, garantissant ainsi une étape d'évolution fiable, avec une étape de (re)vérification minimale. Nous montrons sur un cas concret de système de gestion de crises, constitué de onze processus métiers et de dix scénarios, que l'utilisation conjointe de Blink et de Smile permet d'identifier, pour chaque évolution, quel sera son effet sur le reste du système, et si la qualité de service sera maintenue ou non.

Cette thèse se situe à l'intersection de deux domaines actifs de recherche: la fouille de règles d'association et la réalité virtuelle. Les limites majeures des algorithmes d'extraction de règles d'association sont (i) la grande quantité de règles produites et (ii) leur faible qualité. Dans la littérature, plusieurs solutions ont été proposées pour remédier à ce problème, comme le post-traitement de règles d'association qui permet la validation des règles et l'extraction de connaissances utiles. Cependant, alors que les règles sont extraites automatiquement par des algorithmes combinatoires, le post-traitement de règles est effectué par l'utilisateur. La visualisation peut aider l'utilisateur à faire face à une grande quantité de règles en les représentants sous forme visuelle. Afin de trouver les connaissances pertinentes dans les représentations visuelles, l'utilisateur doit interagir avec la représentation de règles d'association. Par conséquent, il est essentiel de fournir à l'utilisateur des techniques d'interaction efficaces. Ce travail aborde deux problèmes essentiels : la représentation de règles d'association afin de permettre à l'utilisateur de détecter très rapidement les règles les plus intéressantes et l'exploration interactive des règles. Le premier exige une métaphore intuitive de représentation de règles d'association. Le second nécessite un processus d'exploration très interactif permettant à l'utilisateur de fouiller l'espace de règles en se concentrant sur les règles intéressantes. Les principales contributions de ce travail peuvent être résumées comme suit : (i) Nous proposons une nouvelle classification pour les techniques de fouille visuelles de données, basée sur des représentations en 3D et des techniques d'interaction. Une telle classification aide l'utilisateur à choisir une configuration pertinente pour son application. (ii) Nous proposons une nouvelle métaphore de visualisation pour les règles d'association qui prend en compte les attributs de la règle, la contribution de chacun d'eux et leurs corrélations. (iii) Nous proposons une méthodologie pour l'exploration interactive de règles d'association. Elle est conçue pour faciliter la tâche de l'utilisateur face à des grands ensembles de règles en tenant en compte ses capacités cognitives. Dans cette méthodologie, des algorithmes locaux sont utilisés pour recommander les meilleures règles basées sur une règle de référence proposée par l'utilisateur. Ensuite, l'utilisateur peut à la fois diriger l'extraction et le post-traitement des règles en utilisant des opérateurs d'interaction appropriés. (iv) Nous avons développé un outil qui implémente toutes les fonctionnalités de la méthodologie. Notre outil est basé sur un affichage intuitif dans un environnement virtuel et prend en charge plusieurs méthodes d'interaction.

Le paradigme architecture orientée service AOS est devenu un standard pour la conception et le développement d'applications distribuées dans base de services Web. Malgré tous les avantages qu'elles apportent en termes d'interopérabilité et de réutilisation, les solutions de développement associées au paradigme AOS sont destinées aux programmeurs et restent difficiles à comprendre par le monde de l'entreprise. Pour être en phase avec le monde de l'entreprise, les applications à base de services Web doivent être décrites en termes d'exigences qu'elles permettent de satisfaire et non pas en termes de fonctionnalités qu'elles permettent de réaliser. Ceci permet de minimiser la discordance conceptuelle entre les services logiciels et l'énoncé des exigences des utilisateurs. Nous proposons dans le cadre de ce travail de thèse, une approche multi-perspective centrée exigences pour la composition de services Web. Notre approche positionne la composition des services dans une perspective centrée exigences dans laquelle les services métiers de haut niveau sont décrits en termes d'exigences qu'ils permettent de satisfaire. Un processus d'alignement est proposé pour assurer une mise en correspondance de ces services avec les services logiciels de bas niveau qui sont décrits en termes de déclarations techniques au niveau d'une perspective centrée fonctions. Ce processus intègre la variabilité de composition tout au long des étapes de construction de ces applications à base de services.

Notre thème de recherche général concerne les aides informatisées au dialogue en langue seconde, oral et/ou écrit. Cette thèse se concentre sur la dénition et l'étude, au moyen de corpus et d'un prototype, de procédés d'aide au dialogue écrit (tchat) en langue seconde, dans un contexte de médiation faible. Nous présentons dans un premier temps ce qu'est le tchat "ordinaire" en langue première, ses divergences de surface et ses convergences profondes vis à vis des autres formes d'écrit. Nous montrons ensuite les limites des aides actuelles, à médiation forte, dans laquelle l'outil d'aide est interposé entre des locuteurs supposés totalement incapables de communiquer par un autre biais, de sorte qu'on ne traite jamais le cas pourtant fréquent où ils peuvent utiliser une langue intermédiaire. Nous adaptons au tchat le scénario du projet VerbMobil (1992-2000) et proposons une approche à médiation faible pour locuteurs partiellement bilingues, capable de tenir compte de leurs compétences et de leurs problèmes spéciques. Le prototype développé dans ce cadre, Koinè, permet d'étudier les contraintes informatiques, ergonomiques et linguistiques d'un tel système, de proposer des solutions, et de les expérimenter. Des aides au dialogue oral ont été prévues, mais, comme la reconnaissance vocale du tout venant au téléphone ou sur IP n'est pas encore assez avancée pour ce type d'utilisation, la version actuelle est centrée sur l'écrit. Koinè est un service Web, construit à l'aide de la bibliothèque logicielle Krater, qui accélère et simplifie le développement d'applications Web. Koinè agrège des fonctionnalités utiles pour surmonter les obstacles de la communication en langue non native, telle que tableau blanc, livre de phrases interactif personnalisable, pré- traduction par traduction automatique, mesures d'intelligibilité et de prototypicalité des énoncés, et possibilité de désambiguïsation interactive et participative.

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.