Understanding how software developers do their work is an important first step to improving their productivity. Previous research has generally focused either on laboratory experiments or coarsely-grained industrial case studies; however, studies that seek a finegrained understanding of industrial programmers working within a realistic context remain limited. In this work, we propose to use interaction histories — that is, finely detailed records of developers’ interactions with their IDE — as our main source of information for understanding programmer’s work habits. We develop techniques to capture, mine, and analyze interaction histories, and we present two industrial case studies to show how this approach can help to better understand industrial programmers’ work at a detailed level: we explore how the basic characteristics of software maintenance task structures can be better understood, how latent dependence between program artifacts can be detected at interaction time, and show how patterns of interaction coupling can be identified. We also examine the link between programmer interactions and some of the contextual factors of software development, such as the nature of the task being performed, the design of the software system, and the expertise of the developers. In particular, we explore how task boundaries can be automatically detected from interaction histories, how system design and developer expertise may affect interaction coupling, and whether newcomer and expert developers differ in their interaction history patterns. These findings can help us to better reason about the multidimensional nature of software development, to detect potential problems concerning task, design, expertise, and other contextual factors, and to build smarter tools that exploit the inherent patterns within programmer interactions and provide improved support for task-aware and expertise-aware software development.

Domain-specific languages can significantly speed up the development of software applications. However, it usually takes a few iterations of the language design before it achieves such power. At the same time, many domains tend to evolve quite often today, which implies that domain-specific languages have to evolve accordingly. Thus, being able to evolve a language in a painless manner is crucial. Unfortunately, current state-of-the-art research does not provide enough answers on how to efficiently evolve domain-specific languages. We present an approach to evolving a language in order to reduce the amount of code cloning it introduces. The approach specifically targets those languages whose design causes users to create many duplicated code segments. We target domain-specific languages as they tend to be more challenging to evolve due to their specifics, but the approach may be applicable to general purpose programming languages as well. The approach was tested on a real-world domain-specific language that is used in a financial domain. We proposed three improvements and current users helped us evaluate them. We found that the proposed improvements would reduce code cloning, which provides evidence that the approach can be used in a real-world environment. Furthermore, this work provides a solid basis for further research in the area of application of code cloning detection results. In particular, code cloning detection results and the ideas we presented show potential to be extended and used to facilitate domain analysis.

Diss. Västerås : Mälardalens högskola, 2004.

Thesis (M. Sc.)--Carleton University, 1993. / Accompanying material: 1 diskette in pocket. Includes bibliographical references. Also available in electronic format on the Internet.

Thesis (Ph. D.)--University of California, Santa Cruz, 1998. / Typescript. Includes bibliographical references (leaves 327-354) and index.

Thesis (Ph. D.)--University of Canterbury, 2007. / Typescript (photocopy). Includes bibliographical references (p. 191-197). Also available via the World Wide Web.

Pour profiter des nombreux matériels actuellement, les logiciels s'exécutant sur des téléphones mobiles doivent devenir sensibles au contexte, c'est-à-dire, qu'ils doivent surveiller les événements provenant de leur environnement et réagir en conséquence. Nous considérons que ces logiciels peuvent bénéficier d'une approche basée sur les Lignes de Produits Logiciels (LPL). Les LPLs sont définies pour exploiter les points communs par la définition d'éléments réutilisables. Néanmoins, les LPLs ne prennent pas en compte les modifications à l'exécution des applications. Cette thèse propose une ligne de produits logiciels dynamique (LPLD) qui étend une LPL classique en fournissant des mécanismes pour adapter les produits à l'exécution. Notre objectif principal est d'unifier les adaptations à la conception et à l'exécution en utilisant des artefacts logiciels de haut niveau. Concrètement, nous introduisons un modèle de variabilité et un modèle de composition pour modulariser les produits sous forme de modèles d'aspect. Chaque modèle d'aspect a trois parties : l'architecture, les modifications, et le point de coupe. Ensuite, nous proposons deux processus de dérivation du produit : un pour la conception que vise à construire un produit, et un pour l'exécution que vise à adapter un produit. Ce travail de recherche s'est déroulé dans le cadre du projet FUI CAPPUCINO. Nous avons défini une LPLD pour une étude de cas de vente d'un hypermarché sensible au contexte. Le scénario démontre les avantages de notre approche et, en particulier, l'unification réalisée par les modèles d'aspect utilisés à la fois à la conception et à l'exécution.

