Essais sur les logiciels libres : licences doubles, effets de réseau, et concurrence

This thesis examines the microeconomic consequences of the arrival of open source in the software market. Specifically, it analyzes three features of open source software by using specific models of industrial organization. Open source software is free, and may be modified or duplicated by anyone. The first paper studies the entry of an open source software in a closed source software market. Using a model of horizontal differentiation, the analysis considers a closed source firm's investment in the quality of its software. The introduction of open source on the market reduces the firm's investment in quality and increases the price of its software. Moreover, the entry of open source software may reduce consumer welfare. Post-entry by an open source software, the reduction in market share lowers the firm's incentive to invest in quality. The second paper features vertical differentiation to study a monopolist selling supporting product to its software. The study begins by contrasting the supply of support by an open source provider and a closed source vendor. The model shows that in both cases the levels of support offered are the same. In addition, consumer welfare is higher and profit lower under an open source software. Then, the paper considers the competition in the provision of support. Here, the supply of high level support is greater than under a monopolist. Finally, the monopolist adopts a dual licensing strategy to extract more surplus from developers interested in modifying open source software and redistributing the resulting product. This technique, when the developers place high value on the source code, generates more profit if the monopolist chooses to publish as open source rather than closed source. The last paper studies how a closed source firm is affected by the introduction of an open source benefiting from contributions by users. A vertical differentiation model is used, and reveals that, when contribution of users is present, the closed source vendor may lower its price to a level where it forces the open source out of the market. The firm's lower price not only increases demand for its software, but also induces consumers into switching from open to closed source software therefore reducing the contribution of users.

Impacts and Detection of Design Smells

Les changements sont faits de façon continue dans le code source des logiciels pour prendre en compte les besoins des clients et corriger les fautes. Les changements continus peuvent conduire aux défauts de code et de conception. Les défauts de conception sont des mauvaises solutions à des problèmes récurrents de conception ou d’implémentation, généralement dans le développement orienté objet. Au cours des activités de compréhension et de changement et en raison du temps d’accès au marché, du manque de compréhension, et de leur expérience, les développeurs ne peuvent pas toujours suivre les normes de conception et les techniques de codage comme les patrons de conception. Par conséquent, ils introduisent des défauts de conception dans leurs systèmes. Dans la littérature, plusieurs auteurs ont fait valoir que les défauts de conception rendent les systèmes orientés objet plus difficile à comprendre, plus sujets aux fautes, et plus difficiles à changer que les systèmes sans les défauts de conception. Pourtant, seulement quelques-uns de ces auteurs ont fait une étude empirique sur l’impact des défauts de conception sur la compréhension et aucun d’entre eux n’a étudié l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes. Dans cette thèse, nous proposons trois principales contributions. La première contribution est une étude empirique pour apporter des preuves de l’impact des défauts de conception sur la compréhension et le changement. Nous concevons et effectuons deux expériences avec 59 sujets, afin d’évaluer l’impact de la composition de deux occurrences de Blob ou deux occurrences de spaghetti code sur la performance des développeurs effectuant des tâches de compréhension et de changement. Nous mesurons la performance des développeurs en utilisant: (1) l’indice de charge de travail de la NASA pour leurs efforts, (2) le temps qu’ils ont passé dans l’accomplissement de leurs tâches, et (3) les pourcentages de bonnes réponses. Les résultats des deux expériences ont montré que deux occurrences de Blob ou de spaghetti code sont un obstacle significatif pour la performance des développeurs lors de tâches de compréhension et de changement. Les résultats obtenus justifient les recherches antérieures sur la spécification et la détection des défauts de conception. Les équipes de développement de logiciels doivent mettre en garde les développeurs contre le nombre élevé d’occurrences de défauts de conception et recommander des refactorisations à chaque étape du processus de développement pour supprimer ces défauts de conception quand c’est possible. Dans la deuxième contribution, nous étudions la relation entre les défauts de conception et les fautes. Nous étudions l’impact de la présence des défauts de conception sur l’effort nécessaire pour corriger les fautes. Nous mesurons l’effort pour corriger les fautes à l’aide de trois indicateurs: (1) la durée de la période de correction, (2) le nombre de champs et méthodes touchés par la correction des fautes et (3) l’entropie des corrections de fautes dans le code-source. Nous menons une étude empirique avec 12 défauts de conception détectés dans 54 versions de quatre systèmes: ArgoUML, Eclipse, Mylyn, et Rhino. Nos résultats ont montré que la durée de la période de correction est plus longue pour les fautes impliquant des classes avec des défauts de conception. En outre, la correction des fautes dans les classes avec des défauts de conception fait changer plus de fichiers, plus les champs et des méthodes. Nous avons également observé que, après la correction d’une faute, le nombre d’occurrences de défauts de conception dans les classes impliquées dans la correction de la faute diminue. Comprendre l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes est important afin d’aider les équipes de développement pour mieux évaluer et prévoir l’impact de leurs décisions de conception et donc canaliser leurs efforts pour améliorer la qualité de leurs systèmes. Les équipes de développement doivent contrôler et supprimer les défauts de conception de leurs systèmes car ils sont susceptibles d’augmenter les efforts de changement. La troisième contribution concerne la détection des défauts de conception. Pendant les activités de maintenance, il est important de disposer d’un outil capable de détecter les défauts de conception de façon incrémentale et itérative. Ce processus de détection incrémentale et itérative pourrait réduire les coûts, les efforts et les ressources en permettant aux praticiens d’identifier et de prendre en compte les occurrences de défauts de conception comme ils les trouvent lors de la compréhension et des changements. Les chercheurs ont proposé des approches pour détecter les occurrences de défauts de conception, mais ces approches ont actuellement quatre limites: (1) elles nécessitent une connaissance approfondie des défauts de conception, (2) elles ont une précision et un rappel limités, (3) elles ne sont pas itératives et incrémentales et (4) elles ne peuvent pas être appliquées sur des sous-ensembles de systèmes. Pour surmonter ces limitations, nous introduisons SMURF, une nouvelle approche pour détecter les défauts de conception, basé sur une technique d’apprentissage automatique — machines à vecteur de support — et prenant en compte les retours des praticiens. Grâce à une étude empirique portant sur trois systèmes et quatre défauts de conception, nous avons montré que la précision et le rappel de SMURF sont supérieurs à ceux de DETEX et BDTEX lors de la détection des occurrences de défauts de conception. Nous avons également montré que SMURF peut être appliqué à la fois dans les configurations intra-système et inter-système. Enfin, nous avons montré que la précision et le rappel de SMURF sont améliorés quand on prend en compte les retours des praticiens.

