Programmiersprachen-Hassliebe

7 Gründe, Rust zu hassen – und zu lieben

12.10.2022
Von 
Peter Wayner schreibt unter anderem für unsere US-Schwesterpublikation InfoWorld.com und ist Autor verschiedener Bücher - unter anderem zu den Themen Open Source Software, autonomes Fahren und digitale Transaktionen.
Rust erobert die Welt der Systemprogrammierung im Sturm. Wir werfen einen Blick darauf, was die Programmiersprache großartig macht – und was nicht.
Rust kann Ihre Softwareentwicklung in Gang - oder zum Erliegen - bringen. Lesen Sie, was Developer an der Programmiersprache lieben und hassen.
Rust kann Ihre Softwareentwicklung in Gang - oder zum Erliegen - bringen. Lesen Sie, was Developer an der Programmiersprache lieben und hassen.
Foto: magnetplus - shutterstock.com

Manchmal entsteht der Eindruck, als ob jeden Tag eine neue Programmiersprache erfunden wird. Mit Sicherheit gibt es inzwischen mehr Coding-Sprachen, als die meisten Developer jemals nutzen werden. Darunter befinden sich unzählige Nischensprachen, die geschaffen wurden, um spezifische Probleme zu lösen. Dass eine neue Sprache den "Durchbruch" schafft und es zu weiterer Verbreitung bringt, kommt dabei nur selten vor.

Rust ist eine dieser wenigen neueren Sprachen, die in der Unternehmenspraxis ein Zuhause gefunden hat. Dabei füllt auch Rust ohne Zweifel eine Nische: Es soll Developern dabei helfen, Code zu erstellen, der Dutzende, Tausende oder gar Millionen von Ereignissen parallel jongliert. Solche Systeme zu bauen, ist schon diffizil - sie von ihren Fehlern zu befreien, noch schwieriger.

Das Kernteam um Rust führt jedes Jahr eine Umfrage unter den Entwicklern durch. Im Jahr 2021 verwendeten erstmals mehr als die Hälfte aller Rust-Programmierer die Sprache im Rahmen ihrer Tätigkeit. Die Zeiten, in denen Rust lediglich eine Spielerei darstellte, sind vorbei - inzwischen entsteht mit der Programmiersprache ernstzunehmender Code.

Dieser Artikel wirft einen Blick darauf, was Softwareentwickler an der Arbeit mit Rust hassen und lieben.

7 Gründe, Rust zu hassen

1. Concurrency-Modell zu komplex

Multithreading-Systeme werden zwar immer beliebter, aber viele Entwickler brauchen sie nicht wirklich. Programmierer im Research-Bereich neigen dazu, Single-Thread-Funktionen zu schreiben, die sich durch endlose Datenströme fressen. Webentwickler können PHP-Code schreiben, der einen einfachen, deklarativen Ansatz bietet, um Webseiten zu erstellen. Serverless-Developer schreiben eine Funktion und überlassen die harte Arbeit jemand anderem. Entwickler, die anspruchsvollere Webanwendungen erstellen müssen, wenden sich an Node.js, das eine andere Strategie für Multithreading-Anwendungen ermöglicht. Das ereignisgesteuerte Modell von Node in Verbindung mit promise-based Code kann zu einfachen und eleganten Ergebnissen führen.

Mit anderen Worten: Das Multithreading-Modell von Rust bietet mehr Raffinesse, als die meisten Programmierer benötigen. Natürlich ließen sich diese zusätzlichen Funktionen einfach ignorieren. Viele Developer verzichten jedoch lieber vollständig auf zusätzliche Komplexität.

2. Steile Lernkurve

Wenn Sie Rust erlernen wollen, müssen Sie in gewisser Hinsicht einige Konzepte und Techniken über Bord werfen, die Sie seit Beginn Ihrer Developer-Karriere begleiten. Rust verabschiedet sich beispielsweise vom Konzept des Scope und dem der Ownership, wie man sie von älteren Sprachen wie JavaScript und Java kennt.

Wenn Sie die Vorteile von Rust für sich nutzen wollen, müssen Sie bereit sein, auf einige vertraute Funktionen zu verzichten, die zu Fehlern führen können. Die Sprachsyntax von Rust ist zudem komplex - für manche zu komplex. Denn sie besteht nicht mehr nur aus geschweiften und normalen Klammern - auch eckige Klammern, senkrechte Linien und das Größer-als-Symbol halten Einzug.

