Warum Matt Godbolt mich durch C++ für Rust begeisterte: Eine tiefgehende Sprachexploration

Die Welt der Programmiersprachen entwickelt sich stetig weiter, angetrieben von dem Wunsch, immer funktionalere, sicherere und effizientere Werkzeuge für Softwareentwicklung zu schaffen. Inmitten vieler populärer Sprachen hat Rust in den letzten Jahren enorm an Bedeutung gewonnen – nicht zuletzt dank Vordenkern wie Matt Godbolt, der mit seinem tiefgründigen Verständnis von Compilern und Sprachen einen entscheidenden Beitrag zur Popularisierung von Rust geliefert hat. Interessanterweise hat mich Godbolt gerade durch seine Arbeit mit C++ für Rust begeistert. Wie genau das funktioniert hat und welche Lektionen sich daraus ziehen lassen, ist das zentrale Thema dieses Beitrags. Wir schauen uns zunächst die Herausforderungen an, die Matt Godbolt in der Programmiersprache C++ aufzeigt, bevor wir verdeutlichen, wie Rust diese Probleme elegant löst und damit einen neuen Standard setzt.

Matt Godbolt, bekannt als Schöpfer von Compiler Explorer, hat sich intensiv mit der Frage beschäftigt, wie Programmiersprachen dazu beitragen können, Fehler schon in der Entwicklungsphase zu verhindern – nicht nur klassische Speicherfehler, sondern auch Fehler in der Nutzbarkeit von APIs. Seine Erkenntnisse stellte er unter anderem in seinem Vortrag "Correct by Construction: APIs That Are Easy to Use and Hard to Misuse" vor. Die darin angesprochene Thematik traf bei vielen Entwickler*innen, die lange mit C und C++ gearbeitet haben, einen Nerv. Die Erfahrung lehrt, dass trotz der mächtigen Features von C++ nicht selten Fehler auftreten, die durch eine bessere Typabsicherung verhindert werden könnten. Eine vom Vortrag inspirierte Fallstudie beschreibt eine typische Börsenanwendung: Eine Funktion, die Aufträge an eine Stock Exchange senden soll.

Dabei lautet die einfache Signatur der Funktion in C++ zunächst so: void sendOrder(const char *symbol, bool buy, int quantity, double price). Auf den ersten Blick unspektakulär, doch die Probleme zeigen sich schnell in der Praxis. So ist es möglich, versehentlich stattdessen ein Preisargument an die Stellen zu übergeben, an denen eine Menge erwartet wird – ein Fehler, den der Compiler nicht immer zuverlässig erkennt, da automatische Typkonvertierungen oft stillschweigend akzeptiert werden. Ähnliches gilt bei der Verwendung primitiver boolescher Flags anstelle von aussagekräftigen Datentypen, was zu Missverständnissen und schwer auffindbaren Bugs führt. Ein naheliegender Lösungsansatz in C++ ist die Verwendung von Aliasen für Datentypen.

So könnten zum Beispiel Price als Alias für double und Quantity als Alias für int definiert werden. Dennoch zeigt sich schnell, dass Compiler wie Clang oder GCC diese Aliasdefinitionen ignorieren, wodurch die erwähnten Fehlübertragungen unbemerkt bleiben. Erst das Einführen von Klassen mit expliziten Konstruktoren verbessert die Situation merklich. Klassen wie Price und Quantity kapseln die Werte, während das explizite Schlüsselwort unerwünschte automatische Konvertierungen verhindert. Doch auch hier besteht noch die Gefahr, dass inkorrekte Werte übergeben werden, etwa negative Mengen, die eigentlich unmöglich sein sollten.

Die Einführung von unsigned int als Datentyp mindert dieses Risiko, beseitigt es aber nicht vollständig. Eine zusätzliche Kompilationsevaluierung mittels statischer Assertions („static_asserts“) ist nötig, um falschgenutzte Typen bereits beim Kompilieren auszuschließen. Trotz dieses Aufwands bleibt ein Problem: Was passiert, wenn der Wert von Nutzereingaben als String kommt, etwa über eine grafische Oberfläche? Die Umwandlung von String zu Zahl darf nicht blindlings geschehen. Andernfalls könnten bei ungültigen Eingaben unerwartete Werte wie extrem hohe positive Zahlen erzeugt werden – etwa weil der String "-100" als unsigned Zahl eingelesen wird und damit als großer positiver Wert interpretiert wird, was in der Finanzwelt katastrophale Folgen haben kann. In C++ fehlen hierfür standardisierte Lösungen, und es bedarf aufwändiger Absicherung auf Laufzeitebene.

