© LIU MING | 123RF.com

Einige Programmiersprachen stehen im Ruf, besonders energiesparende Anwendungen hervorzubringen. Das gilt insbesondere für das noch recht junge Go. Wir machen den Reality Check.

Anwendungen beanspruchen den Prozessor unterschiedlich stark, was sich später in der Stromrechnung widerspiegelt. Dabei beeinflusst bereits die gewählte Programmiersprache maßgeblich den Energieverbrauch. Wie das Beispiel Go zeigt, müssen dazu allerdings auch die Entwickler die entsprechenden Fähigkeiten der Sprache ausreizen.

Es klingt verlockend: Schreiben Sie ein Programm in Go, erzeugt der Compiler automatisch eine energiesparende Anwendung. Auf den ersten Blick bringt Go dazu alles Notwendige mit. So besitzt es eine schlanke Syntax, die pfiffigen Goroutinen verteilen parallele Aufgaben effizient auf die Prozessorkerne [1]. Dementsprechend gibt es keine aufgeblasene Laufzeitumgebung, die komplexe Klassenhierarchien verwalten oder klassische Threads jonglieren müsste.

Außerdem übersetzt ein Compiler den Quellcode in ein natives und somit flott zu Werke gehendes Programm. Der Prozessor kann sich folglich schneller wieder schlafen legen und Energie sparen. Obendrein linkt Go alle externen Module statisch ins fertige Binary, womit bei der Ausführung sogar der Verwaltungsaufwand für dynamische Bibliotheken wegfällt.

Das kontrastiert stark mit Java, wo ein Compiler das Programm in einen Zwischencode überführt, den dann wiederum eine virtuelle Maschine ausführt. Diese zusätzliche Softwareschicht bremst die Ausführung und kostet unnötig Energie. Noch schlechter sieht es bei interpretierten Sprachen aus: PHP und Python arbeiten während der Ausführung jede Codezeile Schritt für Schritt ab. Zahlreiche Optimierungen und Just-in-Time-Compiler sollen den entsprechenden Anwendungen zwar Beine machen, dennoch bleibt je nach Aufgabe ein Verlust. Wer energieeffiziente Programme entwickeln möchte, sollte also Go bevorzugen. Oder vielleicht doch nicht?

Fragwürdige Forschung

Bereits 2017 wollten portugiesische Forscher wissen, welche Programmiersprache besonders energieeffiziente Anwendungen hervorbringt. Die Ergebnisse ihrer Studie stellten sie auf der International Conference on Software Language Engineering (SLE [2]) vor. Demnach arbeiten kompilierende Programmiersprachen wie C und Go deutlich effizienter als ihre interpretierenden Kollegen wie PHP oder Python.

Weniger deutlich fallen die Ergebnisse bei Sprachen aus, die einen Zwischencode generieren. So laufen Java-Programme im Schnitt schneller und energiesparender als ihre Go-Pendants (Abbildung 1). Die virtuelle Maschine scheint erstaunlicherweise nicht zu bremsen zu sein – zumindest nicht in der Studie, die bei genauem Hinsehen ein paar Haken und Ösen aufweist.

Abbildung 1: Beim Benchmark K-Nucleotide verbraucht Go mehr CPU- und Hauptspeicherenergie als andere Sprachen.

Zunächst nutzten die Forscher für jede Sprache nur einen möglichen Compiler beziehungsweise Interpreter. Für Go existiert beispielsweise mit TinyGo ein weiterer Compiler, der das LLVM-Framework einspannt, um hochoptimierten Maschinencode für Mikrocontroller zu erstellen [3]. Analog übersetzte den C-Code ausschließlich GCC. Damit bleibt offen, ob LLVM nicht energieeffizientere Programme erzeugt.

Darüber hinaus kam der Go-Compiler in der Version 1.6 zum Einsatz, die zum Zeitpunkt der Studie schon als veraltet galt. Auch die übrigen Compiler und Interpreter haben ihre jeweiligen Entwickler mittlerweile überarbeitet und weiter optimiert. PHP 8 verarbeitet zum Beispiel deutlich mehr gleichzeitige Anfragen als die Vorgänger. Zwar lieferten die portugiesischen Wissenschaftler im Jahr 2020 vor allem für einige funktionale Sprachen aktuelle Messwerte nach. Go, Java und Co stellten sie jedoch nicht mehr auf den Prüfstand. Ihre Ergebnisse lassen sich dementsprechend nicht auf die heutige Zeit übertragen.