L'ingénierie des modèles considère les modèles comme des entités de première classe pour le développement logiciel. Les processus dirigés par les modèles se doivent d'être capables de prendre en compte le savoir-faire d'experts, généralement exprimé en termes de patrons, qu'ils soient d'analyse, de conception ou d'architecture. Choisir le bon patron et assurer sa bonne intégration au sein d'une modélisation constitue des freins à l'utilisation systématique des bonnes pratiques de conception. Afin d'alléger ces tâches, nous proposons une approche basée sur l'inspection automatique des modèles. De la même manière qu'il existe des revues de code visant à vérifier l'absence de mauvaises pratiques de codage dans un programme, nous avons outillé une activité de revue de conception identifiant, expliquant et corrigeant les mauvaises pratiques de conception dans un modèle. Un patron abîmé est comparable à un patron de conception, ses contextualisations résolvant les mêmes types de problèmes, mais avec une architecture différente et certainement améliorable. Des expérimentations ont été menées afin de collecter des patrons abîmés, nous amenant à proposer un catalogue de mauvaises pratiques, complémentaire au catalogue du GoF. La détection des contextualisations de patrons abîmés dans un modèle UML est apparentée à un morphisme de graphe étendu. Les graphes UML ayant des sommets typés, la détection s'appuie sur des particularités structurelles locales et globales permettant de résoudre ce problème NP-Complet par des filtrages successifs. Cet algorithme est ainsi capable de détecter toutes les contextualisations possibles d'un patron abîmé, en gérant de plus les arcs interdits et facultatifs. La sémantique d'un fragment de modèle est donnée par son intention et celle-ci est validée par le concepteur. L'intention des fragments détectés et les bénéfices d'un remplacement par le patron adéquat sont déduits par des requêtes sur une ontologie conçue à cet effet. La transformation des fragments en contextualisations de patrons de conception est réalisée grâce à des restructurations de modèles déduites automatiquement des différences structurelles entre un patron abîmé et un patron de conception.

Les travaux décrits dans ce document ont pour objectif le développement de procédures de décision (et de résolution) pour la vérification. La logique considérée est la logique du premier ordre avec égalité. Cette logique est évidemment indécidable en général, mais l'étude de fragments intéressants pour la vérification peut conduire à des outils automatiques de type "presse-bouton". La notion d'égalité est particulièrement intéressante pour programmer, par orientation des égalités, c'est-à-dire par réécriture, ou pour prouver, grâce au principe de remplacement d'égal par égal. Dans une modélisation en logique du premier ordre avec égalité, on est très facilement amené à utiliser simultanément plusieurs théories différentes pour représenter par exemple les fonctions et la mémoire d'un programme ainsi que les opérations arithmétiques effectuées par le programme. On se retrouve ainsi naturellement face à un problème exprimé dans un mélange de théories, qu'il est souhaitable de résoudre de façon modulaire en réutilisant les procédures de décision connus pour les théories composant le mélange. Cette problématique est au coeur de mes travaux. L'originalité de mon approche consiste à développer des méthodes de combinaison pour les procédures de décision utilisées dans le domaine de la vérification. Toutes les procédures de décision obtenues ont été évidemment élaborées en suivant une démarche de conception sûre, qui s'appuie sur une description à base de systèmes d'inférence pour faciliter leurs preuves.

Les organisations actuelles se structurent et agissent en s'appuyant sur leurs systèmes d'information. Malgré les progrès considérables réalisés par la technologie informatique, on constate que les acteurs restent très souvent critiques par rapport à leur systèmes d'information. Une des causes de cet écart entre les espoirs et la réalité trouve sa source dans la difficulté à produire un cahier des charges suffisamment détaillé pour les opérationnels et interprétable par les spécialistes des systèmes d'information. Notre proposition vise à surmonter cet obstacle en organisant l'expression des besoins dans un langage commun aux opérationnels et aux experts techniques. Pour cela, le langage proposé pour exprimer les besoins est basé sur la notion de but. L'ensemble de cette démarche repose sur l'ingénierie dirigée par les modèles. Celle-ci a aujourd'hui montré la majorité de ces résultats dans la phase de développement logiciel et tout particulièrement avec l'approche MDA. Tandis que cette phase est grandement étudiée par la communauté IDM, la phase de spécification et d'expression du besoin est, aujourd'hui, peu approfondie. Notre proposition repose sur la mise en œuvre de l'ingénierie dirigée par les modèles dans cette phase, qui semble être l'une des plus importantes dans le processus de développement logiciel, avec pour objectif d'améliorer la qualité de la spécification des besoins et ainsi apporter une information plus fiable et plus claire aux étapes suivantes. Cette proposition repose sur un méta-modèle de spécification du besoin fonctionnel et d'un mécanisme d'interprétation à l'aide de transformations de modèles.