Quelltext der Seite Programmfehler

'''Programmfehler''' oder '''Softwarefehler''' oder '''Software-Anomalie''', häufig auch '''Bug''' ({{enS}}) 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.&nbsp;B. eine bestimmte Festlegung der [[Spezifikation]] fehlerhaft ist oder falsch [[Implementierung|umgesetzt]] wurde („Fehlhandlung“), und führen zunächst zu einem internen „Fehlerzustand“ im [[Computerprogramm|Programm]], der wiederum während der [[Computerprogramm#Übersetzung und Ausführung|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.&nbsp;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,<ref name="PKS" /> während Fehler im laufenden Betrieb je nach Fehlerwirkung u.&nbsp;U. kritische Anomalien/Störungen darstellen. In der Praxis treten [[Computerprogramm]]e ohne Programmfehler selten auf. Als Qualitätsmerkmal für Programme kennt man u.&nbsp;a. die [[Fehlerquotient#Fehlerdichte|Fehlerdichte]]. Sie bezeichnet die Anzahl an Fehlern pro 1.000 Zeilen Code ([[Lines of 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.&nbsp;B. Flugzeugsteuerung) wird mitunter eine (aufwendige) [[Verifizierung#Automatisierte/formale Verifikation|formale Verifikation]] durchgeführt.

Zur Erfassung und Dokumentation werden sogenannte ''[[Bugtracker]]'' (wie [[Bugzilla]] oder [[Mantis Bug Tracker|Mantis]]) eingesetzt. Diese nehmen sowohl [[Fehlerbericht]]e als auch Verbesserungsvorschläge und Wünsche (sog. ''{{lang|en|[[Feature-Request]]s}}'') der Nutzer oder allgemeine Vorgänge auf. Siehe auch [[Fehlermanagement]].

Der Vorgang des Beseitigens eines Programmfehlers wird umgangssprachlich ''Bugfixing'' genannt. Das Ergebnis der Verbesserung wird in der Fachsprache als ''Bugfix,'' [[Patch (Software)|''Patch'']] oder ''Softwarepatch'' bezeichnet.

== Definitionen ==

Ein Programm- oder Softwarefehler ist, angelehnt an die allgemeine Definition für „[[Fehler]]“
: „Nichterfüllung einer Anforderung“.<ref name="ISO-9000">{{Literatur |Autor=DIN-Normenausschuss Qualitätsmanagement, Statistik und Zertifizierungsgrundlagen (NQSZ) |Titel=DIN EN ISO 9000 |TitelErg=Qualitätsmanagementsysteme - Grundlagen und Begriffe |Hrsg=DIN Deutsches Institut für Normung e.&nbsp;V. |Verlag=Beuth Verlag GmbH |Ort=Berlin |Datum=2015-11 |Sprache=de |Umfang=104 |Kapitel=3.6.9 |Seiten=40}}</ref>
Konkret definiert sich der Fehler danach als
: „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]]<ref>Spillner et al. ''Praxiswissen Softwaretest - Testmanagement''{{Webarchiv|url=https://www.dpunkt.de/leseproben/3028/Kapitel%201.pdf |wayback=20101217001244 |text=Leseprobe Kap. 1.1 Basiswissen / ''Fehlerbegriff'' }} (PDF) dpunkt.de</ref> 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&nbsp;…“
* 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 [[Computerprogramm#Überblick|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.&nbsp;B. die Verletzung von Vorschriften zum [[Programmierstil]], die Lieferung falscher Ergebnisse oder ein [[Programmabbruch]].

== „Bug“ als Synonym für Programmfehler ==
[[Datei:First Computer Bug, 1947.jpg|mini|Logbuch-Seite des Mark II Aiken Relay Calculator mit dem ersten ''bug'' (1947)]]
Das Wort ''bug'' bedeutet im Englischen „[[Schnabelkerfe|Schnabelkerf]]; [[Wanzen|Wanze]]“ und umgangssprachlich „landlebender [[Gliederfüßer]]“ oder „(insektenartiges) [[Ungeziefer]]“.<ref>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]] …''</ref> Im [[Jargon]] amerikanischer [[Ingenieur]]e 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 Edison]]s 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:

