Rust Überblick

Rust ist eine Programmiersprache, deren Entwicklung 2006 von Graydon Hoare begonnen und zwischen 2009 und 2020 maßgeblich durch seinen damaligen Arbeitgeber Mozilla Corporation gefördert und bestimmt wurde. Nachdem 2 Ansätze in C++ gescheitert waren, erhoffte sich Mozilla, mit Rust erstmals eine sichere und parallelisierte Webbrowser-Engine entwickeln zu können.

Mittlerweile sind mehrere Firefox-Komponenten durch Rust-Code ersetzt. Viele andere Unternehmen (siehe unten), sowie Entwickler von Projekten wie Apache httpd, AWS Firecracker, Google Android (Bluetooth, Keystore), Google Fuchsia (Bluetooth, Netzwerk), librsvg, Mercurial, Node.js, Parcel, Rome, Signal, Threema, Tor und das Unicode Consortium haben Software teilweise oder vollständig in Rust neu- oder umgeschrieben. Für Chromium (experimenteller Branch) wird dieser Schritt geprüft.

Seit 2021 wird Rust durch die Rust Foundation gefördert, welcher AWS, Google, Huawei, Meta, Microsoft und Mozilla angehören. Einige Rust- und Tokio-Entwickler sind inzwischen Angestellte dieser Firmen.

Design

In der ersten Präsentation zu Rust wurde 2010 die Absicht ausgedrückt, ausschließlich auf Erkenntnisse und Erfahrungen anderer Programmiersprachen zurückzugreifen. Auch heute ist wohl nur das Zusammentreffen bestimmter Aspekte an Rust besonders.

Rust wurde gleichzeitig mit Servo entwickelt. Servo war, bis zu der firmenweiten Reorganisation im August 2020, das in Rust geschriebene Mozilla-Forschungsprojekt einer parallelisierten Webbrowser-Engine. Komponenten, die sich in Servo bewährt hatten, wurden in Firefox integriert. Erfahrungen aus der Programmierung von Servo beeinflussten wiederum das Design von Rust. So unterscheidet sich das Rust 1.0 von 2015 deutlich von dem Rust aus 2010. Das frühe Rust hatte z.B. Green Threads und einen Garbage-Collector. Letzterer wurde durch das Ownership-Modell und den Borrow-Checker ersetzt, als man erkannte, dass sowohl Thread- als auch Speichersicherheit mit den gleichen Mechanismen erreicht werden können.

Diskussion

Rust ist keine einfache Sprache. Das liegt vor allem an den Randbedingungen, die sich Rust verpflichtet hat, zu erfüllen. Diese führten auch dazu, dass die Entscheidungsfindung zum await-Syntax schwieriger war, als bei anderen Sprachen.

Rust wichtigstes Angebot ist die Verhinderung ganzer Klassen von Laufzeitfehlern bereits zur Kompilierzeit. Speicher- und Thread-Sicherheit ohne Garbage Collection sind dabei nur ein Aspekt. Dass Sprache und Ökosystem insgesamt eine hohe langfristige Produktivität ermöglichen können, wird oft übersehen. Aber: nicht nur das Erlernen von Rust ist einmalig eine Investition, sondern jedes mal, neuen oder veränderten Code kompilierbar zu machen. Ob diese Investition profitabel ist, lässt sich nur im Einzelfall entscheiden.

Im Folgenden eine Aufstellung von Rusts Chancen und Risiken. Da in Rust die Erfahrungen anderer Programmiersprachen eingeflossen sind, gibt es naturgemäß Übereinstimmungen, besonders mit den Sprachen aus der ML-Familie.

Chancen

