Die Nutzbarmachung von automatischen Debugging-Ansätzen

Der Prozess der Fehlerkorrektur in Software wird als Debugging bezeichnet. Das Debugging ist ein zeitintensiver Prozess, da selbst kleine Programme aus mehreren tausend Codezeilen bestehen können, die manuell untersucht werden müssen um diejenigen Zeilen zu finden, die für einen beobachteten Fehler (z. B. falsche Berechnungen oder Programmabstürze) verantwortlich sind. Es wird geschätzt, dass Softwareentwickler 30 % bis 90 % ihrer Zeit für das Debuggen verwenden. Somit könnte die Verbesserung des Debugging-Prozesses eine enorme Menge an Geld und Zeit sparen. Viele Forscher haben Ansätze entwickelt, die Softwareentwickler beim Debuggen unterstützen. Leider werden diese Ansätze in der Praxis selten verwendet. Dieses Projekt hat daher das Ziel die Lücke zwischen akademischer Forschung und Debugging in der Praxis zu schließen und besteht aus drei Phasen: Zunächst werden wir die Gründe untersuchen, warum existierende akademische Ansätze in der Praxis selten genutzt werden. Wir werden Softwareentwickler beim Debuggen von Programmen beobachten, um den Status quo des Debuggens in der Praxis zu beurteilen. Solche Beobachtungsstudien sind sehr zeitaufwendig; daher können sie nur für eine kleine Gruppe von Studienteilnehmern durchgeführt werden. Um sicherzustellen, dass unsere Ergebnisse allgemein gültig sind, werden wir zusätzlich eine groß angelegte Online-Umfrage durchführen. Zweitens werden wir die Erkenntnisse aus den Beobachtungsstudien und der Online-Umfrage nutzen, um bestehende Debugging-Ansätze zu verbessern. Dabei konzentrieren wir uns insbesondere auf die Skalierbarkeit, die Genauigkeit und die Praktikabilität der Ansätze: Skalierbarkeit: Die Debugging-Ansätze sollten in der Lage sein große Programme mit mehr als einer Million Codezeilen zu verarbeiten. Genauigkeit: Die Debugging-Ansätze sollten den Softwareentwickler auf die Codezeilen aufmerksam machen, die für einen beobachteten Fehler verantwortlich sind, jedoch nicht auf andere, irrelevante Codezeilen. Praktikabilität: Die Debugging-Ansätze sollten einfach zu verwenden sein. Softwareentwickler sind möglicherweise akademischen Debugging-Ansätzen gegenüber negativ eingestellt, weil sie nicht glauben, dass ein solcher Ansatz ihnen helfen kann. Außerdem wissen sie nicht, welcher Ansatz für ihr Debugging-Problem am besten geeignet ist. Daher werden wir in dieser Projektphase zwei besonders interessante Forschungsfragen beantworten: (1) Kann die Kombination von Debugging-Ansätzen helfen, das Debugging insgesamt zu verbessern? (2) Ist es möglich, die am besten geeignete Debugging-Methode für ein bestimmtes Programm automatisch auszuwählen? Drittens werden wir die Debugging-Ansätze in die Entwicklungsumgebungen und -prozesse integrieren. Ein Debugging-Ansatz, der in die Entwicklungsumgebung und den Prozess des Softwareentwicklers integriert ist, wird eher verwendet als ein eigenständiger Ansatz. Um den Nutzen unserer Entwicklungen zu bewerten, werden wir umfangreiche Experimente durchführen.

Die Fehlerkorrektur in Software wird als Debugging bezeichnet. Debugging ist ein zeitintensiver Prozess, da selbst kleine Programme aus mehreren tausend Codezeilen bestehen können, die manuell untersucht werden müssen um die Code-Zeilen zu finden, die für einen beobachteten Fehler (zB falsche Berechnungen oder Programmabstürze) verantwortlich sind. Es wird geschätzt, dass Softwareentwickler 30 % bis 90 % ihrer Zeit für das Debuggen verwenden. Verbesserungen des Debugging-Prozesses haben daher das Potenzial, Geld und Zeit einzusparen. In einem ersten Schritt haben wir uns mit einer Online-Umfrage an Softwareentwickler gewandt, um zu erfahren, wo die größten Probleme beim Debugging liegen. Diese Umfrage zeigte, dass die meisten Fehler semantische Fehler sind, die Benutzer beispielsweise durch eine falsche Funktionsweise des Programms bemerken. Der Debugging-Prozess folgt oft demselben Muster: Nachstellen des Fehlers (Ausführen einer Abfolge von Schritten, die zum Fehler führen), Beobachtungen machen (Welche Werte haben bestimmte Variablen? Bei welchen Änderungen der Schritt-Abfolge tritt der Fehler nicht mehr auf? ) und Schlussfolgerungen ziehen (zB Fokussierung auf bestimmte Code-Zeilen). Während die Mehrheit der Programmierer angab, dass es einfach ist, Fehler zu reproduzieren, empfinden viele das Auffinden der fehlerhaften Codestelle als schwierig. Desweiteren zeigt die Studie, dass Fehler oft komplex sind und es nicht ausreicht, einzelne Codezeilen zu ändern. Daraus folgt, dass Forscher Werkzeuge zur Fehlerentwicklung entwickeln sollten, die in der Lage sind Fehler, die aus mehreren Code-Zeilen bestehen, zu identifizieren. In einem zweiten Schritt haben wir uns damit beschäftigt, wie wir Softwareentwickler bei dem schwierigsten Teil des Debugging-Prozesses, der Lokalisierung von fehlerhaften Codestellen, unterstützen können. Hierfür haben wir uns auf die Verbesserung von zwei bestehenden Ansätzen fokussiert: Der erste Ansatz (Information retrieval fault localization) arbeitet mit textuellen Beschreibungen von Fehlern, sogenannten Bug reports, und findet mithilfe von künstlicher Intelligenz Code, welcher zu der Fehlerbeschreibung passt. Eine unserer Erweiterungen berechnet zusätzlich den Fehlertyp aufgrund von Wahrscheinlichkeiten. Dieser Ansatz eignet sich für beliebig große Programme (Stichwort Skalierbarkeit). Der zweite Ansatz (Slicing) zielt auf kleinere Programme ab: Softwareentwickler reproduzieren Fehler und das entwickelte Slicing-Werkzeug markiert alle Code-Zeilen, die eine Auswirkung auf den berechneten Fehler haben. Alle Datensätze, alle durchgeführten Evaluierungen sowie sämtlicher im Projekt geschriebener Code sind öffentlich verfügbar (siehe https://amadeus.ist.tugraz.at/).