Zum Haupt­in­halt springen

Wie nach­hal­tig sind die be­lieb­tes­ten Pro­gram­mier­spra­chen?

Wohin man auch blickt, das Thema Nach­hal­tig­keit ist om­ni­prä­sent. Kli­ma­wan­del, En­er­gie­kri­se, Inflation – all diese Faktoren tragen zu einem ge­stei­ger­ten Be­wusst­sein bei, dass ein scho­nen­der Umgang mit Res­sour­cen er­for­der­lich ist. Kaum eine Branche ist von dem Thema nicht betroffen, und so wird Nach­hal­tig­keit auch in der IT immer wichtiger. Wir stellen eine Studie vor, die die nach­hal­tigs­ten Pro­gram­mier­spra­chen un­ter­sucht hat. Handelt es sich dabei auch um die be­lieb­tes­ten?

Warum nach­hal­ti­ger Code?

Nach­hal­tig­keit ist ein Thema, das in oft un­ter­schätz­tem Maße auch für die IT gilt, Stichwort „Green IT“. Schließ­lich benötigt es Energie, um Programme aus­zu­füh­ren. Umso mehr, wenn Code schwer lesbare oder gar red­un­dan­te Ab­schnit­te enthält, durch die sich die In­itia­li­sie­rungs­zeit für An­wen­dun­gen erhöht.

Es ist wichtig, sich vor Augen zu führen, dass tat­säch­lich jeder Quellcode einen öko­lo­gi­schen Fuß­ab­druck hat. Hält man diesen gering, ergeben sich enorme Po­ten­zia­le zur Ein­spa­rung von Energie. Denn so klein eine Zeile Code auch sein mag – rechnet man ihre Anwendung auf Server weltweit und zudem auf die gi­gan­ti­sche Menge an End­ge­rä­ten hoch, wird schnell klar: Je schlanker ein Code, desto höher die Ein­spar­po­ten­zia­le und desto niedriger die Emis­sio­nen.

Eine Studie aus Portugal von 2021 hat sich damit be­schäf­tigt, welche Pro­gram­mier­spra­chen am en­er­gie­ef­fi­zi­en­tes­ten und damit am nach­hal­tigs­ten sind. Pro­gram­mie­ren­de und Un­ter­neh­men können diese Er­geb­nis­se also nutzen, um ihren Beitrag zu einer res­sour­cen­scho­nen­den Software-Ent­wick­lung und -Nutzung zu leisten. Wir fassen die Er­geb­nis­se zusammen und nehmen dabei auch Bezug auf eine Umfrage von Stack Overflow von 2022, in der die be­lieb­tes­ten Pro­gram­mier­spra­chen gelistet werden. Sind diese auch am nach­hal­tigs­ten?

Nach­hal­ti­ge Pro­gram­mie­rung – eine De­fi­ni­ti­on

Bevor wir zur Aus­wer­tung der erwähnten Studie kommen, wollen wir kurz auf den Begriff „Green Coding“ eingehen. Er bedeutet aus dem Eng­li­schen übersetzt „Grünes Pro­gram­mie­ren“. Ziel ist es, Software möglichst en­er­gie­ef­fi­zi­ent und damit nach­hal­tig zu pro­gram­mie­ren. Dabei werden die Nach­hal­tig­keit des Codes selbst sowie dessen Aus­wir­kun­gen auf die Umwelt be­rück­sich­tigt.

Dem­zu­fol­ge sind in einer ersten De­fi­ni­ti­on Software-Lösungen nach­hal­tig, wenn:

  • ihr Code möglichst schlank ist, sodass er auf End­ge­rä­ten schnell aus­ge­führt wird.
  • sie über einen längeren Zeitraum nutzbar, ver­än­der­bar und wei­ter­ent­wi­ckel­bar sind sowie effizient und einfach auf neue Markt- oder Kun­den­an­for­de­run­gen angepasst werden können.

Damit be­stehen­de Programme angepasst und wei­ter­ent­wi­ckelt werden können, ist es wichtig, so­ge­nann­te Code-Erosion (engl. „code rot“) zu vermeiden, also die all­mäh­li­che Ver­schlech­te­rung des Codes. Be­stehen­der Code muss demnach gepflegt und ak­tua­li­siert werden, um möglichst lang nutzbar zu sein. Das spart Zeit, Geld und Energie ein und ist somit auch aus wirt­schaft­li­cher Per­spek­ti­ve sinnvoll.