Rétro ingénierie des modèles d’objets dynamiques pour JavaScript

La compréhension des objets dans les programmes orientés objet est une tâche impor- tante à la compréhension du code. JavaScript (JS) est un langage orienté-objet dyna- mique, et son dynamisme rend la compréhension du code source très difficile. Dans ce mémoire, nous nous intéressons à l’analyse des objets pour les programmes JS. Notre approche construit de façon automatique un graphe d’objets inspiré du diagramme de classes d’UML à partir d’une exécution concrète d’un programme JS. Le graphe résul- tant montre la structure des objets ainsi que les interactions entre eux. Notre approche utilise une transformation du code source afin de produire cette in- formation au cours de l’exécution. Cette transformation permet de recueillir de l’infor- mation complète au sujet des objets crées ainsi que d’intercepter toutes les modifications de ces objets. À partir de cette information, nous appliquons plusieurs abstractions qui visent à produire une représentation des objets plus compacte et intuitive. Cette approche est implémentée dans l’outil JSTI. Afin d’évaluer l’utilité de l’approche, nous avons mesuré sa performance ainsi que le degré de réduction dû aux abstractions. Nous avons utilisé les dix programmes de réfé- rence de V8 pour cette comparaison. Les résultats montrent que JSTI est assez efficace pour être utilisé en pratique, avec un ralentissement moyen de 14x. De plus, pour 9 des 10 programmes, les graphes sont suffisamment compacts pour être visualisés. Nous avons aussi validé l’approche de façon qualitative en inspectant manuellement les graphes gé- nérés. Ces graphes correspondent généralement très bien au résultat attendu. Mots clés: Analyse de programmes, analyse dynamique, JavaScript, profilage.

Improving automation in model-driven engineering using examples

