Programmfehler

Ein Programmfehler oder Softwarefehler, häufig auch als Bug (bʌg) benannt, bezeichnet im Allgemeinen ein Fehlverhalten von Computerprogrammen. Dies tritt auf, wenn der Programmierer einen bestimmten Zustand in der Programmlogik beim Umsetzen der Vorgaben nicht berücksichtigt hat, oder wenn die Laufzeitumgebung fehlerhaft arbeitet. Weiterhin können auch Unvollständigkeit, Ungenauigkeit oder Mehrdeutigkeiten in der Spezifikation des Programms zu Fehlern führen. In der Praxis treten Computerprogramme ohne Programmfehler selten auf. Statistische Erhebungen in der Softwaretechnik weisen im Mittel etwa zwei bis drei Fehler je 1000 Zeilen Code aus.

Bei der Suche nach den Ursachen für Fehler in Programmen sind sogenannte Debugger hilfreich, mit denen ein Programm Schritt für Schritt ausgeführt werden kann. Die internen Zustände der (Variablen) können hierbei angezeigt werden.

Zur Erfassung und Dokumentation werden sogenannte Bug-Tracker (wie Bugzilla oder Mantis) eingesetzt. Diese nehmen sowohl Fehlerberichte, als auch Verbesserungsvorschläge und Wünsche der Nutzer oder allgemeine Vorgänge auf.

Der Vorgang des Beseitigens eines Programmfehlverhaltens wird umgangssprachlich bugfixing genannt. Das Ergebnis der Verbesserung wird in der Fachsprache als Bugfix, Patch oder Softwarepatch bezeichnet.

Das engl. Wort „Bug“ als Synonym für Programmfehler

Logbuch-Seite des Mark II Aiken Relay Calculator mit dem ersten Bug (1947)

Das Wort „Bug“ wurde schon im 19. Jahrhundert für kleine Fehler in mechanischen und elektrischen Teilen verwendet. Knistern und Rauschen in der Telefonleitung würden daher rühren, dass kleine Tiere („Bugs“: engl: Wanze) an der Leitung knabbern. Edison schrieb an seinen Freund Tivadar Puskás, den Erfinder der Telefonzentrale und Gründer einer Telefonzeitung einen Brief über die Entwicklung seiner Erfindungen, in dem er kleine Störungen und Schwierigkeiten als „Bugs“ bezeichnete. “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” (Edison 1878^[1], deutsch: „Immer wenn man denkt, ein neues Maschinchen läuft wie geschmiert, streuen einem so genannte „Bugs“ Sand ins Getriebe.“) Edison ist zwar nicht Erfinder, aber immerhin Kronzeuge für eine schon damals kursierende Neuschöpfung.

Die Verknüpfung des Begriffs mit Computern geht möglicherweise auf die Computerpionierin Grace Hopper zurück.^[2] 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 und in das Logbuch geklebt mit den Worten “First actual case of bug being found.” (deutsch: „Das erste Mal, dass tatsächlich ein ‚Käfer‘ gefunden wurde.“). Die Legende von der Begriffsfindung hält sich hartnäckig, obwohl die Logbuch-Eintragung gerade auf die frühere Verwendung des Begriffs hinweist. 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.

Arten von Programmfehlern

In der Softwaretechnik wird zwischen folgenden Typen von Fehlern in Programmen unterschieden:

• Syntaxfehler sind Verstöße gegen die grammatischen Regeln der benutzten Programmiersprache. Ein Syntaxfehler verhindert die Kompilierung des fehlerhaften Programms. Bei Programmiersprachen, die sequentiell interpretiert werden, bricht das Programm an der syntaktisch fehlerhaften Stelle undefiniert ab.

• Laufzeitfehler sind alle Arten von Fehlern, die auftreten, während das Programm abgearbeitet wird. Da diese Fehler die Programmlogik und damit die Bedeutung des Programmcodes betreffen, spricht man hier auch von semantischen Fehlern. Ihre Ursache liegt in den meisten Fällen in einer inkorrekten Implementierung der gewünschten Funktionalität im Programm. Gelegentlich tritt als Ursache auch eine ungeeignete Laufzeitumgebung auf (z. B. eine falsche Betriebssystem-Version). 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“). 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 Zusammenhang mit Multithreading, etwa Race Conditions, welche Konstellationen bezeichnen, in denen das Ergebnis einer Operation vom zeitlichen Verhalten bestimmter Einzeloperationen abhängt, oder Deadlocks.

• 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.

• Logische Fehler und semantische Fehler bestehen in einem falschen Problemlösungsansatz, beispielsweise auf Grund eines Fehlschlusses oder eines fehlerhaften oder falsch interpretierten Algorithmus. 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.

