Nachhaltige Softwareentwicklung wird immer wichtiger, um mit den rasanten technologischen Fortschritten, die eine digitale Transformation mit sich bringt, Schritt halten zu können. Nicht selten bringen diese nämlich sich verändernde Kunden- und Marktanforderungen mit sich, auf die es zu reagieren gilt. Und solch eine Reaktion kann nicht immer daraus bestehen, eine neue Softwarelösung einzukaufen oder zu entwickeln. Das ist weder technologisch noch wirtschaftlich nachhaltig. Doch wie kann man Software nachhaltig entwickeln? Und was bedeutet das eigentlich?
Nachhaltige Softwareentwicklung in 5 Minuten: Unser CTO Sebastian Betzin fasst das Thema zusammen und gibt einen groben Überblick.
Nachhaltigkeit in der Softwareentwicklung bedeutet Softwarelösungen zu entwickeln, die über einen längeren Zeitraum nutzbar, vor allen Dingen aber auch veränderbar und weiterentwickelbar sind. Denn letztendlich geht es auch in der Softwareentwicklung darum, verantwortungsvoll mit Ressourcen umzugehen. Software zu entwickeln, benötigt Zeit, Geld und Energie. Schon aus wirtschaftlicher Perspektive macht es wenig Sinn, jeder neuen Anforderung mit einem komplett neuen Produkt zu begegnen. Eine Softwarelösung ist dann nachhaltig, wenn sie dazu im Stande ist, sich effizient und einfach auf neue Markt- oder Kundenanforderungen adaptieren zu lassen.
Beschäftigt man sich mit nachhaltiger Softwareentwicklung, muss man sich auch zwangsläufig mit Softwarequalität auseinandersetzen. Denn eine hohe Softwarequalität ist die Grundvoraussetzung für flexibel veränderbare und weiterentwickelbare – und damit nachhaltige – Software. Dabei ist sowohl die innere wie auch die äußere Qualität entscheidend.
Bei der äußeren Softwarequalität sind es die Treiber Funktionalität, Skalierbarkeit und Effizienz einer Applikation sowie die Usability der Software. Features müssen flexibel veränderbar und erweiterbar sein – und das bei gleichbleibender Performance und Benutzerfreundlichkeit der Softwarelösung.
Noch elementarer für die Nachhaltigkeit ist jedoch die innere Softwarequalität, denn sie bildet das Fundament der Lösung und ist die Voraussetzung für eine hohe äußere Qualität. Hier kommt es auf die Beschaffenheit des Quellcodes an. Wichtig sind drei Gesichtspunkte: die Les- und Nachvollziehbarkeit sowie die Testbarkeit und Evolvierbarkeit. Quellcode muss jederzeit und von jedem und jeder Softwareentwickler:in sowohl in seiner Syntax wie auch in seiner Semantik verständlich sein. Das bedeutet, er muss formal eindeutig lesbar und semantisch eindeutig nachvollziehbar sein. Gleichzeitig muss er im Einzelnen über Unit Tests wie auch im Ganzen über Integrations- und Systemtests automatisiert testbar sein. Das primäre Ziel ist eine hohe Evolvierbarkeit der Software – das bedeutet: die „Fähigkeit“ des Quellcodes, sich flexibel verändern zu lassen. Eine hohe Lesbarkeit, Nachvollziehbarkeit und Testbarkeit sind bereits wichtige Grundpfeiler für diese Fähigkeit, jedoch kommt es bei Evolvierbarkeit auch auf das Code-Design an. Also wie der Quellcode aufgebaut und strukturiert ist. Doch auch hierfür gibt es heutzutage Tools und Methoden, die eine hohe Wandelbarkeit von Grund auf sicherstellen können.
Hochqualitativen und damit nachhaltigen Quellcode zu schreiben, startet schon vor dem eigentlichen Coding. Nämlich mit einem durchdachten Software-Design. Damit ist nicht gemeint, wie die komplette Lösung und die System-Architektur aufgebaut ist oder wie die Interfaces später aussehen, sondern wie der Quellcode strukturiert ist. Am Ende geht es um die Frage, wie man auf dem besten Wege von der (Kunden-)Anforderung zum Code kommt. Und es lohnt sich, diese Frage mit dem gesamten Dev-Team zu beantworten, noch bevor eine Zeile Code geschrieben wird. Eine besonders in der Praxis bewährte Technik für solch ein Vorgehen ist das sogenannte Flow Design.
Bei Flow Design werden Anforderungen zunächst hierarchisch zerlegt, um die primären Funktionen, hier als Dialoge bezeichnet, herauszuarbeiten. Ein Dialog besteht dabei immer aus einer oder mehreren Interaktionen, die wiederum in Datenflüsse zerlegt werden können. Diese Datenflüsse (Flows) werden grafisch mit unterschiedlichen Symbolen und Pfeilen dargestellt. Ziel ist es, das Problem aus der Anforderung mithilfe sinnvoller Datenflüsse bis ins Detail zu lösen, um Kontrakte für Klassen und Methoden bestimmen zu können. Die komplette Struktur mitsamt den Klassen, Methoden, Zustandsvariablen und Parametern ist also bereits bekannt und muss anschließend „nur noch“ in Code gegossen werden.
Clean Code Development ist ein Wertesystem für Softwareentwickler:innen, das darauf ausgelegt ist, langfristig flexiblen Quellcode zu entwickeln. Über Werte und Tugenden wird ein entsprechendes Mindset bei den Entwickler:innen aufgebaut, die Clean Code Prinzipien und Praktiken liefern nützliche Handlungsempfehlungen und Tipps für die alltägliche Arbeit.
Viele Clean Code Prinzipien, die auf die Evolvierbarkeit des Quellcodes abzielen, können bereits durch die gemeinsame Codegestaltung mit Flow Design berücksichtigt werden. Beispielsweise können dadurch Klassen hinsichtlich ihrer Aufgaben und Verantwortlichkeiten so gegliedert und gestaltet werden, dass es zu keinen Abhängigkeiten kommt. Und auch eine konsistente Testabdeckung kann bereits via Flow Design geplant werden.
Bei der eigentlichen Umsetzung des Code-Designs – also der Programmierung – helfen insbesondere die Clean Code Prinzipien und Praktiken zu den Themen Lesbarkeit und Nachvollziehbarkeit. So sollten sich die Entwickler:innen an syntaktische Konventionen halten, die ein schnelles Lesen und Erfassen des Codes erlauben. Dadurch wird sichergestellt, dass sich auch zukünftige Entwickler:innen gut im Code zurechtfinden. Ein weiteres Prinzip heißt „Don’t Repeat Yourself“. Hier geht es darum, einzelne Code-Abschnitte nicht einfach zu kopieren, marginal zu verändern und dann wiederzuverwenden. Wird eine Befehlsfolge mehrfach verwendet, ist sie meistens falsch gegliedert. Die Folge: der Code wird unnötig länger, die Gefahr der Inkonsistenz steigt und die Wandelbarkeit leidet, da eine Veränderung an mehreren Stellen durchgeführt werden muss.
Bisher haben wir uns nur mit dem Quellcode einer Softwarelösung auseinandergesetzt. Jedoch muss Softwareentwicklung, um wirklich nachhaltig zu sein, immer ganzheitlich betrachtet werden. Denn letztendlich geht es auch darum, für wen und für was die Softwarelösung überhaupt entwickelt wird. Egal, ob es um das MVP geht oder um spätere Weiterentwicklungen – die Themen Requirements Engineering und User Experience Design sind für die Nachhaltigkeit einer Lösung maßgeblich entscheidend und müssen mitsamt der Programmierung Hand in Hand gehen. Werden hier Fehler gemacht oder falsche Annahmen getroffen, bringt auch der sauberste und nachhaltigste Quellcode nicht viel.
Mit Flow Design gelangt man auf dem nachhaltigsten Wege von der Anforderung zum Code. Doch wie gelangt man überhaupt erst zur Anforderung. Viele Unternehmen gehen diesen Weg nach wie vor über ein Lastenheft. Als erste Maßnahme ist solch ein Vorgehen nicht verkehrt, es jedoch dabei zu belassen und davon auszugehen, dass das Lastenheft einfach Stück für Stück abgearbeitet wird und dann das perfekte Softwareprodukt entsteht, greift zu kurz. Häufig fehlt dabei nämlich der holistische Blick, da nicht alle Stakeholder in den Prozess der Anforderungsdefinition involviert sind. Noch riskanter ist es jedoch, Requirements Engineering als einmaligen und abgeschlossenen Prozess zu verstehen. Vielmehr muss die Anforderungsdefinition kontinuierlicher Bestandteil der Softwareentwicklung und eigentlicher Startpunkt jeder Iteration sein, um ein nachhaltiges Produkt zu entwickeln.
Werden Anforderungen nicht von allen Stakeholdern getroffen und nicht regelmäßig validiert, hinterfragt und ggf. angepasst, wird schlichtweg nicht das richtige Softwareprodukt entwickelt. Fehlen die entsprechenden Blickwinkel und Prognosen und wird nicht rechtzeitig auf neue Sachverhalte reagiert, sinkt natürlich auch die Halbwertszeit der späteren Lösung.
Wie schon erwähnt, müssen idealerweise alle Stakeholder des späteren Softwareprodukts in den Softwareentwicklungsprozess involviert werden. Gerade bei der Entwicklung komplexer Enterprise-Lösungen wird jedoch häufig eine wichtige Gruppe vernachlässigt: die späteren Nutzer:innen. Die Gefahr dabei: Können sie mit der Softwarelösung nicht richtig arbeiten, werden sie unzufrieden sein, im schlimmsten Fall die Software erst gar nicht nutzen.
Bei B2C-Apps wird viel mehr Wert auf die User Experience und eine gute Usability gelegt – das liegt auf der Hand, schließlich sind die Nutzer:innen in diesem Fall die direkten Kund:innen. Das Denken, dass Enterprise-Lösungen in erster Linie für ein Unternehmen entwickelt werden – das Unternehmen also mit dem Kunden gleichgesetzt wird –, ist jedoch obsolet. Denn letztendlich nutzen auch in diesem Fall Menschen das Softwareprodukt und müssen damit umgehen können – bestenfalls sogar mit Freude.
Nachhaltige Softwareentwicklung bedeutet daher (auch für Enterprise-Lösungen) die Nutzer:innen zu involvieren. Das geschieht zunächst dadurch, dass über sogenannte Personas nutzercharakteristische Prototypen gebildet werden. Anhand dieser Personas können die Nutzergruppen hinsichtlich ihrer Eigenschaften, Pains und Wünschen beschrieben und im nächsten Schritt Interaktionskonzepte entwickelt werden. Dabei ist es unerlässlich, die getroffenen Annahmen regelmäßig zu prüfen. Ähnlich der Gestaltung des Quellcodes ist eine hohe Testabdeckung also auch für die User Experience elementar. Warum Usability-Tests so wichtig sind und wie man UX-Design testen kann, hat unser Head of UX Uwe Betzin in diesem Artikel beschrieben: UX-Design muss funktionieren
Bleibt noch die Frage, warum nicht alle Softwareentwicklungsunternehmen nachhaltig entwickeln. Um diese Frage zu beantworten, muss man verschiedene Blickwinkel einnehmen:
Blickwinkel des Softwareentwicklers:
Nachhaltige Code-Gestaltung und die Arbeit nach Clean Code ist (noch) kein fester Bestandteil der Ausbildung zur Softwareentwicklerin oder zum Softwareentwickler. Gleichzeitig erfordert Clean Coder zu werden, viel Engagement, Fleiß und Übung. Oft fehlt es Entwickler:innen in einem Unternehmen schlicht an den notwendigen Rahmenbedingungen, um Clean Code Development überhaupt erlernen und üben zu können.
Blickwinkel des Dienstleisters:
Eben diese Rahmenbedingungen zu schaffen, in nachhaltige Softwareentwicklung zu investieren, das Personal zu schulen und eine entsprechende Qualitätssicherung in den Projekten zu implementieren, geht mit hohen Kosten einher. Viele Softwaredienstleister gehen solch ein Risiko aus Angst des fehlenden ROIs nicht ein.
Und auch das Thema Ganzheitlichkeit kann nicht von jedem Softwaredienstleister geleistet werden, da nicht jedes Unternehmen Kompetenzen und Personal über alle Entwicklungsebenen hinweg bereitstellt.
Blickwinkel des Auftraggebers:
Die initialen Kosten für nachhaltige Softwarelösungen liegen höher. Das liegt zum einen an der ganzheitlichen Herangehensweise hinsichtlich kontinuierlichem Requirements Engineering und UX-Design. Zum anderen geht die Softwareentwicklung mit Clean Code zunächst mit einem höheren Invest einher als die konventionelle Entwicklung. Diese Mehrkosten schrecken viele Unternehmen zunächst ab.
Was bei dieser Rechnung jedoch oft vernachlässigt wird, ist die eigentliche Idee hinter nachhaltiger Software – und damit der Blick in die Zukunft. Denn betrachtet man die Total Cost of Ownership über die gesamte Produt Lifetime hinweg, zeichnet sich schnell ein ganz anderes Bild. Nehmen wir lediglich den Clean Code Aspekt: Wird in der Entwicklung kaum Wert auf hohe innere Softwarequalität gelegt, wird es mit jeder Iteration aufwändiger, neue Features zu implementieren. Die Aufwände steigen dabei nicht linear, sondern exponentiell – und das hat in der Realität zur Folge, dass die Software irgendwann gar nicht mehr weiterentwickelt werden kann.
Nachhaltige Softwareentwicklung meint die Entwicklung von langlebigen Softwareprodukten, die flexibel und effizient verändert und weiterentwickelt werden können. Um nachhaltige Software zu entwickeln, sollten folgende Regeln beachtet werden:
Auf welche Softwarequalitätsmerkmale es aus technischer & wirtschaftlicher Sicht ankommt und wie Clean Code Development dabei helfen kann, diese zu erreichen
Clean Code Development ist in verschiedenen Graden unterteilt, die man als Entwickler eine nach der anderen erklimmt und in einem ewigen Kreislauf wiederholt