Les systèmes logiciels évoluent pour ajouter de nouvelles fonctionnalités, corriger des bugs ou refactoriser du code source. Durant ce processus, certains problèmes peuvent survenir provoquant l'inconsistance ou l'échec des systèmes en évolution et avec leurs clients, ce qui aboutit finalement à une baisse de la qualité du code. Pour faire face à ces problèmes, il est possible d'utiliser des règles. Ces règles peuvent être créées par des experts ou extraites de précédentes versions du code source. Nous soutenons que les approches existantes : (i) n'analysent pas précisément les avantages des règles créées par des experts; (ii) gagneraient à mieux utiliser les dépôt de codes sources pour extraire des règles basées sur l'historique, et (iii) devraient analyser à grande échelle et sur des cas réels l'impact de l'évolution du code source sur les clients. Dans cette thèse, nous proposons d'analyser et d'améliorer les règles pour aider les développeurs à mieux suivre l'évolution du code source. Pour cela, nous étudions trois aspects différents :- Les avantages prévus par les règles créées par des experts : nous analysons précisément ces règles pour comprendre si elles valent la peine d'être adoptées malgré le coût pour les produire.- L'amélioration des règles basées sur l'historique : nous proposons deux solutions pour extraire de meilleures règles à partir du dépôt de codes sources.- L'impact de l'évolution du code source sur un écosystème logiciel : nous étudions les conséquences de l'évolution de code source sur des systèmes clients dans le contexte d'un écosystème de grande échelle.Les résultats que nous avons obtenus démontrent l'utilité de nos approches. / Software systems evolve by adding new features, fixing bugs or refactoring existing source code. During this process, some problems may occur causing evolving systems and their clients to be inconsistent or to fail, decreasing code quality. One solution to deal with such maintainability problems is the usage of rules to ensure consistency. These rules may be created by experts or extracted from source code repositories, which are commonly evaluated in small-scale case studies. We argue that existing approaches lack of: (i) a deep understanding of the benefits provided by expert-based rules, (ii) a better use of source code repositories to extract history-based rules, and (iii) a large-scale analysis of the impact of source code evolution on the actual clients.In this thesis we propose to analyze and improve rules to better support developers keeping track of source code evolution. We cover three aspects: - The benefits provided by expert-based rules: we report on an investigation of rules created based on expert opinion to understand whether they are worthwhile to be adopted given the cost to produce them.- The improvement of history-based rules: we propose two solutions to extract better rules from source code history.- The impact of source code evolution on a software ecosystem: we undergo an investigation, in a large-scale ecosystem, on the awareness of the client systems about source code evolution. We evaluated the proposed approaches qualitatively and quantitatively. The results we obtained demonstrate the usefulness of our approaches.

Le logiciel est devenu omniprésent dans nos vies de sorte qu'on le retrouve dans plusieurs domaines de la vie courante. Cependant cette omniprésence, n'est pas sans conséquences. Les bogues de logiciel peuvent causer de vrais désastres, économiques, écologiques voire sanitaires. Vu la forte omniprésente du logiciel dans nos vies, le fonctionnement de nos sociétés dépend fortement de sa qualité. La programmation par contrat a pour but de produire des logiciels fiables, c'est-à-dire corrects et robustes. En effet, ce paradigme de programmation vise à introduire des assertions qui sont des spécifications de services. Ces spécifications représentent une forme de contrat. Les contrats définissent les responsabilités entre le client et le fournisseur. Le respect des contrats permet de garantir que le logiciel ne fait ni plus ni moins que ce que l'on attend de lui qu'il fasse. Le test unitaire est un test qui permet de s'assurer du bon fonctionnement d'une partie précise d'un logiciel. C'est un test dont la vérification se fait en exécutant une petite unité de code. En somme, un test unitaire est un code qui exécute de manière indirecte le code d'une classe pour vérifier que le code fonctionne bien. L'outil Génération de Squelettes des Contrats de classes et des tests unitaires (GACTUS) permet la génération automatique de squelettes de contrats de classes et celles des classes des tests unitaires d'un projet Java. La génération automatique du code source permet d'obtenir un code uniforme. GACTUS est un plug-in pour l'environnement de développement Eclipse écrit en Java. L'objectif principal de GACTUS est de faciliter la réalisation de logiciel de qualité grâce à la génération automatique des squelettes de contrats de classe et celui des tests unitaires et aussi d'accroître la productivité des développeurs. Pour faciliter son utilisation, GACTUS dispose d'une interface graphique permettant de guider l'utilisateur.

