30.11.22
Clean Code
Development
Digitalisierung

Nachhaltige Software­entwicklung: Was man darunter versteht und wie man nachhaltig entwickelt

Nachhaltige Software­entwicklung wird immer wichtiger, um mit den rasanten techno­logischen Fort­schritten, die eine digitale Trans­formation mit sich bringt, Schritt halten zu können. Nicht selten bringen diese nämlich sich verändernde Kunden- und Markt­anforderungen mit sich, auf die es zu reagieren gilt. Und solch eine Reaktion kann nicht immer daraus bestehen, eine neue Software­lösung einzukaufen oder zu entwickeln. Das ist weder technologisch noch wirtschaftlich nachhaltig. Doch wie kann man Software nachhaltig entwickeln? Und was bedeutet das eigentlich?  


  1. Was bedeutet nachhaltige Software­entwicklung eigentlich?
  2. Nachhaltige Software­entwicklung und Softwarequalität
  3. Wie man Software nachhaltig entwickelt
    3.1 Nachhaltige Software­gestaltung mit Flow Design
    3.2 Nachhaltige Programmierung durch Clean Code Prinzipien
    3.3 Nachhaltigkeit durch Ganzheitlichkeit
  4. Warum entwickeln nicht alle Software­dienstleister nachhaltig?  
  5. Fazit

Nachhaltige Software­­entwicklung in a Nutshell

Nachhaltige Softwareentwicklung in 5 Minuten: Unser CTO Sebastian Betzin fasst das Thema zusammen und gibt einen groben Überblick.


1. Was bedeutet nachhaltige Software­entwicklung eigentlich?

Nachhaltigkeit in der Software­entwicklung bedeutet Software­lösungen zu entwickeln, die über einen längeren Zeitraum nutzbar, vor allen Dingen aber auch veränderbar und weiter­entwickel­bar sind. Denn letztendlich geht es auch in der Software­entwicklung darum, verantwortungs­voll 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 Software­lösung ist dann nachhaltig, wenn sie dazu im Stande ist, sich effizient und einfach auf neue Markt- oder Kunden­anforderungen adaptieren zu lassen.

2. Nachhaltige Software­entwicklung und Software­qualität

Beschäftigt man sich mit nach­haltiger Software­entwicklung, muss man sich auch zwangsläufig mit Software­qualität auseinandersetzen. Denn eine hohe Software­qualität ist die Grund­voraus­setzung für flexibel veränderbare und weiter­entwickelbare – und damit nachhaltige – Software. Dabei ist sowohl die innere wie auch die äußere Qualität entscheidend.

Bei der äußeren Software­qualitä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 gleich­bleibender Performance und Benutzer­freundlichkeit der Software­lösung.

Noch elementarer für die Nach­haltigkeit ist jedoch die innere Software­qualität, denn sie bildet das Fundament der Lösung und ist die Voraus­setzung für eine hohe äußere Qualität. Hier kommt es auf die Beschaffenheit des Quell­codes an. Wichtig sind drei Gesichts­punkte: die Les- und Nach­voll­zieh­barkeit sowie die Testbarkeit und Evolvierbarkeit. Quellcode muss jederzeit und von jedem und jeder Software­entwickler:in sowohl in seiner Syntax wie auch in seiner Semantik verständlich sein. Das bedeutet, er muss formal eindeutig lesbar und semantisch eindeutig nachvoll­ziehbar sein. Gleich­zeitig muss er im Einzelnen über Unit Tests wie auch im Ganzen über Integrations- und System­tests automatisiert testbar sein. Das primäre Ziel ist eine hohe Evolvierbarkeit der Software – das bedeutet: die „Fähigkeit“ des Quell­codes, sich flexibel verändern zu lassen. Eine hohe Lesbarkeit, Nach­voll­zieh­barkeit und Test­barkeit sind bereits wichtige Grund­pfeiler für diese Fähigkeit, jedoch kommt es bei Evolvierbarkeit auch auf das Code-Design an. Also wie der Quell­code aufgebaut und strukturiert ist. Doch auch hierfür gibt es heutzutage Tools und Methoden, die eine hohe Wandel­barkeit von Grund auf sich­erstellen können.

Software­qualität ist nicht gleich Software­qualität: Wir unterscheiden in die äußere Qualität (links) und die innere Qualität (rechts)

3. Wie man Software nach­haltig entwickelt

3.1 Software­gestaltung mit Flow Design

Hochqualitativen und damit nachhaltigen Quell­­code zu schreiben, startet schon vor dem eigentlichen Coding. Nämlich mit einem durch­dachten 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 Quell­code 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 soge­nannte Flow Design.

Bei Flow Design werden Anforderungen zunächst hierarchisch zerlegt, um die primären Funktionen, hier als Dialoge bezeichnet, heraus­­zuarbeiten. Ein Dialog besteht dabei immer aus einer oder mehreren Interaktionen, die wiederum in Daten­flüsse zerlegt werden können. Diese Daten­flüsse (Flows) werden grafisch mit unter­schiedlichen Symbolen und Pfeilen dargestellt. Ziel ist es, das Problem aus der Anforderung mithilfe sinn­voller Daten­flü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, Zustands­variablen und Parametern ist also bereits bekannt und muss anschließend „nur noch“ in Code gegossen werden.

