Not logged in.
Quick Search - Contribution
Contribution Details
| Type | Dissertation |
| Scope | Discipline-based scholarship |
| Title | Fine-grained code changes and bugs: Improving bug prediction |
| Organization Unit | |
| Authors |
|
| Supervisors |
|
| Language |
|
| Institution | University of Zurich |
| Faculty | Faculty of Economics, Business Administration and Information Technology |
| Number of Pages | 219 |
| Date | 2012 |
| Abstract Text | Software development and, in particular, software maintenance are time consuming and require detailed knowledge of the structure and the past development activities of a software system. Limited resources and time constraints make the situation even more difficult. Therefore, a significant amount of research effort has been dedicated to learning software prediction models that allow project members to allocate and spend the limited resources efficiently on the (most) critical parts of their software system. Prominent examples are bug prediction models and change prediction models: Bug prediction models identify the bug-prone modules of a software system that should be tested with care; change prediction models identify modules that change frequently and in combination with other modules, i.e., they are change coupled. By combining statistical methods, data mining approaches, and machine learning techniques software prediction models provide a structured and analytical basis to make decisions.Researchers proposed a wide range of approaches to build effective prediction models that take into account multiple aspects of the software development process. They achieved especially good prediction performance, guiding developers towards those parts of their system where a large share of bugs can be expected. For that, they rely on change data provided by version control systems (VCS). However, due to the fact that current VCS track code changes only on file-level and textual basis most of those approaches suffer from coarse-grained and rather generic change information. More fine-grained change information, for instance, at the level of source code statements, and the type of changes, e.g., whether a method was renamed or a condition expression was changed, are often not taken into account. Therefore, investigating the development process and the evolution of software at a fine-grained change level has recently experienced an increasing attention in research.The key contribution of this thesis is to improve software prediction models by using fine-grained source code changes. Those changes are based on the abstract syntax tree structure of source code and allow us to track code changes at the fine-grained level of individual statements. We show with a series of empirical studies using the change history of open-source projects how prediction models can benefit in terms of prediction performance and prediction granularity from the more detailed change information.First, we compare fine-grained source code changes and code churn, i.e., lines modified, for bug prediction. The results with data from the Eclipse platform show that fine grained-source code changes significantly outperform code churn when classifying source files into bug- and not bug-prone, as well as when predicting the number of bugs in source files. Moreover, these results give more insights about the relation of individual types of code changes, e.g., method declaration changes and bugs. For instance, in our dataset method declaration changes exhibit a stronger correlation with the number of bugs than class declaration changes.Second, we leverage fine-grained source code changes to predict bugs at method-level. This is beneficial as files can grow arbitrarily large. Hence, if bugs are predicted at the level of files a developer needs to manually inspect all methods of a file one by one until a particular bug is located.Third, we build models using source code properties, e.g., complexity, to predict whether a source file will be affected by a certain type of code change. Predicting the type of changes is of practical interest, for instance, in the context of software testing as different change types require different levels of testing: While for small statement changes local unit-tests are mostly sufficient, API changes, e.g., method declaration changes, might require system-wide integration-tests which are more expensive. Hence, knowing (in advance) which types of changes will most likely occur in a source file can help to better plan and develop tests, and, in case of limited resources, prioritize among different types of testing.Finally, to assist developers in bug triaging we compute prediction models based on the attributes of a bug report that can be used to estimate whether a bug will be fixed fast or whether it will take more time for resolution.The results and findings of this thesis give evidence that fine-grained source code changes can improve software prediction models to provide more accurate results. |
| Zusammenfassung | Die Entwicklung und insbesondere die Wartung heutiger Software Systeme sind zeitintensiv und erfordern in hohem Masse detaillierte Kenntnisse über deren innere Struktur sowie über die historischen Änderungen und Designentscheide solcher Systeme. Dieser Umstand wird zusätzlich erschwert durch strenge Zeitvorgaben und limitierte Entwicklungsressourcen. Die Forschung im Bereich der Softwareentwicklung konzentriert sich daher vermehrt auf die Erforschung von Methoden, die einen möglichst effizienten Einsatz der verfügbaren Ressourcen erlauben und die Wartung bestehender Software Systeme als Ganzes vereinfachen und beschleunigen. Bekannte Beispiele für solche Methoden sind Fehler- und Änderungsvorhersagemodelle: Fehlervorhersagemodelle sollen mit möglichst hoher Zuverlässigkeit die fehlerhaften Module einer Software (im Voraus) identifizieren, damit diese eingehend getestet werden können. So können zum Beispiel Testkapazitäten von fehlerfreien Modulen hin zu besonders fehleranfälligen Modulen verlagert werden; Änderungsvorhersagemodelle sollen möglichst genau die Module bestimmen, die mit hoher Frequenz geändert werden müssen. Da Änderungen am Programmcode immer mit Kosten und potentiell mit Fehler verbunden sind, stellen solche Module Kandidaten für Gegenmassnahmen dar, um in Zukunft die Anzahl Änderungen tief zu halten. In der Literatur existieren zahlreiche Ansätze für die Erzeugung solcher Vorhersagemodelle. Die meisten dieser Ansätze verwenden hierfür historische Daten der Entwicklungsgeschichte eines Systems. Diese Daten werden von speziellen Programmen für Versionierung von Programmcode, z.B. CVS, SVN oder Git, zur Verfügung gestellt. Heutige Versionierungsprogramme verwalten Änderungen am Programmcode jedoch nur auf der Ebene von einzelnen Dateien. Des Weiteren wird Programmcode als Text behandelt, und dessen implizite Struktur wird daher weitgehend ignoriert. Bestehende Vorhersagemodelle basieren daher auf relativ groben und generischen Änderungsdaten. Änderungen auf fein granularer Ebene, z.B. auf der Ebene einzelner Instruktionen, sowie der Typ der Änderungen, z.B. wurde die Bedingung einer Schleife angepasst oder der Name einer Methode geändert, werden daher in der Regel nicht berücksichtig für solche Modelle. In jüngster Zeit wurde dieses Defizit erkannt, und die Forschung hat sich vermehrt auf die Analyse von Änderungen am Programmcode auf fein granularer Ebene konzentriert. Ziel der vorliegenden Arbeit ist es, Vorhersagemodelle im Bereich der Softwareentwicklung durch den Einbezug von feinkörniger und strukturbedingter Änderungsinformation zu verbessern. Wir zeigen in einer Reihe von empirischen Studien die Vorteile solcher Modelle an Hand der Entwicklungsgeschichte bekannter Open-Source Systeme. Im ersten Schritt vergleichen wir dazu die Genauigkeit von Vorhersagemodellen basierend auf feinkörniger Änderungsdaten und von solchen, die auf herkömmlichen Änderungsdaten basieren. Die Resultate zeigen, dass unsere Modelle die fehlerhaften Module eines Systems statisch signifikant besser identifizieren können. Zusätzlich können explizit die empirischen Zusammenhänge einzelner Änderungstypen und der Fehleranfälligkeit eines Moduls aufgezeigt werden. In einem zweiten Schritt benutzen wir fein granulare Änderungsdaten, um Fehler auf der Ebene von Methoden anstatt auf der Ebene von Dateien zu identifizieren. Dies hat den Vorteil, dass anstatt ganzer Dateien nur gewisse Methoden inspiziert werden müssen, um einen Fehler zu lokalisieren und zu beheben. Dies insbesondere dann von Nutzen, wenn Dateien, die fehlerhaften Programmcode enthalten, sehr gross werden, da der Suchraum erheblich eingeschränkt wird. Als dritten Schritt bilden wir Modelle, welche es uns erlauben die Typen von Änderungen vorherzusagen. Dies hat zum Beispiel für die Manager eines Software Projektes den Vorteil, dass sie ihre Testvorgänge besser planen können: Sind in erster Linie Änderungen an der Programmschnittstelle zu erwarten, können rechtzeitig genügend Ressourcen für aufwendige Schnittstellen- und Integrationstests mit anderen, abhängigen Modulen eingeplant werden. Kommen jedoch vor allem kleine Änderungen vor, sind in der Regel einfache Unit-Tests ausreichend. Zum Abschluss entwickeln wir Modelle, die den Entwickler beim Beheben von Fehlern in seiner Software unterstützen sollen. Diese Modelle erlauben eine Einschätzung, ob ein bestimmter Fehler länger benötigen wird zur Behebung oder in relativ wenig Zeit behoben werden kann. Die Resultate dieser Arbeit zeigen auf, dass feinkörnige Änderungen sowie die Information über den Typ bestimmter Änderungen Vorhersagemodelle für die Entwicklung von Software Systemen signifikant verbessern können. |
| Other Identification Number | merlin-id:6924 |
| PDF File |
Download from ZORA
|
| Export |
BibTeX
EP3 XML (ZORA)
|