Bugfix

Bugfix – der beseitige Softwarefehler

Die Beseitigung von Softwarefehlern wird als Bugfixing bezeichnet. Ein Bugfix ist das Ergebnis einer Fehlerbeseitigung, Bugfixing ist die Tätigkeit der Fehlerbehebung. Was in der Theorie relativ leicht klingt, ist in der Praxis der Softwareentwicklung häufig eine Herausforderung.

Bevor eine Fehlerbeseitigung implementiert werden kann, muss ein Bug – der englische Begriff “Bug” bedeutet Fehler – identifiziert und lokalisiert werden. Die Identifikation von Programmfehlern geht oftmals von Anwendern aus, die Lokalisierung hingegen meist vom Support und/oder Entwicklungsteam. Was sind die Auswirkungen und der Schweregrad eines Programmfehlers? Wann tritt der Bug auf, in welchen Anwendungsfällen oder Szenarien, in welcher Häufigkeit und mit welchen Konsequenzen?

Die Priorisierung von Bugfixes

Idealerweise werden die Antworten auf diese Fragen für jeden identifizierten Defect – ein anderes, gebräuchliches Wort für Fehler – schriftlich festgehalten, so dass sie konkret für die Priorisierung des Bugfixings genutzt werden können:

• Niedrig: Der Fehler wird lediglich dokumentiert und erst dann wieder thematisiert, wenn seine Häufigkeit oder sein Schweregrad steigt.
• Mittel: Die Fehlerbeseitigung wird im Zuge der nächsten Planungsrunde – bspw. im Sprint Planning, in der Iterations- oder der Release-Planung – diskutiert und ggf. eingeplant.
• Hoch: Die Fehlerbeseitigung wird direkt in die laufende Iteration bzw. den laufenden Sprint aufgenommen.
• Sehr hoch: Der Fehler ist so elementar, dass die Beseitigung nicht auf das Ende des laufenden Entwicklungsintervalls warten kann. Eine direkte, unmittelbare Lösung ist notwendig. Die Bereitstellung der Fehlerbeseitigung kann als Hotfix erfolgen.

Im Zuge eines Refactorings werden häufig sogenannte Code-Smells entdeckt, also Konstrukte im Code, die zwar funktionieren, aber besser strukturiert werden könnten. Die Beseitigung solcher Code-Smells wird nicht als Bugfixing erachtet. Werden jedoch beim Refactoring tatsächliche Fehler im Code entdeckt und im Anschluss beseitigt, handelt es sich um einen Bugfix.

Wie lange braucht ein Entwickler, um einen Bug zu fixen?

Die Frage lässt sich nicht universell beantworten. Häufig ist aber die Beseitigung des Fehlers nicht die größte Herausforderung; die größte Herausforderung ist die Identifikation der Fehlerursache. Dabei helfen einige Fragen:

• Welcher Nutzer entdeckte den Fehler und welche Handlung löste ihn aus?
• Was war das erwartete Verhalten, was geschah tatsächlich und welche Fehlermeldung erschien?
• In welcher Umgebung (z. B. Betriebssystem, Endgerät) trat der Fehler auf?
• Gibt es es Screenshots, die den Fehler zeigen?
• Und gibt es ggf. Tickets aus der Vergangenheit zu ähnlichen Fehlern?

Eine einfache Regel lautet: Je mehr Aufwand Entwickler in die Beantwortung dieser Fragen stecken müssen, desto länger dauert es, bis das Bugfixing beginnt. Oder anders herum: Je mehr dieser Informationen vorliegen, desto schneller und einfacher können Entwickler den Bug beheben.

Die Dokumentation von Bugfixes

Es ist gelebte Praxis, dass beseitige Fehler nicht nur intern, sondern auch für Anwender dokumentiert werden. Dies kann u.a. in einem separaten Bugfixlog oder in einem Changelog passieren. In den meisten Dokumentationen finden sich auch Hinweise zur Inbetriebnahme der als Patch, Hotfix, Update oder Upgrade zur Verfügung gestellten Fehlerbeseitigung.

Hinweise:

Übrigens: Wir suchen Softwareentwicklerinnen und -entwickler.

Die Inhalte auf dieser Seite dürfen Sie gerne teilen oder verlinken.

Hier finden Sie ergänzende Informationen aus unserem Blog: