Die exponentiellen Kosten der Fehlerbehebung in der Softwareentwicklung

Einer der häufigsten Gründe dafür, dass IT-Projekte ihre Budgets überschreiten, sind Softwarefehler. Und das Problem mit Fehlern ist, dass man für sie nie im Voraus bezahlt, sondern normalerweise erst nach dem Schreiben des Codes. Die meisten Fehler kosten am Ende mehr, als es gekostet hätte, sie zu vermeiden. Fehler sind teuer, wenn sie auftreten, und zwar sowohl die direkten Kosten für die Behebung der Fehler als auch die indirekten Kosten aufgrund beschädigter Beziehungen, verlorener Umsätze und verlorener Zeit für Entwicklung.

Die Erkennung und Vermeidung von Fehlern ist eine große Herausforderung in der Softwarebranche. Der größte Teil der Kosten in der Softwareentwicklung entfällt auf die Beseitigung von Fehlern und die Nachbesserung der Software. Die Überarbeitung ist wesentlich kostspieliger als der ursprüngliche Prozess, sodass eine frühzeitige Erkennung von Fehlern unerlässlich ist, um diese zusätzlichen Kosten zu vermeiden. Eine große Zahl von Fehlern tritt in der Regel in der Anfangsphase einer Softwareentwicklung.

Phasen der Softwareentwicklung

Der Lebenszyklus der Softwareentwicklung (engl. Software System Development Lyfe Cycle, kurz SDLC) ist eine Reihe von Schritten, die ein Team von Softwareentwicklern befolgen muss, um Software zu entwickeln und zu pflegen. Ein Softwareentwicklungs-Lebenszyklus beginnt mit der Entscheidung, Software zu entwickeln, und endet, nachdem die Software aus der Nutzung genommen wurde. Der Softwareentwicklungsprozess umfasst 5 Hauptphasen. Jede dieser Phasen umfasst mehrere Schritte.

In welcher Phase des Softwareentwicklungszyklus ist es am kostengünstigsten, Fehler zu erkennen und zu beheben?

In der Softwareentwicklung steigen die Kosten für Erkennung und Behebung von Softwarefehlern mit der Zeit exponentiell an. Die Behebung von Fehlern ist unglaublich kostspielig und riskant. Die Kosten entstehen nicht nur in Form von Zeit und Ressourcen, die in der Gegenwart verschwendet werden, sondern auch in Form von verpassten Chancen in der Zukunft.

Folgende Grafik veranschaulicht, wie der Aufwand für die Erkennung und Behebung von Fehlern zunimmt, wenn die Software die fünf großen Phasen der Softwareentwicklung durchläuft.

Im Folgenden werden die Kosten in der einzelnen Phasen erläutert:

1. Anforderungsanalyse
   Kosten = die Zeit, die für die Neuformulierung der Anforderungen benötigt wird.
   In dieser Phase werden die Anforderungen an der Software erfasst und formuliert. Nach der Analyse wird eine Systemspezifikation erstellt. Da noch keine Software programmiert wurde, können die Änderungen und Korrekturen sehr schnell und ohne großen Aufwand vorgenommen werden.
2. Design / Coding
   Kosten = zusätzlich benötigte Stunden von Entwicklern und anderen Systemingenieuren.
   Der Zeitaufwand ist in der Regel mindestens doppelt so hoch als in der ersten Phase, da das Problem auf einer höheren Ebene auftritt und es notwendig ist, genau herauszufinden, welcher Code oder welche Konfiguration falsch ist.
3. Umsetzung / Component Testing
   Kosten = zusätzlich benötigte Entwickler-, Systemingenieur-, PM- und QS-Stunden.
   Die Qualitätssicherung (QS) ist ein Prozess, bei dem ein Produkt geprüft und überwacht wird, um sicherzustellen, dass das fertige Produkt fehlerfrei funktioniert. Der QS-Tester muss nun in der Lage sein, die Schritte zu reproduzieren und zu dokumentieren, einen Fehler einzureichen, den Fehler zu priorisieren und sich mit den Entwicklern zu besprechen. Sobald der Entwickler den Fehler behoben hat, muss der Code wieder in die Testumgebung integriert werden, wo die Tests erneut durchgeführt werden müssen und der Fehler als behoben verifiziert werden muss.
4. Akzeptanztest
   Kosten = zusätzlich benötigte Entwickler-, Systemtechniker-, PM-, Kunden- und QS-Stunden.
   Ein Akzeptanztest (engl. User Acceptance Testing, kurz UAT) ist eine Testmethode, bei der der Endbenutzer oder der Kunde das Softwaresystem verifiziert/akzeptiert, bevor die Softwareanwendung in die Produktionsumgebung überführt wird. UAT wird in der letzten Testphase durchgeführt, nachdem die Funktions-, Integrations- und Systemtests abgeschlossen sind.
   In dieser Phase muss der Akzeptanztester in der Lage sein, den Fehler dem Systemtester mitzuteilen. Der Systemtester wird versuchen, den Fehler zu reproduzieren, um zu entscheiden, ob es sich um einen Fehler handelt oder ob das System wie vorgesehen funktioniert. Wenn der Systemtester den Fehler nicht reproduzieren kann, informiert er den Benutzer über seine Erkenntnisse. Wenn der Systemtester den Fehler reproduzieren kann, muss er die Schritte dokumentieren, einen Fehler melden, den Fehler priorisieren und sich mit den Entwicklern treffen, um ihn zu besprechen. Der Fehler muss auch im Fehlerverfolgungssystem verfolgt und aktualisiert werden. Der Code muss dann wieder in die UAT-Umgebung eingespielt werden, damit die Benutzertests fortgesetzt werden können.
5. Veröffentlichung / Instandhaltung
   Kosten = Stunden für Entwickler, Support, Systemtechniker, PM, Kunden und QS.
   Normalerweise geht ein Anruf beim Support ein, und dieser entscheidet, ob es sich um einen Fehler handelt oder ob das System wie vorgesehen funktioniert. Der Kunde wird benachrichtigt, der PM wird kontaktiert, und dann wird der Prozess in der UAT-Phase fortgesetzt.

Wenn Fehler in einem frühen Stadium des Softwareentwicklungszyklus erkannt und behoben werden, kann dies zu einer höheren Kapitalrendite (ROI) führen.

Fazit

Die Kosten für die Behebung von Fehlern sind am geringsten, wenn sie in der ersten Phase der Softwareentwicklung entdeckt werden, wenn die Anforderungen erfasst und formuliert werden und eine Systemspezifikation erstellt wird. In späteren Phasen des Softwareentwicklungszyklus steigen sie exponentiell an. Deshalb ist es äußerst wichtig, Fehler möglichst früh zu beheben, um Zeit und Geld zu sparen.

Bildnachweis: Olga_Shestakova.