L'un des problèmes des équipes de développement de logiciel consiste à évaluer la facilité d'utilisation de leurs produits, c'est-à-dire, à évaluer la qualité de l'interaction personne-machine. Le développeur lui-même n'est pas capable, dans la plupart des cas, de juger la qualité d'utilisation de l'interface qu'il propose, pour la simple raison qu'il n'est pas l'utilisateur réel du produit. Une fois les erreurs de code éliminées, il est possible que les utilisateurs d'un logiciel ne puissent pas encore travailler efficacement à cause d'erreurs de conception d'utilisabilité. Il s'avère nécessaire de disposer d'une méthodologie d'évaluation dès le départ d'un projet logiciel. Il n'existe pas d'outils d'évaluation génériques applicables à tout type de logiciel. Il est nécessaire de développer une méthodologie appropriée au profil de la communauté d'utilisateurs et des tâches qu'ils veulent automatiser à partir de leur utilisation. Cette méthodologie doit aussi tenir compte des caractéristiques de l'environnement de développement des produits. Le logiciel ciblé dans ce projet est un système d'aide à la construction d'horaires 1 utilisée dans un environnement de travail administratif. Le système comprend une application autonome (le logiciel appelé Diamant) et une application web (le logiciel appelé Diamant Web). Une évaluation sommative a été réalisée étant donné que le système sous évaluation avait été déjà livré. Celle-ci a été appliquée au sein du groupe de recherche en génie logiciel eXit 2 . Il s'agit d'une petite équipe de développement de logiciel avec des ressources limitées où le but est de créer un produit qui marche selon les exigences le plus rapidement possible. Le système ciblé exécutait correctement les fonctionnalités demandées, mais les utilisateurs réels le trouvaient difficile à utiliser. Les résultats d'une évaluation d'utilisabilité devaient être obtenus rapidement et au plus bas coût possible. Cela conduit à proposer une méthodologie simple et légère. L'approche utilisée afin de mener au terme une évaluation d'utilisabilité est basée sur la prise et l'analyse de données de terrain et la construction de prototypes d'évaluation d'utilisabilité. La contribution principale du présent travail comprend un ensemble de documents, modèles de guides, de maquettes d'interaction, de rapports et d'analyse d'interfaces conçus et construits à l'occasion de l'évaluation d'utilisabilité du système ciblé. Ces documents et ces modèles sont des exemples applicables à n'importe quel logiciel dont les caractéristiques et l'analyse contextuelle seraient similaires aux logiciels évalués. En outre, la méthodologie constitue elle-même une contribution en raison des contraintes de temps et de coût imposées. Les résultats obtenus comprennent des lignes directrices simples pour mettre en oeuvre l'évaluation d'utilisabilité dans un projet logiciel, les exemples de suggestions et de guides afin d'améliorer l'interaction personne-machine présentée par le logiciel sous évaluation.

Le projet de ce mémoire est d'essayer de mesurer le pouvoir de marché dans l'industrie du logiciel. Pour cela, il faut identifier et mesurer une ou des caractéristiques structurelles du secteur. Le logiciel étant un bien immatériel, il est naturel de penser que les économies d'échelle sont cette caractéristique recherchée. Mais pour faire une analyse empirique, il faut identifier les frontières du secteur, car les résultats dépendent lourdement du périmètre retenu. C'est pour cela que nous montrons que le logiciel est un secteur distinct du secteur des services informatiques. Cette démonstration demande une méthodologie d'analyse de secteur. Voici la logique de notre démarche. Cette étude comprend donc quatre chapitres. Le premier chapitre explicite la méthodologie d'analyse de secteurs. Cette méthodologie permet d'identifier les phénomènes de convergence et/ou de divergence sectorielle. Elle sera utilisée ici pour identifier le secteur objet de notre investigation, celui des logiciels informatiques. En conséquence, le second chapitre identifie et quantifie la différence entre l'industrie du logiciel et l'industrie des services informatiques. Le troisième chapitre présentera une tentative de mesure des économies d'échelle dans le secteur du logiciel, économies d'échelle qui apparaissent beaucoup moins radicales qu'une approche purement théorique peut induire. Enfin, le dernier chapitre utilisera les résultats empiriques concernant les économies d'échelle dans l'industrie du logiciel pour évaluer sur moyenne-longue période (10 ans) le pouvoir de marché de l'entreprise dominante, Microsoft.

Les systèmes sur puces actuels mettent à profit des architectures multiprocesseurs (MPSoC) afin de répondre aux exigences en termes de performances et de consommation. Cette dominance du logiciel nous contraint à débuter la validation et l'intégration avec le matériel dès les premières étapes des flots de conception. Les principales contributions de cette thèse sont (1) la proposition d'une méthodologie de conception de plateformes de simulation basée sur l'exécution native du logiciel, (2) une technique d'instrumentation permettant l'annotation du logiciel s'exécutant sur cette plateforme de simulation. Les plateformes de simulation ainsi développées permettent l'exécution de la quasi totalité du logiciel final (y compris le système d'exploitation) sur des modèles réalistes de l'architecture matérielle du système. Associées à la technique d'instrumentation, ces plateformes permettent de prendre en compte de manière précise des grandeurs physiques telles que le temps liées à l'exécution du logiciel.

