“Quick & Dirty” in der Software-Entwicklung spart kurzfristig Zeit, kann aber langfristig mehr schaden als nützen. Hier ist ein Umdenken in Richtung “vernünftige” Software-Entwicklung gefragt. Erfahren Sie hier, worauf es dabei ankommt.

Software, die schnell aber handwerklich schlecht entwickelt wird, verursacht weltweit immensen Schaden – der größte Teil davon durch Software-Ausfälle im Betrieb. Studien zufolge lagen die Kosten von Ausfällen infolge schlechter Softwarequalität in den USA im Jahr 2020 bei 1,56 Billionen US-Dollar. Das ist 10-mal teurer, als Fehler in der Entwicklung zu vermeiden bzw. zu beheben, bevor die Software in Betrieb genommen wird.

Wenn Software weiterentwickelt wird und wächst, neigt ihre Architektur dazu, komplex zu werden. Das macht die Wartung der Software schwierig und fehleranfällig. Sind Design, Architektur und Quellcode zudem von vornherein schlecht angelegt, kann früher oder später jede noch so kleine Anpassung für Product Owner und Entwickler zum Alptraum werden. 

Die Herausforderung für Entwickler ist, Fehler im Programmiercode zu vermeiden bzw. so früh wie möglich zu erkennen, sodass sie relativ kostengünstig zu beheben sind. Dazu müssen Software-Handwerk und Qualitätsmanagement ab der ersten Zeile Code eng ineinandergreifen. Denn bereits in Zeile 1 wird die Basis für qualitätvolle und nachhaltige Software gelegt. 

Vernünftige Software-Entwicklung zielt darauf ab, Geschwindigkeit und Qualität bestmöglich zu vereinbaren. Der Schlüssel liegt in gutem Software-Design, das nicht “quick & dirty” sondern nachhaltig entwickelt werden sollte.

Grundwerte unseres Software-Handwerks (Software Craftsmanship)

  • Qualität: Software soll nicht nur funktionieren, sondern auch gut gemacht sein
  • Mehrwert: Wir reagieren nicht nur auf Veränderungen, sondern schaffen stetig Mehrwerte
  • Team: Nicht Individuen schaffen gute Ergebnisse, sondern eine Gemeinschaft von Fachleuten
  • Kooperation: Produktive Partnerschaften statt nur Zusammenarbeit mit Kunden

Quelle: manifesto.softwarecraftsmanship.org


Komplexe Software schnell und auf höchstem Qualitätsniveau entwickeln

Software Code wird heutzutage dank fortgeschrittener Tools und Methoden schneller als je zuvor veröffentlicht. Dadurch können Unternehmen neue Funktionen in immer kürzerer Zeit entwickeln. Gleichzeitig wächst auch die Komplexität der Funktionen, die früher sehr viel mehr Zeit für Entwicklung und Testing beansprucht hat als heute. Diese erfreuliche Entwicklung hat jedoch Grenzen, wenn die Qualität der Software unter Zeitdruck und Komplexität leidet. 

Die Herausforderung: Je schneller Unternehmen neue Funktionen entwickeln, desto schwieriger ist es, die Qualität und Zuverlässigkeit von Software sicherzustellen. Durch sehr kurze Testzeiten wächst das Risiko, dass mehr Fehler unentdeckt bleiben und ihren Weg in die Produktion finden. Je nach Häufigkeit und Umfang von Anpassungen akkumulieren diese Fehler und lassen Software-Design und -Architektur über kurz oder lang erodieren bzw. verrotten. Die Kosten für das Finden und Beheben von Fehlern in erodierenden Systemen steigen mit jeder Anpassung.

Kosten eines Fehlers im Software-Entwicklungsprozess

Kritische Software-Fehler im laufenden Betrieb zu finden und zu beheben ist 10-mal teurer, als diese zu finden und zu beheben, bevor die Software in Betrieb genommen wird. Es lohnt sich also zu Beginn in die Vermeidung von Fehlern durch sauberes Design zu investieren, statt unter Zeit- und Erfolgsdruck “quick & dirty” zu entwickeln.