Les analyses des marchés des logiciels ont longtemps été limitées à l'unique confrontation libre-propriétaire ou propriétaire-piratage. Cette thèse fournit à l'opposé une vision originale d'une confrontation articulée entre propriétaire-libre-piratage. L'analyse du marché des logiciels est réalisée premièrement à travers un descriptif économique et technique du produit "logiciel". Cette description est nécessaire pour saisir le comment et le pourquoi de la déclinaison du produit "logiciel" sous trois formes : propriétaire, libre et piraté. L'aspect technique est particulièrement substantiel puisqu'il permet de comprendre parfois l'impossibilité technique de délimiter le piratage informatique. Cette analyse est appuyée ensuite par un descriptif historique de la construction du marché et l'introduction des droits de propriété qui ont été un facteur déterminant pour la transformation des échanges. On identifie par la suite, les principaux acteurs (producteurs et diffuseurs) de ses trois déclinaisons du bien logiciel et leurs modes organisationnels. En parallèle aux entreprises éditrices de logiciel propriétaire et des communautés de logiciel libre (Hackers), une nouvelle catégorie d'acteurs développant du "matériel informatique libre" est identifiée (open hardware). L'accent est mis sur l'enchevêtrement des frontières entre les communautés libres et le groupe des pirates dont la distinction est complexe, puisque certaines pratiques de piratage sont de fait tolérées par le marché. Les pirates sont aussi considérés dans le cadre de cette thèse, selon leurs compétences techniques. Une typologie des pirates est donc proposée, distinguant les "utilisateurs" des "producteurs" de logiciels piratés (pirates passifs et pirates actifs). Notre analyse se poursuit ensuite avec des modélisations mathématiques et économétriques pour défendre la thèse que les trois déclinaisons du bien logiciel s'inter-influencent et que la concurrence sur le marché des logiciels est ternaire. Cette approche est originale en ce qui concerne les logiciels libres, car vu la récente nouveauté du phénomène, peu d'études de quantification ont été réalisé. Un théorème mathématique, largement utilisé en contrôle optimale, est sollicité pour analyser la façon dont les acteurs des logiciels propriétaires tiennent compte à la fois de la présence concurrentielle des logiciels piratés et celle des logiciels libres. Il est montré qu'une stratégie de tolérance du piratage peut servir favorablement le logiciel propriétaire sur le marché pour réduire "l'effet réseau" des logiciels libres et de renforcer l'effet de "lock-in" du propriétaire. Le modèle économétrique soutient également la thèse que la diffusion des logiciels libres impacte celle des logiciels piratés. La construction d'une base de données de pays à différents niveaux de développement, montre que les politiques gouvernementales en faveur des logiciels libres et l'intérêt de population locale pour linux, peuvent réduire les pratiques du piratage. Ce constat varie selon les catégories de pays étudiés (pays développés, émergents, en voie de développement et pauvres). Les résultats du modèle économétrique appuient ceux de la modélisation. / Publishers of proprietary software are confronted both by the onset of piracy practices and free/open software. So far, the obstacles faced by proprietary software have been presented in the literature by means of two distinct approaches :(i) the piracy/proprietary software (illicit competition), or (ii) the open source/proprietary software (licit competition) standpoints. In this thesis we propose an alternative approach of the software market, which focuses on the coexistence of competitive forces piracy practices and open software. The three forces are supported by di_erent actors, to which we add the new one of open hardware that consolidated the position of free software on the market. The new approach distinguishes also between sophisticated active pirates producers and casual passive pirate users. We emphasized that it is di_cult to distinguish between hackers and pirates, as piracy practices are sometimes tolerated by the market. Using an econometric and mathematics model we show the impacts that one in_icts over the other. The mathematical model investigates how changes in the _rm's anti-piracy policya_ect the number of pirates users, given that the free software network size increases if pirates become free software users. The proposed econometric model shows that government policies in favour of open source software and adoption of Linux by individuals tends to decrease software piracy. A majorempirical result concerns the emerging and developing countries where policies in favour of free software can in some speci_c cases reduce piracy.