Auch wenn es höhere initiale Kosten zur Folge hat: Es ist wichtig, dass Pro­gram­mie­ren­de nicht aus­nahms­los auf bereits be­stehen­de Lösungen zu­rück­grei­fen, sondern sich auf die Ende-zu-Ende-Op­ti­mie­rung der Software kon­zen­trie­ren können. Letztlich gilt es, über­flüs­si­gen Code möglichst zu vermeiden.

Methodik der Studie

Die ur­sprüng­li­che Studie „Ranking Pro­gramming Languages by Energy Ef­fi­ci­en­cy“ wurde 2017 von sieben por­tu­gie­si­schen Forschern ver­öf­fent­licht. 2021 wurde sie dann erneut durch­ge­führt – auf diese Er­geb­nis­se beruft sich dieser Beitrag.

Die Studie un­ter­such­te die Aus­füh­rungs­zeit und die Spit­zen­spei­cher­aus­las­tung von 27 Pro­gram­mier­spra­chen. Beides wurde in Bezug zum En­er­gie­ver­brauch gesetzt und dann geschaut, wie Zeit und Verbrauch zu­sam­men­hän­gen. Me­tho­disch wurde auf das Software-Re­po­si­to­ry „Computer Language Benchmark Game“ (CLBG) zu­rück­ge­grif­fen, mit dem sich die En­er­gie­bi­lanz von Software quan­ti­fi­zie­ren lässt.

Die Werte für jede einzelne Pro­gram­mier­spra­che wurden anhand von zehn häufigen Ope­ra­tio­nen gemessen, die beim Pro­gram­mie­ren eine Rolle spielen können (z. B. das Ge­ne­rie­ren und Schreiben zu­fäl­li­ger DNA-Sequenzen), und für Bench­marks ver­gli­chen. Im Anschluss wurden die Er­geb­nis­se in einer Tabelle zu­sam­men­ge­fasst, die den je­wei­li­gen Bedarf an Energie, Zeit und Speicher ver­gleich­bar darstellt.

Zu welchem Ergebnis kommt die Studie?

Bei einem Vergleich der 27 un­ter­such­ten Pro­gram­mier­spra­chen stellt man fest, dass es teils ex­or­bi­tan­te Un­ter­schie­de bezüglich der einzelnen Werte gibt. Auf den vorderen Plätzen, also den­je­ni­gen, die den ge­rings­ten En­er­gie­ver­brauch, die schnells­te Aus­füh­rungs­zeit und den ge­rings­ten Spei­cher­be­darf haben, befinden sich u. a. C, Pascal, Go, Rust, C++ und Ada. Im Folgenden gehen wir etwas genauer auf die einzelnen Daten ein.

  • En­er­gie­ver­brauch: Auf den Plätzen 1 bis 5 befinden sich (in ab­stei­gen­der Rei­hen­fol­ge) C (1,00 Joule), Rust (1,03 J), C++ (1,34 J), Ada (1,70 J) und Java (1,98 J). Auffällig ist vor allem die große Dis­kre­panz zu den hinteren Rängen: Die letzt­plat­zier­te Pro­gram­mier­spra­che Perl kommt auf einen Verbrauch von 79,58 Joule.
  • Aus­füh­rungs­zeit: Diese Resultate ent­spre­chen grob denen des En­er­gie­ver­brauchs. Die ersten Plätze sind un­ver­än­dert und werden belegt von C (1,00 Mil­li­se­kun­de), Rust (1,04 ms), C++ (1,56), Ada (1,85 ms) und Java (1,89 ms). Auf Platz 27 liegt Lua (82,91 ms).
  • Spit­zen­spei­cher­aus­las­tung: Hier ändert sich das Bild. Zwar nehmen C (1,17 Megabyte) und C++ (1,34 MB) noch immer Top-5-Plätze ein (nämlich 3 und 5), doch Pascal (1,00 MB; Platz 1), Go (1,05 MB; Platz 2) und Fortran (1,24 MB; Platz 4) er­reich­ten in den anderen Ka­te­go­rien keine Top-Werte. Ada (1,47 MB; Platz 6) und Rust (1,54 MB; Platz 7) sind noch recht weit vorn dabei, während Java weit zu­rück­fällt (6,01 MB; Platz 22). Den letzten Platz belegt Jruby (19,84 MB).

Es ist deutlich zu erkennen, dass einige der un­ter­such­ten Pro­gram­mier­spra­chen durchweg besser ab­schnei­den als andere. C, C++, Rust, Ada, Pascal und mit Ab­stri­chen Fortran und Chapel erreichen in allen Ka­te­go­rien gute Werte, während Sprachen wie Python, Ruby, Perl, Lua und Erlang weniger gut ab­schnei­den.

