Évolution biologique et applications en génie logiciel

Résumé : La maintenance des programmes orientés objets est une activité très coûteuse et la compréhension des programmes par les mainteneurs est essentielle pour la réaliser. L'analyse de l'évolution de l'architecture d'un programme aide à comprendre les problèmes rencontrés lors de sa conception ainsi que les solutions apportées. Les techniques existantes utilisées pour l'analyse de l'évolution de logiciels présentent toutes, cependant, un problème de performance. Le but de notre travail de recherche est d'étudier l'évolution de logiciels d'un point de vue biologique. Nous proposons un mapping entre l'évolution biologique et l'évolution logicielle. Ce mapping propose une solution aux problèmes de performance, en adaptant des algorithmes efficaces de comparaisons et d'alignements de chaînes de caractères de bio-informatique, pour bénéficier de leurs performances sur des programmes de grande taille. Parmi nos résultats actuels, nous rapportons l'évidence de l'utilité de notre mapping en identifiant les classes en évolution qui maintiennent une structure stable des relations (utilisation, association, agrégation, création, héritage) avec d'autres classes et constituent ainsi probablement les épines dorsales des programmes. Nous rapportons aussi l'application de notre approche sur plusieurs programmes différents et comparons son exécution et résultats avec l'approche la plus récente de la littérature.----------Abstract : The maintenance of large programs is a costly activity because their evolution often leads to two problems: an increase in their complexity and an erosion of their design. These problems impede the comprehension and the future evolution of the programs. Most previous approaches of software evolution analysis are limited because of their performance. The goal of our research work is to study the evolution of programs from a biological point of view by presenting a mapping between biological evolution and software evolution. This mapping offers a solution to the efficiency problem by using adaptation of string matching algorithms from bio-informatics to benefit from their performance on large programs. We report evidence of the usefulness of this mapping by identifying evolving classes that maintain a stable structure of relations (use, association, aggregation, inheritance, creation) with other classes and thus likely constitute the backbones of the programs. We apply our approach on several different size programs and compare its performance and results with the most recent approach from the literature

Change decision support:extraction and analysis of late architecture changes using change characterization and software metrics

Software maintenance is one of the most crucial aspects of software development. Software engineering researchers must develop practical solutions to handle the challenges presented in maintaining mature software systems. Research that addresses practical means of mitigating the risks involved when changing software, reducing the complexity of mature software systems, and eliminating the introduction of preventable bugs is paramount to today’s software engineering discipline. Giving software developers the information that they need to make quality decisions about changes that will negatively affect their software systems is a key aspect to mitigating those risks. This dissertation presents work performed to assist developers to collect and process data that plays a role in change decision-making during the maintenance phase. To address these problems, developers need a way to better understand the effects of a change prior to making the change. This research addresses the problems associated with increasing architectural complexity caused by software change using a twoold approach. The first approach is to characterize software changes to assess their architectural impact prior to their implementation. The second approach is to identify a set of architecture metrics that correlate to system quality and maintainability and to use these metrics to determine the level of difficulty involved in making a change. The two approaches have been combined and the results presented provide developers with a beneficial analysis framework that offers insight into the change process

Unique identification of elements in evolving models : towards fine-grained traceability in model-driven engineering

Model-driven engineering (MDE) is a widely accepted methodology in software engineering. At the same time, the ability to retrace the engineering process is an important success factor for software projects. In MDE, however, such traceability is often impeded by the inadequate management of model evolution. Although models have a very fine-grained structure, their different revisions and variants are prevalently managed as monoliths in a file-based software configuration management (SCM). This causes the identification problem: if the fine-grained elements are not assigned with globally unique identifiers, we cannot identify them over time. If such identifiers would be given, they can be misleading. As a consequence, we cannot comprehend the evolution of elements and traceability relationships among the elements cannot be managed sufficiently. This thesis presents a novel solution to the identification problem. It establishes a representation to describe the history of a model and its fine-grained elements inside. The key feature of the representation is a new kind of traceability relationship, called identification links. They allow us to identify elements of a given revision in other revisions or variants of the model. The identification is even applicable to anonymous elements and model fragments. It provides us with a broad spectrum of opportunities: e.g. management of fine-grained traceability links, evolution analysis, merging of development branches. Due to the expression of model evolution in the history representation, we are further able to capture the changes that have been applied to the traced elements. This thesis further presents an algorithm to infer the identification links automatically. The approach does not rely on persistent identifiers, but it utilizes a similarity-based model comparison technique to locate the model elements in other revisions. The algorithm and the history representation have been implemented in a prototype. It is metamodel and tool independent and can work with an arbitrary SCM. Existing modeling environments do not have to be modified. Traceability information and evolution information is accessible through a service interface and can thus be integrated in arbitrary tools. The evaluation of our approach by means of controlled experiments with data from real models attested excellent precision and recall values for the identification of model elements over time. Furthermore, different evolution analysis tools have already been built on our approach, which documents the practical applicability of our solution.Die modellgetriebene Entwicklung ist eine weit verbreitete Methode zur Softwareentwicklung. Die ungeeignete Versionierung von Modellen verhindert jedoch oftmals die Nachverfolgbarkeit des Entwicklungsprozesses. Trotz ihrer feinkörnigen Struktur werden Modelle oft monolithisch auf Basis dateibasierter Konfigurationsmanagementsysteme verwaltet. Modellelemente können in diesem Fall nicht über die Zeit hinweg identifiziert werden, weil globale Identifizierer entweder fehlen oder irreführend sein können. Aufgrund dieses Identifikationsproblems können Änderungen an Modellelementen nur sehr schwer nachvollzogen werden. Außerdem können Referenzen zur Nachverfolgbarkeit zwischen Elementen verschiedener Revisionen nicht sinnvoll verwaltet werden. Diese Dissertation löst das Identifikationsproblem. Sie führt eine Repräsentation ein, mit der die Historie von Modellen und deren feinkörnigen Elementen abgebildet werden kann. Ein zentraler Bestandteil dieser Repräsentation sind Identifizierungslinks, die es ermöglichen ein gegebenes Element in anderen Revisionen oder Varianten des Modells wiederzufinden. Der Ansatz unterstützt auch anonyme Elemente und komplette Modellfragmente. Diese neuartige Identifizierung ermöglicht z.B. die Verwaltung von feinkörniger Nachverfolgbarkeitsinformation, die Analyse von Modellevolution oder das Mischen von Entwicklungszweigen. Da die Repräsentation auch die Evolution eines Modells abbilden kann, können die Veränderungen identifizierter Elemente besser erfasst werden. Zudem wird in dieser Dissertation ein Algorithmus entwickelt, mit dem Identifizierungslinks zwischen Modellelementen verschiedener Revisionen inferiert werden. Dieser stützt sich nicht auf persistente Identifizierer, sondern nutzt einen ähnlichkeitsbasierten Differenzalgorithmus, um Elemente in anderen Revisionen wiederzufinden. Der Algorithmus und die Historienrepräsentation wurden in einem modelltyp- und werkzeugunabhängigen Prototyp implementiert, der mit beliebigen Konfigurationsmanagementsystemen zusammenarbeitet, ohne dass diese angepasst werden müssen. Die Informationen zur Nachverfolgbarkeit und Evolution von Modellelementen sind über eine Programmierschnittstelle abfragbar, die sich in beliebigen Werkzeugen nutzen lässt. Der beschriebene Ansatz wurde mit kontrollierten Experimenten auf Basis realer Modellhistorien erfolgreich evaluiert. Darüber hinaus wurde seine praktische Anwendbarkeit durch verschiedene darauf aufbauende Werkzeuge zur Evolutionsanalyse belegt

Approximate Graph Matching for Software Engineering