Keine Bewölkung

Abschließend griffen die Forscher für ihre Messungen zum Computer Language Benchmark Game (Abbildung 2). Dieser Benchmark [4] besteht aus zehn einzelnen Tests, die in insgesamt 28 Sprachen implementiert wurden. Unter anderem berechnen die enthaltenen kleinen Programme Mandelbrot-Mengen und binäre Bäume. Die Wissenschaftler haben damit allerdings nur untersucht, welche Programmiersprachen diese einzelnen überschaubaren Berechnungen besonders energieeffizient ausführen. Reale Anwendungen müssen aber gänzlich andere Aufgaben lösen. So mühen sich etwa Verschlüsselungswerkzeuge mit extrem knackigen mathematischen Problemen ab, während Webserver lediglich Datenpakete durch das Netzwerk schieben.

Abbildung 2: Das Computer Language Benchmark Game vergleicht eigentlich die Geschwindigkeit der Programmiersprachen.

Gänzlich unberücksichtigt blieben zudem komplexe Internet- und Cloud-Anwendungen wie die in Go implementierte Filesharing-Plattform Owncloud Infinite Scale (OCIS [5]). Sie entstand als leistungsfähigere Alternative zur klassischen PHP-Anwendung Owncloud, die bei größeren Lasten und vielen gleichzeitigen Nutzern an ihre Grenzen stieß. Mit entsprechenden Messungen wollte das OCIS-Team herausfinden, wie leistungsfähig und energiesparend ihre Private-Cloud-Lösung tatsächlich arbeitet. Anders als die kleinen Benchmark-Programme besteht OCIS jedoch aus zahlreichen Diensten, die im Netzwerk zusammenarbeiten. Die OCIS-Entwickler mussten bei ihren Messungen etwas anders vorgehen als die portugiesischen Forscher. Gleichzeitig stützten sie sich auf eine weitverbreitete Ansicht.

Schneller ist effizienter

Wenn eine Anwendung eine Aufgabe möglichst zügig löst, kann der Prozessor schneller wieder in einen seiner Energiesparmodi wechseln. Es verwundert also nicht, dass in der Studie die kompilierenden Programmiersprachen gleichzeitig die energiesparendsten waren. Die OCIS-Entwickler gehen derzeit ebenfalls davon aus, dass performante Programme weniger Energie verbrauchen. Diese Annahme erlaubt, sich auf Performance-Messungen und entsprechende Optimierungen zu konzentrieren, für die bereits etablierte Werkzeuge und Prozesse existieren.

Go greift dabei seinen Entwicklern mit einem eingebauten Profiler unter die Arme [6]. Er misst die Ausführungszeiten von Codeteilen und spürt so ineffiziente Operationen auf. Laut Klaas Freitag, CIO der Owncloud GmbH, eignet sich der Go-Profiler vor allem in verteilten Systemen meist nur zum Aufspüren von Bugs. Für seine Performance-Messungen nutzt das OCIS-Team deshalb ein selbst entwickeltes Werkzeug namens Cdperf [7], das seinerseits das bekannte Test-Tool k6 [8] einspannt (Abbildung 3). Letzteres simuliert mehrere Benutzer, die gleichzeitig auf die Filesharing-Plattform zugreifen.

Abbildung 3: Für ihre Performance- und Energiemessungen nutzen die OCIS-Entwickler das Open-Source-Werkzeug k6.

Auf Wunsch führt der Go-Compiler zusätzlich maßgeschneiderte Benchmarks aus, mit denen sich unter anderem die Performance von Codeänderungen ermitteln lässt [9]. Berechnet etwa eine Funktion den größten gemeinsamen Teiler, könnte man einen selbst geschriebenen Benchmark nacheinander mit Tausenden verschiedener Zahlenpaaren aufrufen. Liefert der Benchmark nach einer Codeänderung eine kürzere Laufzeit, ließe sich die Berechnung des größten gemeinsamen Teilers erfolgreich optimieren. Die Benchmarks lassen sich gemeinsam mit den (Unit-)Tests pflegen und so von Anfang an in die Entwicklung einbeziehen.

Kenne deine Sprache