Quelle: altexsoft.com

Die Kehrseite von “quick & dirty”

Software-Erosion, -Zerfall oder -Verrottung bezeichnet die schleichende Verschlechterung einer Software infolge schlechter Planung und/ oder Umsetzung. Indizien für Software-Erosion sind u.a. die Akkumulation von Programmfehlern, erschwerte Anpassbarkeit, Rückgang der Performanz, sowie Inkompatibilitäten mit neuen und zukünftigen Software-Umgebungen. Die Software bekommt mittelfristig einen “Code-Smell”, bei dem der Quellcode zwar noch funktioniert, aber schlecht strukturiert ist. Die Software wird nach und nach zu einem Altsystem und damit funktional und wirtschaftlich unbrauchbar.

Symptome für verrottendes Software-Design

  1. Starrheit: das System lässt sich nur schwer und mit viel Aufwand ändern
  2. Fragilität: kleine Änderungen haben unvorhersehbare Konsequenzen im System
  3. Unbeweglichkeit: einzelne Komponenten lassen sich nur schwer isolieren
  4. Viskosität: die Architektur der Software lässt sich bei Eingriffen schwer erhalten
  5. Unnötige Komplexität: die Software enthält Infrastruktur ohne direkten Nutzen
  6. Unnötige Wiederholungen: Architektur enthält Code-Strukturen, die sich wiederholen
  7. Undurchsichtigkeit: Quellcode ist schwer zu lesen und zu verstehen

Quelle: in Anlehnung an Robert C. Martin

Nachhaltige Software-Entwicklung statt “quick & dirty”

Die Qualität von Software steht und fällt langfristig mit einem guten Software-Design und einer sauberen Umsetzung des Software-Codes. Die Weiche für Qualität wird bereits im Design gestellt, denn der Plan für eine Computersoftware ist so wichtig wie der Plan für ein Haus, sonst entsteht Chaos. Das Software-Design definiert, was in der Umsetzung in Form von Software-Code gebaut werden soll. Beide – Design und Code – erfordern höchstes handwerkliches Niveau.

Die Rolle von gutem Software-Design

Gutes Design kostet zwar Zeit und Mühe, zahlt sich aber aus, weil es die Weiterentwicklung der Software in Zukunft erleichtert. Schlechtes Design spart kurzfristig Zeit und Aufwand, verursacht aber technische Schulden, die die Produktivität der Software-Entwicklung später bremsen.

Gutes versus schlechtes Software-Design

Quelle: in Anlehnung an geeksforgeeks.org

Die Rolle von gutem Software-Code

Die Qualität und Struktur des Quellcodes entscheidet wesentlich darüber, ob sich eine Software wirtschaftlich weiterentwickeln lässt oder nicht. Wird Software-Code etwa zu Beginn der Entwicklung unter Zeitdruck schnell und “schmutzig” entwickelt, schleichen sich Fehler ein, die man später im Projekt teuer bezahlt. Anders als bei “Clean Code”, der einfach und strukturiert geschrieben ist, wachsen die Kosten für Anpassungen von “schmutzigem” Code über die Zeit.

“Dirty and Fast Code” hat nur der Entwickler im Griff, der diesen geschrieben hat und selbst dieser tut sich nach einiger Zeit und tausenden von Zeilen irgendwann schwer damit, seinen eigenen Code zu verstehen. Und was passiert, wenn dieser Entwickler ausfällt, etwa durch Krankheit, Urlaub oder, weil er zu einem anderen Arbeitgeber wechselt? Dann kann es zur Katastrophe kommen – der sogenannte “Bus-Faktor” beschreibt dieses Risiko.