Die Vorteile von Flow Design:

  • Anforderungen werden in die Breite und in die Tiefe zerlegt, wodurch der Quell­code bis ins Detail geplant werden kann, gleichzeitig das Big Picture aber nie aus den Augen verloren wird.
  • Das gesamte Team kann in den Software-Design­prozess involviert werden, was sich u. a. positiv auf die Verantwortlich­keiten im Team sowie die Lesbarkeit des Codes auswirkt.
  • Die genaue Planung bildet die ideale Vorlage für eine durch­dachte Test­suite und stellt damit eine hohe Test­abdeckung sicher.
Software-Design im Team: Mit Flow Design kann der gesamte Quell­code von Grund auf geplant und strukturiert werden – noch bevor eine Zeile Code geschrieben wird

3.2 Nachhaltige Programmierung mit Clean Code

Clean Code Development ist ein Werte­system für Software­entwickler:innen, das darauf ausgelegt ist, lang­fristig flexiblen Quell­code zu entwickeln. Über Werte und Tugenden wird ein entsprechendes Mindset bei den Entwickler:innen aufgebaut, die Clean Code Prinzipien und Praktiken liefern nützliche Handlungs­empfehlungen und Tipps für die alltägliche Arbeit.

Viele Clean Code Prinzipien, die auf die Evolvierbarkeit des Quell­codes abzielen, können bereits durch die gemeinsame Code­gestaltung mit Flow Design berücksichtigt werden. Beispiels­weise können dadurch Klassen hinsichtlich ihrer Aufgaben und Verantwortlich­keiten so gegliedert und gestaltet werden, dass es zu keinen Abhängig­keiten kommt. Und auch eine konsistente Test­abdeckung 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 Les­barkeit und Nach­voll­zieh­barkeit. So sollten sich die Entwickler:innen an syntaktische Konventionen halten, die ein schnelles Lesen und Erfassen des Codes erlauben. Dadurch wird sicher­gestellt, dass sich auch zukünftige Entwickler:innen gut im Code zurecht­finden. 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 wieder­zuverwenden. Wird eine Befehls­folge mehrfach verwendet, ist sie meistens falsch gegliedert. Die Folge: der Code wird unnötig länger, die Gefahr der Inkonsistenz steigt und die Wandel­barkeit leidet, da eine Veränderung an mehreren Stellen durch­geführt werden muss.

Die wichtigsten Clean Code Prinzipien für die Evolvierbarkeit

  • Don’t Repeat Yourself
    Code­bestandteile dürfen nicht dupliziert werden – Copy/Paste ist verboten
  • Single Responsibility Principle
    Eine Klasse sollte immer nur eine Aufgabe/Verant­wortlich­keit haben
  • Open Closed Principle
    Eine Klasse muss offen für Erweiterungen sein, jedoch geschlossen für Modifizierungen
  • Dependency Inversion Principle
    Klassen dürfen nicht voneinander abhängig sein, sondern nur von Interfaces
Clean Code Development: Das Werte­system transportiert aufgeteilt über fünf Grade Prinzipien und Praktiken der nach­haltigen Software­entwicklung

3.3 Nach­haltigkeit durch Ganzheit­lichkeit

Bisher haben wir uns nur mit dem Quell­code einer Software­lösung auseinander­gesetzt. Jedoch muss Software­entwicklung, um wirklich nachhaltig zu sein, immer ganzheitlich betrachtet werden. Denn letztendlich geht es auch darum, für wen und für was die Software­lösung überhaupt entwickelt wird. Egal, ob es um das MVP geht oder um spätere Weiter­entwicklungen – die Themen Requirements Engineering und User Experience Design sind für die Nach­haltigkeit 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 nach­haltigste Quell­code nicht viel.

Nachhaltigkeit mittels (kontinuierlichem) Requirements Engineering

Mit Flow Design gelangt man auf dem nach­h­altigsten 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 Lasten­heft einfach Stück für Stück abgearbeitet wird und dann das perfekte Software­produkt entsteht, greift zu kurz. Häufig fehlt dabei nämlich der holistische Blick, da nicht alle Stake­holder in den Prozess der Anforderungs­definition involviert sind. Noch riskanter ist es jedoch, Requirements Engineering als einmaligen und abgeschlossenen Prozess zu verstehen. Vielmehr muss die Anforderungs­definition kontinuierlicher Bestandteil der Software­entwicklung und eigentlicher Start­punkt 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 Software­produkt entwickelt. Fehlen die entsprechenden Blick­winkel und Prognosen und wird nicht rechtzeitig auf neue Sach­verhalte reagiert, sinkt natürlich auch die Halbwerts­zeit der späteren Lösung.  