Haben Sie ineffiziente Programmteile identifiziert, sollten Sie den entsprechenden Quellcode optimieren, vor allem durch den Einsatz effizienter Algorithmen. Viele Programmiersprachen unterstützen außerdem die effiziente Entwicklung mit passenden Konstrukten. Beispielsweise kann bereits der Go-Compiler konstante Ausdrücke auswerten, was später bei der Ausführung Rechenzeit spart. Das setzt jedoch voraus, dass die Entwickler konstante Ausdrücke korrekt in den Quellcode einbauen.

Des Weiteren ist Go eine typisierte Sprache, die unter anderem zwischen Fließkomma- und Integer-Zahlen unterscheidet. Da viele Prozessoren mit Ganzzahlen schneller rechnen, sollten Sie ihnen nach Möglichkeit den Vorzug geben. Das gilt insbesondere beim Einsatz als Schleifenzähler. Apropos Schleifen: Zu den klassischen Bremsern und somit Stromfressern gehören vor allem verschachtelte, aber eigentlich unnötige Schleifen, ausufernde Rekursionen und überflüssige Wiederholungen. Muss ein Programm etwa bei jedem Aufruf der Bildergalerie sämtliche Vorschaubilder neu berechnen, frisst diese repetitive Arbeit unnötig Energie.

Viele weitere Tipps für die effiziente Programmierung [10] horten die Go-Entwickler auf einer eigenen Seite (Abbildung 4). Für andere Sprachen existieren vergleichbare Sammlungen. In jedem Fall sollten Sie sich nicht auf jede einzelne Dateioperation stürzen. Aus der Sicht von Klaas Freitag sind derart einfache Operationen bereits optimiert. So speichert etwa PHP eine Datei genauso schnell auf der Festplatte wie ein entsprechendes Go-Programm.

Abbildung 4: Go bringt ein Test-Framework mit, das auch das Ausführen von Benchmarks erlaubt.

Effizienzbremsen

Effizienter Code führt allerdings nicht zwangsläufig zu einem energiesparenden Programm. Das räumt auch Freitag ein. Beispielsweise saugt eine durchlaufende NAS-Lösung mehr Strom aus dem Netz als immer wieder anlaufende Server-Dienste. Beansprucht eine Anwendung die CPU kurzzeitig stark und muss diese daraufhin hochtakten oder ihre stromdurstigen Hochleistungskerne einschalten, kann die Energiebilanz schlechter ausfallen als bei einem langsam vor sich hin rechnenden Programm, das sich mit einem Stromsparkern zufriedengibt. Go-Entwickler können zwar mit der Funktion »NumCPU()« aus der Standardbibliothek die Anzahl der verfügbaren Prozessorkerne abfragen, die Arbeit aber nicht gezielt auf einen bestimmten CPU-Kern verschieben. Hier müssen Sie dem Betriebssystem vertrauen beziehungsweise den Linux-Scheduler passend manipulieren.

Spezielle Rechenwerke können den Energieverbrauch senken. Beispielsweise helfen Kryptoeinheiten beim stromsparenden Aufbau von SSL-Verbindungen, während KI-Beschleuniger flott neuronale Netze auswerten. Über entsprechende Bibliotheken geben Go-Programme ihre Berechnungen an derartige Beschleuniger ab. Beispielsweise erlaubt das Package GoCV, Nvidias CUDA-Schnittstelle zu nutzen [11].

Weitere Energiefresser verbergen sich in den mittlerweile zahlreichen Zwischenschichten. Das in PHP geschriebene Owncloud setzt zum Beispiel einen kompletten LAMP-Stack voraus. Auf der Stromrechnung finden sich dementsprechend mindestens eine Datenbank, ein Webserver und der PHP-Interpreter wieder. Häufig sind die einzelnen Dienste zudem in einer mehr oder weniger komplexen Container-Umgebung oder in Virtualisierungslösungen eingesperrt. OCIS hingegen läuft wie die meisten Go-Programme nativ auf dem Server, was den PHP-Interpreter und einige andere Zwischenschichten obsolet macht.

Was häufig unter den Tisch fällt: Bereits das Entwickeln einer Software verursacht Energiekosten. In dieser Phase bauen und testen komplexe CI-Systeme wiederholt den aktuellen Quellcode. OCIS entsteht beispielsweise unter Drone [12]. Der dabei automatisch angeworfene Compiler und die stetig wiederholten (Unit-)Tests tragen zum grünen Fußabdruck der Software bei. Der Go-Compiler selbst gilt immerhin als recht flotter und somit sparsamer Geselle.