Cette thèse a pour but d’améliorer l’automatisation dans l’ingénierie dirigée par les modèles (MDE pour Model Driven Engineering). MDE est un paradigme qui promet de réduire la complexité du logiciel par l’utilisation intensive de modèles et des transformations automatiques entre modèles (TM). D’une façon simplifiée, dans la vision du MDE, les spécialistes utilisent plusieurs modèles pour représenter un logiciel, et ils produisent le code source en transformant automatiquement ces modèles. Conséquemment, l’automatisation est un facteur clé et un principe fondateur de MDE. En plus des TM, d’autres activités ont besoin d’automatisation, e.g. la définition des langages de modélisation et la migration de logiciels. Dans ce contexte, la contribution principale de cette thèse est de proposer une approche générale pour améliorer l’automatisation du MDE. Notre approche est basée sur la recherche méta-heuristique guidée par les exemples. Nous appliquons cette approche sur deux problèmes importants de MDE, (1) la transformation des modèles et (2) la définition précise de langages de modélisation. Pour le premier problème, nous distinguons entre la transformation dans le contexte de la migration et les transformations générales entre modèles. Dans le cas de la migration, nous proposons une méthode de regroupement logiciel (Software Clustering) basée sur une méta-heuristique guidée par des exemples de regroupement. De la même façon, pour les transformations générales, nous apprenons des transformations entre modèles en utilisant un algorithme de programmation génétique qui s’inspire des exemples des transformations passées. Pour la définition précise de langages de modélisation, nous proposons une méthode basée sur une recherche méta-heuristique, qui dérive des règles de bonne formation pour les méta-modèles, avec l’objectif de bien discriminer entre modèles valides et invalides. Les études empiriques que nous avons menées, montrent que les approches proposées obtiennent des bons résultats tant quantitatifs que qualitatifs. Ceux-ci nous permettent de conclure que l’amélioration de l’automatisation du MDE en utilisant des méthodes de recherche méta-heuristique et des exemples peut contribuer à l’adoption plus large de MDE dans l’industrie à là venir.

A Mono- and Multi-objective Approach for Recommending Software Refactoring

Les systèmes logiciels sont devenus de plus en plus répondus et importants dans notre société. Ainsi, il y a un besoin constant de logiciels de haute qualité. Pour améliorer la qualité de logiciels, l’une des techniques les plus utilisées est le refactoring qui sert à améliorer la structure d'un programme tout en préservant son comportement externe. Le refactoring promet, s'il est appliqué convenablement, à améliorer la compréhensibilité, la maintenabilité et l'extensibilité du logiciel tout en améliorant la productivité des programmeurs. En général, le refactoring pourra s’appliquer au niveau de spécification, conception ou code. Cette thèse porte sur l'automatisation de processus de recommandation de refactoring, au niveau code, s’appliquant en deux étapes principales: 1) la détection des fragments de code qui devraient être améliorés (e.g., les défauts de conception), et 2) l'identification des solutions de refactoring à appliquer. Pour la première étape, nous traduisons des régularités qui peuvent être trouvés dans des exemples de défauts de conception. Nous utilisons un algorithme génétique pour générer automatiquement des règles de détection à partir des exemples de défauts. Pour la deuxième étape, nous introduisons une approche se basant sur une recherche heuristique. Le processus consiste à trouver la séquence optimale d'opérations de refactoring permettant d'améliorer la qualité du logiciel en minimisant le nombre de défauts tout en priorisant les instances les plus critiques. De plus, nous explorons d'autres objectifs à optimiser: le nombre de changements requis pour appliquer la solution de refactoring, la préservation de la sémantique, et la consistance avec l’historique de changements. Ainsi, réduire le nombre de changements permets de garder autant que possible avec la conception initiale. La préservation de la sémantique assure que le programme restructuré est sémantiquement cohérent. De plus, nous utilisons l'historique de changement pour suggérer de nouveaux refactorings dans des contextes similaires. En outre, nous introduisons une approche multi-objective pour améliorer les attributs de qualité du logiciel (la flexibilité, la maintenabilité, etc.), fixer les « mauvaises » pratiques de conception (défauts de conception), tout en introduisant les « bonnes » pratiques de conception (patrons de conception).

Génération automatique de configurations et de scénarios d'utilisation d'outils de visualisation à partir de spécifications de tâches d'analyse de logiciels