Nachhaltigkeit durch Nutzer­zentrierung: Enterprise-UX

Wie schon erwähnt, müssen idealerweise alle Stakeholder des späteren Software­produkts in den Software­entwicklungs­prozess 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 Software­lö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 Unter­nehmen entwickelt werden – das Unternehmen also mit dem Kunden gleich­gesetzt wird –, ist jedoch obsolet. Denn letzt­endlich nutzen auch in diesem Fall Menschen das Software­produkt und müssen damit umgehen können – bestenfalls sogar mit Freude.

Nachhaltige Software­entwicklung bedeutet daher (auch für Enterprise-Lösungen) die Nutzer:innen zu involvieren. Das geschieht zunächst dadurch, dass über sogenannte Personas nutzer­charakteristische Proto­typen gebildet werden. Anhand dieser Personas können die Nutzer­gruppen hinsichtlich ihrer Eigenschaften, Pains und Wünschen beschrieben und im nächsten Schritt Interaktions­konzepte entwickelt werden. Dabei ist es unerlässlich, die getroffenen Annahmen regelmäßig zu prüfen. Ähnlich der Gestaltung des Quell­codes ist eine hohe Test­abdeckung 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

4. Warum entwickeln nicht alle Software­dienstleister nach­haltig?

Bleibt noch die Frage, warum nicht alle Software­entwicklungs­unternehmen nach­haltig entwickeln. Um diese Frage zu beantworten, muss man verschiedene Blick­winkel einnehmen:

Blickwinkel des Softwareentwicklers:

Nachhaltige Code-Gestaltung und die Arbeit nach Clean Code ist (noch) kein fester Bestandteil der Ausbildung zur Software­entwicklerin 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 Rahmen­bedingungen, um Clean Code Development überhaupt erlernen und üben zu können.  

Blickwinkel des Dienstleisters:

Eben diese Rahmen­bedingungen zu schaffen, in nachhaltige Software­entwicklung zu investieren, das Personal zu schulen und eine entsprechende Qualitäts­sicherung in den Projekten zu implementieren, geht mit hohen Kosten einher. Viele Software­dienstleister gehen solch ein Risiko aus Angst des fehlenden ROIs nicht ein.

Und auch das Thema Ganzheitlich­keit kann nicht von jedem Software­dienstleister geleistet werden, da nicht jedes Unternehmen Kompetenzen und Personal über alle Entwicklungs­ebenen hinweg bereit­stellt.

Blickwinkel des Auftraggebers:

Die initialen Kosten für nach­haltige Software­lösungen liegen höher. Das liegt zum einen an der ganz­heitlichen Heran­gehens­weise hinsichtlich kontinuierlichem Requirements Engineering und UX-Design. Zum anderen geht die Software­entwicklung mit Clean Code zunächst mit einem höheren Invest einher als die konventionelle Entwicklung. Diese Mehr­kosten schrecken viele Unternehmen zunächst ab.

Was bei dieser Rechnung jedoch oft ver­nachl­ässigt wird, ist die eigentliche Idee hinter nach­haltiger 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 Software­qualitä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 weiter­entwickelt werden kann.

 

5. Fazit

Nachhaltige Software­entwicklung meint die Entwicklung von lang­lebigen Software­produkten, die flexibel und effizient verändert und weiter­e­ntwickelt werden können. Um nachhaltige Software zu entwickeln, sollten folgende Regeln beachtet werden:

  1. Ein Lastenheft ist eine gute Arbeits­grund­lage, ersetzt jedoch nie iteratives Requirements Engineering mit allen beteiligten Stakeholdern.
  2. Bevor die erste Zeile Code geschrieben wird, sollte die Code-Struktur mithilfe von Tools wie Flow Design gemeinsam im Dev-Team detailliert geplant und eine durch­dachte Testsuite entwickelt werden.
  3. Während dem Programmieren sollten Clean Code Prinzipien und Praktiken genutzt werden, um syntaktisch lesbaren und semantisch nachvollziehbaren Quell­code zu schreiben, den eine hohe Wandel­barkeit auszeichnet.
  4. Eine auf die Nutzer:innen abgestimmte User Experience sollte auch bei Enterprise-Lösungen im Mittel­punkt stehen und muss ebenso wie der Code kontinuierlich getestet werden.
Autor
Thomas Bittner
Softwareentwickler
Autor
Alexander Weber
Marketing Manager

Weitere Artikel

Development
Clean Code
14.7.22

Software­qualität: Kriterien „guter“ Software­produkte und die Rolle von Clean Code

Auf welche Softwarequalitäts­merkmale es aus technischer & wirtschaftlicher Sicht ankommt und wie Clean Code Development dabei helfen kann, diese zu erreichen

Clean Code
9.9.21

Clean Code Development: Die Grade

Clean Code Development ist in verschiedenen Graden unterteilt, die man als Entwickler eine nach der anderen erklimmt und in einem ewigen Kreislauf wiederholt