Nous proposons dans cette thèse une démarche permettant de décrire un DSML (Domain Specific Modeling Language) et les outils nécessaires à l'exécution, la vérification et la validation des modèles. La démarche que nous proposons offre une architecture générique de la syntaxe abstraite du DSML pour capturer les informations nécessaires à l'exécution d'un modèle et définir les propriétés temporelles qui doivent être vérifiées. Nous nous appuyons sur cette architecture pour expliciter la sémantique de référence et l'implanter. Plus particulièrement, nous étudions les moyens :<br />- d'exprimer et de valider la définition d'une traduction vers un domaine formel dans le but de réutiliser des outils de model-checking.<br />- de compléter la syntaxe abstraite par le comportement; et profiter d'outils génériques pour pouvoir simuler les modèles construits.<br />Enfin, de manière à valider les différentes sémantiques implantées vis-à-vis de la sémantique de référence, nous proposons un cadre formel de métamodélisation.

L'objectif de notre travail de recherche est de vérifier si un processus BPEL satisfait sa spécification d'interface représentant son comportement externe en utilisant la vérification de modèles. Dans ce mémoire, nous présentons essentiellement l'approche de notre logiciel qui permet dans un premier temps de traduire un processus BPEL en modèle Promela et une expression d'interface en assertion de traces, et par la suite, il lance la vérification en utilisant l'outil Spin. Cette vérification du comportement du processus concret se fait par rapport à une spécification abstraite de son interface comportementale, c'est-à-dire, nous vérifions uniquement ce qui est visible à l'exterieur du processus. Nous expliquons les étapes franchies pour atteindre notre objectif et nous montrons à l'aide d'exemples que notre logiciel est fonctionnel.

Ce mémoire est une évaluation de la qualité de Moodle, une plateforme de téléapprentissage (PTA) basée sur du logiciel libre et récemment implantée à l'UQAM pour remplacer la plateforme propriétaire WebCT. Cette évaluation a été entreprise selon une approche du génie logiciel, en l'occurrence une analyse de conformité de Moodle aux exigences de la norme de qualité ISO 9126, un référentiel normatif international qui décrit 6 caractéristiques de qualité et leurs sous caractéristiques. Ce choix méthodologique a semblé moins subjectif et plus rigoureux que celui des méthodes courantes d'évaluation de la qualité des PTA (ex: méthode de la grille des critères ou les questionnaires) car cette norme repose sur un modèle très structuré et un ensemble de métriques pour évaluer la qualité du logiciel. En outre l'approche est fiable si l'on considère que cette norme a fait l'objet d'applications multiples en génie logiciel et possède une reconnaissance internationale. Les résultats obtenus montrent un haut niveau de conformité de Moodle1.6.5 aux exigences de qualité technique d'ISO 9126, à raison de 91% pour la fonctionnalité et un indice de conformité de 87,5% aux exigences de qualité ergonomique pour les facteurs d'utilisabilité. L'évaluation montre aussi que l'interopérabilité, qui est un facteur technique critique dans un environnement Open Source comme Moodle, a connu une amélioration importante avec un indice de conformité de 86 % à la norme alors que cet indice n'est que de 37 % pour l'interopérabilité technique et 57 % pour l'interopérabilité pédagogique pour la PTA propriétaire WebCT. Au terme de ce processus d'évaluation, cette méthode du génie logiciel nous est apparue aussi comme étant plus efficace et plus efficiente que les méthodes traditionnelles d'évaluation car elle exige moins de temps, moins d'argent et ne nécessite pas le recours à des évaluateurs experts. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : e-Learning, Moodle, ISO 9126, Évaluation, Exigence, Génie logiciel, Interopérabilité, Fonctionnalité, Ergonomie, Conformité.