Rust-Entwickler, die komplexe Multithreading-Tools entwickeln, sehen in der syntaktischen Komplexität von Rust eventuell einen lohnenden Kompromiss. Echte Hardcore-Fans, die den funktionalen Ablauf verstehen, werden das vielleicht sogar genießen können. Der Rest wird einfach nur frustriert sein: Alle semantischen Regeln von Rust zu erlernen, ist nichts für Gelegenheitsnutzer.

3. Respekteinflößender Compiler

Manche Entwickler wollen einfach nur eine Sprache, mit der sie Schleifen erstellen können, die ohne Absturz ablaufen. Sie wollen eine Sprache, die die Hintergrundarbeit erledigt, so dass sie sich nicht darum kümmern müssen.

Wenn der Compiler manchmal etwas langsameren oder leicht fehlerhaften Code erzeugt, ist das in Ordnung. Viele Aufgaben sind nicht übermäßig komplex und es ist nicht allzu schwer, sie zu debuggen. Das Ding ist: Es ist billiger, mehr Hardware bereitzustellen, als sich durch all die zusätzlichen Details zu quälen, die der Rust-Compiler verlangt.

4. Keine strenge Objektorientierung

Rust hält sich nicht an die Prinzipien der objektorientierten Programmierung, was für manche Entwickler ein Problem darstellen kann. Zwar lassen sich einige Aspekte der objektorientierten Programmierung in Rust nachahmen (echte Fans kennen die besten Möglichkeiten, OOP mit Rust-Konstrukten zu imitieren) - aber jeder, der ausgefeilte Typenhierarchien aufbauen will, wird von Rust zutiefst frustriert sein.

5. Asynchrone Hürden

Auch Rust hat keine Features an Bord, die Deadlocks oder Verzögerungen automatisch beseitigen und es überflüssig machen, gründlich über Ihren Code nachzudenken. Die Programmiersprache kann eine weniger fehleranfällige Struktur bieten - es liegt jedoch nach wie vor in der Verantwortung der Developer, sauberen Code zu schreiben und ihre Anwendungen gut zu designen. Rust ist kein Zaubermittel und asnychrones Coding kein Kinderspiel.

6. Riskante Byte-Ebene

Viele Sprachen haben sind so konzipiert, dass der Zugriff auf Byte-Ebene vermieden wird. Der Grund: Das ist ein schneller Weg für Entwickler, in Schwierigkeiten zu geraten. Den Zugriff auf Byte-Ebene zu "verstecken" vermeidet Risiken. Denn für einige Programmierer ist es die bessere Wahl, die Details der Speicherzuweisung und der Datendarstellung dem Backend zu überlassen.

7. Memory Management ist eine Qual

Viele gängige Programmiersprachen (etwa Java) verfügen über eine interne Speicherverwaltung, um Memory Leaks und andere Fehler zu verhindern. Die meisten Programme müssen sich keine Gedanken über gelegentliche "Hickups" machen, die durch die Garbage Collection verursacht werden. Als Programmierer ziehen Sie es eventuell ohnehin vor, sich nicht um Speicher zu kümmern.

Rust ist nicht die einzige Sprache, die eine Alternative zur traditionellen Garbage Collection bietet. Node.js zum Beispiel vereinfacht die Multithread-Programmierung und nutzt die Speicherverwaltung der JavaScript-Laufzeit. Dabei kommt es zwar gelegentlich zum Stillstand, das ist allerdings ein guter Kompromiss, wenn es Ihre Benutzer nicht stört.

7 Gründe, Rust zu lieben

1. Skalierung meets Concurrency

Weil die Developer mit Skalierungs- und Concurrency-Problemen - also gleichzeitige Inputs aus einer Vielzahl verschiedener Quellen - zu kämpfen haben, wird Softwareentwicklung zunehmend komplexer. Nicht wenige Entwickler halten Rust für die beste Programmiersprache, um Tools zu entwickeln, die für heutige Architekturen geeignet sind.

Der Webbrowser ist ein gutes Beispiel für eine Anwendung, die massive Skalierbarkeit erfordert. Als die Entwickler von Mozilla Probleme mit ihrem Code untersuchten, kamen sie auf eine bessere Lösung: Rust.

2. State of the Art

Bei der Entwicklung von Programmiersprachen geht es heute vor allem darum, funktionale Sprachen zu schaffen, die die Developer dazu anleiten, leichter zu analysierende Software zu schreiben. Rust ist Teil dieses Trends: Viele Entwickler lieben seine logische, funktionale Syntax, die dazu ermutigt, Code als eine Sequenz verschachtelter Funktionsaufrufe zu strukturieren.