Alors que l'informatique est résolument tournée vers l'avenir, cette thèse se concentre sur le passé ; non pas par nostalgie mais plutôt parce que le futur des logiciels âgés est une question d'actualité. Plus particulièrement trois thèmes sont abordés : la maintenance, la ré-ingénierie et la programmation globale. L'objectif de cette étude est d'explorer l'intersection entre la ré-ingénierie et la programmation globale, domaine que nous avons baptisé ré-ingénierie globale. L'idée principale est de réutiliser des concepts et des techniques de programmation détaillée. En fait nous proposons de définir la programmation globale en distinguant 4 aspects du logiciel : l'architecture, la manufacture, la variation et l'évolution. Un modèle abstrait basé sur des concepts ensemblistes est proposé pour modéliser les différentes entités de programmation globale. La technologie relative à ce domaine est ensuite décrite en considérant aussi bien l'état de l'art que l'état de la pratique. La différence entre ces deux aspects souligne l'intérêt de la ré-ingénierie globale. A titre d'illustration, nous étudions le cas des préprocesseurs en tant qu'outils de programmation globale. Ces outils de bas niveau provenant des années 70 sont traditionnellement utilisés pour décrire des familles de programmes. Pour faciliter la compréhension de tels artefacts nous proposons d'utiliser des techniques comme l'évaluation partielle, l'analyse inter-procédurale de flot de données ou encore le découpage. Ces techniques, définies de manière rigoureuse, s'appuient sur la sémantique dénotationnelle du préprocesseur utilisé. Un prototype montrant leur utilité a été réalisé. Il prouve qu'une approche basée sur des fondements théoriques issus de la programmation détaillée est applicable pour résoudre des problèmes pratiques de programmation globale.

Cette thèse consiste en l'étude d'une méthodologie d'évaluation de la performance en conception en vue de la conduite des systèmes de conception. Elle s'articule autour d'un modèle de référence pour l'évaluation des systèmes de conception, d'une méthodologie pour mettre en œuvre le modèle et d'un prototype logiciel support à la méthodologie. Le modèle de référence pour l'évaluation des systèmes de conception dans un environnement multi-acteurs, multi-disciplinaires et multi-projets permet la prise en compte des vecteurs (ou inducteurs) de performance en conception. Ce modèle positionne la performance des systèmes de conception dans le cadre plus large de la performance globale de l'entreprise en décrivant les éléments du contexte de l'entreprise qui vont influencer la conception. La mise en œuvre du modèle d'évaluation est effective par l'intermédiaire d'une méthodologie de modélisation et de suivi de l'entreprise et du système de conception. Cette méthodologie s'articule autour des méthodes GIM, GRAI Ingénierie, GRAI R&D et des approches GEM et ECOGRAI. Enfin, la méthodologie est instrumentée via un prototype logiciel d'assistance aux acteurs de la conception. Ce prototype reprend en partie les résultats obtenus dans le cadre du projet IPPOP (labellisé par le RNTL) et est spécifié sous la forme de modèles UML.

La récente évolution de l'informatique a ouvert la voie à de nouveaux types d'applications. En effet, la convergence de l'Internet et de l'informatique ubiquitaire permet le développement d'applications intégrant le monde virtuel dans le monde physique. Cependant, cette convergence a vu émerger de nouveaux besoins tel que le dynamisme. Bien que de nombreux travaux aient étudié cette propriété, la création d'applications pouvant évoluer et réagir aux changements environnementaux et contextuels reste très complexe. <br />Cette thèse s'intéresse à la conception, au développement et à l'exécution d'applications dynamiques. L'approche proposée s'appuie sur les récents efforts réalisés autour des modèles à composant. En effet, iPOJO, le modèle réalisé, combine l'approche à service et la programmation par composant afin d'introduire des caractéristiques de dynamisme au sein d'un modèle à composant. iPOJO propose un langage de composition permettant la conception d'applications nativement dynamiques, tout en facilitant le développement des ces applications. Celles-ci sont décrites de manière à réduire le couplage avec des implémentations de composants spécifiques. Enfin, iPOJO fournit une machine d'exécution. Cette machine propose des mécanismes d'introspection, de reconfiguration et d'extensibilité permettant la supervision d'applications ainsi que l'adaptabilité de cette plate-forme iPOJO à différents domaines. <br />L'implémentation d'iPOJO est hébergée sur le projet Apache Felix. Elle est actuellement utilisée dans différents projets industriels tel que des plates-formes domestiques, le serveur d'applications JEE JOnAS ainsi que l'intergiciel pour téléphone mobile OW2 uGASP.