SableCC est un générateur de compilateurs. Il permet de construire des analyseurs lexicaux, des analyseurs syntaxiques et des arbres syntaxiques. Il est toutefois limité à la génération de code en langage Java. Dans ce mémoire, nous présentons un outil qui s'intègre à SableCC et qui permet à celui-ci une génération de code dans d'autres langages orientés objets. La méthode que nous proposons pour permettre la génération de code dans un autre langage consiste à construire des scripts et des patrons pour chaque nouveau langage. La rédaction des scripts se fait dans le langage Hiber, un langage que nous avons conçu pour faciliter la tâche de décrire les règles de génération de code. Les scripts sont interprétés par un interpréteur construit avec SableCC. Cet interpréteur reçoit de SableCC une structure de données qui est accessible à partir de scripts. Le principe original de SableCC pour la génération de code est donc conservé. Pour vérifier le bon fonctionnement de l'interpréteur et de la structure de données, nous avons effectué la génération en Java avec notre méthode et nous avons comparé le code généré avec celui de la version originale de SableCC. Par la suite, nous avons ajouté la génération en C++. C'est un langage ayant des similitudes avec Java. Cet exercice nous a permis de raffiner l'interpréteur et la structure de données. Dans le but de démontrer une plus grande maturité de la génération, un troisième langage est ajouté: Python. Ce langage est très différent des deux derniers, ce qui démontre l'adéquation de notre méthode de génération pour les langages orientés objets. La méthode de génération proposée permet de bien séparer les modèles de génération, les règles de génération et la structure de données. Elle rend possible l'ajout d'un nouveau langage destination en écrivant un script qui est peu volumineux, facile à lire et à maintenir. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Générateur de compilateur, Interpréteur, Structure de données, Hiber, Script.

Les F/OSS font face à de nombreux problèmes de qualité [67, 108, 115] et cette problématique de qualité est d'actualité. Malgré un nombre important de publications sur les F/OSS, nous déplorons la rareté des recherches qui se sont penchées sur l'application des normes de base de développement du génie logiciel au processus de développement libre. Cependant, certains projets libres ont pu développer du logiciel de qualité et ont maintenu ce niveau de qualité dans les logiciels développés ou maintenus au sein de leurs communautés. Cette recherche a donc pour but d'analyser si une norme de développement du génie logiciel telle que la jeune norme ISO/IEC 29110 peut soutenir ou améliorer le processus de développement libre compte tenu de la culture du libre. La méthodologie de recherche utilisée est divisée en deux phases. La première phase est une étude exploratoire des F/OSS au travers de l'étude des projets : Linux, Apache, Mozilla et GNOME. Elle a permis de se familiariser aux F/OSS, d'identifier les problèmes de qualité rencontrés, d'extraire et d'évaluer le processus de développement actuel des F/OSS par rapport à la norme ISO/IEC 29110. Les résultats de cette évaluation rejoignent à littérature en ce sens que le développement libre souffre d'un manque de documentation. La deuxième phase consiste en une analyse de compatibilité des activités du processus d'implémentation de la norme ISO/IEC 29110 avec les F/OSS, afin d'identifier les activités de la norme qui sont compatibles aux F/OSS. Cette évaluation a permis l'identification de 4 activités de la norme ISO/IEC 29110 qui sont compatibles aux F/OSS, et qui ont été la base d'une stratégie d'amélioration de la performance du processus de développement libre. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Assurance qualité, qualité, processus de développement, valeurs, logiciels libres, valeurs, culture, principes, activités, artefacts, norme de développement du génie logiciel, logiciels open source, génie logiciel.