Nous proposons une approche qui génère des scénarios de visualisation à partir des descriptions de tâches d'analyse de code. La dérivation de scénario est considérée comme un processus d'optimisation. Dans ce contexte, nous évaluons différentes possibilités d'utilisation d'un outil de visualisation donnée pour effectuer la tâche d'analyse, et sélectionnons le scénario qui nécessite le moins d'effort d'analyste. Notre approche a été appliquée avec succès à diverses tâches d'analyse telles que la détection des défauts de conception.

Bridging The Unknown : An Interdisciplinary Case Study of Paratext in Electronic Literature

This chapter presents a dual perspective on the paratextual apparatus of a work of electronic literature, The Unknown: The Original Great American Hypertext Novel by William Gillespie, Scott Rettberg, Dirk Stratton, and Frank Marquardt. Approaches from literature studies and information science are combined to offer qualitative content analyses and close readings of the table of contents, titular apparatus, comments hidden in the source code, and other paratextual elements, in relation to the narrative. Findings indicate that the work's paratextual content presents inconsistencies and contradictions, both in terms of the use of the paratextual structure and of the information conveyed. The paratextual elements are analyzed through the lens of Gérard Genette's theory, as outlined in Paratexts: Thresholds of Interpretation, in order to gauge their role and efficiency as identifiers, organizational components, and information providers, as well as their literary effect. The value of the theory as an interdisciplinary tool is also discussed.

La recherche de naines brunes et étoiles de faible masse dans les associations cinématiques jeunes du voisinage solaire

L’objectif principal de cette thèse est d’identifier les étoiles de faible masse et naines brunes membres d’associations cinématiques jeunes du voisinage solaire. Ces associations sont typiquement âgées de moins de 200 millions d’années et regroupent chacune un ensemble d’étoiles s’étant formées au même moment et dans un même environnement. La majorité de leurs membres d'environ plus de 0.3 fois la masse du Soleil sont déjà connus, cependant les membres moins massifs (et moins brillants) nous échappent encore. Leur identification permettra de lever le voile sur plusieurs questions fondamentales en astrophysique. En particulier, le fait de cibler des objets jeunes, encore chauds et lumineux par leur formation récente, permettra d’atteindre un régime de masses encore peu exploré, jusqu'à seulement quelques fois la masse de Jupiter. Elles nous permettront entre autres de contraindre la fonction de masse initiale et d'explorer la connection entre naines brunes et exoplanètes, étant donné que les moins massives des naines brunes jeunes auront des propriétés physiques très semblables aux exoplanètes géantes gazeuses. Pour mener à bien ce projet, nous avons adapté l'outil statistique BANYAN I pour qu'il soit applicable aux objets de très faibles masses en plus de lui apporter plusieurs améliorations. Nous avons entre autres inclus l'utilisation de deux diagrammes couleur-magnitude permettant de différencier les étoiles de faible masse et naines brunes jeunes à celles plus vieilles, ajouté l'utilisation de probabilités a priori pour rendre les résultats plus réalistes, adapté les modèles spatiaux et cinématiques des associations jeunes en utilisant des ellipsoïdes gaussiennes tridimensionnelles dont l'alignement des axes est libre, effectué une analyse Monte Carlo pour caractériser le taux de faux-positifs et faux-négatifs, puis revu la structure du code informatique pour le rendre plus efficace. Dans un premier temps, nous avons utilisé ce nouvel algorithme, BANYAN II, pour identifier 25 nouvelles candidates membres d'associations jeunes parmi un échantillon de 158 étoiles de faible masse (de types spectraux > M4) et naines brunes jeunes déjà connues. Nous avons ensuite effectué la corrélation croisée de deux catalogues couvrant tout le ciel en lumière proche-infrarouge et contenant ~ 500 millions d’objets célestes pour identifier environ 100 000 candidates naines brunes et étoiles de faible masse du voisinage solaire. À l'aide de l'outil BANYAN II, nous avons alors identifié quelques centaines d'objets appartenant fort probablement à une association jeune parmi cet échantillon et effectué un suivi spectroscopique en lumière proche-infrarouge pour les caractériser. Les travaux présentés ici ont mené à l'identification de 79 candidates naines brunes jeunes ainsi que 150 candidates étoiles de faible masse jeunes, puis un suivi spectroscopique nous a permis de confirmer le jeune âge de 49 de ces naines brunes et 62 de ces étoiles de faible masse. Nous avons ainsi approximativement doublé le nombre de naines brunes jeunes connues, ce qui a ouvert la porte à une caractérisation statistique de leur population. Ces nouvelles naines brunes jeunes représentent un laboratoire idéal pour mieux comprendre l'atmosphère des exoplanètes géantes gazeuses. Nous avons identifié les premiers signes d’une remontée dans la fonction de masse initiale des naines brunes aux très faibles masses dans l'association jeune Tucana-Horologium, ce qui pourrait indiquer que l’éjection d’exoplanètes joue un rôle important dans la composition de leur population. Les résultats du suivi spectroscopique nous ont permis de construire une séquence empirique complète pour les types spectraux M5-L5 à l'âge du champ, à faible (β) et très faible (γ) gravité de surface. Nous avons effectué une comparaison de ces données aux modèles d'évolution et d'atmosphère, puis nous avons construit un ensemble de séquences empiriques de couleur-magnitude et types spectraux-magnitude pour les naines brunes jeunes. Finalement, nous avons découvert deux nouvelles exoplanètes par un suivi en imagerie directe des étoiles jeunes de faible masse identifiées dans ce projet. La future mission GAIA et le suivi spectroscopique complet des candidates présentées dans cette thèse permettront de confirmer leur appartenance aux associations jeunes et de contraindre la fonction de masse initiale dans le régime sous-stellaire.