Hier tritt Rust auf den Plan und zeigt, warum es als moderne Systemprogrammiersprache so vielversprechend ist. Statt nur mit Typaliasen zu arbeiten, betrachtet Rust Datentypen als strikt getrennte Typen. Der Compiler syntaktisch und semantisch prüft, ob Variablen den korrekten Typ besitzen. So führt ein falsches vertauschtes Argument in einem Funktionsaufruf zu einer Kompilierfehlermeldung, die klar angibt, wo und welche Typinkonsistenz vorliegt. Rusts Typsystem schafft es sogar, passende Korrekturhinweise zu geben – man lebt also tatsächlich in der Zukunft der Entwicklung.

Darüber hinaus macht Rust den Einsatz neuer Datentypen durch sogenannte Tuple-Structs einfach. Mit wenigen Zeilen definiert man explizite Typen wie Price und Quantity, die innere Typen einkapseln. Dank streng getypten unsigned Ganzzahlen erkennt Rust sogar bei Versuchen, negative Werte an diese Typen zu übergeben, sofort Fehler und verhindert deren Kompilierung. Diese erste Fehlerentdeckung zur Compile-Zeit bewahrt nicht nur vor Laufzeitfehlern, sondern spart auch wertvolle Entwicklungszeit. Der kritische Teil ist natürlich auch in Rust die Umwandlung von Nutzereingaben, die als Strings vorliegen, in gültige numerische Werte.

Doch auch hier bietet Rust Mechanismen, die den Programmierer dazu zwingen, Fehlerfälle explizit zu behandeln. Ein primitiver Befehl wie parse::<u64>() liefert keinen simplen Wert, sondern ein Result-Objekt zurück. Dieses muss verstanden und entweder in inhaltliche Werte umgewandelt oder Fehlerfälle abgefangen werden. Diese Zwangshandhabungvon Fehlern ist fundamental für Rusts Sicherheit und Stabilität und verhindert klassische Crashs oder verdeckte Fehlverhalten. Eine weitere wichtige Erkenntnis aus dieser Betrachtung ist, dass Rusts Stärke weit über die vielfach bekannten Aspekte der Speicher- und Datenracesicherheit hinausgeht.

Gerade im Bereich von Typsicherheit und API-Design zeigt Rust, dass eine durchdachte Spracharchitektur die Nutzbarkeit großer Softwareprojekte enorm verbessert. Fehler, die früher mühsam lokalisiert und korrigiert werden mussten, werden schon während der Entwicklung vermieden. Dies erhöht die Produktqualität und schont die Ressourcen und Nerven der Entwicklerteams. Matt Godbolts Vergleich zwischen modernen C++ Techniken – mit all ihren Tücken und Mühen – und der Eleganz von Rusts Typensystem zeigt exemplarisch, wie wichtig es ist, geeignete Werkzeuge zu wählen. Die explizite Fehlererkennung, das erzwungene Fehlerhandling und die klare Trennung von Datentypen erlauben einen natürlicheren Denkmuskel bei der Programmierung und verhindern viele klassische Missgeschicke.

Natürlich hat auch Rust seine Schattenseiten. Der oft zitierte "Borrow Checker" sorgt gerade Einsteigern anfangs für Herausforderungen, da er strikte Regeln für Speicherzugriffe durchsetzt, die verständlich, aber ungewohnt sein können. Dennoch ist der Lernaufwand eine lohnende Investition in langfristige Qualität und Fehlerfreiheit. Das betrifft besonders Großprojekte, bei denen der Kostendruck und der Wartungsaufwand hoch sind. Zusammenfassend lässt sich sagen, dass der Schlüssel für effiziente und sichere Softwareentwicklung heute darin liegt, eine Sprache zu wählen, die nicht nur auf Performance sondern vor allem auf Typensicherheit und Fehlervermeidung ausgelegt ist.

Rust erfüllt diese Kriterien und profitiert von Jahrzehnten an Erfahrungen, die in C++ gesammelt wurden – nicht zuletzt auch dank Vordenkern wie Matt Godbolt, die diese Gemeinsamkeiten und Unterschiede aufzeigen. Wer also Software mit möglichst geringem Risiko für schwerwiegende Fehler und hoher Entwicklerproduktivität bauen möchte, sollte Rust in Erwägung ziehen. Die Sprache schützt nicht nur vor komplexen Speicherproblemen, sondern auch vor alltäglichen Logikfehlern und erleichtert die Handhabung von Nutzereingaben. Entwickler können sich somit mehr darauf konzentrieren, die eigentliche Geschäftslogik umzusetzen, anstatt defensive Programmierung und Laufzeitsicherungen in aufwändiger Weise nachzurüsten. Das Studium von Matt Godbolts Arbeiten und Vorträgen ist dabei eine wertvolle Inspirationsquelle, gerade für Entwickler, die bereits tiefe C++ Kenntnisse besitzen.