Fehlende Software-Qualität kann auch große Unternehmen gefährlich stolpern lassen!

Dass fehlende Qualität von Software ein Unternehmen in Krisen führen kann, bestätigt sich auf jeden Fall dann, wenn anhaltende Probleme mit einen unter­nehmenskritischen neuen System den CFO zu einer Gewinnwarnung zwingen und so auch die Aktionäre beunruhigen.

Sie glauben nicht, dass so was passiert? Nun, hier ist ein Beispiel:

Wie die Computerwoche berichtet, droht das misslungene neue Computersystem “New Forwarding Environment” (NFE) die Deutsche Post im Frachtgeschäft um Jahre zurückzuwerfen.

Deteils finden sich auf FinanzNachrichten.de in einer Meldung vom 29.10.2015:
 

Larry Rosen, der Finanzchef der deutschen Post, erklärt, NFE sei zu fehleranfällig und müsse wohl ersetzt werden, was Jahre dauern könne, denn eine neue, weniger komplexe Lösung stehe kurzfristig nicht zur Verfügung.

Man überlege nun, schrittweise neue Komponenten zu integrieren und habe Rückstellungen in Höhe von 37 Millionen Euro gebildet für Ausgaben zur erwarteten Rückabwicklung des Systems in den bereits umgestellten Pilotländern.

Der Bonner Konzern schätze die Wahrscheinlichkeit, aus dem derzeitigen System positive Effekte erzielen zu können, als sehr gering ein und habe deshalb auch Abschreibungen in Höhe von 309 Mio. Euro vorgenommen.

Die bereits nach dem zweiten Quartal 2015 schon einmal korrigierte Prognose sei nun nicht mehr zu halten.

 

Nachdenklich macht: NFE basiert auf Software von SAP und wurde mit IBM Global Business Services als Implementierungspartner umgesetzt.

Da sollte man sich schon fragen, wie es zu einem solchem Unglück kommen konnte.

Eines dürfte klar sein:

Obgleich zu akzeptabler Software-Qualität weit mehr gehört als nur die Abwesen­heit von Programmierfehlern, wird sie doch (vom Software-Lieferanten) gerne auf genau solche reduziert gesehen. Dem Auftraggeber fällt das zunächst gar nicht auf.

Doch können denn wirklich nur Programmierfehler so ein Desaster verursachen, wenn das System auf Code beruht, den SAP und IBM entwickelt haben (Firmen also, von denen man erwartet, dass sie kompetentes Personal einsetzen)?

Meine etwa 30-jährige Erfahrung mit Software-Entwicklung sagt mir, dass ein System, dessen Anforderungen vor Beginn der Programmierung genau und vollständig schriftlich spezifiziert und entsprechend gründlich durchdacht worden sind, von erfahrenen Programmierern auf keinen Fall derart verkorkst werden kann, dass es nicht gelingt, alles wesentliche Fehlverhalten innerhalb weniger Monate, wenn nicht Wochen, beseitigen zu können.

An was aber mag es denn dann liegen, dass selbst weltweit bekannte Software-Lieferanten wie IBM — solche, denen man größtmögliche Erfahrung unterstellt — ein System abliefern, welches seine Anwender und Betreiber als kaum nutzbar, auf jeden Fall aber als nicht länger tragbar einstufen?

Mein Verdacht: Man wird wohl versucht haben, nach dem Agilen Manifest zu arbeiten — nach dem Vorgehensmodell also, das seit der Jahrtausendwende unter dem Label “Agile” hochgelobt wird, weil junge Entwickler sich nicht mehr die Mühe machen wollen, die klassischen Verfahren des Software-Engineerings wirklich zu verstehen und der inzwischen neu hinzugekommenen Notwendigkeit, maximal flexibel zu sein, erfolgreich anzupassen — auch und gerade unter der Neben­bedingung, dass heute fast alle Entwicklungsaufträge zum Festpreis vergeben werden.

Wenn die Deutsche Post jetzt plant — und sich sogar gezwungen sieht — “eher evolu­tionär” vorzugehen (wie Rosen sich ausdrückt), klingt mir das schon fast nach einer Wiederholung des von mir vermuteten Fehlers.

Will man wirklich riskieren, dass ich recht habe? Will man nicht zuerst über die Ursachen des Mißerfolgs nachzudenken?