Datenflut

Der Energieverbrauch hängt nicht nur von der Prozessorlast ab, sondern auch von den verarbeiteten Daten. So verbraucht ein ständig mit Bestellungen bombardierter Online-Shop mehr Energie als das stündliche Ausliefern einer textlastigen Webseite. Große Datenmengen aus dem Hauptspeicher zu holen, kostet deutlich weniger Strom, als sie von einer Datenbank anzufordern oder von einem Plattenspeicher zu kratzen. Caches fangen darüber hinaus Zwischenergebnisse auf, etwa generierte Vorschaubilder. Erneut müssen Sie hier das Rad nicht neu erfinden: Viele Bibliotheken stellen einen effizienten Zwischenspeicher bereit. Go-Entwickler können beispielsweise einen Blick auf Gocache werfen [13].

Allerdings steht auch der Hauptspeicher unter Strom: Passen die benötigten Daten in den Prozessor-Cache, döst der Hauptspeicher vor sich hin. Wer also etwa mit spärlich besetzten Matrizen jongliert, sollte diese mit effizienten Verfahren komprimieren. In ihrer Studie haben sich die portugiesischen Forscher übrigens auch den Hauptspeicherverbrauch vorgeknöpft. Die von Go erzeugten Programme beanspruchen demnach durchschnittlich weniger Platz als die Pendants der Konkurrenz. Nur Pascal ging noch sparsamer mit dem Speicher um.

Bei der energieeffizienten Hauptspeichernutzung spielen wieder die Programmierer eine wichtige Rolle: Übergeben Sie einer Funktion einen Wert (Call By Value), kopieren ihn Go und viele andere Sprachen im Speicher. Kommt die Funktion sehr häufig zum Einsatz, entstehen dementsprechend viele Kopien desselben Werts. Übergeben Sie der Funktion hingegen eine Referenz auf den Wert (Call By Reference), verringert das die Speicherzugriffe. Ähnlich wie C bietet Go dazu sogenannte Pointer (Abbildung 5), mit deren Hilfe Sie nur Fingerzeige auf die tatsächlichen Daten durchreichen. Das spart bei zahlreichen Zugriffen und großen Datenstrukturen Energie.

Abbildung 5: Pointer beschleunigen in Go die Speicherzugriffe und die Übergabe von Daten. So tauschen Sie schnell Variableninhalte, ohne sie aufwendig kopieren zu müssen.

Die Referenzimplementierung des aktuellen Go 1.19 verwaltet den Speicher mit einem Garbage Collector [14]. Er räumt im Hintergrund auf und gibt automatisch nicht mehr benötigten Speicherplatz frei. Seine Tätigkeit schluckt allerdings Rechenzeit und somit Strom. Zwar könnten Sie den der Garbage Collector abschalten, handeln sich damit aber unter Umständen einen volllaufenden Hauptspeicher oder andere unangenehme Seiteneffekte ein. Die Studienergebnisse der portugiesischen Forscher legen zudem nahe, dass der Garbage Collector in Go recht wenig Energie beansprucht.

Energetisches Pingpong

Zum Computer Language Benchmark Game zählt das Benchmark-Programm K-Nucleotide. Es berechnet in der Go-Implementierung die Ergebnisse gleichzeitig mit Goroutinen. Auch die Javascript-Fassung arbeitet dank der Laufzeitumgebung Node.js nebenläufig. Die Typescript-Version dagegen muss alle Berechnungen nacheinander anstellen und ist damit per se langsamer als die Javascript- und Go-Implementierungen. In den Messergebnissen der portugiesischen Wissenschaftler entpuppte sich wenig überraschend Typescript als 17 Mal energiehungriger als seine fast identische Schwestersprache Javascript.

Parallele Berechnungen führen also zu einem stromsparenden Programm. Ähnliches gilt, wenn ein Prozess aktiv auf das Ende einer Aktion warten muss. Klopft etwa ein Client in kurzen Abständen bei einem nicht reagierenden Server an (Polling), saugt er immer wieder leicht an der Steckdose. Für mehr Effizienz sorgen zum Beispiel Callback-Funktionen oder Push-Nachrichten. Hierbei schläft das Programm, bis fertig berechnete Daten oder ein Ereignis es wecken. Go unterstützt dieses Vorgehen über seine Channels sowie bei der Netzprogrammierung mit Listenern aus dem »net«-Package.