{{Zitat
 |Text=[…] I did find a ‘bug’ in my apparatus, but it was not in the telephone proper. It was of the genus ‘callbellum.’<ref>ein Wortspiel eines scheinbar lateinischen Gattungsnamens aus ''call'' (Anruf[en]) und ''Bellum'' (Akkusativ zu [[Alexander Graham Bell|Bell]])</ref>
 |Sprache=en
 |Quelle=Thomas Edison in einem Brief an William Orton, datiert auf den 3. März 1878
 |Übersetzung=[…] Ich fand in der Tat einen ‚Bug‘ in meinem Apparat, allerdings nicht im Telefon selbst. Er war von der Gattung ‚callbellum‘.
 |ref=<ref>Paul B. Israel (Hrsg.): ''The Papers of Thomas A. Edison.'' Vol. 4, Baltimore and London, 1993 ([https://catalogue.swanngalleries.com/asp/fullCatalogue.asp?salelot=2470++++++41+&refno=++743398&saletype= Online]).</ref>}}

sowie
{{Zitat
 |Text=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&nbsp;[…].
 |Sprache=en
 |Quelle=Thomas Edison in einem Brief an Tivadar Puskás, datiert auf den 18. November 1878
 |Übersetzung=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‘ –&nbsp;wie solche kleinen Fehler und Schwierigkeiten genannt werden&nbsp;– sich zeigen&nbsp;[…].}}

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 [[Nachtfalter|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: {{" |Sprache=en |Text=First actual case of bug being found. |Übersetzung=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 [[United States Navy|US-Marine]] in [[Dahlgren (Virginia)|Dahlgren]], [[Virginia]], aufbewahrt. Zurzeit befindet sich diese Logbuchseite mit der Motte am [[Smithsonian Institution|Smithsonian Institute]].<ref>Fred R. Shapiro: ''Etymology of the Computer Bug: History and Folklore.'' In: ''American Speech.'' Band 62, Nr. 4, 1987, S. 376–378.</ref>

== Arten von Programmfehlern ==

In der [[Softwaretechnik]] (siehe auch<ref name="UniO" />) 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.&nbsp;B. fehlende Klammern), Typkonflikte, falsche Anzahl Parameter.

Lexikalische und Syntaxfehler verhindern in der Regel die [[Compiler|Kompilierung]] des fehlerhaften Programms und werden daher frühzeitig erkannt. Bei Programmiersprachen, die sequentiell [[Interpreter|interpretiert]] werden, bricht das Programm üblicherweise erst an der syntaktisch/lexikalisch fehlerhaften Stelle ab.

* ''[[Formale Semantik|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.
* ''[[Logik|Logische Fehler]]'' bestehen in einem im Detail falschen Problemlösungsansatz, beispielsweise auf Grund eines [[Fehlschluss]]es, 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 [[Datentyp]]en, sind je nach verwendeter [[Programmiersprache]] sehr unterschiedlich ausgeprägt und können schwierig zu überschauende [[Sicherheitslücke]]n und [[Absturz (Computer)|Programmabstürze]] verursachen.
* ''Designfehler'' sind Fehler im Grundkonzept, entweder bei der Definition der [[Anforderung (Informatik)|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]], un[[strukturierte Programmierung]] oder auf Folgefehler durch Fehler in der [[Anforderungserhebung|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 [[DV-Konzept|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'''
{{Anker|Regressionsbug}}

* ''[[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.&nbsp;B. eine falsche [[Betriebssystem]]-Version, falsche [[Parameter (Informatik)|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“). [[Datei:Wikipedia-Reiter-Bug02 OHNE TON.webm|mini|Auswirkungsbeispiel eines Programmfehlers]] Wird in Programmiersprachen ohne [[Garbage Collection|automatische Speicherbereinigung]] (etwa [[C (Programmiersprache)|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 [[Garbage Collection|automatischer Speicherbereinigung]] (etwa [[Java (Programmiersprache)|Java]] oder [[C-Sharp|C#]]) können ähnliche Probleme auftreten, wenn zum Beispiel Objekte durch [[Systemprogrammierung|systemnahe Programmierung]] unkontrolliert angesammelt werden. Noch kritischer sind versehentlich vom [[Programmierer]] freigegebene Speicherbereiche, die oft trotzdem noch durch [[Hängender Zeiger|hängende Zeiger]] referenziert werden, da dies zu völlig unkontrolliertem Verhalten der Software führen kann. Manche [[Laufzeitumgebung]]en 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.<!-- , welche jedoch gerade bei kleineren Projekten nicht immer gegeben ist. // Projektgröße und Compilerverbreitung/-reife sind zwei gänzlich verschiedene Baustellen! -->
* 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.&nbsp;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#Definition|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“.<ref name="ISO-9000"/> 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.

Konkrete Beispiele von Fehlern mit medial besonderer Wirkung finden sich in der [[Liste von Programmfehlerbeispielen]].

== Wirtschaftliche Bedeutung ==

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<ref>[[iX – Magazin für professionelle Informationstechnik|iX-Magazin]], Studie ''Software-Testmanagement'', war früher {{Webarchiv|url=http://www.heise.de/kiosk/special/ixstudie/06/01 | wayback=20130109024912 | text=im IX Kiosk erwerbbar}}</ref> zeigte z.&nbsp;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.<ref>{{Literatur |Autor=Herbert Krasner |Titel=The Cost of Poor Software Quality in the US |TitelErg=A 2022 Report - From Problem to Solutions |Hrsg=Consortium for Information & Software Quality |Datum=2022-12-15 |Sprache=en |Umfang=61 |Seiten=3-4 |Online=https://www.it-cisq.org/wp-content/uploads/sites/6/2022/11/CPSQ-Report-Nov-22-2.pdf |Format=PDF |Abruf=2024-09-25}}</ref>

Besonders viele Misserfolge zeigt ein Bericht des obersten Rechnungshofs für neue Projekte (1985) bei der US-Bundesverwaltung,<ref name="Wallm_SWQ" /> 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:<ref>Junginger: ''Wertorientierte Steuerung von Risiken im Informationsmanagement''. 2005, ISBN 3-8244-8225-8.</ref> 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:<ref name="Wallm_SWQ">Wallmüller: ''Software-Qualitätsmanagement in der Praxis,'' [http://www.beck-shop.de/fachbuch/leseprobe/9783446213678_Excerpt_001.pdf beck-shop.de] (PDF; 612&nbsp;kB), Hanser, München 2001, ISBN 978-3-446-21367-8.</ref>
* 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.<ref>{{Literatur |Autor=Steve C. McConnel |Titel=Code Complete |Auflage=2 |Verlag=Microsoft Press |Datum=2004 |Sprache=en |Umfang=914 |ISBN=0-7356-1967-0 |Kapitel=20.5 |Seiten=474 |Zitat=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.}}</ref> Studien belegen daher, dass es oft günstiger ist, qualitativ hochwertige Software zu entwickeln, als qualitativ minderwertige.<ref>{{Literatur |Autor=Capers Jones |Titel=Software Assessments, Benchmarks, and Best Practices |Verlag=Addison-Wesley |Datum=2000 |Sprache=en |ISBN=0-201-48542-7 |Kapitel=3 |Seiten=99 |Online=https://archive.org/details/softwareassessme0000jone/mode/2up |Abruf=2022-05-29 |Zitat=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.}}</ref>

== Vermeidung, Auffindung und Behebung von Programmfehlern ==
Generell gilt:<ref>Georg Edwin Thaller ''Softwaretest, Verifikation und Validation'' 2002, ISBN 978-3-88229-198-8.</ref> ''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.<ref>{{Literatur |Autor=John Ronald-Cummings, Peer Owais |Titel=Leading Quality |TitelErg=How Great Leaders Deliver High Quality Software and Accelerate Growth |Hrsg=ROI Press |Datum=2019-07-30 |Sprache=en |Umfang=154 |ISBN=978-1916185807 |Seiten=64 |Zitat=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.}}</ref>

=== Während der Planung ===
Am wichtigsten ist eine gute und geeignete Planung des Entwicklungsprozesses. Hierfür gibt es bereits etliche [[Vorgehensmodell zur Softwareentwicklung|Vorgehensmodelle]], aus denen ein geeignetes ausgewählt werden kann.

=== In der Analysephase ===
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.

=== In der Entwurfsphase ===
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 (Informationstheorie)|Redundanz]] und die Überwachung von Programmen (z.&nbsp;B. durch [[Watchdog]]-Timer) sowie die [[Plausibilisierung]] des Programmes während der Entwicklung und der Daten während des Programmablaufs.

=== Bei der Programmierung ===
Die Entwicklung immer abstrakterer [[Programmierparadigma|Programmierparadigmen]] und [[Programmierstil]]e wie die [[funktionale Programmierung]], [[objektorientierte Programmierung]], [[Design by contract]] und die [[aspektorientierte Programmierung]] dienen unter anderem der Fehlervermeidung und Vereinfachung der Fehlersuche. Aus den zur Verfügung stehenden Techniken für das Problem ist eine geeignete auszuwählen. Ein wichtiger Punkt hierbei ist aber auch, dass für das jeweilige Paradigma erfahrene Programmierer zur Verfügung stehen müssen, sonst entsteht oft der gegenteilige Effekt.

Ferner ist es sehr nützlich, von den Entwicklungswerkzeugen möglichst viele Aufgaben der Fehlervermeidung zuverlässig und automatisch erledigen zu lassen, was z.&nbsp;B. mit Hilfe von [[Strukturierte Programmierung|strukturierter Programmierung]] erleichtert wird. Dies betrifft zum einen bereits Kontrollen wie [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|Sichtbarkeitsregeln]] und [[Typsicherheit]], sowie die Vermeidung von [[Zirkelbezug|Zirkelbezügen]], die bereits vor der Übersetzung von Programmen vom [[Compiler]] übernommen werden können, aber auch Kontrollen, die erst zur [[Laufzeit (Informatik)|Laufzeit]] durchgeführt werden können, wie zum Beispiel [[Buffer Overflow|Indexprüfung]] bei [[Feld (Datentyp)|Datenfeldern]] oder [[Typsicherheit|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 [[Speicherleck]]s zuverlässig aufspüren. Beispiele sind das frei erhältliche Tool [[Valgrind]] und das kommerzielle [[Rational Purify|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 (Programmierwerkzeug)|Lint]] und [[Splint (Software)|Splint]].

=== Beim Testen ===
Es ist durchaus sinnvoll, dass der [[Softwaretest|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 [[Testfall|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.&nbsp;B. für eine  [[Testautomatisierung]] vorbereitet werden können.

Manche Softwareanbieter führen Testphasen teilweise öffentlich durch und geben [[Betaversion]]en heraus, um die unvorhersehbar vielfältigen Nutzungsbedingungen verschiedener Anwender durch diese selbst testen und kommentieren zu lassen.

=== Im Betrieb ===
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 [[Assertion (Informatik)|Assertions]], mit deren Hilfe Bedingungen abgefragt werden, die gemäß Programmdesign immer erfüllt sind. Weitere Mechanismen sind [[Ausnahmebehandlung]]en 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.

== Fehlerfreiheit ==

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 (Logik)|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.&nbsp;B. bei militärisch oder medizinisch genutzter Software oder in der Luft- und Raumfahrt, verwendet man zudem eine „(formale) [[Verifizierung#Informatik (Verifizieren von Software)|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 (Informatik)|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 [[Test]]s 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“.

== Klassifizierung von Fehlern ==

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).<ref>[http://my.safaribooksonline.com/book/-/9781457170911/19-abweichungsmanagement/255 my.safaribooksonline.com]</ref> In jedem dieser Schritte werden die Verwaltungsaktivitäten Aufzeichnen (Recording), Klassifizieren (Classifying), Wirkung identifizieren (Identifying Impact) ausgeführt.<ref name="IEEE_1044en">{{Internetquelle |url=https://standards.ieee.org/findstds/standard/1044-2009.html |titel=IEEE Standard Classification for Software Anomalies |autor= |hrsg=IEEE Standards Board |werk= |seiten=32 |datum=1993 |format=PDF |kommentar=White Paper; Dokument hinter Paywall |zugriff=2014-11-22}}</ref>

Kriterien, nach denen Fehler dabei ''klassifiziert'' werden können, sind u.&nbsp;a. (mit Beispielen):
{{Hauptartikel|Fehlerklassifizierung}}
* die Art des Fehlers: Nach<ref name="UniO">{{Internetquelle |url=http://www.informatik.uni-oldenburg.de/~iug10/sli/index01ce.html?q=node/25 |titel=Sicherheitslücken im Internet – Fehler im Programmcode |werk=informatik.uni-oldenburg.de |archiv-url=https://web.archive.org/web/20230328093835/http://www.informatik.uni-oldenburg.de/~iug10/sli/index01ce.html?q=node/25 |archiv-datum=2023-03-28 |abruf=2024-07-22}}</ref> werden dabei unterschieden: Lexikalische Fehler (unbekannter Bezug), syntaktische Fehler (vergessenes Semikolon), semantische Fehler (falsche [[Deklaration (Programmierung)|Deklaration]]), Laufzeitfehler (falsch formatierte Eingabedaten) und logische Fehler (plus statt minus, [[Schleife (Programmierung)|Schleifenfehler]], …)
* die Fehlerursache: unpräzise Vorgabe, Zahlendreher, falsche Formel, nicht geprüfte (falsche) Eingabedaten&nbsp;…
* der Zeitpunkt der Fehlerentstehung (‚Fehlhandlung‘): Bereits bei der Programmvorgabe, im Codeentwurf, beim Codieren,&nbsp;…
* 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<ref name="PKS" />) oder im [[Produktivbetrieb|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.&nbsp;A. die Korrekturmaßnahme verlaufen.
* die Reproduzierbarkeit des Fehlers: Je schwieriger ein Fehler reproduzierbar ist, desto aufwändiger wird i.&nbsp;A. die Korrekturmaßnahme verlaufen.
* die Auswirkung(en) des Fehlers: Darstellungsfehler, falsches Ergebnis, Programmabbruch, Außenwirkung&nbsp;…
* Aufwand und Dauer zur Fehlerbehebung: minimal … sehr hoch; sofort … sehr lange Dauer;
* Bearbeitungsstatus: aufgetreten, untersucht, Korrekturauftrag in Bearbeitung, [[Regressionstest|Retest]] möglich, …, erledigt
Mit Hilfe von [[Softwaremetrik|Metriken]] „sollten die Ergebnisse [und Erkenntnisse über Fehler] auch Anlass zur Suche nach den ''Ursachen'' hinter den Problemen sein“.<ref name="PKS">M. Pol, T. Koomen, A. Spillner: ''Management und Optimierung des Testprozesses.'' dpunkt.Verlag, Heidelberg 2002, ISBN 3-89864-156-2.</ref> „Fehlerklassifikationen bilden die Grundlage für standardisierte Verfahren zur Fehlerbehandlung und unterstützen zudem eine kontinuierliche Qualitätsverbesserung im Sinne des [[Qualitätsmanagement]]s.“<ref name="BITKOM">{{Internetquelle |url=https://www.bitkom.org/Bitkom/Publikationen/Bitkom-Leitfaden-Fehlerklassifikation-fuer-Software.html |titel=Bitkom Leitfaden Fehlerklassifikation für Software {{!}} Bitkom e.&nbsp;V. |sprache=de |abruf=2022-07-26}}</ref> 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.<ref name="BITKOM" />

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,&nbsp;… oder 1, 2, 3,&nbsp;… usw. eingeteilt. Beispiele siehe BITKOM-Leitfaden,<ref name="BITKOM" /> insbesondere im Anhang.

== Folgen von Programmfehlern ==

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&nbsp;…) – 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.

Konkrete Beispiele für Programmfehler und deren Folgen finden sich in der [[Liste von Programmfehlerbeispielen]].

== Reproduzierbarkeit von Programmfehlern ==

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äufigkeit|nebenläufigen]] Umgebungen mit mangelnder [[Synchronisation]] (genauer: [[Sequentialisierung]]) auftreten. Wegen der hieraus folgenden [[Race Condition|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 Fehlers 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.

== Weiterführende Themen ==
* Zum Prinzip, noch „unreife“ Software auszuliefern, siehe [[Bananenware]].
* Software, die (oft kostenlos angeboten) z.&nbsp;B. Mängel in der Sicherheit, der Übersichtlichkeit oder ihrer nutzbaren Funktionalität aufweist; siehe [[Crapware]]

== Literatur ==
* 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.&nbsp;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.&nbsp;a. 1999, ISBN 0-471-35846-0.

== Weblinks ==
{{Wiktionary}}
* [http://cwe.mitre.org/top25/ Die 25 gefährlichsten Programmierfehler] (englisch)
* {{Internetquelle
   |url=http://www.computerwoche.de/a/die-spektakulaersten-softwarefehler-2012,2531034
   |titel=Die spektakulärsten Softwarefehler 2012
   |autor=SQS
   |werk=Computerwoche
   |datum=2013-01-17
   |zugriff=2013-01-20}}

== Einzelnachweise ==
<references />

[[Kategorie:Programmfehler| ]]
[[Kategorie:Wikipedia:Artikel mit Video]]