Oder will man einfach nicht einsehen, dass der klassische Weg, Software zu ent­wickeln, eher Erfolg garantiert als SCRUM-artig gestaltete Prozesse in Kombination mit dem blinden Glauben an die Effektivität der allzu naiven Prinzipien des Agilen Manifests?

Ist uns denn nicht bewusst, dass Agile, SCRUM und dieser ganze verhängnisvolle, viel zu wenig durchdachte Trend auf eine kleine Gruppe von Wartungsprogram­mieren zurückgehen, die dachten zu wissen, wie man wirklich große Software-Entwicklungsprojekte so durchführt, dass (fast) nichts mehr schief gehen kann?

Wer glaubt, man könne die Wahl des Prozessmodells zur Entwicklung einer umfangreichen IT-Lösung einfach der Mode oder nur an ihren Code denkenden Programmierern überlassen, der irrt gewaltig.

Dem CIO der Deutschen Post jedenfalls kann man nur raten, die Ursachen seines Desasters genau zu identifizieren.

Versäumt er das, könnte die Deutsche Post in einer eher noch folgenreicheren IT-Sackgasse landen. Ob es dann noch reichen würde, einfach nur eine Gewinn­warnung herauszugeben, kann bezweifelt werden.
 

Advertisement

Wie oft — und wie dramatisch — Software-Tester versagen

Dass es wirklich höchste Zeit wird, auch die Effektivität von Software-Testern systematisch zu kontrollieren, zeigt eine ganz unglaubliche Sicherheitslücke, die im Februar 2015 in gleich mehreren Tausend per Internet zugänglicher Anwendun­gen entdeckt wurde:

Wie die Computerwoche schrieb, handelte es sich um Konfigurationsfehler die zur Folge hatten, dass — im Prinzip wenigstens — jeder Internet-Nutzer mehrere Millionen Kundendaten nach Name, Adresse, E-Mail und Kreditkartennummer im Internet nicht nur abrufen, sondern auch manipulieren konnte.

Von den zahlreichen Entwicklern dieser vielen Anwendungen war ganz offensicht­lich keinerlei ernsthafter Sicherheitstest durchgeführt worden.

Will da noch jemand behaupten, sie hätten professionell genug gearbeitet?

Und ganz offensichtlich hat auch niemand unter den Verantwortlichen ernsthaft ge­prüft, wie vollständig der Test, für den sie bezahlt hatten, denn nun eigentlich war.

Glaubt die Software-Industrie wirklich, sich derart dilettantisches Vorgehen noch lange leisten zu können?

|

Man lese auch: Was es bedeuten kann, wenn Software-Tester versagen

Software-Qualität – eine oft böse Überraschung

Wer für Software-Entwicklung bezahlt, hält es für selbstverständlich, qualitätsvolle Software zu bekommen. Welch ein Irrtum das sein kann!

Selbst weltweit anerkannte IT-Dienstleister (s.u. Beispiele) liefern hin und wieder absolut unbrauch­bare Software und bescheren so ihren Kunden Verluste in Millionen-Höhe.

Warum nur fühlen sich Software-Entwickler so wenig für die Qualität ihrer Erzeugnisse verantwortlich?

Warum nur sehen sie Qualität so gar nicht als eines ihrer wichtigsten Ziele?

Liegt es daran, dass ihre Auftraggeber Qualität nur allzu pauschal fordern (und denken, sie nicht extra bezahlen zu müssen)?

Traurige Tatsachen sind:

• Wartbarkeitsaspekte — für Eigentümer und Betreiber der Software extrem wichtig — adressiert kaum jemand: Wie sich die Total Cost of Ownership niedrig halten lässt, diskutieren Entwickler nicht wirklich (sie müsste vom Auftraggeber schon explizit gefordert sein, …).
   
• Benutzerfreundlichkeit scheint Entwicklern völlig egal (so ergab eine Studie aus 2012).

 

Eine 2001 im Auftrag des deutschen Forschungsministeriums erstellte Studie kam zum Ergebnis: Für Software-Dienstleister ist Qualität ein Fremdwort, und so ist es heute noch:

• Im Früjahr 2013 bestätigt ein SAP-Team diese Einschätzung ganz unfreiwillig im wirklich übelsten Sinne des Wortes: durch Auslieferung einer absolut unbrauchbaren Neuimplementierung des Payroll Systems der kalifornischen Behörden auf der SAP Plattform (siehe [1], kürzer [CW]).
   