OCIS besteht aus zahlreichen Microservices, die jeweils eine klar definierte Aufgabe erledigen. Performance und somit Energie kostet laut Klaas Freitag vor allem die Kommunikation zwischen den Diensten. Schicken sich beispielsweise zwei Microservices ständig gegenseitig Anfragen, treibt dieses Pingpong den Energieverbrauch nach oben. Die Stromrechnung steigt auch dann, wenn alle verbundenen Systeme eine neue Einstellung übernehmen müssen. Sollen etwa mehrere Dienste von einer Rechteänderung erfahren, flitzen zwangsläufig zahlreiche Nachrichten durch das Netz, die zudem noch koordiniert und ausgewertet werden müssen. In verteilten Systemen lässt sich folglich mit reduzierter Kommunikationsfrequenz Energie sparen.

Hungrige KI

Besonders viel Energie verheizt das Training der momentan recht populären neuronalen Netze. Sie imitieren ein stark vereinfachtes menschliches Gehirn und erkennen dann zum Beispiel Blumen auf Bildern. Je länger Sie ein solches Netz auf seine Aufgabe trainieren, desto genauer arbeitet es später. Aufgrund der dazu notwendigen Rechenleistung blasen Sie jedoch im Extremfall sogar mehr CO₂ in die Luft als fünf Autos bis zu ihrer Verschrottung [15]. Trainieren Sie ein neuronales Netz über das eigentlich für die Aufgabe notwendige Maß hinaus, vergeuden Sie also eine Menge Energie. Eine solche umweltschädliche KI bezeichnet man als Red AI.

Hinzu kommt, dass viele Wissenschaftler in der KI-Forschung auf Python setzen. Um dort den Berechnungen Beine zu machen, greifen sie zu einigen Tricks. Unter anderem kommt der Cython-Compiler zum Einsatz, der Python-Code in sein C-Pendant verwandelt. Darüber hinaus sind viele verwendete Python-Bibliotheken direkt in C implementiert. Wer KI-Modelle entwickelt, sollte sie möglichst stromsparend auslegen und trainieren, wer bereits konfigurierte Exemplare nutzt, zu möglichst energiesparenden Varianten greifen.

Stärken und Schwächen

Nur wenn Sie die Vor- und Nachteile einer Programmiersprache kennen, können Sie sie effizient verwenden. So ist zum Beispiel der Quellcode einiger Skriptsprachen ziemlich kurz. Arbeitet der Interpreter diese Anweisungen flott ab, laufen die Skripte ähnlich effizient wie ein kompiliertes Pendant und lassen sich obendrein deutlich einfacher warten.

Einige Sprachen sind darüber hinaus auf ganz bestimmte Einsatzzwecke zugeschnitten. So entstehen in PHP beispielsweise vorwiegend dynamische Webanwendungen. Nur wenige Programmierer dürften damit komplexe numerische Analysen anstellen. Für die eignet sich wiederum die funktionale Programmiersprache Julia. In Go entstehen derzeit vor allem Server-Dienste und Kommandozeilenprogramme. Die Sprache verfügt über recht effiziente String-Manipulationen, allerdings lassen sich nicht alle parallel auszuführenden Aufgaben effizient mit den angebotenen Goroutinen lösen.

Nachdem es Go erst wenige Jahre gibt, greifen die darin geschriebenen Programme auf ebenfalls recht junge Bibliotheken zurück. Anders sieht das bei gestandenen Programmiersprachen wie C, Python oder PHP aus. In damit vor Jahren entwickelter Software schlummern allzu häufig ineffiziente Altlasten. Dort kann ein Refactoring und das Ausmustern von alten Bibliotheken beim Energiesparen helfen. Die OCIS-Entwickler nutzten die Neuimplementierung ihrer Filesharing-Plattform, um ein paar alte Zöpfe abzuschneiden. So kommt OCIS anders als Owncloud ohne klassische Datenbank aus, sodass mindestens ein kompletter Server samt der zugehörigen Netzwerkkommunikation der Vergangenheit angehört.

Wer misst …

Um herauszufinden, welcher Codeteil tatsächlich wie viel Energie verbrät, helfen letztendlich nur eigene Verbrauchsmessungen. Diese sollten schon während der Entwicklung und in Echtzeit stattfinden. Unter Linux lässt sich der Energieverbrauch etwa über Intels RAPL-Interface abrufen, das auch die portugiesischen Forscher anzapften.

