Programmfehler oder Softwarefehler oder Software-Anomalie, häufig auch Bug (englisch) genannt, sind Begriffe aus der Softwaretechnik, mit denen für Software-Systemkomponenten Abweichungen zu einem geforderten oder gewünschten Sollzustand bezeichnet werden. Diese können auftreten, wenn z. B. eine bestimmte Festlegung der Spezifikation fehlerhaft ist oder falsch umgesetzt wurde („Fehlhandlung“), und führen zunächst zu einem internen „Fehlerzustand“ im Programm, der wiederum während der Programmausführung zu einem unerwarteten Verhalten oder Ergebnis führt oder führen kann („Fehlerwirkung“).
Zur möglichst vollständigen Erkennung und Behebung von Programmfehlern wird üblicherweise in den Prozessen der Softwareentwicklung, d. h. vor dem tatsächlichen, „produktiven“ Einsatz von Software, die Projektphase „Softwaretest“ durchlaufen, wobei eine Validierung durchgeführt wird. Dabei auftretende Fehler sind üblich und sie zu finden ist Ziel des Testens,[1] während Fehler im laufenden Betrieb je nach Fehlerwirkung u. U. kritische Anomalien/Störungen darstellen. In der Praxis treten Computerprogramme ohne Programmfehler selten auf. Als Qualitätsmerkmal für Programme kennt man u. a. die Fehlerdichte. Sie bezeichnet die Anzahl an Fehlern pro 1.000 Zeilen Code (Kilo Source Lines of Code) bzw. je Function Point.
Als spezielle Instrumente zur Suche nach den Ursachen für Fehler in Programmen sind sogenannte Debugger hilfreich, mit denen ein Programm Schritt für Schritt ausgeführt und kontrolliert werden kann. Bei besonders kritischer Software (z. B. Flugzeugsteuerung) wird mitunter eine (aufwendige) formale Verifikation durchgeführt.
Der Vorgang des Beseitigens eines Programmfehlers wird umgangssprachlich Bugfixing genannt. Das Ergebnis der Verbesserung wird in der Fachsprache als Bugfix,Patch oder Softwarepatch bezeichnet.
„Abweichung des IST (beobachtete, ermittelte, berechnete Zustände oder Vorgänge) vom SOLL (festgelegte, korrekte Zustände und Vorgänge), wenn sie die vordefinierte Toleranzgrenze [die auch 0 sein kann] überschreitet.“
Nach ISTQB[3] bildet sich der Begriff 'Fehler' aus den folgenden Zusammenhängen:
eine Fehlhandlung (englisch Error)
„die menschliche Handlung, die zu einem Fehlerzustand führt ([nach IEEE 610])“
… führt zu einem Fehlerzustand (engl. Defect)
„Defekt (innerer Fehlerzustand) in einer Komponente oder einem System, der eine geforderte Funktion des Produktes beeinträchtigen kann …“
der eine Fehlerwirkung (engl. Failure) nach sich ziehen kann
„Die Manifestierung eines inneren Fehlers bei der Ausführung [des Programms] als ein inkorrektes Verhalten oder Resultat bzw. als Versagen des Systems.“
Beispiel Division durch null: Fehlhandlung: Null als möglicher Divisor wurde nicht geprüft/ausgeschlossen; Fehlerzustand: Das Programm ist (ggf. unbemerkt) fehlerhaft; Fehlerwirkung: Bei Auftreten eines Nullwerts als Divisor tritt während der Ausführung des Befehls ein Laufzeitfehler auf.
Als Synonym für „Fehler“ oder ergänzend dazu sind auch Ausdrücke wie Problem, Defekt, Abweichung, Anomalie, Mangel gebräuchlich. Damit kann die „Fehlerschwere“ auch begrifflich unterschieden werden, z. B. die Verletzung von Vorschriften zum Programmierstil, die Lieferung falscher Ergebnisse oder ein Programmabbruch.
Logbuch-Seite des Mark II Aiken Relay Calculator mit dem ersten bug (1947)
Das Wort bug bedeutet im Englischen „Schnabelkerf; Wanze“ und umgangssprachlich „landlebender Gliederfüßer“ oder „(insektenartiges) Ungeziefer“.[4] Im Jargon amerikanischer Ingenieure ist seit dem späten 19. Jahrhundert die Bedeutung „Fehlfunktion“ oder auch „Konstruktionsfehler“ bezeugt; diesem Wortgebrauch liegt die (scherzhafte) Vorstellung zugrunde, dass sich kleines Krabbelvieh am Getriebe, der Leitung usw. zu schaffen macht. Die ältesten Belege sind zwei Briefe Thomas Edisons aus dem Jahr 1878 an William Orton, den Präsidenten der Telegraphiegesellschaft Western Union, bzw. Tivadar Puskás, den Erfinder der Telefonzentrale, in denen es heißt:
“[…] I did find a ‘bug’ in my apparatus, but it was not in the telephone proper. It was of the genus ‘callbellum.’[5]”
„[…] Ich fand in der Tat einen ‚Bug‘ in meinem Apparat, allerdings nicht im Telefon selbst. Er war von der Gattung ‚callbellum‘.“
– Thomas Edison in einem Brief an William Orton, datiert auf den 3. März 1878[6]
sowie
“The first step [in all of my inventions] is an intuition, and comes with a burst, then difficulties arise – this thing gives out and [it is] then that ‘Bugs’ – as such little faults and difficulties are called – show themselves […].”
„Der erste Schritt [bei all meinen Erfindungen] ist ein intuitiver Gedanke, der in einem Ausbruch kommt, doch dann tauchen Schwierigkeiten auf – das Ding funktioniert nicht mehr und [es ist] dann, dass ‚Bugs‘ – wie solche kleinen Fehler und Schwierigkeiten genannt werden – sich zeigen […].“
– Thomas Edison in einem Brief an Tivadar Puskás, datiert auf den 18. November 1878
Edison ist zwar nicht Erfinder, aber immerhin Kronzeuge für eine schon damals kursierende Bedeutung des Wortes. Die Verknüpfung des Begriffs mit Computern geht möglicherweise auf die Computerpionierin Grace Hopper zurück. Sie verbreitete die Geschichte, dass am 9. September 1945 eine Motte in einem Relais des Computers Mark II Aiken Relay Calculator zu einer Fehlfunktion führte. Die Motte wurde entfernt, in das Logbuch geklebt und mit folgender Notiz versehen: “First actual case of bug being found.” (deutsch: „Das erste Mal, dass tatsächlich ein ‚Ungeziefer‘ gefunden wurde.“). Die Legende der Begriffsfindung hält sich hartnäckig, obwohl die Logbuch-Eintragung gerade darauf verweist, dass der Begriff schon zuvor gängig war. Zudem irrte Grace Hopper sich hinsichtlich des Jahres: Der Vorfall ereignete sich tatsächlich am 9. September 1947. Die entsprechende Seite des Logbuchs wurde bis Anfang der 1990er Jahre am Naval Surface Warfare Center Computer Museum der US-Marine in Dahlgren, Virginia, aufbewahrt. Zurzeit befindet sich diese Logbuchseite mit der Motte am Smithsonian Institute.[7]
In der Softwaretechnik (siehe auch[8]) wird zwischen folgenden Typen von Fehlern in Programmen unterschieden:
Lexikalische Fehler sind nicht interpretierbare Zeichenketten, also undefinierte Bezeichner (Variablen, Funktionen, Literale...)
Syntaxfehler sind Verstöße gegen die grammatischen Regeln der benutzten Programmiersprache, zum Beispiel die falsche Verwendung reservierter Symbole (z. B. fehlende Klammern), Typkonflikte, falsche Anzahl Parameter.
Lexikalische und Syntaxfehler verhindern in der Regel die Kompilierung des fehlerhaften Programms und werden daher frühzeitig erkannt. Bei Programmiersprachen, die sequentiell interpretiert werden, bricht das Programm üblicherweise erst an der syntaktisch/lexikalisch fehlerhaften Stelle ab.
Semantische Fehler sind Fehler, in denen eine programmierte Anweisung zwar syntaktisch fehlerfrei, aber inhaltlich trotzdem fehlerhaft ist, zum Beispiel Verwechslung des Befehlscodes, syntaktisch nicht erkennbare falsche Parameterreihenfolge.
Logische Fehler bestehen in einem im Detail falschen Problemlösungsansatz, beispielsweise auf Grund eines Fehlschlusses, einer falsch interpretierten Spezifikation oder einfach eines Versehens oder Schreibfehlers. Beispiele: plus statt minus, kleiner statt kleiner/gleich usw. Die Toleranz gegenüber solchen Fehlern und die diese einschränken sollende Attributgrammatik von Programmiersprachen, wie etwa bei der Zuweisungskompatibilität von Datentypen, sind je nach verwendeter Programmiersprache sehr unterschiedlich ausgeprägt und können schwierig zu überschauende Sicherheitslücken und Programmabstürze verursachen.
Designfehler sind Fehler im Grundkonzept, entweder bei der Definition der Anforderungen an die Software, oder bei der Entwicklung des Softwaredesigns, auf dessen Grundlage das Programm entwickelt wird. Fehler bei der Anforderungsdefinition beruhen oft auf mangelnder Kenntnis des Fachgebietes, für das die Software geschrieben wird oder auf Missverständnissen zwischen Nutzern und Entwicklern. Fehler direkt im Softwaredesign hingegen sind oft auf mangelnde Erfahrung der Softwareentwickler, unstrukturierte Programmierung oder auf Folgefehler durch Fehler in der Anforderungsspezifikation zurückzuführen. In anderen Fällen ist das Design historisch gewachsen und wird mit der Zeit unübersichtlich, was wiederum zu Designfehlern bei Weiterentwicklungen des Programms führen kann. Oftmals wird ohne Vorliegen eines richtigen Konzepts direkt programmiert, was dann insbesondere bei höherem Komplexitätsgrad der Software zu Designfehlern führen kann. Sowohl für Fehler in der Anforderungsdefinition als auch im Softwaredesign kommen darüber hinaus vielfach Kosten- oder Zeitdruck in Frage. Ein typischer Designfehler ist die Codewiederholung, die zwar nicht unmittelbar zu Programmfehlern führt, aber bei der Softwarewartung, der Modifikation oder der Erweiterung von Programmcode sehr leicht übersehen werden kann und dann unweigerlich zu unerwünschten Effekten führt.
Fehler im Bedienkonzept. Das Programm verhält sich anders als es einzelne oder viele Anwender erwarten, obwohl es technisch an sich fehlerfrei arbeitet.
Sonstige Fehlerbegriffe
Laufzeitfehler: Während die vorgenannten Fehler ein tatsächlich fehlerhaftes Programm bedeuten, das entweder nicht ausführbar ist oder fehlerhafte Ergebnisse liefert, kann auch ein „korrektes“ Programm bei seiner Ausführung zu Fehlern führen. Laufzeitfehler sind alle Arten von Fehlern, die auftreten, während das Programm abgearbeitet wird. Je nach Situation kann die Ursache beispielsweise eine unpassenden Programmumgebung sein (z. B. eine falsche Betriebssystem-Version, falsche Parameter beim Aufruf des Programms (auch als Unterprogramm), falsche Eingabedaten etc.)
Laufzeitfehler können sich auf die unterschiedlichsten Arten zeigen. Oftmals zeigt das Programm ungewünschtes Verhalten, im Extremfall wird die Ausführung des Programms abgebrochen („Absturz“), oder das Programm geht in einen Zustand über, in dem es keine Benutzereingaben mehr akzeptiert („Einfrieren“, „Hängen“). Auswirkungsbeispiel eines Programmfehlers Wird in Programmiersprachen ohne automatische Speicherbereinigung (etwa C oder C++) Speicher nach der Verwendung nicht mehr freigegeben, so wird durch das Programm auf Dauer immer mehr Speicher belegt. Diese Situation wird Speicherleck genannt. Aber auch in Programmiersprachen mit automatischer Speicherbereinigung (etwa Java oder C#) können ähnliche Probleme auftreten, wenn zum Beispiel Objekte durch systemnahe Programmierung unkontrolliert angesammelt werden. Noch kritischer sind versehentlich vom Programmierer freigegebene Speicherbereiche, die oft trotzdem noch durch hängende Zeiger referenziert werden, da dies zu völlig unkontrolliertem Verhalten der Software führen kann. Manche Laufzeitumgebungen erlauben daher solche programmierbaren Speicherfreigaben grundsätzlich nicht. Des Weiteren gibt es auch Bugs im Zusammenspiel mit anderen Programmen.
Fehler im Compiler, der Laufzeitumgebung oder sonstigen Bibliotheken. Solche Fehler sind meist besonders schwer nachzuvollziehen, da das Verhalten des Programms in solchen Fällen nicht seiner Semantik entspricht. Insbesondere von Compiler und Laufzeitumgebung wird daher besondere Zuverlässigkeit erwartet.
Ein Regressionsbug (Regression bedeutet „Rückschritt“) ist ein Fehler, der erst in einer späteren Programmversion auftaucht. Dies sind häufig unerkannte Nebeneffekte von Fehlerbehebungen oder Programmänderungen an anderer Stelle.
Fehler als Folge physikalischer Betriebsbedingungen. Verschiedenste Begebenheiten wie elektromagnetische Felder, Strahlen, Temperaturschwankungen, Erschütterungen usw. können auch bei sonst einwandfrei konfigurierten und innerhalb der Spezifikationen betriebenen Systemen zu Fehlern führen. Fehler dieses Typs sind sehr unwahrscheinlich, können nur sehr schwer festgestellt werden und haben bei Echtzeitanwendungen unter Umständen fatale Folgen. Sie dürfen aber aus statistischen Gründen nicht ausgeschlossen werden. Das berühmte „Umfallen eines Bits“ im Speicher oder auf der Festplatte auf Grund der beschriebenen Einflüsse stellt zum Beispiel solch einen Fehler dar. Da die Auswirkungen eines solchen Fehlers (z. B. Absturz des Systems oder Boot-Unfähigkeit, weil eine Systemdatei beschädigt wurde) von denen anderer Programmfehler meist nur sehr schwer unterschieden werden können, vermutet man oft eine andere Ursache, zumal ein solcher Fehler häufig nicht reproduzierbar ist.
Programmfehler vs. Softwarefehler: Soweit diese beiden Bezeichnungen nicht als Synonyme verstanden werden, kann – entsprechend dem Bedeutungsunterschied zwischen Computerprogramm und Software – auch für ‚Softwarefehler‘ eine breitere Definition zutreffen: Danach wären etwa auch Fehler oder Mängel in der Dokumentation Softwarefehler, unabhängig davon, ob sie zu fehlerhaften Programmen führten. Auch dürften fehlerhafte Daten (auch dieser Begriff wird je nach Definition der Software zugerechnet) kaum als Programm-, sondern, wenn überhaupt, höchstens als Softwarefehler gelten.
Technische Schulden und Qualitätsmängel: Gemäß ISO 9000 ist ein Fehler die „Nichterfüllung einer Anforderung“. Anforderungen wiederum werden definiert als „Erfordernis oder Erwartung, das oder die festgelegt, üblicherweise vorausgesetzt oder verpflichtend ist“.[2] Dazu gehört auch das Nichtvorhandensein von technischen Schulden oder sonstigen Qualitätsmängeln.
Bei manchen Projekten wird nicht der Begriff Bug verwendet, sondern man spricht zum Beispiel von Metabugs, bei denen ein Bug ein Element einer Aufgabenliste darstellt. Bei einigen Projekten spricht man stattdessen auch von „Issues“ (Angelegenheiten), da sich dieser Ausdruck nicht auf Programmfehler beschränkt.
Softwarefehler sind weit mehr als nur ärgerliche Begleitumstände für Softwareentwickler, sondern sie verursachen aus betriebswirtschaftlicher und ökonomischer Sicht erhebliche Kosten. Die IX-Studie 1/2006[9] zeigte z. B. folgende für Deutschland ermittelte Werte:
Ca. 84,4 Mrd. Euro betragen die jährlichen Verluste durch Softwarefehler in Mittelstands- und Großunternehmen
Ca. 14,4 Mrd. Euro jährlich (35,9 % des IT-Budgets) werden für die Beseitigung von Programmfehlern verwendet;
Ca. 70 Mrd. Euro betragen die Produktivitätsverluste durch Computerausfälle aufgrund fehlerhafter Software
In derselben Studie wird auch die Entwicklung der Softwarequalität für die Zeit von 2002 bis 2004 untersucht – mit dem Ergebnis:
die Quote gescheiterter Projekte stieg von 15 % auf 18 %
die Quote erfolgreicher Projekte sank von 34 % auf 29 %
die Quote der Projekte mit Kostenüberschreitung stieg von 43 % auf 56 %
die Quote der Projekte mit Terminüberschreitung stieg von 82 % auf 84 %
die Quote der Projekte mit passender Funktionalität sank von 67 % auf 64 %
Für die USA werden die Kosten von Programmierfehlern 2022 auf 2,41 Billionen Dollar geschätzt, davon 1,81 Billionen für Fehler im Betrieb, 607 Milliarden für die Fehlersuche und -behebung und 260 Milliarden für fehlerbedingte Projektabbrüche.[10]
Besonders viele Misserfolge zeigt ein Bericht des obersten Rechnungshofs für neue Projekte (1985) bei der US-Bundesverwaltung,[11] wonach
27 % der bezahlten Software nie geliefert wurden,
52 % nie funktionierten,
18 % erst nach einer aufwändigen Sanierung zum Einsatz kamen.
Lediglich 3 % der in Auftrag gegebenen Software erfüllten die vereinbarten Vertragsbedingungen.
Die Standish Group International stellte fest:[12] Durchschnittlich überschreiten Projekte
die ursprünglich geplanten Projektkosten um 89 %
die geplanten Termine um 222 %.
Als Gründe für Projektabbrüche aufgrund schlechter Softwarequalität ermittelte Ewusi-Menach folgende Faktoren:[11]
Unklare Zielsetzung
Falsche Projektteambesetzung
Unzulängliche Qualitätssicherung
Fehlendes technisches Know-how
Unzureichende Berücksichtigung der Ausgangssituation
Mangelnde Beteiligung der Anwender
Die Kosten für Debugging und Beseitigung bei in späteren Projektphasen bzw. in Produktion gefundenen Fehlern übersteigen üblicherweise die Kosten für das Verhindern und Finden von Fehlern.[13] Studien belegen daher, dass es oft günstiger ist, qualitativ hochwertige Software zu entwickeln, als qualitativ minderwertige.[14]
Vermeidung, Auffindung und Behebung von Programmfehlern
Generell gilt:[15]Je früher im Entwicklungsprozess der Fehler auftritt und je später er entdeckt wird, umso aufwändiger wird es, den Fehler zu beheben.
Im Schnitt rechnet man mit Kosten von 16.000 Dollar je in Produktion gefundenem Bug, während die Kosten für das Verhindern von Fehlern während der Designphase bei 25 Dollar liegen.[16]
Am wichtigsten ist eine gute und geeignete Planung des Entwicklungsprozesses. Hierfür gibt es bereits etliche Vorgehensmodelle, aus denen ein geeignetes ausgewählt werden kann.
Ein Problem ist, dass die Korrektheit eines Programms nur gegen eine entsprechend formalisierte Spezifikation bewiesen werden kann. Eine solche Spezifikation zu erstellen kann jedoch im Einzelfall ähnlich kompliziert und fehlerträchtig sein, wie die Programmierung des Programms selbst.
Softwareexperten sind sich darüber einig, dass praktisch jedes nicht-triviale Programm Fehler enthält. Deshalb wurden Techniken entwickelt, mit Fehlern innerhalb von Programmen tolerant umzugehen. Zu diesen Techniken gehören defensives Programmieren, Ausnahmebehandlung, Redundanz und die Überwachung von Programmen (z. B. durch Watchdog-Timer) sowie die Plausibilisierung des Programmes während der Entwicklung und der Daten während des Programmablaufs.
Ferner ist es sehr nützlich, von den Entwicklungswerkzeugen möglichst viele Aufgaben der Fehlervermeidung zuverlässig und automatisch erledigen zu lassen, was z. B. mit Hilfe von strukturierter Programmierung erleichtert wird. Dies betrifft zum einen bereits Kontrollen wie Sichtbarkeitsregeln und Typsicherheit, sowie die Vermeidung von Zirkelbezügen, die bereits vor der Übersetzung von Programmen vom Compiler übernommen werden können, aber auch Kontrollen, die erst zur Laufzeit durchgeführt werden können, wie zum Beispiel Indexprüfung bei Datenfeldern oder Typprüfung bei Objekten der objektorientierten Programmierung.
Darüber hinaus wird eine Reihe fortgeschrittener Anwendungen angeboten, die entweder den Quellcode oder den Binärcode analysieren und versuchen, häufig gemachte Fehler automatisiert zu finden. In diese Kategorie fallen etwa Programme zur Ausführungsüberwachung, die üblicherweise fehlerhafte Speicherzugriffe und Speicherlecks zuverlässig aufspüren. Beispiele sind das frei erhältliche Tool Valgrind und das kommerzielle Purify. Eine weitere Kategorie von Prüfprogrammen umfasst Anwendungen, die Quell- oder Binärcode statisch analysieren und etwa nicht geschlossene Ressourcen und andere Probleme auffinden und melden können. Darunter fallen etwa FindBugs, Lint und Splint.
Es ist durchaus sinnvoll, dass der Test vor dem eigentlichen Programm entwickelt wird. Damit wird erreicht, dass nicht ein Test geschrieben wird, der zu dem bereits geschriebenen Programm passt. Dies kann durch Ermittlung von Testfällen anhand der Spezifikation bereits während der Analyse- bzw. Designphase erfolgen. Die Ermittlung von Testfällen in diesem frühen Stadium der Softwareentwicklung ermöglicht zudem die Prüfung der Anforderungen an das Programm auf Testbarkeit und Vollständigkeit. Die anhand der Spezifikation ermittelten Testfälle sind die Basis für die Abnahmetests – die kontinuierlich über den gesamten Entwicklungsprozess verfeinert und z. B. für eine Testautomatisierung vorbereitet werden können.
Manche Softwareanbieter führen Testphasen teilweise öffentlich durch und geben Betaversionen heraus, um die unvorhersehbar vielfältigen Nutzungsbedingungen verschiedener Anwender durch diese selbst testen und kommentieren zu lassen.
Tritt ein Fehler während des Betriebs auf, so muss versucht werden, seine Auswirkungen möglichst gering zu halten und seinen Wirkungskreis durch Schaffung von „Schutzwällen“ oder „Sicherungen“ einzudämmen. Dies erfordert zum einen Möglichkeiten der Fehlererkennung und zum anderen, adäquat auf einen Fehler reagieren zu können.
Ein Beispiel zur Fehlererkennung zur Laufzeit eines Computerprogrammes sind Assertions, mit deren Hilfe Bedingungen abgefragt werden, die gemäß Programmdesign immer erfüllt sind. Weitere Mechanismen sind Ausnahmebehandlungen wie Trap und Exception.
Durch die Implementierung von Proof-Carrying Code kann die Software zur Laufzeit ihre Zuverlässigkeit in gewissem Rahmen gewährleisten und sicherstellen.
Völlige Fehlerfreiheit für Software, die eine gewisse Komplexitätsgrenze überschreitet, ist praktisch weder erreich- noch nachweisbar. Mit steigender Komplexität sinkt die Überblickbarkeit, insbesondere auch, wenn mehrere Personen an der Programmierung beteiligt sind. Selbst teure oder vielfach getestete Software enthält Programmierfehler. Man spricht dann bei gut brauchbaren Programmen nicht von Fehlerfreiheit, sondern von Robustheit. Eine Software gilt dann als robust, wenn Fehler nur sehr selten auftreten und diese dann nur kleinere Unannehmlichkeiten mit sich bringen und keine größeren Schäden oder Verluste verursachen.
In Spezialfällen ist ein Beweis der Fehlerfreiheit (bzgl. der festgelegten Anforderungen) eines Programms möglich. Insbesondere in Bereichen, in denen der Einsatz von Software mit hohen finanziellen, wirtschaftlichen oder menschlichen Risiken verbunden ist, wie z. B. bei militärisch oder medizinisch genutzter Software oder in der Luft- und Raumfahrt, verwendet man zudem eine „(formale) Verifizierung“ genannte Methode, bei der die Korrektheit einer Software formal-mathematisch nachgewiesen wird. Dieser Methode sind allerdings wegen des enormen Aufwands enge Grenzen gesetzt und sie ist daher bei komplexen Programmen praktisch unmöglich durchzuführen (siehe auch Berechenbarkeit). Allerdings gibt es mittlerweile Werkzeuge, die diesen Nachweis laut eigenen Angaben zumindest für Teilbereiche (Laufzeitfehler) schnell und zuverlässig erbringen können.
Neben der mathematischen Verifizierung gibt es noch eine praxistaugliche Form der Verifizierung, die durch die Qualitätsmanagement-Norm ISO 9000 beschrieben wird. Bei ihr wird formal nur dann ein Fehler konstatiert, wenn eine Anforderung nicht erfüllt ist. Umgekehrt kann demnach ein Arbeitsergebnis (und damit auch Software) als ‚fehlerfrei‘ bezeichnet werden, wenn es nachweisbar alle Anforderungen erfüllt. Die Erfüllung einer Anforderung wird dabei durch Tests festgestellt. Bringen alle zu einer Anforderung definierten Tests die erwarteten Ergebnisse, so ist die Anforderung erfüllt. Gilt dies für die Tests aller Anforderungen (korrektes und vollständiges Testen vorausgesetzt), so wird „fehlerfrei bzgl. der Anforderungen“ gefolgert. Sind die den Tests zugrundeliegenden Anforderungen fehlerhaft oder unvollständig, so arbeitet die Software dementsprechend dennoch nicht „wie gewünscht“.
Aufgetretene Fehler werden im Allgemeinen im Fehlermanagement systematisch bearbeitet. Nach der IEEE-Norm 1044 (Klassifizierung von Softwareanomalien) durchläuft dabei jeder Fehler einen sogenannten Klassifizierungsprozess, bestehend aus den vier Schritten Erkennung (Recognition), Analyse (Investigation), Bearbeitung (Action) und Abschluss (Disposition).[17] In jedem dieser Schritte werden die Verwaltungsaktivitäten Aufzeichnen (Recording), Klassifizieren (Classifying), Wirkung identifizieren (Identifying Impact) ausgeführt.[18]
Kriterien, nach denen Fehler dabei klassifiziert werden können, sind u. a. (mit Beispielen):
die Art des Fehlers: Nach[8] werden dabei unterschieden: Lexikalische Fehler (unbekannter Bezug), syntaktische Fehler (vergessenes Semikolon), semantische Fehler (falsche Deklaration), Laufzeitfehler (falsch formatierte Eingabedaten) und logische Fehler (plus statt minus, Schleifenfehler, …)
die Fehlerursache: unpräzise Vorgabe, Zahlendreher, falsche Formel, nicht geprüfte (falsche) Eingabedaten …
der Zeitpunkt der Fehlerentstehung (‚Fehlhandlung‘): Bereits bei der Programmvorgabe, im Codeentwurf, beim Codieren, …
der Zeitpunkt des Fehlerauftretens (‚Fehlerwirkung‘): Ein grundsätzlicher Unterschied ergibt sich daraus, ob der Fehler während der Programmentwicklung auftritt, zum Beispiel beim Testen (hier ist dies ein Normalfall[1]) oder im produktiven Betrieb (wo er häufig eine kritische Störung darstellt).
der Zeitpunkt der Entdeckung: Je länger die „Fehlerverweilzeit“ ist, desto aufwändiger wird i. A. die Korrekturmaßnahme verlaufen.
die Reproduzierbarkeit des Fehlers: Je schwieriger ein Fehler reproduzierbar ist, desto aufwändiger wird i. A. die Korrekturmaßnahme verlaufen.
die Auswirkung(en) des Fehlers: Darstellungsfehler, falsches Ergebnis, Programmabbruch, Außenwirkung …
Aufwand und Dauer zur Fehlerbehebung: minimal … sehr hoch; sofort … sehr lange Dauer;
Bearbeitungsstatus: aufgetreten, untersucht, Korrekturauftrag in Bearbeitung, Retest möglich, …, erledigt
Mit Hilfe von Metriken „sollten die Ergebnisse [und Erkenntnisse über Fehler] auch Anlass zur Suche nach den Ursachen hinter den Problemen sein“.[1] „Fehlerklassifikationen bilden die Grundlage für standardisierte Verfahren zur Fehlerbehandlung und unterstützen zudem eine kontinuierliche Qualitätsverbesserung im Sinne des Qualitätsmanagements.“[19] Weitere Angaben je Fehler wie eine ausführliche Fehlerbeschreibung, betroffene Programme, beteiligte Personen etc. begleiten die Maßnahmen zur Behebung der Fehler und dokumentieren diese. Näheres siehe BITKOM-Leitfaden.[19]
Vereinfachend werden Programmfehler im Fehlerbearbeitungsprozess häufig nur nach der Fehlerschwere, das schließt außerdem die Fehlerwirkung und den Behebungsaufwand ein, in Kategorien/Klassen wie A, B, C, … oder 1, 2, 3, … usw. eingeteilt. Beispiele siehe BITKOM-Leitfaden,[19] insbesondere im Anhang.
Die Folgen von Programmfehlern können hochgradig unterschiedlich sein und sich in vielfältiger Weise zeigen. Werden Fehler im Rahmen der Entwicklungsprozesse entdeckt, so beschränken sich die Fehlerfolgen außerdem auf die Überarbeitung der Software (Codekorrekturen, Konzeptüberarbeitung, Dokumentation …) – je nach Situation mit mehr oder weniger großen Auswirkung auf das Projektbudget und die Projektdauer. Dagegen wirken erst im Produktivbetrieb erkannte Fehler nicht selten ungleich kritischer, zum Beispiel können sie Prozess-Störungen oder Produktionsstillstand bewirken, Imageschäden hervorrufen, den Verlust von Kunden und Märkten verursachen, Regresspflichten auslösen oder gar das Unternehmen in Existenzgefahr bringen. Fehler in technischen Anwendungen können im schlimmsten Fall zu Katastrophen führen.
Manche Programmfehler sind nur äußerst schwer oder gar nicht zuverlässig reproduzierbar. Bei der Wiederholung eines zuvor gescheiterten Vorgangs unter scheinbar unveränderten Bedingungen ist die Wahrscheinlichkeit gegeben, dass sich diese Fehler nicht erneut äußern. Es gibt zwei mögliche Gründe für dieses Verhalten: Zum einen kann es zu Verzögerungen zwischen der Fehleraktivierung und dem letztlich auftretenden Problem beispielsweise einem Programmabsturz kommen, welche die tatsächliche Ursache verschleiern und deren Identifikation erschweren. Zum anderen können andere Elemente des Softwaresystems (Hardware, Betriebssystem, andere Programme) das Verhalten der Fehler in dem betrachteten Programm beeinflussen. Ein Beispiel hierfür sind Fehler, die in nebenläufigen Umgebungen mit mangelnder Synchronisation (genauer: Sequentialisierung) auftreten. Wegen der hieraus folgenden Wettlaufsituationen(Race Conditions) können die Prozesse in einer Reihenfolge abgearbeitet werden, welche zu einem Laufzeitfehler führt. Bei einer Wiederholung der gleichen Aktion ist es möglich, dass die Reihenfolge der Prozesse unterschiedlich ist und kein Problem auftritt.
Die Reproduzierbarkeit eines Programmfehlers lässt sich anhand dessen Beobachtungsgüte in Kategorien/Klassen wie A, B, C ... oder 1, 2, 3 ... usw. einteilen. Die Beobachtungsstufe eines Fehler kann sich über die Nutzungszeit der Software verändern, so kann sich bspw. ein nicht reproduzierbarer Fehler zu einem eindeutig reproduzierbaren Fehler entwickeln. Bei nicht ohne weiteres reproduzierbaren Fehlern, welche aber wiederholt aufgetreten sind, können Experten zur Ursachensuche hinzugezogen werden.
A: Eindeutig festgestellter Fehler, welcher mit Belegen jederzeit reproduziert werden kann.
B: Nicht ohne weiteres reproduzierbarer Fehler, welcher aber nachweislich wiederholt aufgetreten ist.
C: Nicht reproduzierbarer und nicht nachweislich wiederholt aufgetretener Fehler.
Zum Prinzip, noch „unreife“ Software auszuliefern, siehe Bananenware.
Software, die (oft kostenlos angeboten) z. B. Mängel in der Sicherheit, der Übersichtlichkeit oder ihrer nutzbaren Funktionalität aufweist; siehe Crapware
William E. Perry: Software Testen. Mitp-Verlag, Bonn 2002, ISBN 3-8266-0887-9.
Elfriede Dustin, Jeff Rashka, John Paul: Software automatisch testen. Verfahren, Handhabung und Leistung. Springer, Berlin u. a. 2001, ISBN 3-540-67639-2.
Cem Kaner, Jack Falk, Hung Quoc Nguyen: Testing Computer Software. 2nd edition. John Wiley & Sons, New York NY u. a. 1999, ISBN 0-471-35846-0.
↑ abcM. Pol, T. Koomen, A. Spillner: Management und Optimierung des Testprozesses. dpunkt.Verlag, Heidelberg 2002, ISBN 3-89864-156-2.
↑ abDIN-Normenausschuss Qualitätsmanagement, Statistik und Zertifizierungsgrundlagen (NQSZ): DIN EN ISO 9000. Qualitätsmanagementsysteme - Grundlagen und Begriffe. Hrsg.: DIN Deutsches Institut für Normung e. V. Beuth Verlag GmbH, Berlin November 2015, 3.6.9, S.40 (104 S.).
↑Merriam-Webster Unabridged Dictionary (iOS-App, 2016): bug: a) an insect or other creeping or crawling invertebrate … b) any of certain insects commonly considered especially obnoxious … c) an insect of the order Hemiptera, especially: a member of the suborder Heteroptera …
↑ein Wortspiel eines scheinbar lateinischen Gattungsnamens aus call (Anruf[en]) und Bellum (Akkusativ zu Bell)
↑Paul B. Israel (Hrsg.): The Papers of Thomas A. Edison. Vol. 4, Baltimore and London, 1993 (Online).
↑Fred R. Shapiro: Etymology of the Computer Bug: History and Folklore. In: American Speech. Band 62, Nr. 4, 1987, S. 376–378.
↑Herbert Krasner: The Cost of Poor Software Quality in the US. A 2022 Report - From Problem to Solutions. Hrsg.: Consortium for Information & Software Quality. 15. Dezember 2022, S.3–4 (englisch, 61 S., it-cisq.org [PDF; abgerufen am 25. September 2024]).
↑Junginger: Wertorientierte Steuerung von Risiken im Informationsmanagement. 2005, ISBN 3-8244-8225-8.
↑Steve C. McConnel: Code Complete. 2. Auflage. Microsoft Press, 2004, ISBN 0-7356-1967-0, 20.5, S.474 (englisch, 914 S.): “The single biggest activity on most projects is debugging and correcting code that doesn’t work properly. Debugging and associated rework consume about 50 percent of the time on a traditional, naive software-development cycle.”
↑Capers Jones: Software Assessments, Benchmarks, and Best Practices. Addison-Wesley, 2000, ISBN 0-201-48542-7, Kap.3, S.99 (englisch, archive.org [abgerufen am 29. Mai 2022]): “The relationship between quality and productivity is well supported by emperical data, even if the topic is not well understood by the industry as a whole. As far back as the early 1970s, IBM discovered that software projects with the lowest levels of defects had the shortest development schedules and the highest development productivity. The reason for this situation is because software defect removal is actually the most expensive and time-consuming form of work for software.”
↑Georg Edwin Thaller Softwaretest, Verifikation und Validation 2002, ISBN 978-3-88229-198-8.
↑John Ronald-Cummings, Peer Owais: Leading Quality. How Great Leaders Deliver High Quality Software and Accelerate Growth. Hrsg.: ROI Press. 2019, ISBN 978-1-916185-80-7, S.64 (englisch, 154 S.): “Research by Capers Jones found that the cost to address bugs post-release is $16,000, but a bug found at the design phase costs $25.”
