7 research outputs found
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
É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
Evaluating Design Decay during Software Evolution
Les logiciels sont en constante évolution, nécessitant une maintenance et un développement continus. Ils subissent des changements tout au long de leur vie, que ce soit pendant l'ajout de nouvelles fonctionnalités ou la correction de bogues
dans le code. Lorsque ces logiciels évoluent, leurs architectures ont tendance à se dégrader avec le temps et deviennent moins adaptables aux nouvelles spécifications
des utilisateurs. Elles deviennent plus complexes et plus difficiles à maintenir. Dans certains cas, les développeurs préfèrent refaire la conception de ces architectures à partir du zéro plutôt que de prolonger la durée de leurs vies, ce qui engendre une augmentation importante des coûts de développement et de maintenance. Par conséquent, les développeurs doivent comprendre les facteurs qui conduisent à la dégradation des architectures, pour prendre des mesures proactives qui facilitent les futurs changements et ralentissent leur dégradation.
La dégradation des architectures se produit lorsque des développeurs qui ne comprennent pas la conception originale du logiciel apportent des changements au logiciel. D'une part, faire des changements sans comprendre leurs impacts peut conduire à l'introduction de bogues et à la retraite prématurée du logiciel. D'autre part, les développeurs qui manquent de connaissances et–ou d'expérience dans la résolution d'un problème de conception peuvent introduire des défauts de conception. Ces défauts ont pour conséquence de rendre les logiciels plus difficiles à maintenir et évoluer. Par conséquent, les développeurs ont besoin de mécanismes
pour comprendre l'impact d'un changement sur le reste du logiciel et d'outils pour détecter les défauts de conception afin de les corriger. Dans le cadre de cette thèse, nous proposons trois principales contributions.
La première contribution concerne l'évaluation de la dégradation des architectures logicielles. Cette évaluation consiste à utiliser une technique d’appariement de diagrammes, tels que les diagrammes de classes, pour identifier les changements structurels entre plusieurs versions d'une architecture logicielle. Cette étape nécessite l'identification des renommages de classes. Par conséquent, la première étape de
notre approche consiste à identifier les renommages de classes durant l'évolution de l'architecture logicielle. Ensuite, la deuxième étape consiste à faire l'appariement de plusieurs versions d'une architecture pour identifier ses parties stables et celles qui sont en dégradation. Nous proposons des algorithmes de bit-vecteur et de clustering pour analyser la correspondance entre plusieurs versions d'une architecture.
La troisième étape consiste à mesurer la dégradation de l'architecture durant l'évolution du logiciel. Nous proposons un ensemble de m´etriques sur les parties stables du logiciel, pour évaluer cette dégradation. La deuxième contribution est liée à l'analyse de l'impact des changements dans un logiciel. Dans ce contexte, nous présentons une nouvelle métaphore inspirée de la séismologie pour identifier l'impact des changements. Notre approche considère un changement à une classe comme un tremblement de terre qui se propage dans le logiciel à travers une longue chaîne de classes intermédiaires. Notre approche combine l'analyse de dépendances structurelles des classes et l'analyse de leur historique (les relations de co-changement) afin de mesurer l'ampleur de la propagation du changement dans le logiciel, i.e., comment un changement se propage à partir de
la classe modifiée è d'autres classes du logiciel. La troisième contribution concerne la détection des défauts de conception. Nous proposons une métaphore inspirée du système immunitaire naturel. Comme toute créature vivante, la conception de systèmes est exposée aux maladies, qui sont des défauts de conception. Les approches de détection sont des mécanismes de défense pour les conception des systèmes. Un système immunitaire naturel peut détecter des pathogènes similaires avec une bonne précision. Cette bonne précision a inspiré une famille d'algorithmes de classification, appelés systèmes immunitaires artificiels (AIS), que nous utilisions pour détecter les défauts de conception.
Les différentes contributions ont été évaluées sur des logiciels libres orientés objets et les résultats obtenus nous permettent de formuler les conclusions suivantes:
• Les métriques Tunnel Triplets Metric (TTM) et Common Triplets Metric (CTM), fournissent aux développeurs de bons indices sur la dégradation de l'architecture. La d´ecroissance de TTM indique que la conception originale de l'architecture s’est dégradée. La stabilité de TTM indique la stabilité de
la conception originale, ce qui signifie que le système est adapté aux nouvelles spécifications des utilisateurs.
• La séismologie est une métaphore intéressante pour l'analyse de l'impact des changements. En effet, les changements se propagent dans les systèmes comme les tremblements de terre. L'impact d'un changement est plus important autour de la classe qui change et diminue progressivement avec la distance à cette classe. Notre approche aide les développeurs à identifier l'impact d'un changement.
• Le système immunitaire est une métaphore intéressante pour la détection des défauts de conception. Les résultats des expériences ont montré que la précision et le rappel de notre approche sont comparables ou supérieurs à ceux des approches existantes.Software systems evolve, requiring continuous maintenance and development.
They undergo changes throughout their lifetimes as new features are added and
bugs are fixed. As these systems evolved, their designs tend to decay with time and become less adaptable to changing users'requirements. Consequently, software
designs become more complex over time and harder to maintain; in some not-sorare
cases, developers prefer redesigning from scratch rather than prolonging the life of existing designs, which causes development and maintenance costs to rise. Therefore, developers must understand the factors that drive the decay of their designs and take proactive steps that facilitate future changes and slow down decay. Design decay occurs when changes are made on a software system by developers who do not understand its original design. On the one hand, making software changes without understanding their effects may lead to the introduction of bugs
and the premature retirement of the system. On the other hand, when developers lack knowledge and–or experience in solving a design problem, they may introduce design defects, which are conjectured to have a negative impact on the evolution of systems, which leads to design decay. Thus, developers need mechanisms to understand how a change to a system will impact the rest of the system and tools to detect design defects.
In this dissertation, we propose three principal contributions. The first contribution aims to evaluate design decay. Measuring design decay consists of using a diagram matching technique to identify structural changes among versions of a design, such as a class diagram. Finding structural changes occurring in long-lived, evolving designs requires the identification of class renamings. Thus, the first step of our approach concerns the identification of class renamings in evolving designs. Then, the second step requires to match several versions of an evolving design to identify decaying and stable parts of the design. We propose bit-vector and incremental clustering algorithms to match several versions of an evolving design. The third step consists of measuring design decay. We propose a set of metrics to evaluate this design decay. The second contribution is related to change impact analysis. We present a new metaphor inspired from seismology to identify the change impact. In particular, our approach considers changes to a class as an earthquake that propagates through a long chain of intermediary classes. Our approach combines static dependencies between classes and historical co-change relations to measure the scope of change propagation in a system, i.e., how far a change propagation will proceed from a “changed class” to other classes. The third contribution concerns design defect detection. We propose a metaphor inspired from a natural immune system. Like any living creature, designs are subject to diseases, which are design defects. Detection approaches are defense mechanisms if designs. A natural immune system can detect similar pathogens with good precision. This good precision has inspired a family of classification algorithms, artificial Immune Systems (AIS) algorithms, which we use to detect design defects. The three contributions are evaluated on open-source object-oriented systems and the obtained results enable us to draw the following conclusions:
• Design decay metrics, Tunnel Triplets Metric (TTM) and Common Triplets Metric (CTM), provide developers useful insights regarding design decay. If TTM decreases, then the original design decays. If TTM is stable, then the original design is stable, which means that the system is more adapted to the new changing requirements.
• Seismology provides an interesting metaphor for change impact analysis. Changes propagate in systems, like earthquakes. The change impact is most severe near the changed class and drops off away from the changed class. Using external information, we show that our approach helps developers to
locate easily the change impact.
• Immune system provides an interesting metaphor for detecting design defects. The results of the experiments showed that the precision and recall of our approach are comparable or superior to that of previous approaches
Analysing artefacts dependencies to evolving software systems
Les logiciels sont en constante évolution, nécessitant une maintenance et un développement continus. Ils subissent des changements tout au long de leur vie, que ce soit pendant l'ajout de nouvelles fonctionnalités ou la correction de bogues.
Lorsque les logiciels évoluent, leurs architectures ont tendance à se dégrader et deviennent moins adaptables aux nouvelles spécifications des utilisateurs. En effet, les architectures de ces logiciels deviennent plus complexes et plus difficiles à maintenir à cause des nombreuses dépendances entre les artefacts.
Par conséquent, les développeurs doivent comprendre les dépendances entre les artefacts des logiciels
pour prendre des mesures proactives qui facilitent les futurs changements et ralentissent la dégradation des architectures des logiciels.
D'une part, le maintien d'un logiciel sans la compréhension des les dépendances entre ses artefacts peut conduire à l'introduction de défauts.
D'autre part, lorsque les développeurs manquent de connaissances sur l'impact de leurs activités de maintenance, ils peuvent introduire des défauts de conception, qui ont un impact négatif sur l'évolution du logiciel. Ainsi, les développeurs ont besoin de mécanismes pour comprendre comment le changement d'un artefact impacte le reste du logiciel.
Dans cette thèse, nous proposons trois contributions principales :
La spécification de deux nouveaux patrons de changement et leurs utilisations pour fournir aux développeurs des informations utiles concernant les dépendances de co-changement.
La spécification de la relation entre les patrons d'évolutions des artefacts et les fautes.
La découverte de la relation entre les dépendances des anti-patrons et la prédisposition des différentes composantes d'un logiciel aux fautes.Program maintenance accounts for the largest part of the costs of any program.
During maintenance activities, developers implement changes (sometimes simultaneously) on artefacts to fix bugs and to implement new requirements.
Thus, developers need knowledge to identify hidden dependencies among programs artefacts and detect correlated artefacts.
As programs evolved, their designs become more complex over time and harder to
change. In the absence of the necessary knowledge on artefacts dependencies, developers could introduce design defects and faults that causes development and maintenance costs to rise.
Therefore, developers must understand the dependencies among program artefacts
and take proactive steps to facilitate future changes and minimize fault proneness.
On the one hand, maintaining a program without understanding the different
dependencies between their artefacts may lead to the introduction of faults. On the
other hand, when developers lack knowledge about the impact of their maintenance
activities, they may introduce design defects, which have a negative impact on program evolution. Thus, developers need mechanisms to understand how a change to an artefact will impact the rest of the programs artefacts and tools to detect design defects impact.
In this thesis, we propose three principal contributions. The first contribution is two novel change patterns to model new co-change and change propagation scenarios.
We introduce the Asynchrony change pattern, corresponding to macro co-changes, i.e., of files that co-change within a large time interval (change periods), and the Dephase change pattern, corresponding to dephase macro co-changes, i.e., macro co-changes that always happen with the same shifts in time. We present our approach, named Macocha, and we show that such new change patterns provide interesting
information to developers.
The second contribution is proposing a novel approach to analyse the evolution of different classes in object-oriented programs and to link different evolution behaviour
to faults. In particular, we define an evolution model for each class to study the evolution and the co-evolution dependencies among classes and to relate such dependencies with fault-proneness.
The third contribution concerns design defect dependencies impact. We propose
a study to mine the link between design defect dependencies, such as co-change
dependencies and static relationships, and fault proneness.
We found that the negative impact of design defects propagate through their dependencies.
The three contributions are evaluated on open-source programs
Recommended from our members
Mining software repositories to determine the impact of team factors on the structural attributes of software
This thesis was submitted for the award of PhD and was awarded by Brunel University LondonSoftware development is intrinsically a human activity and the role of the development team has been established as among the most decisive of all project success factors. Prior research has proven empirically that team size and stability are linked to stakeholder satisfaction, team productivity and fault-proneness. Team size is usually considered a measure of the number of developers that modify the source code of a project while team stability is typically a function of the cumulative time that each team member has worked with their fellow team members. There is, however, limited research investigating the impact of these factors on software maintainability - a crucial aspect given that up to 80% of development budgets are consumed in the maintenance phase of the lifecycle. This research sheds light on how these aspects of team composition influence the structural attributes of the developed software that, in turn, drive the maintenance costs of software. This thesis asserts that new and broader insights can be gained by measuring these internal attributes of the software rather than the more traditional approach of measuring its external attributes. This can also enable practitioners to measure and monitor key indicators throughout the development lifecycle taking remedial action where appropriate. Within this research the GoogleCode open-source forge is mined and a sample of 1,480 Java projects are selected for further study. Using the Chidamber and Kemerer design metrics suite, the impact of development team size and stability on the internal structural attributes of software is isolated and quantified. Drawing on prior research correlating these internal attributes with external attributes, the impact on maintainability is deduced. This research finds that those structural attributes that have been established to correlate to fault-proneness - coupling, cohesion and modularity - show degradation as team sizes increase or team stability decreases. That degradation in the internal attributes of the software is associated with a deterioration in the sub-attributes of maintainability; changeability, understandability, testability and stability
Studying software evolution of large object-oriented software systems using an ETGM algorithm
Analyzing and understanding the evolution of large object-oriented software systems is an important but difficult task in which matching algorithms play a fundamental role. An error-tolerant graph matching (ETGM) algorithm can identify evolving classes that maintain a stable structure of relations (associations, inheritances, and aggregations) with other classes and thus likely constitute the backbone of the system. Therefore, to study the evolution of class diagrams, we first develop a novel ETGM algorithm, which improves the performance of our previous algorithm. Second, we describe the process of building an oracle to validate the results of our approach to solve the class diagram evolution problem. Third, we report for the new algorithm the impact of its parameters on the F-measure summarizing precision (quantifying the exactness of the solution) and recall (quantifying the completeness of the solution). Finally, with tuned parameters, we carry out and report an extensive empirical evaluation of our algorithm using small (Rhino), medium (Azureus and ArgoUML), and large systems (Mozilla and Eclipse). We thus show that this novel algorithm is scalable, stable and has better time performance than its earlier versio