Genetic Programming meets Model-Driven Development

Genetic programming is known to provide good solutions for many problems like the evolution of network protocols and distributed algorithms. In such cases it is most likely a hardwired module of a design framework that assists the engineer to optimize specific aspects of the system to be developed. It provides its results in a fixed format through an internal interface. In this paper we show how the utility of genetic programming can be increased remarkably by isolating it as a component and integrating it into the model-driven software development process. Our genetic programming framework produces XMI-encoded UML models that can easily be loaded into widely available modeling tools which in turn posses code generation as well as additional analysis and test capabilities. We use the evolution of a distributed election algorithm as an example to illustrate how genetic programming can be combined with model-driven development. This example clearly illustrates the advantages of our approach – the generation of source code in different programming languages.

A User-Centric Perspective on Parallel Programming with Focus on OpenMP

The process of developing software that takes advantage of multiple processors is commonly referred to as parallel programming. For various reasons, this process is much harder than the sequential case. For decades, parallel programming has been a problem for a small niche only: engineers working on parallelizing mostly numerical applications in High Performance Computing. This has changed with the advent of multi-core processors in mainstream computer architectures. Parallel programming in our days becomes a problem for a much larger group of developers. The main objective of this thesis was to find ways to make parallel programming easier for them. Different aims were identified in order to reach the objective: research the state of the art of parallel programming today, improve the education of software developers about the topic, and provide programmers with powerful abstractions to make their work easier. To reach these aims, several key steps were taken. To start with, a survey was conducted among parallel programmers to find out about the state of the art. More than 250 people participated, yielding results about the parallel programming systems and languages in use, as well as about common problems with these systems. Furthermore, a study was conducted in university classes on parallel programming. It resulted in a list of frequently made mistakes that were analyzed and used to create a programmers' checklist to avoid them in the future. For programmers' education, an online resource was setup to collect experiences and knowledge in the field of parallel programming - called the Parawiki. Another key step in this direction was the creation of the Thinking Parallel weblog, where more than 50.000 readers to date have read essays on the topic. For the third aim (powerful abstractions), it was decided to concentrate on one parallel programming system: OpenMP. Its ease of use and high level of abstraction were the most important reasons for this decision. Two different research directions were pursued. The first one resulted in a parallel library called AthenaMP. It contains so-called generic components, derived from design patterns for parallel programming. These include functionality to enhance the locks provided by OpenMP, to perform operations on large amounts of data (data-parallel programming), and to enable the implementation of irregular algorithms using task pools. AthenaMP itself serves a triple role: the components are well-documented and can be used directly in programs, it enables developers to study the source code and learn from it, and it is possible for compiler writers to use it as a testing ground for their OpenMP compilers. The second research direction was targeted at changing the OpenMP specification to make the system more powerful. The main contributions here were a proposal to enable thread-cancellation and a proposal to avoid busy waiting. Both were implemented in a research compiler, shown to be useful in example applications, and proposed to the OpenMP Language Committee.