Als Ergebnis ist vor allem Folgendes fest­zu­hal­ten: Zum einen sind die schnells­ten Pro­gram­mier­spra­chen häufig auch die res­sour­cen­schon­ends­ten. Zum anderen bestehen große Un­ter­schie­de zwischen den ersten und den letzten Plätzen: fast das Acht­zig­fa­che beim En­er­gie­ver­brauch, fast das Drei­und­acht­zig­fa­che bei der Aus­füh­rungs­zeit und fast das Zwan­zig­fa­che beim Spei­cher­platz.

An­ge­sichts all dieser Zahlen wäre es wün­schens­wert, wenn die­je­ni­gen Pro­gram­mier­spra­chen, die gute Werte aufweisen, auch die be­lieb­tes­ten und am weitesten ver­brei­ten wären. Ist das der Fall?

Was sind die be­lieb­tes­ten Pro­gram­mier­spra­chen?

Um das zu über­prü­fen, ziehen wir eine Umfrage von Stack Overflow Developer Survey vom Mai 2022 zurate, in der u. a. nach den be­lieb­tes­ten Pro­gram­mier­spra­chen gefragt wurde. Befragt wurden 71.547 Personen, von pro­fes­sio­nel­len Ent­wick­lern und Ent­wick­le­rin­nen bis hin zu Menschen, die das Coden gerade erst lernen. Die Fra­ge­stel­lung lautete: „Auf welche Pro­gram­mier-, Scripting- und Markup-Sprachen haben Sie in den letzten Jahren umfassend beim Ent­wi­ckeln zu­rück­ge­grif­fen, und mit welcher wollen Sie in den nächsten Jahren arbeiten?“ („Which pro­gramming, scripting, and markup languages have you done extensive de­ve­lo­p­ment work in over the past year, and which do you want to work in over the next year?“). Und das sind die Er­geb­nis­se:

Knapp zwei Drittel der Befragten nennen Ja­va­Script, etwas über die Hälfte HTML/CSS und knapp die Hälfte SQL und Python. In ab­stei­gen­der Rei­hen­fol­ge von gut einem Drittel bis zu knapp einem Fünftel der Befragten werden Ty­pe­Script, Java, Bash/Shell, C#, C++, PHP und C genannt. Die in der por­tu­gie­si­schen Studie durchweg gut plat­zier­ten Rust, Ada, Pascal, Fortran und Chapel spielen hier keine we­sent­li­chen Rollen: Rust kommt auf unter zehn Prozent Nennungen, Fortran nur auf unter ein Prozent. Die übrigen drei werden sogar überhaupt nicht genannt.

En­er­gie­ver­brauch, Aus­füh­rungs­zeit, Spit­zen­spei­cher­aus­las­tung: Welche Pro­gram­mier­spra­che schneidet insgesamt am besten ab?

Pro­gram­mie­ren­de haben oft bestimmte Ziel­set­zun­gen hin­sicht­lich der Funktion ihres Codes: Mal macht die Anwendung es er­for­der­lich, dass die Software möglichst en­er­gie­spa­rend ist (z. B. bei Smart­phone-Apps), mal geht es darum, dass die Spei­cher­aus­las­tung möglichst gering ist (z. B. bei An­wen­dun­gen, die im Hin­ter­grund laufen). Was aber, wenn alle drei Cha­rak­te­ris­ti­ka, nach denen die Studie Pro­gram­mier­spra­chen bewertet, gleich wichtig sind oder man wissen möchte, welche die „beste“ ist, also unter dem Strich die nied­rigs­ten Werte in allen Bereichen aufweist?

Die Antwort liefert folgende Grafik. Sie listet alle Pro­gram­mier­spra­chen hin­sicht­lich ihres Ab­schnei­dens in allen drei Bereichen auf, also En­er­gie­ver­brauch, Aus­füh­rungs­zeit und Spit­zen­spei­cher­aus­las­tung. Da in jedem einzelnen Bereich möglichst niedrige Werte vor­teil­haft sind, ergibt sich eine gute Ver­gleich­bar­keit. Um es In­ter­es­sier­ten und Nutzenden zu er­leich­tern, sowohl die generelle Nach­hal­tig­keit als auch die Be­liebt­heit einer Pro­gram­mier­spra­che auf einen Blick zu erfassen, haben wir auch letztere mit­an­ge­ge­ben. Die Grafik fasst somit die wich­tigs­ten Er­kennt­nis­se aus beiden Quellen zusammen:

Das Ergebnis: C, Pascal und Go belegen die Spit­zen­plät­ze, gefolgt von Rust, C++ und Fortran. Schluss­licht ist Perl, aber auch beliebte Sprachen wie  Ja­va­Script, Python und Ty­pe­Script belegen hintere Plätze.