Gleichzeitig wollten die Rust-Schöpfer auch etwas entwickeln, das die bit-lastige Low-Level-Programmierung bewältigen kann, die beispielsweise erforderlich ist, damit das Internet of Things (IoT) funktionieren kann. Softwareentwickler, die diese realen Herausforderungen in modernem Stil angehen wollen, finden in Rust das richtige Werkzeug.

3. Williger Compiler

Einige Entwickler sehen all die zusätzlichen Details von Rust als Vorteil. So können sie Hinweise einfügen, die es dem Compiler erleichtern, herauszufinden, was vor sich geht, und mögliche Fehler zu erkennen. Der komplizierte Code bietet dem Entwickler eine bessere Möglichkeit, die gewünschten Abläufe vollständig zu spezifizieren. Das hilft wiederum, Compiler-Fehler zu vermeiden. Rust lädt Entwickler dazu ein, besseren und schnelleren Code zu schreiben, indem es Hinweise darauf gibt, wie der Code funktionieren sollte.

4. Hervorragende Abwärtskompatibilität

Das Entwicklungsteam hinter Rust setzt sich dafür ein, dass der Code auch dann noch funktioniert, wenn die Sprache weiterentwickelt wird. Deshalb arbeiten die Verantwortlichen daran, sicherzustellen, dass älterer Code weiterhin mit neueren Versionen der Sprache kompiliert und ausgeführt werden kann - etwas, das nicht selbstverständlich ist. Rust-Enthusiasten stellen oft fest, dass sie ihre Codebasis ganz ohne endlose Änderungssessions pflegen können.

5. Asynchron ist sicherer

Das asynchrone Entwicklungsmodell von Rust ermöglicht Developern, separate Funktionen zu erstellen, die unabhängig voneinander ablaufen. Die Ergebnisse lassen sich anschließend zusammenführen. Viele Entwickler sind davon überzeugt, dass diese Struktur sie dabei unterstützt, schnelleren, sichereren und weniger fehleranfälligen Programmcode zu erstellen.

6. Programmieren ohne Abstraktionen

Rust wurde entwickelt, um Programmierer auf Systemebene zu unterstützen, die Low-Level-Code schreiben und Bytes verändern. Die Sprache ist so konzipiert, dass sie mit einem Großteil des alten C- oder Assembler-Codes, der Teil der unteren Ebenen von Betriebssystemen und Netzwerkstapeln ist, zusammenarbeiten kann. Echte Programmierer wollen diesen Zugang, um den besten, reaktionsschnellsten Stack zu bauen - und Rust liefert.

7. Besserer Weg zur Garbage Collection

Viele gängige Sprachen übernehmen die interne Speicherzuweisung und die Garbage Collection für Sie. Das ist ein netter Service. Solange, bis der Garbage Collector alles zum Stillstand bringt.

Rust verfolgt in Sachen Memory Management einen eigenen Ansatz, der nicht so umfassend ist wie der traditionelle Weg, dafür aber leistungsfähiger sein kann. Ein guter Entwickler kann mit dem Speichermodell von Rust großartige Performance erzielen, muss ddafür aber das Typsystem und die atomare Referenzzählung beherrschen. Für eingefleischte Rust-Fans ist die praktische Speicherverwaltung eine hervorragende Funktion: Selbst wenn das bedeutet, mit zahlreichen Threads jonglieren und sicherstellen zu müssen, dass der Code reaktionsschnell ist - diese Developer machen das lieber selbst. Und Rust legt die Macht in ihre Hände.

Rust entwickelt sich noch weiter

Ob Rust das beste Modell für asynchrone Programmierung bietet und ob die Abschaffung der Garbage Collection dem Entwickler wirklich hilft - darüber lässt sich trefflich diskutieren. Letztendlich ist Rust aber immer noch eine relativ neue Programmiersprache. Die Entwicklergemeinschaft ist immer noch aktiv dabei, die Details zu erlernen und Best Practices für die Arbeit mit Rust zu entdecken. Denn auch über die richtige Art und Weise, Rust-Anwendungen zu erstellen, lässt sich streiten.

Rust ist für Entwickler eine aufregende Option mit vielen Möglichkeiten, um zu experimentieren, weist jedoch eine steile Lernkurve auf. Programmierern gibt Rust einen Grund, ihre Herausforderungen zu überdenken, ihre Ziele neu zu formulieren und den besten Weg zu finden, um moderne Software zu coden. (fm)

Dieser Beitrag basiert auf einem Artikel unserer US-Schwesterpublikation InfoWorld.