Green Software Engineering: Erste Schritte
Der Begriff Nachhaltigkeit ist in aller Munde und bedeutet, dass eine Problemlösung langfristig funktioniert und somit auch, dass die Lösung die natürliche Regenerationsfähigkeit der beteiligten Systeme nicht zerstört [1]. Der Begriff kommt ursprünglich aus der Forstwirtschaft und was für die Forstwirtschaft noch recht klar ist, ist angewandt auf Software schwer abzuschätzen: Wie viele Berechnungseinheiten (also Energie) stehen für die Bewahrung "der" Regenerationsfähigkeit zur Verfügung? Oder besser: Wann ist Software eigentlich so effizient, dass sie als "grün" bezeichnet werden kann? Diese Fragen können in diesem Artikel nicht final beantwortet werden. Trotzdem: Auch wenn die Antworten auf diese Fragen nicht einfach sind, gibt es bereits Anregungen, die dazu beitragen, so wenig Ressourcen wie möglich zu verbrauchen.
In diesem Beitrag werden bezogen auf Software-Entwicklung Ansätze zum Ressourcensparen mit Beispielen aus dem Bereich der Serveranwendungen im JVM-Umfeld aufgezeigt. Auf andere Aspekte, die die IT betreffen, wie Hardware, Frontend oder User-Experience, wird an dieser Stelle nicht eingegangen, dazu existieren bereits andere interessante Beiträge [2].
Effiziente Software schreiben
Für den Bereich der Software-Entwicklung soll hier die vereinfachende Annahme getroffen werden, dass je effizienter eine Berechnung ist, desto weniger Ressourcen werden verbraucht. Tatsächlich ist das Problem komplexer [3]. Davon ausgehend ist es klar, dass man effiziente Algorithmen schreiben sollte. Zu diesem Thema bietet die theoretische Information eine ganze Menge Literatur, deswegen soll hier nur auf folgende Aspekte hingewiesen werden:
- Standard-Bibliotheken von Apache, Guava oder Java Core bieten meist bessere Algorithmen als Eigenimplementierungen.
- Wenn häufig Berechnungen auf größeren Kollektionen von Objekten stattfinden, sollten filternde Operationen so früh wiemöglich durchgeführt werden.
- Einige Methoden der Software-Entwicklung, wie Pair-Programming, Mob-Programming oder Code-Reviews, helfen dabei, ineffiziente Codestellen zu identifizieren und zu verbessern.
- Effizienz sollte kontinuierlich auch mithilfe von Makro- (z. B. Gatling.io oder JavaMeter) und Micro-Benchmarks (JMH) überwacht werden.
- Effizienz sollte in den Fokus der Entwicklung gerückt werden (Stichwort: Definition of Done).
Berechnungen vermeiden
Nachhaltigkeit bedeutet im Bereich der Software-Entwicklung immer auch, die Notwendigkeit von Berechnungen zu hinterfragen und so viele Berechnungen wie möglich zu vermeiden. Dabei liegt der Ball einerseits bei der Auswahl von Features und anderseits bei der Umsetzung von Features. Bei der Umsetzung sollte darauf geachtet werden, dass Ergebnisse, die sich nicht oder nur wenig ändern, so selten wie möglich berechnet werden. In Microservice- oder Multiinstanz-Architekturen können verteilte Caches helfen, die Anzahl der Berechnungen zu reduzieren. Jobs sollten nicht von jeder Instanz ausgeführt werden, sondern nur von einer. Kubernetes beispielsweise bietet dafür gute Ansätze.
Fokus auf Frameworks und Virtuelle Maschinen legen
Im Entwicklungsalltag hat wohl die Auswahl von Frameworks und virtuellen Maschinen den größten Einfluss auf die Effizienz von Software. Die GraalVM soll beispielsweise weniger Energie benötigen als die JVM [4].
Im Hinblick auf Frameworks gilt hier: weniger ist mehr. Je mehr Features ein Framework anbietet, desto mehr Ressourcen wird es tendenziell auch verbrauchen. Auch Techniken wie aspekt-orientierte Programmierung oder Reflections scheinen die Hardware deutlich zu beanspruchen. Deswegen ist es aus Nachhaltigkeitssicht ratsam, einen genauen Blick auf Microframeworks wie Quarkus, Micronaut oder Ktor zu werfen.
Diese Microframeworks bieten im Vergleich zu den doch recht komplexen Frameworks wie Spring Boot auch den Vorteil, dass sie recht geringe Startzeiten haben. Das ermöglicht es, sie in Szenarien einzusetzen, die hohe Skalierbarkeit benötigen. Skalierbarkeit von Anwendungen sollten gerade im Zusammenhang mit Green Software Engineering als Skalierbarkeit nach oben und nach unten gedacht werden. Ein Webshop um 21 Uhr werktags benötigt andere Ressourcen, um performant zu antworten, als um 4 Uhr nachts oder am Black Friday. Idealerweise sollten die Frameworks Applikationen ermöglichen, die in deutlich weniger als einer Sekunde starten können. Mit einer solchen Startzeit sind Applikationen in der Lage, auf null herunterzuskalieren.
Netzwerklast minimieren
Wiederum vereinfachend soll angenommen werden, dass je mehr und je häufiger Daten über das Internet ausgetauscht werden, desto mehr Energie benötigt wird. Services, die als Teile einer Applikation intern kommunizieren, sollten tatsächlich die Nachrichten innerhalb des Netzes austauschen und nicht den Umweg über das Internet nehmen.
Moderne Webapplikationen tauschen viele Daten aus, um eine ansprechende Nutzererfahrung zu gewährleisten. Trotzdem sollte jedes Bit darauf untersucht werden, ob es wirklich vom jeweiligen Client benötigt wird. Ein spannender Ansatz dazu ist GraphQL als "Konkurrent" zu RESTful-APIs. Durch GraphQL werden elegant die benötigten Daten eines Datenmodells vom Client angefordert und (fast) nur diese übermittelt. Das kann potenziell jede Menge an Datenaustausch einsparen, auch bei der Anbindung einer Drittapplikation. Bei der Auswahl von Applikationen sollte darauf geachtet werden, dass diese GraphQL als Schnittstellentechnik anbieten. Binäre Protokolle helfen ebenfalls, weniger Bits und Bytes über die Leitung zu senden.
Serialisierungs- und Deserialisierungsbibliotheken sind in Hinblick auf Effizienz berüchtigte Komponenten. Hier lohnt sich eine Gegenüberstellung von Komfort und Nachhaltigkeit [5].
Reaktive Applikationen
Nicht-blockierende Applikationen kamen vor einigen Jahren auch in der JVM-Community in Mode, nachdem NodeJS-Anwendungen eine gute Performance zeigten [6]. Das Thema ist nach wie vor aktuell und verschiedene Bibliotheken stehen für die reaktive Entwicklung zur Verfügung. Nicht immer lohnt sich der Overhead, der durch reaktive Entwicklung entsteht, im Allgemeinen sind Effekte aber vielversprechend [7]. Deutlich schnellere Antwortzeiten und höhere Lasttoleranz sind bei einer konsequenten Nutzung von reaktiven Bibliotheken möglich [8]. Konsequent bedeutet hier, dass die besten Effekte durch eine Nutzung reaktiver Methoden bei allen Teilschritten von der Deserialisierung eines Requests über die Treiber für Datenquellen bis zur Serialisierung des Responses erreicht wird.
Das Schreiben und die Lesbarkeit reaktiven Codes sind gerade in Java-Anwendungen allerdings nicht besonders komfortabel. Häufig wird zu viel und schwer verständlicher Code benötigt, um ein reaktives Verhalten abzubilden. Es sei an dieser Stelle auf Kotlin-Coroutines verwiesen, die die Problematik deutlich eleganter lösen.
Ausblick
Neben dem Zusammenhang zwischen CPU-Auslastung und Energieverbrauch gibt es wahrscheinlich auch einen zwischen Anforderungen an die Software und dem Energieverbrauch. Product Owner könnten bei der Ausgestaltung und Priorisierung von Features einen Schwerpunkt auf Ressourcenverbrauch legen, denn ein nicht umgesetztes Feature verbraucht wohl die wenigste Energie. Dieser Ansatz würde bedeuten, dass neben Aspekten wie Wartbarkeit, Sicherheit, Ergonomie auch die Nachhaltigkeit als Kriterium zur Bewertung von Software (und dessen Funktionsumfang) im Prozess der Software-Entwicklung eine wichtige Rolle spielen müsste.
Die Nachhaltigkeit bei der Software-Entwicklung wird in nächster Zeit an Bedeutung zunehmen und auch gegenüber Endanwendern ein wichtiges Verkaufsargument [9]. Software-Entwickler und -Entwicklerinnen, Software-Tester, Product Owner und Stack Holder sollten deshalb damit beginnen, Aspekte der Nachhaltigkeit in ihre Entscheidungen einfließen zu lassen.
Ein nicht umgesetztes Feature verbraucht wohl die wenigste Energie.
Möglicherweise ist es wirtschaftlicher, ein Framework zu verwenden, mit dem die Developer vertraut sind, welches aber eventuell nicht nachhaltiger oder "grüner" ist. Diese Aspekte sollten gegeneinander abgewogen werden. Auch bei der Wahl von Bibliotheken, Kommunikations- und Speicherkonzepten kann Nachhaltigkeit ein wichtiger Aspekt sein, um Rechenzeit und Energie zu sparen.
Dieser Beitrag sollte ein paar Vorschläge dokumentieren, aber sicherlich gibt es noch viele weitere Techniken, um Software nachhaltig(er) zu entwickeln.
- Schubert, Klaus/Martina Klein: Das Politiklexikon. 7., aktual. u. erw. Aufl. Bonn: Dietz 2020
- Informatik Aktuell - S. Roos: Mit Digitalisierung zu mehr IT-Nachhaltigkeit
Informatik Aktuell - C. Windler: Coden gegen den Klimawandel
Informatik Aktuell - A. Guldner, E. Kern, S. Kreten & S. Naumann: Software und Nachhaltigkeit – Wie passt das zusammen? - M. Pichler: Nachhaltige It Im Rechenzentrum
- S. Quan: GraalVM Enterprise helps save energy when running Java applications
- E. Decanini: Benchmarking Gson vs Jackson vs Moshi
E. Decanini: Benchmarking Kotlin JSON Parsers: Jackson-Kotlin and Kotlinx Serialization - DA14: Node.js vs Java: Choosing a Back-end Language for Large App Development
- 5 Aspekte über reaktive Programmierung in Java
- G.T. Cunha: Reactive vs. Synchronous Performance Test with Spring Boot 2.0
- adesso: Nachhaltigkeit wird zum Wettbewerbsvorteil