Des logiciels complexes, assemblés à partir de nombreux composants préexistants, sont aujourd'hui utilisés pour des emplois de plus en plus critiques (télécommunication, ferroviaire, automobile...). Les risques encourus, aussi bien humains qu'économiques, exigent de pouvoir mettre en place dans ces systèmes des mécanismes de tolérance aux fautes flexibles et adaptables indépendamment des composants utilisés. Mais la complexification des logiciels pose problème, car les approches développées jadis pour assurer la sûreté de fonctionnement de petits systèmes ne leur sont plus applicables. Connues depuis longtemps, les architectures réflexives, en autorisant le découplage des aspects fonctionnels et non-fonctionnels d'un système, visent à résoudre ce problème. Jusqu'ici cependant, les approches proposées s'étaient limitées à des prototypes simples, souvent réalisés ex-nihilo pour expérimentation. Or la tolérance aux fautes est une propriété globale des systèmes considérés, qui requiert la prise en compte de tous les niveaux d'abstraction rencontrés. Dans cette thèse, nous étudions comment le paradigme réflexif peut être adapté pour permettre d'intégrer les considérations algorithmiques de la tolérance aux fautes (validité, observation, contrôle) aux contraintes architecturales rencontrées dans les systèmes complexes (abstraction, transparence, inter-opérabilité). Pour aborder cette problématique, nous développons un nouveau cadre conceptuel, la réflexivité multi-niveaux, et les concepts d'empreinte réflexive et de lien inter-niveaux qui lui sont associés. Nous validons ensuite la pertinence pratique de notre proposition en abordant la réplication de serveurs CORBA à brins d'exécution multiples (multithreaded) sur un exemple concret constitué de GNU/Linux et de l'ORB commercial ORBacus. Nous concluons finalement à la nécessité d'un nouveau paradigme de développement basé sur des composants rendus réflexifs dès leur réalisation.

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. / Applications based on streams, ordered sequences of data values, are important targets of program optimization because of their high computational requirements and the diversity of their application domains: communication, embedded systems, multimedia, etc. One of the most important and difficult problems in special purpose stream language design and implementation is how to schedule these applications in a fine-grain way to exploit available machine resources In this thesis we propose a framework for fine-grain scheduling of streaming applications and nested loops in general. First, we try to pipeline steady state phases (inner loops), by finding the repeated kernel pattern, and executing actor occurrences in parallel as much as possible. Then we merge the kernel prolog and epilog of pipelined phases to move them out of the outer loop. Merging the kernel prolog and epilog means that we shift acotor occurrences, or instructions, from one phase iteration to another and from one outer loop iteration to another, a multidimensional shifting. Experimental shows that our framwork can imporove perfomance, prallelism extraction without increasing the code size, in streaming applications and nested loops in general.

Dans de multiples domaines, un nombre grandissant d'applications interagissant avec des entités communicantes apparaissent dans l'environnement pour faciliter les activités quotidiennes~(domotique et télémédecine). Leur impact sur la vie de tous les jours des utilisateurs rend ces applications critiques: leur défaillance peut mettre en danger des personnes et leurs biens. Bien que l'impact de ces défaillances puisse être majeur, la sécurité est souvent considérée comme un problème secondaire dans le processus de développement et est traitée par des approches ad hoc.Cette thèse propose d'intégrer des aspects de sécurité dans le cycle de développement des systèmes d'informatique ubiquitaire. La sécurité est spécifiée à la conception grâce à des déclarations dédiées et de haut niveau. Ces déclarations sont utilisées pour générer un support de programmation afin de faciliter l'implémentation des mécanismes de sécurité, tout en séparant ces aspects de sécurité de la logique applicative. Notre approche se concentre sur le contrôle d'accès aux entités et la protection de la vie privée. Notre travail a été implémenté et fait levier sur une suite outillée existante couvrant le cycle de développement logiciel. / A growing number of environments is being populated with a range of networked devices. Applications leverage these devices to support everyday activities in a variety of areas (e.g., home automation and patient monitoring). As these devices and applications get woven into our everyday activities, they become critical: their failure can put people and assets at risk. Failures can be caused by malicious attacks and misbehaving applications. Although the impact of such situations can be major, security concerns are often considered a secondary issue in the development process, and treated with ad hoc approaches. This thesis proposes to address security concerns throughout the development lifecycle of a pervasive computing system. Security is addressed at design time thanks to dedicated, high-level declarations. These declarations are processed to implement security mechanisms, and to generate programming support to ease the development of the security logic, while keeping it separate from the application logic. Our approach is studied in the context of access control and privacy concerns. Our work has been implemented and leverages an existing software-design language and a suite of tools that covers the software development lifecycle.

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.