Was bedeutet das Ergebnis für Green Coding?

Die be­lieb­tes­ten Pro­gram­mier­spra­chen sind nicht die nach­hal­tigs­ten – eher ist das Gegenteil der Fall. Dass dem so ist, hat mehrere Gründe. So lassen sich Aufgaben mit einigen der res­sour­cen­auf­wen­digs­ten Pro­gram­mier­spra­chen wie z. B. Python oft deutlich schneller lösen als mit anderen, nach­hal­ti­ge­ren. Insofern stehen Nach­hal­tig­keits­aspek­te oft hinter Funk­tio­na­li­tät zurück. Zudem sind ver­gleichs­wei­se kurze Python-Skripte nicht nur sehr schlank und schnell ge­schrie­ben, es ist sogar möglich, sie innerhalb von C oder C++ zu im­ple­men­tie­ren und un­kom­pli­ziert auf andere Platt­for­men über­tra­gen. En­er­gie­auf­wen­di­ger Code ist also oft schlicht einfacher zu handhaben als res­sour­cen­scho­nen­der.

Zudem sind drei wichtige Ein­schrän­kun­gen hin­sicht­lich der por­tu­gie­si­schen Studie zu beachten:

  • Es gibt neben En­er­gie­ver­brauch, Aus­füh­rungs­zeit und Spit­zen­spei­cher­aus­las­tung noch andere Faktoren, die die Nach­hal­tig­keit betreffen, aber keine Erwähnung finden. Dazu gehört bei­spiels­wei­se die nach­hal­ti­ge Pro­duk­ti­on von Geräten.
  • Code-Ei­gen­schaf­ten allein ent­schei­den nicht darüber, wie gut und effizient ein Code auf einer Plattform läuft. Letzten Endes kommt es hierbei immer auf ein Zu­sam­men­spiel von Software und Hardware an.
  • Zudem wird in der Studie die Hardware komplett außen vor­ge­las­sen. Diese spielt jedoch eine wichtige Rolle dabei, wie gut sich ein Code auf ver­schie­de­ne Systeme portieren lässt und wie effizient der Be­fehls­satz aus­ge­führt wird.
Zitat

"Die Trans­pa­renz durch die por­tu­gie­si­sche Studie hilft, Nach­hal­tig­keit als funk­tio­na­len Aspekt in der Soft­ware­ent­wick­lung zu be­rück­sich­ti­gen. Un­ter­neh­men haben durchaus einen ex­trin­si­schen Anreiz nach­hal­ti­gen Code zu schreiben, da dieser un­mit­tel­bar mit niedrigen Hard­ware­kos­ten ein­her­geht. Ist es jedoch wichtig zu verstehen, dass Soft­ware­ar­chi­tekt:innen nicht frei zwischen Sprachen ent­schei­den können, sondern Sprachen wählen müssen, die zum An­wen­dungs­fall, exis­tie­ren­der Software und dem Skillset des Ent­wick­lungs­teams passen. Unter diesem Aspekt ist es si­cher­lich sinnvoll, wenn Uni­ver­si­tä­ten und Be­rufs­schu­len ihre Un­ter­richts­spra­chen auch nach Nach­hal­tig­keits­aspek­ten wählen."

- Robert Sch­lein­he­ge (IONOS)

Fazit & Ausblick

Das Nach­hal­tig­keits-Ranking der Studie gibt in­ter­es­san­te Einblicke und kann dazu beitragen, dass sich Ent­wi­ckeln­de und Her­stel­ler künftig für res­sour­cen­scho­nen­de­re Pro­gram­mier­spra­chen ent­schei­den. Es ist aber nicht als finales Urteil zu verstehen, denn die oben erwähnten Ein­schrän­kun­gen müssen in Betracht gezogen werden.

Unter dem Strich gilt, dass diejenige Software am nach­hal­tigs­ten ist, die gut ge­schrie­ben ist. Das bedeutet: Der Code sollte möglichst kompakt sein, sich schnell ausführen lassen und wenig Spei­cher­platz benötigen. Genau dafür gilt es bei Un­ter­neh­men, In­sti­tu­tio­nen und Pro­gram­mie­ren­den ein Be­wusst­sein zu schaffen. Wün­schens­wert wäre es demnach, wenn Ver­ant­wort­li­che län­ger­fris­tig denken und Pro­gram­mie­ren­de dazu anhalten würden, auf schlanken, leicht pfleg­ba­ren und somit nach­hal­ti­gen Code zu achten. Die höheren initialen Kosten würden durch Ein­spa­run­gen im Zeit­ver­lauf u. a. durch geringere Hardware-Kosten mehr als wett­ge­macht.