Resource for UK Computing Law - INFO2009 - 09/10

Zip file containing source code and database dump for the resource

WAIS seminar: Application Performance Monitoring and Architecture Discovery with Kieker

Wednesday 23rd April 2014 Speaker(s): Willi Hasselbring Organiser: Leslie Carr Time: 23/04/2014 14:00-15:00 Location: B32/3077 File size: 802Mb Abstract The internal behavior of large-scale software systems cannot be determined on the basis of static (e.g., source code) analysis alone. Kieker provides complementary dynamic analysis capabilities, i.e., monitoring/profiling and analyzing a software system's runtime behavior. Application Performance Monitoring is concerned with continuously observing a software system's performance-specific runtime behavior, including analyses like assessing service level compliance or detecting and diagnosing performance problems. Architecture Discovery is concerned with extracting architectural information from an existing software system, including both structural and behavioral aspects like identifying architectural entities (e.g., components and classes) and their interactions (e.g., local or remote procedure calls). In addition to the Architecture Discovery of Java systems, Kieker supports Architecture Discovery for other platforms, including legacy systems, for instance, inplemented in C#, C++, Visual Basic 6, COBOL or Perl. Thanks to Kieker's extensible architecture it is easy to implement and use custom extensions and plugins. Kieker was designed for continuous monitoring in production systems inducing only a very low overhead, which has been evaluated in extensive benchmark experiments. Please, refer to http://kieker-monitoring.net/ for more information.

Systems analysis of absorbing media

A complete treatment of the charcterastic admittance-matrix representation of multilayer thin-film systems with absorbing media is presented. The algorithm from the systems analysis is implemented on an IBM microcomputer and some examples of filter design calculation are presented. Relevant source code in IBM Advanced Basic interpreter are also included.

Modula-2 applied

Programming is a skill which requires knowledge of both the basic constructs of the computer language used and techniques employing these constructs. How these are used in any given application is determined intuitively, and this intuition is based on experience of programs already written. One aim of this book is to describe the techniques and give practical examples of the techniques in action - to provide some experience. Another aim of the book is to show how a program should be developed, in particular how a relatively large program should be tackled in a structured manner. These aims are accomplished essentially by describing the writing of one large program, a diagram generator package, in which a number of useful programming techniques are employed. Also, the book provides a useful program, with an in-built manual describing not only how the program works, but also how it does it, with full source code listings. This means that the user can, if required, modify the package to meet particular requirements. A floppy disk is available from the publishers containing the program, including listings of the source code. All the programs are written in Modula-2, using JPI's Top Speed Modula-2 system running on IBM-PCs and compatibles. This language was chosen as it is an ideal language for implementing large programs and it is the main language taught in the Cybernetics Department at the University of Reading. There are some aspects of the Top Speed implementation which are not standard, so suitable comments are given when these occur. Although implemented in Modula-2, many of the techniques described here are appropriate to other languages, like Pascal of C, for example. The book and programs are based on a second year undergraduate course taught at Reading to Cybernetics students, entitled Algorithms and Data Structures. Useful techniques are described for the reader to use, applications where they are appropriate are recommended, but detailed analyses of the techniques are not given.

The development of a data-driven application benchmarking approach to performance modelling

Performance modelling is a useful tool in the lifeycle of high performance scientific software, such as weather and climate models, especially as a means of ensuring efficient use of available computing resources. In particular, sufficiently accurate performance prediction could reduce the effort and experimental computer time required when porting and optimising a climate model to a new machine. In this paper, traditional techniques are used to predict the computation time of a simple shallow water model which is illustrative of the computation (and communication) involved in climate models. These models are compared with real execution data gathered on AMD Opteron-based systems, including several phases of the U.K. academic community HPC resource, HECToR. Some success is had in relating source code to achieved performance for the K10 series of Opterons, but the method is found to be inadequate for the next-generation Interlagos processor. The experience leads to the investigation of a data-driven application benchmarking approach to performance modelling. Results for an early version of the approach are presented using the shallow model as an example.