Das gelingt allerdings im Fall von Go ausschließlich über weitere Hilfsanwendungen, da Go-Programmen selbst bislang diese Fähigkeit fehlt. Einen Vorschlag für eine entsprechende Funktion aus dem Jahr 2019 haben die Entwickler abgelehnt, da nach ihrer Ansicht weder die Betriebssysteme noch die CPUs präzise Verbrauchswerte für kurze ausgeführte Codeteile liefern [16]. Zum Redaktionsschluss existierten keine aktuellen Bibliotheken, mit denen Go-Entwickler den Energieverbrauch messen könnten.

Immerhin bringt Go in seiner Standardbibliothek einige Debugging-Funktionen mit. So enthält beispielsweise das »debug«-Package eine Funktion, mit der Sie die Garbage Collection anstoßen. Während die Funktion »ReadMemStats()« aus dem »runtime«-Package Informationen über den Speicherverbrauch ausgibt, erzeugen Sie über das »metrics«-Package eigene Metriken.

… misst Mist

Bei der Messung des Energieverbrauchs stellt sich außerdem die Frage, welche Programmpfade man dabei ausführt. Klaas Freitag weist beispielsweise darauf hin, dass während der Messungen keine Fehler auftreten dürfen: Die führen häufig dazu, dass die jeweilige Operation abbricht und so das Programm weniger Last erzeugt.

Des Weiteren sollten Sie möglichst unter realen Bedingungen messen. Untersuchen Sie etwa WordPress, dürfen Sie nicht SQLite als Datenbank verwenden: Die arbeitet, anders als MySQL, äußerst ressourcensparend. Umgekehrt können vermeintliche Vereinfachungen die Messergebnisse verfälschen. Die OCIS-Entwickler hatten während ihrer Messungen zur einfachsten Authentifizierungsmethode gegriffen (Basic Auth). In der Folge dekodierte das entsprechende System immer wieder rechenaufwendig dasselbe Sicherheitstoken. Nach dem Umschwenken auf OpenID Connect lief das komplette System messbar flotter.

Die Energiemessungen sollten deswegen möglichst alle Softwareteile abdecken. Klaas Freitag empfiehlt, mehrere praxisrelevante Anwendungsfälle zu ermitteln und diese durchzutesten. Bei einer Filesharing-Software macht es einen Unterschied, ob ein Unternehmen nur wenige sehr große Dateien austauscht oder extrem viele kleine. Einen solchen Querschnitt sollten die Messungen berücksichtigen.

Die Messergebnisse der portugiesischen Forscher lesen Sie bei Interesse online nach [17], die Testprogramme finden Sie auf Github [4]. Auch die OCIS-Entwickler wollen ihre Vergleiche zwischen Owncloud, OCIS und dem Konkurrenten Nextcloud offenlegen. Zum Redaktionsschluss lief allerdings noch eine interne Validierung. Mit dem quelloffenen Tool Cdperf können Sie jedoch selbst die Performance messen [7].

Fazit

Mit den Sprachen C, Pascal und Go erzielen Sie den optimalen Kompromiss zwischen Laufzeit, Speicherbelegung und Energieeffizienz – das legt zumindest die Studie der portugiesischen Forscher nahe. Dennoch produziert der Go-Compiler nicht automatisch stromsparende Anwendungen. Dafür spielen zu viele andere Faktoren eine Rolle, zum Beispiel ein im Hintergrund rund um die Uhr laufender Speicher-Pool.

Laut Klaas Freitag beeinflusst vor allem die Softwarearchitektur die Performance und so indirekt die Energieeffizienz einer Anwendung. Beispielsweise verschlingt die Kommunikation zwischen Internet-Diensten unter Umständen mehr Energie als das Speichern einer Datei. Wichtig ist daneben eine effiziente Implementierung, die wiederum vom konkreten Anwendungsfall abhängt.

Zwar fragen laut Owncloud derzeit noch keine Kunden explizit nach dem Energieverbrauch von Software. Da sich Einsparungen insbesondere in der Cloud jedoch schnell bemerkbar machen, dürfte sich das bald ändern. Zweifellos lohnt es sich, schon jetzt mit einer ressourcenschonenden Programmierung zu beginnen. Allgemeine Tipps dazu liefert der Kasten “Tipps zur energieeffizienten Implementierung”. (csi)