RÉSUMÉ La représentation en graphes est l’une des plus communément utilisées pour la modélisation de toutes sortes d’objets ou problèmes. Un graphe peut être brièvement présenté comme un ensemble de nœuds reliés entre eux par des relations appelées arêtes ou arcs. La comparaison d’objets, représentés sous forme de graphes, est un problème important dans de nombreuses applications et une manière de traiter cette question consiste à recourir à l’appariement de graphes. Le travail présenté dans cette thèse s’intéresse aux techniques d’appariement approché de graphes et à leur application dans des activités de génie logiciel, notamment celles ayant trait à l’évolution d’un logiciel. Le travail de recherche effectué comporte trois principaux aspects distincts mais liés. Premièrement, nous avons considéré les problèmes d’appariement de graphes sous la formulation ETGM (Error-Tolerant Graph Matching : Appariement de Graphes avec Tolérance d’Erreurs) et proposé un algorithme performant pour leur résolution. En second, nous avons traité l’appariement d’artefacts logiciels, tels que les diagrammes de classe, en les formulant en tant que problèmes d’appariement de graphes. Enfin, grâce aux solutions obtenues sur les diagrammes de classes, nous avons proposé des mesures d’évolution et évalué leur utilité pour la prédiction de défauts. Les paragraphes suivants détaillent chacun des trois aspects ci-dessus mentionnés. Appariement approché de graphes Plusieurs problèmes pratiques peuvent être formulés en tant que problèmes d’Appariement Approché de Graphes (AAG) dans lesquels le but est de trouver un bon appariement entre deux graphes. Malheureusement, la littérature existante ne propose pas de techniques génériques et efficaces prêtes à être utilisées dans les domaines de recherche autres que le traitement d’images ou la biochimie. Pour tenter de remédier à cette situation, nous avons abordé les problèmes AAG de manière générique. Nous avons ainsi d’abord sélectionné une formulation capable de modéliser la plupart des différents problèmes AAG (la formulation ETGM). Les problèmes AAG sont des problèmes d’optimisation combinatoire reconnus comme étant (NP-)difficiles et pour lesquels la garantie de solutions optimales requiert des temps prohibitifs. Les méta-heuristiques sont un recours fréquent pour ce genre de problèmes car elles permettent souvent d’obtenir d’excellentes solutions en des temps raisonnables. Nous avons sélectionné la recherche taboue qui est une technique avancée de recherche locale permettant de construire et modifier graduellement et efficacement une solution à un problème donné. Nos expériences préliminaires nous ont révélé qu’il était suffisant d’initialiser une recherche locale avec un sous-ensemble très réduit (2 à 5%) d’une solution (quasi-)optimale pour se garantir d’excellents résultats. Étant donné que dans la plupart des cas, cette information n’est pas disponible, nous avons recouru à l’investigation de mesures de similarités pouvant nous permettre de prédire quels sont les appariements de nœuds les plus prometteurs. Notre approche a consisté à analyser les voisinages des nœuds de chaque graphe pour associer à chaque possible appariement de nœud une valeur de similarité indiquant les chances de retrouver la paire de nœuds en question dans une solution optimale. Nous avons ainsi exploré plusieurs possibilités et découvert que celle qui fonctionnait le mieux utilisait l’estimation la plus conservatrice, celle où la notion de voisinage similaire est la plus « restrictive ». De plus, pour attacher un niveau de confiance à cette mesure de similarité, nous avons appliqué un facteur correcteur tenant compte notamment des alternatives possibles pour chaque paire de nœuds. La mesure de similarité ainsi obtenue est alors utilisée pour imposer une direction en début de recherche locale. L’algorithme qui en résulte, SIM-T a été comparé à différents algorithmes récents (et représentant l’état de l’art) et les résultats obtenus démontrent qu’il est plus efficace et beaucoup plus rapide pour l’appariement de graphes qui partagent une majorité d’éléments identiques. Appariement approché de diagrammes en génie logiciel. Compte tenu de la taille et de la complexité des systèmes orientés-objet, retrouver et comprendre l’évolution de leur conception architecturale est une tache difficile qui requiert des techniques appropriées. Diverses approches ont été proposées mais elles se concentrent généralement sur un problème particulier et ne sont en général pas adaptées à d’autres problèmes, pourtant conceptuellement proches. Sur la base du travail réalisé pour les graphes, nous avons proposé MADMatch, un algorithme (plusieurs-à-plusieurs) d’appariement approché de diagrammes. Dans notre approche, les diagrammes architecturaux ou comportementaux qu’on peut retrouver en génie logiciel sont représentés sous forme de graphes orientés dont les nœuds (appelées entités) et arcs possèdent des attributs. Dans notre formulation ETGM, les différences entre deux diagrammes sont comprises comme étant le résultat d’opérations d’édition (telles que la modification, le renommage ou la fusion d’entités) auxquelles sont assignées des coûts. L’une des principales différences des diagrammes traités, par rapport aux graphes de la première partie, réside dans la présence d’une riche information textuelle. MADMatch se distingue par son intégration de cette information et propose plusieurs concepts qui en tirent parti. En particulier, le découpage en mots et la combinaison des termes obtenus avec la topologie des diagrammes permettent de définir des contextes lexicaux pour chaque entité. Les contextes ainsi obtenus sont ultérieurement utilisés pour filtrer les appariements improbables et permettre ainsi des réductions importantes de l’espace de recherche. A travers plusieurs cas d’étude impliquant différents types de diagrammes (tels que les diagrammes de classe, de séquence ou les systèmes à transition) et plusieurs techniques concurrentes, nous avons démontré que notre algorithme peut s’adapter à plusieurs problèmes d’appariement et fait mieux que les précédentes techniques, quant à la précision et le passage à l’échelle. Des métriques d’évolution pour la prédiction de défauts. Les tests logiciels constituent la pratique la plus répandue pour garantir un niveau raisonnable de qualité des logiciels. Cependant, cette activité est souvent un compromis entre les ressources disponibles et la qualité logicielle recherchée. En développement Orienté-Objet (OO), l’effort de tests devrait se concentrer sur les classes susceptibles de contenir des défauts. Cependant, l’identification de ces classes est une tâche ardue pour laquelle ont été utilisées différentes métriques, techniques et modèles avec un succès mitigé. Grâce aux informations d’évolution obtenues par l’application de notre technique d’appariement de diagrammes, nous avons défini des mesures élémentaires d’évolution relatives aux classes d’un système OO. Nos mesures de changement sont définies au niveau des diagrammes de classes et incluent notamment les nombres d’attributs, de méthodes ou de relations ajoutés, supprimés ou modifiés de version en version. Elles ont été utilisées en tant que variables indépendantes dans des modèles de prédiction de défauts visant à recommander les classes les plus susceptibles de contenir des défauts. Les métriques proposées ont été évaluées selon trois critères (variables dépendantes des différents modèles) : la simple présence (oui/non) de défauts, le nombre de défauts et la densité de défauts (relativement au nombre de Lignes de Code). La principale conclusion de nos expériences est que nos mesures d’évolution prédisent mieux, et de façon significative, la densité de défauts que des métriques connues (notamment de complexité). Ceci indique qu’elles pourraient aider à réduire l’effort de tests en concentrant les activités e tests sur des volumes plus réduits de code. ----------ABSTRACT Graph representations are among the most common and effective ways to model all kinds of natural or human-made objects. Once two objects or problems have been represented as graphs (i.e. as collections of objects possibly connected by pairwise relations), their comparison is a fundamental question in many different applications and is referred to as graph matching. The work presented in this document investigates approximate graph matching techniques and their application in software engineering as efficient ways to retrieve the evolution through time of software artifacts. The research work we carried involves three distinct but related aspects. First, we consider approximate graph matching problems within the Error-Tolerant Graph Matching framework, and propose a tabu search technique initialised with local structural similarity measures. Second, we address the matching of software artifacts, such as class diagrams, and propose new concepts able to integrate efficiently the rich lexical information to our tabu search. Third, based on matchings obtained from the application of our approach to subsequent class diagrams, we proposed new design evolution metrics and assessed their usefulness in defect prediction models. The following paragraphs detail each of those three aspects. Approximate Graph Matching Many practical problems can be modeled as approximate graph matching (AGM) problems in which the goal is to find a ”good” matching between two objects represented as graphs. Unfortunately, existing literature on AGM do not propose generic techniques readily usable in research areas other than image processing and biochemistry. To address this situation, we tackled in a generic way, the AGM problems. For this purpose, we first select, out of the possible formulations, the Error Tolerant Graph Matching (ETGM) framework that is able to model most AGM formulations. Given that AGM problems are generally NP-hard, we based our resolution approach on meta-heuristics, given the demonstrated efficiency of this family of techniques on (NP-)hard problems. Our approach avoids as much as possible assumptions about graphs to be matched and tries to make the best out of basic graph features such as node connectivity and edge types. Consequently, the proposal is a local search technique using new node similarity measures derived from simple structural information. The proposed technique was devised as follows. First, we observed and empirically validated that initializing a local search with a very small subset of ”correct” node matches is enough to get excellent results. Instead of directly trying to correctly match all nodes and edges of a given graph to the nodes and edges of another graph, one could focus on correctly matching a reduced subset of nodes. Second, in order to retrieve such subsets, we resorted to the concept of local node similarity. Our approach consists in assessing, by analyzing their neighborhoods, how likely it is to have a pair of nodes included in a good matching. We investigated many ways of computing similarity values between pairs of nodes and proposed additional techniques to attach a level of confidence to computed similarity value. Our work results in a similarity enhanced tabu algorithm (Sim-T) which is demonstrated to be more accurate and efficient than known state-of-the-art algorithms. Approximate Diagram Matching in software engineering Given the size and complexity of OO systems, retrieving and understanding the history of the design evolution is a difficult task which requires appropriate techniques. Building on the work done for generic AGM problems, we propose MADMatch, a Many-to-many Approximate Diagram Matching algorithm based on an ETGM formulation. In our approach, design representations are modeled as attributed directed multi-graphs. Transformations such as modifying, renaming, or merging entities in a software diagram are explicitly taken into account through edit operations to which specific costs can be assigned. MADMatch fully integrates the textual information available on diagrams and proposes several concepts enabling accurate and fast computation of matchings. We notably integrate to our proposal the use of “termal footprints” which capture the lexical context of any given entity and are exploited in order to reduce the search space of our tabu search. Through several case studies involving different types of diagrams (such as class diagrams, sequence diagrams and labeled transition systems), we show that our algorithm is generic and advances the state of art with respect to scalability and accuracy. Design Evolution Metrics for Defect Prediction Testing is the most widely adopted practice to ensure software quality. However, this activity is often a compromise between the available resources and sought software quality. In object-oriented development, testing effort should be focused on defect-prone classes or alternatively on classes deemed critical based on criteria such as their connectivity or evolution profile. Unfortunately, the identification of defect-prone classes is a challenging and difficult activity on which many metrics, techniques, and models have been tried with mixed success. Following the retrieval of class diagrams’ evolution by our graph matching approach, we proposed and investigated the usefulness of elementary design evolution metrics in the identification of defective classes. The metrics include the numbers of added, deleted, and modified attributes, methods, and relations. They are used to recommend a ranked list of classes likely to contain defects for a system. We evaluated the efficiency of our approach according to three criteria: presence of defects, number of defects, and defect density in the top-ranked classes. We conducted experiments with small to large systems and made comparisons against well known complexity and OO metrics. Results show that the design evolution metrics, when used in conjunction with known metrics, improve the identification of defective classes. In addition, they provide evidence that design evolution metrics make significantly better predictions of defect density than other metrics and, thus, can help in reducing the testing effort by focusing test activity on a reduced volume of code