De 2006 à 2010, nous avons étudié le cas d'une université québécoise ayant implanté Moodle, une plateforme en ligne d'apprentissage. Celle-ci permet aux enseignants de créer un espace personnalisé sur Internet destiné à diffuser des ressources numériques à leurs étudiants, à interagir avec ceux-ci et à les faire participer à des activités d'apprentissage. Alors que plusieurs études se sont déjà penchées sur le potentiel pédagogique de ce type de technologie, nous l'avons plutôt abordé en tant qu'outil de travail des enseignants, en nous intéressant à l'émergence d'un processus de co-configuration dans un contexte où l'organisation implante et supporte à l'interne une technologie open source. Contrairement aux méthodologies de design participatif ou de développement logiciel itératif qui se préoccupent de l'implication des usagers dans les phases antérieures de la conception, les pratiques de co-configuration que nous décrivons concernent un produit existant qu'on adapte localement après son implantation. L'accessibilité au code source de Moodle ainsi que les échanges mutuels entre les développeurs et les usagers permettent à l'organisation utilisatrice de personnaliser l'outil tout au long de sa durée de vie, et non seulement lors de périodes circonscrites de design et de conception. Les problèmes rencontrés par les enseignants constituent donc le point de départ temporel de leurs interactions avec les développeurs à l'interne. Les usages en contexte réel de travail révèlent à la fois certaines structures organisationnelles difficilement perceptibles aux développeurs avant l'implantation et rendent plus visibles les pratiques hétérogènes des enseignants. En accroissant la capacité d'action des développeurs, l'accès au code source du logiciel crée un contexte plus favorable à la prise en compte des demandes des usagers, puisque les développeurs peuvent « localiser » plus facilement les problèmes rencontrés en allant regarder comment le logiciel a été programmé et comment il pourrait être modifié pour mieux répondre à leurs besoins. Le caractère incrémental des modifications apportées localement à Moodle fait en sorte que les développeurs puissent accommoder certains besoins très spécifiques - voire uniques - tout en s'assurant de répondre aux besoins de la majorité, en plus d'assurer la compatibilité entre la version locale et la version officielle du logiciel. D'un point de vue conceptuel, nous avons mobilisé la théorie de l'activité en tant que cadre d'analyse (Engestrom, 1987). La théorie de l'activité considère le changement comme un processus de résolution de contradictions, c'est-à-dire une séquence d'événements autour desquels s'articule la transformation des pratiques. Les différents niveaux de contradiction permettent de mieux saisir les liens entre les nouveaux patterns d'interaction et les pratiques institutionnalisées, de même que les implications des changements pour les systèmes d'activité voisins. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : co-configuration, open source, organisation, usages des technologies

Pour les systèmes logiciels, la méthode de validation la plus utilisée est le test. Tester consiste en l'exécution du logiciel en sélectionnant des données et en observant/jugeant les sorties. C'est un processus souvent coûteux. Il dépend de la complexité du logiciel, des objectifs en termes de validation, des outils et du processus de développement. La testabilité logicielle s'intéresse à caractériser et prédire l'effort de test. Cela est nécessaire pour estimer le travail de test, prévoir les coûts, planifier et organiser le travail. De nombreuses mesures ont été proposées dans la littérature comme indicateurs du coût du test. Ces mesures sont focalisées sur l'évaluation de certains attributs qui peuvent rendre le test difficile. D'autres approches proposent de repérer des constructions difficiles à tester à l'aide de patrons (testability antipatterns) par exemple. D'une façon générale, peu d'études ont été réalisées pour valider ces métriques ou patrons. Certaines de ces études donnent des résultats contradictoires. Or il est essentiel de fournir des informations non biaisées. Notre travail de thèse porte en premier lieu sur la validation de certaines métriques de testabilité proposées pour la prédiction du coût du test de programmes objet. Notre approche s'appuie sur une mise en relation des métriques et des stratégies de test et vise à l'établissement de corrélation entre coût prédictive et coût effective. Ceci nous a conduit à raffiner certaines métriques étudiées. Dans un second temps, nous nous sommes intéressés à des patrons (testability antipatterns) visant à détecter des faiblesses dans le code vis à vis du test. Le but de cette étude est de comprendre à quels moments ces constructions sont introduites dans le code, afin de les repérer le plus efficacement possible.