• Ähnliches war einige Monate früher IBM passiert (siehe [2]). Diesem Team misslang die Neuimplementierung eines Order Management Systems. Man streitet sich jetzt vor Gericht um einen zweistelligen Millionenbetrag.
   
• Vorher schon hatte IBM in Australien Software abgeliefert, die unbrauchbar war: "The system, which was delivered 20 months after deadline and 300 per cent over budget, led to 70,000 staff in Queensland’s health system being underpaid, overpaid or not paid for months."
   
• Ein ganz ähnliches Beispiel aus Deutschland (2015).
   
• Leider sind das keineswegs die einzigen Beispiele für in den letzten Jahren komplett schiefgelaufene, wirklich große Software-Entwicklungsprojekte. Siehe auch Zahlen dazu, z.B. von 2010.
   
  Man muss sich ernsthaft fragen, ob gängige Software-Entwicklungsmethodik (insbesondere die neue, sog. agile) nicht ganz grundsätzlich nur für Projekte kleiner oder mittlerer Größenordnung funktioniert.

  Wie sonst nämlich wäre es erklärbar, dass man mit den heute zur Verfügung stehenden wunderbaren, kaum noch verbesserungsfähigen Entwick­lungs­werkzeugen an der Neuimplementierung von Anwendungen scheitert, die man vor 30-40 Jahren schon einmal – und damals doch durchaus erfolgreich – geschaffen hatte (!).

  Oder sind vielleicht die Einkäufer schuld, die davon ausgehen, dass der jeweils billigste Anbieter das Projekt schon stemmen werde? Wollen sie Qualität zum Nulltarif?

 

In 2010 schrieben Wissenschaftler der Carnegie Mellon University, die Software-Entwicklungsprozesse untersucht hatten: The software industry is the only modern high-tech industry that ignores quality until test.

Inzwischen aber zeigt sich noch Schlimmeres:

Selbst wirkungsvoller Test gelingt Software-Entwicklern nicht wirklich (siehe etwa [3], [4] und [5] sowie The Healthcare Go Live Debacle).

Wie wenig effektiv Tester bisher sind, spiegelt sich auch wider in Gartners Erkennt­nis: 40% of problems are found by end users.

Wie lange noch — so frage ich — werden Auftraggeber sich das gefallen lassen?

Und insbesondere: Wann endlich werden Software-Entwickler die Konstruktion von Qualität ebenso ernst nehmen, wie das Konstruieren der Software selbst?

Bisher ist das Streben nach Qualität auf Seiten der Entwickler selten mehr als ein Lippenbekenntnis.

Tatsache ist: Wo Termin und Budget eng werden, wird weniger getestet — mit oft schlimmen Folgen (immer für den Auftraggeber, nicht selten auch für den Auftrag­nehmer). Beide Vertragspartner sollten sich dessen bewusst sein und nicht ver­säumen, dem ganz entschieden zu begegnen: Auf jeden Fall weit effektiver als bisher zu beobachten.

Den oft jungen Entwicklern sei gesagt:

Zu glauben, dass sogenanntes agiles Vorgehen die früher übliche, peinlich genaue Dokumentation aller zu entwickelnden Funktionalität überflüssig macht, ist ein ganz gewaltiger Irrtum: Der Wille, praktisch alles, was man produziert, in jedem noch so unfertigen Zustand gerne dem Anwender zu zeigen (damit der sage, wo er was anders haben möchte), mag ja gut gemeint sein, ist aber einfach nur naiv, denn solches Vorgehen überfordert den Anwender – man schiebt ja so nur eigene Verantwortung auf ihn ab.

Kluge Kunden durchschauen das und akzeptieren es nicht.

Vorzugehen, wie im Agilen Manifest gefordert, kann nur gut sein für prototypische Entwicklung in sehr kleinen Teams. Viele der heutigen Entwickler wollen das nicht einsehen. Methodiker, die ihnen Einhalt gebieten, gibt es nicht mehr wirklich. Es fehlt wohl die Einsicht, dass sie zu bezahlen sehr gut angelegtes Geld wäre …

SCRUM-Verfechter, eine spezifische Subklasse der Agilisten, übersehen, dass sich mit täglichen Stand-up-Meetings nur Mikroprozesse steuern lassen — auf keinen Fall aber Großprojekte.