• 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 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. Vielen Programmierern ist das Softwaredesign auch lästig, sodass oftmals ohne richtiges Konzept direkt entwickelt wird, was dann insbesondere bei steigendem Komplexitätsgrad der Software unweigerlich zu Designfehlern führt. 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.

• Ein Regressionsbug ist ein Fehler, der in einer früheren Programmversion bereits behoben wurde, der aber in einer späteren Programmversion wieder auftaucht.

• Fehler im Bedienkonzept. Das Programm verhält sich anders als es einzelne oder viele Anwender erwarten, obwohl es technisch an sich fehlerfrei arbeitet.

• Fehler infolge der Betriebsumgebung. 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.

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.

Vermeidung und Behebung von Programmfehlern

Generell gilt der Leitsatz: Je früher in einem Entwicklungsprozess der Fehler auftritt und je später er entdeckt wird, umso aufwendiger wird es, den Fehler zu beheben.

Während der Planung

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.

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.

Auch die Entwicklung immer abstrakterer Programmierparadigmen und Programmierstile 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. 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.

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 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.

Bei der 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.

Beim Testen

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 stellen die Basis für die Abnahmetests und können kontinuierlich über den gesamten Entwicklungsprozess verfeinert werden.

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.

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 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.

Fehlerfreiheit

Völlige Fehlerfreiheit für Software, die eine gewisse Komplexitätsgrenze überschreitet, ist weder erreichbar 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 unweigerlich Programmierfehler. Man spricht dann bei gut brauchbaren Programmen nicht von Fehlerfreiheit, sondern von Stabilität und Robustheit. Eine Software gilt dann als stabil bzw. 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 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 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. Wenn alle Tests das erwartete Ergebnis bringen, ist eine Anforderung erfüllt.

Folgen von Programmfehlern

Die Folgen eines Programmfehlers können außerordentlich sein und sich in vielfältiger Weise zeigen. Die folgende Liste ist zeitlich geordnet:

• 1982 stürzte ein Prototyp des F117 Kampfjets ab, da bei der Programmierung die Steuerung des Höhenruders mit der des Seitenruders vertauscht worden war.

• Beim Kampfflugzeug F-16 brachte der Autopilot das Flugzeug in Rückenlage, wenn der Äquator überflogen wurde. Dies kam daher, dass man keine „negativen“ Breitengrade als Eingabedaten bedacht hatte. Dieser Fehler wurde sehr spät während der Entwicklung der F-16 anhand eines Simulators entdeckt und beseitigt.

• Zwischen 1985 und 1987 gab es mehrere Unfälle^[3] mit dem medizinischen Bestrahlungsgerät Therac-25. Infolge einer Überdosis, die durch fehlerhafte Programmierung und fehlende Sicherungsmaßnahmen verursacht wurde, mussten Organe entfernt werden, drei Patienten verstarben aufgrund der Überdosis.

• Am 12. März 1995 kam es wegen eines um wenige Byte zu klein bemessenen Stapelspeichers in der Software eines Hamburger Stellwerks, bei dem auch das Ersatzsystem aus Sicherheitsgründen abgeschaltet wurde, zu massiven Verzögerungen im bundesweiten Zugverkehr.^[4] Am 16. Dezember 2009 kam es zu einem ähnlichen Fehler im Stellwerk des Hauptbahnhofs Hannover.^[5]

• Am 4. Juni 1996 wurde der Prototyp der Ariane-5-Rakete der Europäischen Raumfahrtbehörde eine Minute nach dem Start in vier Kilometern Höhe gesprengt. Der Programmcode für die Steuerung war von der Ariane 4 übernommen worden und funktioniert nur in einem von der Ariane 4 nicht überschreitbaren Bereich (Beschleunigungswert). Die Steuersysteme kamen zum Erliegen, als ebendieser Bereich von der Ariane 5 überschritten wurde, die stärker beschleunigt als die Ariane 4. Bei der Programmierung war es zu einem Fehler bei einer Typumwandlung gekommen^[6], dessen Auftreten durch die verwendete Programmiersprache Ada eigentlich hätte entdeckt und behandelt werden können. Diese Sicherheitsfunktionalität ließen die Verantwortlichen jedoch abschalten. Der Schaden betrug etwa 370 Millionen US-Dollar.

