Dans cette thèse, nous avons adapté trois versions d'une chaine d'algorithmes de reconnaissance biométrique par l'iris appelés OSIRIS V2, V3, V4 qui correspondent à différentes implémentations de l'approche de J. Daugman pour les besoins d'une implémentation logicielle / matérielle. Les résultats expérimentaux sur la base de données ICE2005 montrent que OSIRIS_V4 est le système le plus fiable alors qu'OSIRIS_V2 est le plus rapide. Nous avons proposé une mesure de qualité de l'image segmentée pour optimiser en terme de compromis coût / performance un système de référence basé sur OSIRIS V2 et V4. Nous nous sommes ensuite intéressés à l'implémentation de ces algorithmes sur des plateformes reconfigurables. Les résultats expérimentaux montrent que l'implémentation matériel / logiciel est plus rapide que l'implémentation purement logicielle. Nous proposons aussi une nouvelle méthode pour le partitionnement matériel / logiciel de l'application. Nous avons utilisé la programmation linéaire pour trouver la partition optimale pour les différentes tâches prenant en compte les trois contraintes : la surface occupée, le temps d'exécution et la consommation d'énergie

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.

Nous proposons une méthodologie pour l'analyse de la sûreté de fonctionnement d'un middleware, ou intergiciel, et caractériser son comportement en présence de fautes. Notre méthode est basée sur une analyse structurelle des intergiciels de communication, sur l'élaboration d'un modèle de fautes, une classification des modes de défaillance, et le développement d'un ensemble de techniques d'injection de faute adaptées à l'intergiciel. Nous avons validé notre approche en menant des campagnes d'injection de faute ciblant plusieurs implantations de la norme CORBA, et obtenu des mesures quantitatives de la robustesse des différents candidats testés. Nos travaux permettent à des intégrateurs de systèmes répartis critiques d'obtenir des assurances sur la robustesse des composants intergiciels qu'ils placent au coeur de leurs systèmes, et aux développeurs d'intergiciel d'obtenir des informations sur des points faibles de leurs produits.

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.

Les applications de flux de données sont des cibles importantes de l'optimisation de programme en raison de leur haute exigence de calcul et la diversité de leurs domaines d'application: communication, systèmes embarqués, multimédia, etc. L'un des problèmes les plus importants et difficiles dans la conception des langages de programmation destinés à ce genre d'applications est comment les ordonnancer à grain fin à fin d'exploiter les ressources disponibles de la machine.Dans cette thèse on propose un "framework" pour l'ordonnancement à grain fin des applications de flux de données et des boucles imbriquées en général. Premièrement on essaye de paralléliser le nombre maximum de boucles en appliquant le pipeline logiciel. Après on merge le prologue et l'épilogue de chaque boucle (phase) parallélisée pour éviter l'augmentation de la taille du code. Ce processus est un pipeline multidimensionnel, quelques occurrences (ou instructions) sont décalées par des iterations de la boucle interne et d'autres occurrences (instructions) par des iterationsde la boucle externe. Les expériences montrent que l'application de cette technique permet l'amélioration des performances, extraction du parallélisme sans augmenter la taille du code, à la fois dans le cas des applications de flux des donnée et des boucles imbriquées en général.

Les travaux résumés dans ce mémoire ont pour cadre la sûreté de fonctionnement des systèmes informatiques. Ils portent sur l'élimination des fautes, en s'intéressant plus particulièrement au test du logiciel. Les contributions sont regroupées en quatre chapitres. Le premier chapitre rassemble des travaux pour adapter la conception du test aux technologies de développement logicielles. Deux technologies sont considérées : la technologie orientée-­‐objet et la méthode formelle B. Le deuxième chapitre porte sur des associations test et vérification formelle. Il s'agit selon les cas de consolider la vérification d'algorithmes partiellement prouvés, ou de faciliter l'analyse de contrexemples retournés par un model checker. Le troisième chapitre traite de la génération de test par des procédés métaheuristiques, en prenant l'exemple du recuit simulé. L'accent est mis sur l'utilisation de mesures pour guider le paramétrage de la métaheuristique. Enfin, le quatrième chapitre aborde le test de systèmes mobiles. Lestraces d'exécutions sont vérifiées par rapport à un ensemble de propriétés décrites par des scénarios graphiques, en combinant des algorithmes d'appariement de graphes et de calcul d'ordres partiels d'événements.