Die Achillesferse aller Software-Entwickler

Wissenschaftliche Untersuchungen (z.B. eine der Carnegie Mellon University aus 2003) belegen, dass moderne Software, wenn sie in Betrieb genommen wird, i.A. immer noch bis zu fünf Fehler pro 1000 Lines of Code enthält; sprich: etwa 1 Fehler auf je 3 DIN A4 Seiten manuell erstellten Source Codes.

Selbst im besten untersuchten Programm – bestehend aus 10.000.000 Lines of Code – fand sich immer noch 1 Fehler in je 7500 Zeilen. Wirklich vorhanden waren wohl mehr, denn in großen Systemen entdeckt man niemals alle.

Wären mathematische Publikationen auch nur annähernd so fehlerhaft, wäre die Mathematik als Wissenschaft längst in sich zusam­men gebrochen (es baut dort ja Neues stets auf Älterem auf).

Wir sehen: Die Informatik — wenigstens aber ihre Technik zur Qualitätssicherung — steckt heute wohl noch in Kinderschuhen, die vergleichbar sind mit denen, die die Mathematik noch vor Christi Geburt trug.

Auf jeden Fall ist Software heute noch weit davon ent­fernt, so fehlerfrei zu sein, wie die Ergebnisse der Mathematiker das sein möchten (und i.A. auch wirklich sind).

Siehe auch:

• Das Kreuz mit der Software-Qualität
• Es wird höchste Zeit …

 
Dass es wirklich höchste Zeit wird, zeigt eine ganz unglaubliche Sicherheitslücke, die 2015 in gleich mehreren Tausend auf Mongo-DB basierender Anwendungen entdeckt wurde (aber nicht dem Datenbankhersteller anzulasten ist):

Wie die Computerwoche schrieb, handelte es sich um Konfigurationsfehler die zur Folge hatten, dass — im Prinzip wenigstens — jeder Internet-Nutzer mehrere Millionen Kundendaten nach Name, Adresse, E-Mail und Kreditkartennummer im Internet nicht nur abrufen, sondern auch manipulieren konnte.

Von den zahlreichen Entwicklern dieser vielen Anwendungen war ganz offen­sichtlich kein oder viel zu wenig ernsthafter Sicherheitstest durchgeführt worden.

Will da noch jemand behaupten, sie hätten professionell genug gearbeitet?

 

PS: Im Artikel Dogma-driven Development schreibt ein gewisser David Green recht treffend:
 
The trouble is, in this farcical echo chamber of an industry, where the lessons of 40 years ago still haven’t been learnt properly. Where we keep repeating the mistakes of 20 years ago. Of 10 years ago. Of 5 years ago. Of 2 years ago. Of last week. For Christ’s sake people, can we not just learn a little of what’s gone before?

Man ist versucht zu fragen: Warum gestatten Auftraggeber den Software-Entwicklern derart unprofessionell zu arbeiten? Zählt denn wirklich nur, dass sie einen Festpreis einhalten? Warum interessiert die Auftraggeber kaum die abgelieferte Qualität? Fühlt man sich unfähig, sie zu beurteilen?

 

Wie fehlerbehaftet ist typische Software?

Wissenschaftliche Untersuchungen (z.B. eine der Carnegie Mellon University aus 2003) belegen, dass moderne Software, wenn sie in Betrieb genommen wird, i.A. immer noch bis zu fünf Fehler pro 1000 Lines of Code enthält; sprich: etwa 1 Fehler auf je 3 DIN A4 Seiten manuell erstellten Source Codes.

Selbst in den besten aller je untersuchten (größeren) Programme fand sich immer noch 1 Fehler in je 7500 Zeilen Code.

Wären mathematische Publikationen auch nur annähernd so fehlerhaft, wäre die Mathematik als Wissenschaft sicher längst in sich zusammen gebrochen (denn dort bauen neue Ergebnisse ja stets auf älteren auf).

Wir sehen: Die Informatik — wenigstens aber ihre Technik zur Qualitätssicherung — steckt heute wohl noch in Kinderschuhen, die vergleichbar sind mit denen, die die Mathematik zu Zeiten von Aristoteles, Pythagoras und Euklid trug.

Haben wir da ein Problem?

Und wird man sich leisten können, damit noch lange zu leben?