• Die USS Yorktown, ein weitgehend computerisiertes Schiff der Ticonderoga-Klasse, trieb nach Aussage der NAVY bei einem Manöver im September 1997 knapp drei Stunden hilflos im Mittelmeer, nachdem ein Ingenieur testweise - 0,0 KNOTEN (minus 0,0 Knoten) eingegeben hatte. Da die Eingabe nicht auf gültige Werte überprüft wurde, bewirkte dies einen Überlauf in der Datenbank des Windows-NT Systems. Daraufhin war das Rechnernetzwerk, bestehend aus mehreren Windows NT Servern, zusammengebrochen und es dauerte über drei Stunden die Server wieder zu reanimieren.

• 1999 verpasste die NASA-Sonde Mars Climate Orbiter den Landeanflug auf den Mars, weil die Programmierer das falsche Maßsystem verwendeten - Pound-force • Sekunde statt Newton • Sekunde. Die NASA verlor dadurch die Sonde.

• Bei Toll Collect kam es 2003^[7] unter anderem wegen der fehlenden Kompatibilität von Softwaremodulen zu drastischen Verzögerungen mit Vertragsstrafen und Einnahmeausfällen in Milliardenhöhe.

• Am 8. Oktober 2005 führte im russischen Plessezk ein Programmfehler zum Fehlstart einer Trägerrakete und zum Verlust des Satelliten CryoSat.

• Anfang November 2005 konnte an der Tokioter Börse wegen eines Programmfehlers stundenlang kein Handel betrieben werden. Auch in den nachfolgenden Wochen gab es viele fehlerhafte Wertpapierordern, die in einem Fall sogar einen finanziellen Schaden von über 300 Millionen Dollar ausmachte. Der Präsident der Börse, Takuo Tsurushima, trat daraufhin von seinem Amt zurück.^[8]

• 2007 kam es in Österreich bei der Umstellung auf digitales Satellitenfernsehen zu Problemen in rund 30.000 Haushalten, weil Software im Digitalreceiver fehlerhaft war^[9].

• In der Nacht vom 29. zum 30. Oktober 2007 kam es bei der Deutschen Telekom zu bundesweiten Ausfällen und Fehlverbindungen bei Sprachdiensten im Kommunikationssystem, weil eine aktualisierte Server-Software fehlerhaft war. Das System konnte erst nach mehreren Stunden durch die Installation der alten Software wieder zum Laufen gebracht werden^[10][11].

• Im Oktober 2007 kamen zehn Angehörige der südafrikanischen Armee aufgrund eines Programmfehlers in einem vollautomatisierten 35-mm-Flakgeschütz ums Leben.^[12]

• Zu Beginn des Jahres 2010 konnten wegen eines Softwarefehlers im EMV-Sicherheitschip bei der Verarbeitung der Jahreszahl 2010 viele Bankkunden tagelang an Automaten kein Geld abheben.^[13]

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 hoch, 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.

Siehe auch

• Bug-Tracker
• Patch (Software)
• Bananensoftware

Weblinks

• Die 25 gefährlichsten Programmierfehler (englisch)

Literatur

• William E. Perry: Software Testen, Mitp-Verlag, November 2002, ISBN 3-8266-0887-9
• Elfriede Dustin, Jeff Rashka, John Paul: Software automatisch testen, Springer, Berlin, Januar 2001, ISBN 3-540-67639-2
• Cem Kaner, Jack Falk, Hung Q. Nguyen: Testing Computer Software, John Wiley & Sons, Juni 1999, ISBN 0-471-35846-0

Einzelnachweise

1. ↑ [1]
2. ↑ Vgl. den Beitrag zu Rear Admiral Grace Murray Hopper in The History of Computing (engl.)
3. ↑ Nancy G. Leveson and Clark S. Tyler, An Investigation of the Therac-25 Accidents, IEEE Computer 26(7), p. 18-14, 1993
4. ↑ Software-Katastrophen - Hamburger Stellwerk (Link zur Wayback Machine des Internet Archive)
5. ↑ Software-Panne: Chaos am Hauptbahnhof Hannover
6. ↑ Vortrag über Software Reliability von I. Giese (GSI), u.a. mit Ausschnitt des ursächlichen Quellecodes
7. ↑ Pressemitteilung Toll Collect
8. ↑ Tokioter Börse - Der Chef tritt ab, Manager Magazin vom 20. Dezember 2005
9. ↑ ORF - 22. August 2007 - Fehlerhafte Software verhindert Empfang der ORF-Programme
10. ↑ Server-Ausfall legt bundesweit Telekom-Leitungen lahm - Tagesspiegel vom 30. Oktober 2007
11. ↑ Online FOCUS - Hunderttausendfach „falsch verbunden“
12. ↑ heise online - Defektes Computersystem für den Tod von zehn Soldaten verantwortlich?
13. ↑ Panne zum Jahreswechsel - Tagesspiegel vom 5. Januar 2010