• Ganze Klassen von Fehlern werden bereits zur Kompilierzeit verhindert:
• in Safe Rust: Freiheit von Speicherfehlern, die laut voneinander unabhängigen Untersuchungen von Google, Microsoft und Mozilla, sowie dem Autor von cURL etwa 50 - 70 % der Sicherheitslücken verursachen. Selbst durch Einsatz von Unit-Tests, Memory-Allokatoren und -Debuggern, sowie Fuzzern gelang es weder Google, noch Sqlite, solche Probleme signifikant zu reduzieren oder gar zu verhindern.
• Freiheit von Data Races.
• Freiheit von Exceptions zur Laufzeit (solange Pfade zu panic!() vermieden werden):
• Statische Überprüfung der Fehlerbehandlung mittels Result, die Aufgrund von #[must_use] nicht vergessen werden kann.
• Freiheit von Null-Pointer-Dereferenzierung durch Verwendung von Option anstatt Nullable Types.
• Mit dem Fragezeichen-Operator gibt es dennoch eine Möglichkeit, Optionalität und Fehler zum Aufrufer hochzureichen.
• Freiheit von Iterator-Invalidierung durch den Borrow Checker, der verbietet, Referenzen gleichzeitig lesend und schreibend zu halten.
• Die Behandlung von Varianten müssen exhaustive sein – können also nicht ohne weiteres vergessen werden.
• Annehmlichkeiten:
• Cargo ist Standard-Paketmanager, Standard-Buildsystem und macht es einfach, fremde und eigene Libraries zu kompilieren und einzubinden.
• Reduzierung der Notwendigkeit von Boilerplate Code durch:
• Summentypen
• Pattern Matching
• hygienische Macros, insbesondere #[derive]
• Type Inference
• Eingebaute Unterstützung von Unit-Testing.
• todo!() zum polymorphen Prototypisieren.
• Stetig verbesserte, teilweise sehr hilfreiche Compiler-Fehlermeldungen
• Gute bis sehr gute IDE-Unterstützung durch IntelliJ Rust und rust-analyzer.
• Clippy: Sourcecode-Checker.
• rustfmt ist der Standard-Sourcecode-Formatierer.
• Playground: Online-IDE zum Ausprobieren und Teilen von Beispiel-Code.
• Integrierbarkeit: Rust-Code lässt sich über C-APIs mit Code, der in anderen Sprachen geschrieben ist, verbinden.
• Stück-für-Stück-Rewrites, wie der von librsvg, sind praktikabel.
• C2Rust ermöglicht eine 1:1-Übersetzung von C-Code in Unsafe-Rust.
• Der Ressourcen-Verbrauch (RAM, CPU) der mit Rust entwickelten Software ist oft geringer. Er ist in der gleichen Größenordnung wie Code, der in C/C++ geschrieben ist.
• Die bewusst minimale Standardbibliothek fördert unabhängige Libraries, die sich über Cargo leicht nutzen lassen und dabei:
• nicht an die Stabilitätsgarantien der Sprache gebunden sind
• die Erforschung konkurrierender Ansätze erlaubt
• Portabilität:
• Es gibt nur eine offizielle Rust-Implementierung, die sich überall gleich verhalten soll.
• Rust-Code ist grundsätzlich portabel. Ausnahmen:
• nicht-Rust Libraries werden über das FFI angebunden.
• bedingte Kompilierung wird verwendet.
• Eine Runtime-Umgebung wird nicht benötigt. Dies macht es auch praktikabel, Kommandozeilen-Tools wie ripgrep zu verbreiten und zu nutzen:
• Es gibt keine Warmup-Phase.
• Ein Deployment und Patch-Management einer Runtime-Umgebung ist nicht nötig.
• Es fallen keine Lizenzkosten für die Runtime-Umgebung an.
• Die frei verfügbare Dokumentation ist teilweise exzellent:
• das offizielle Buch
• Rust by Example
• Rust Cookbook
• Rustonomicon
• Cheats.rs
• Die Community ist bemüht, hilfsbereit und konstruktiv zu sein. Einige Anlaufstellen für Supportanfragen:
• Rust Forum
• Reddit Learnrust
• Reddit Rust: der wöchentliche Thread 'Hey Rustaceans! Got an easy question? Ask here'

Risiken

• Die Lernkurve ist am Anfang steil bis frustrierend.
• Die Entwicklung in Rust dauert häufig länger, da dem Compiler gewohnte Ansätze nicht leicht erklärt werden können, so dass er erkennt, dass sie frei von Data-Races sind. Siehe dazu auch Rust: Programmierung von GUI-Applikationen.
• Nicht für alle Anwendungsfälle kann bestehender Code verwendet werden.
• Rust kann nicht genutzt werden, da es keine der erlaubte Sprachen im Unternehmen ist.
• Die minimale Standardbibliothek hat zur Folge:
• dass Crates nicht immer einfach gefunden und bewertet werden können
• Fragmentierung im Ökosystem, wie z.B. bei asynchronen Runtimes
• Es gibt Schwierigkeiten, Rust-Entwickler zu finden.
• Lange Kompilierzeiten behindern schnelle Iterationen.
• Der Compiler rustc ist nur so portable wie LLVM. Siehe aber auch mrustc und das GCC Front-End für Rust.

Unternehmen, die Rust verwenden

mit WebAssembly:

Computerspiel-Hersteller:

mit Blockchain: