C ist unsicher. Das sagen alle. Rust ist sicher. Das sagen auch alle.

Ich höre das oft. In Blogposts, in Kommentarspalten, auf Hackernews. C ist gefährlich. C hat Buffer Overflows. C hat Memory Leaks. C ist ein Relikt. Wir haben jetzt Besseres.

Das Bessere heißt Rust. Oder Go. Oder irgendwas mit Garbage Collector. Irgendwas, das aufpasst. Irgendwas, das zwischen dir und dem Speicher steht und sagt: Keine Sorge. Ich kümmere mich.

Vertrau mir.

Der Borrow Checker ist dein Freund:

So sagt man das. Der Compiler passt auf. Du kannst gar keine Fehler machen. Das System verhindert es.

Aber wer hat den Borrow Checker geschrieben?

Menschen. Die gleichen Menschen, die auch C geschrieben haben. Die gleichen Menschen, die Bugs machen. Die gleichen Menschen, die müde sind, gestresst, unter Zeitdruck.

Der Rust-Compiler hat Bugs. GCC hat Bugs. LLVM hat Bugs. Jeder Compiler hat Bugs. Manche liegen jahrelang unentdeckt. Manche sind Sicherheitslücken.

Wenn du in C einen Fehler machst, siehst du ihn vielleicht. Der Segfault zeigt dir, dass du falsch lagst.

Wenn der Compiler einen Fehler macht, siehst du nichts. Dein Code ist korrekt. Der Compiler sagt, er ist sicher. Du vertraust. Warum auch nicht?

Das ist der Unterschied zwischen einem Fehler, den du machst, und einem Fehler, den jemand anderes für dich versteckt.

Der Garbage Collector kümmert sich um deinen Speicher. Du musst nicht mehr nachdenken. Du allokierst, du vergisst, er räumt auf.

Wann räumt er auf? Keine Ahnung. Wie räumt er auf? Keine Ahnung. Was passiert, wenn er zu spät aufräumt? Keine Ahnung.

Du hast die Kontrolle abgegeben. Das fühlt sich gut an, nicht wahr? Weniger Arbeit. Weniger Verantwortung.

Aber der Speicher ist noch da. Die Maschine ist noch da. Die Nullen und Einsen interessieren sich nicht für Abstraktionen. Irgendwer muss die Entscheidungen treffen. Wenn du es nicht bist, ist es jemand anderes.

Jemand, den du nicht kennst. Jemand, dessen Code du nie gelesen hast. Jemand, dem du blind vertraust.

Die NASA hat Menschen mit C zum Mond geschickt. Mit Code, den Menschen geschrieben, gelesen und verstanden haben. Zeile für Zeile.

Heute schreiben wir Programme, die auf Compilern laufen, die auf Frameworks laufen, die auf Runtimes laufen, die auf Betriebssystemen laufen. Jede Schicht verspricht Sicherheit. Jede Schicht versteckt Komplexität. Jede Schicht ist ein weiterer Fremder, dem du vertraust.

Der Rust-Compiler hat mehr als 500.000 Zeilen Code. Eine halbe Million Zeilen zwischen dir und der Maschine. Geschrieben von Menschen. Geprüft von Menschen. Fehlerhaft wie Menschen.

Wer prüft eine halbe Million Zeilen?

C sagt: Hier ist der Speicher. Hier sind die Pointer. Du bist verantwortlich. Wenn du Mist baust, stürzt es ab.

Die neuen Sprachen sagen: Vertrau uns. Wir kümmern uns. Du musst nicht verstehen, was passiert.

Und wir nicken und glauben es. Weil es bequem ist. Weil es einfacher ist. Weil niemand mehr die Zeit hat, eine halbe Million Zeilen zu lesen.