Exkurs: Der “Bus-Faktor” beziffert die Mindestanzahl von Entwicklern im Team, die plötzlich aus einem Projekt verschwinden müssen, damit ein Projekt wegen Mangel an Code-Wissen zum Stillstand kommt. Wenn sich nur ein Entwickler mit dem Code auskennt, ist das Risiko extrem hoch, dass ein Projekt zum Stillstand kommt, sollte dieser Entwickler ausfallen. Es empfiehlt sich daher, Code-Wissen immer im Team zu verteilen.Sobald andere Entwickler an fremdem Code arbeiten sollen, wächst der Aufwand immens, da diese zunächst die individuelle Struktur verstehen müssen, bevor sie diese anpassen können. Und selbst dann, lassen sich die Risiken von Eingriffen nur schwer abschätzen, da verborgene Beziehungen im System nicht einfach zu erkennen sind. “Clean Code” dagegen macht es Entwicklern, die den Code nicht selbst geschrieben haben, sehr viel leichter, Strukturen zu verstehen und diese mit minimalem Risiko weiterzuentwickeln.

Clean Code ist einfach und direkt. Clean Code liest sich wie eine gut geschriebene Prosa. Clean Code verschleiert nie die Absicht des Designers, sondern ist voller klarer Abstraktionen und geradliniger Kontrolllinien.” – Grady Booch (Autor von Object-Oriented Analysis and Design with Applications)

Leseempfehlung zur Bedeutung der Architektur für die Nachhaltigkeit von Software:
Software-Architektur für KMU: Microservices vs Monolith – Welches ist die beste Lösung? 


Agile Softwareentwicklung nach handwerklichen Prinzipien

Software-Entwicklung nach dem Quick-and-dirty-Prinzip verursacht immense Folgekosten und lässt Product Owner in Unternehmen schlecht schlafen. Deshalb folgen wir bei voltage IT in der Softwareentwicklung den Prinzipien des “Software Craftsmanship”, die nachhaltige Qualität konsequent über kurzfristige Erfolge stellt. 

Nachhaltiges Software-Design und sauberer Code spielen in unseren Projekten eine zentrale Rolle. Für die Umsetzung nutzen wir agile Methoden und Werkzeuge:

  • TDD (Test Driven Development): Die Funktionalität jedes Software Features wird über mindestens einen automatisierten Test überwacht. Dies schafft Sicherheit und Vertrauen bei Code-Änderungen und ermöglicht schnelle Entwicklungszyklen ohne manuelle Testdurchläufe.
  • Pair Programming/ Continuous Code Review: Während ein Entwickler den Code schreibt, liefert ein anderer laufend Feedback und macht Verbesserungsvorschläge. Dadurch entsteht bereits während der Arbeit ein qualitativ besserer Code und spart nachträgliche Code Reviews.
  • Refactoring: Gut gemachte Software muss intensiv und kontinuierlich refaktorisiert werden, um gut gemacht zu bleiben. Beim Refactoring wird die interne Struktur eines bestehenden Code angepasst ohne das externe Verhalten zu ändern.
  • Continuous Delivery: Code wird in sehr kurzen Zyklen angepasst, sodass Änderungen jederzeit für das gesamte Team nachprüfbar bleiben. Damit lassen sich große, verborgenen Softwarefehler in der Produktion vermeiden und kleinere Defekte blitzschnell beheben.

Ein Wort zum Schluss: In vielen Bereichen unseres Lebens konnten handwerkliche Tätigkeiten durch Fließband und Automatisierung rationalisiert werden, was in vielen Fällen aus ökonomischer Sicht seine Berechtigung hat. Unsere langjährige Erfahrung zeigt, dass Fließbandarbeit in der Softwareentwicklung an Grenzen stößt und mittelfristig eher schadet als nützt. Gute Software braucht nach wie vor gutes Handwerk, und das wird so bleiben.

Leseempfehlungen

Wir unterstützen Sie

Seit vielen Jahren kämpfen wir dafür, dass Unternehmen die richtigen IT-Entscheidungen treffen und Software-Systeme bekommen, von denen sie nachhaltig profitieren und die sie selbst beherrschen können. Unser Credo: Vernünftige Lösungen jenseits von Technologie-Hype.