Einführung in Rust

Was ist Rust?

Rust ist eine Systemprogrammiersprache. Du setzt sie für dieselben Aufgaben ein wie C oder C++: Betriebssysteme, Game-Engines, Browser, Datenbanken und Kommandozeilen-Tools – überall dort, wo Geschwindigkeit und Kontrolle zählen.

Das Besondere: Rust liefert dir diese Low-Level-Performance ohne die klassischen Stolperfallen. In C liest du schnell mal versehentlich Speicher, der schon freigegeben wurde, oder löst ein Data Race aus. In Rust lässt sich solcher Code meistens gar nicht erst kompilieren – der Compiler stoppt dich schon beim Bauen.

Rust begann als privates Projekt von Graydon Hoare. Später holte er Mozilla als Sponsor dazu, und 2015 erschien die stabile Version 1.0. Heute kümmern sich die Rust Foundation und eine große Open-Source-Community um die Sprache.

Das Problem, das Rust löst

Früher musstest du dich zwischen zwei Kompromissen entscheiden:

• Low-Level-Sprachen (C, C++): schnell und nah an der Hardware, aber du verwaltest den Speicher von Hand. Fehler führen zu Abstürzen und Sicherheitslücken.
• High-Level-Sprachen (Python, Java, Go): sicher und bequem, aber sie verlassen sich auf einen Garbage Collector (automatische Speicherbereinigung). Das kostet Performance und macht das Programm weniger vorhersehbar.

Die große Idee von Rust ist ein dritter Weg: Es sorgt beim Kompilieren für Speichersicherheit, und zwar mit einem System namens Ownership (Eigentum). Das lernst du später in diesem Kurs kennen. Kein Garbage Collector, kein manuelles free() – der Compiler findet selbst heraus, wann Speicher nicht mehr gebraucht wird.

So kannst du es dir vorstellen

Stell dir den Rust-Compiler als strengen, aber fairen Code-Reviewer vor. Er gibt keinen Code frei, der unsicher sein könnte. Am Anfang nervt das – aber dafür landen ganze Klassen von Bugs gar nicht erst in Produktion.

Rust im Vergleich

Eine grobe Übersicht, wo Rust im Vergleich zu Sprachen steht, die du vielleicht kennst:

Sprache	Geschwindigkeit	Speichersicherheit	Garbage Collector
C / C++	Schnell	Manuell, fehleranfällig	Nein
Go	Gut	Sicher	Ja
Python	Langsamer	Sicher	Ja
Rust	Schnell	Sicher (beim Kompilieren geprüft)	Nein

Das Fazit: Rust will Geschwindigkeit wie C und die Sicherheit einer High-Level-Sprache – beides gleichzeitig. Einen genaueren Vergleich mit echtem Code findest du unter Rust vs. C++, Go und Python.

Wo Rust eingesetzt wird

Wahrscheinlich nutzt du Rust schon, ohne es zu wissen:

• Firefox – Teile der Rendering-Engine sind in Rust geschrieben
• Cloudflare und Discord – performancekritische Backend-Dienste
• Der Linux-Kernel – nimmt inzwischen Treiber an, die in Rust geschrieben sind
• Kommandozeilen-Tools – schnelle Lieblinge wie ripgrep, bat und fd
• WebAssembly – Rust ist eine der ersten Wahlen, um Code in nativer Geschwindigkeit im Browser auszuführen

Ein kleiner Vorgeschmack

Du musst noch nicht jedes Detail verstehen. Achte einfach darauf, wie gut lesbar der Code ist:

fn main() {
    let name = "Rustacean";
    println!("Hallo, {name}!");
}

Ausgabe:

Hallo, Rustacean!

▶ Selbst ausprobieren

Tipp

Übrigens: Rust-Entwickler nennen sich selbst „Rustaceans“ 🦀, und das Maskottchen der Community ist eine freundliche Krabbe namens Ferris.

Wie „sicher“ in der Praxis aussieht

„Speichersicherheit“ klingt abstrakt. Darum hier ein konkreter Fall: Du hast eine Liste mit drei Punktzahlen und fragst nach der zehnten – die es gar nicht gibt.

In C ist das erlaubt. Das Programm liest einfach still und leise, was zufällig hinter deiner Liste im Speicher liegt. Vielleicht bekommst du eine zufällige Zahl, einen Absturz oder eine Sicherheitslücke – und nichts warnt dich.

Rust lässt das nicht durchgehen. Wenn der Compiler den Fehler erkennen kann, weigert er sich, das Programm zu bauen:

fn main() {
    let scores = [90, 85, 77];
    println!("{}", scores[9]);
}

error: this operation will panic at runtime
 --> src/main.rs:3:20
  |
3 |     println!("{}", scores[9]);
  |                    ^^^^^^^^^ index out of bounds: the length is 3 but the index is 9

Die Meldung sagt: Dieser Zugriff würde zur Laufzeit eine Panic auslösen, weil der Index außerhalb des gültigen Bereichs liegt – die Länge ist 3, der Index aber 9.

Und wenn du nicht sicher bist, ob ein Element existiert, kannst du in Rust höflich nachfragen. .get() antwortet mit „hier ist es“ oder „da ist nichts“ (None), statt dir irgendwelchen Datenmüll zu geben:

fn main() {
    let scores = [90, 85, 77];
    println!("erste Punktzahl: {}", scores[0]);
    println!("zehnte Punktzahl: {:?}", scores.get(9));
}

Ausgabe:

erste Punktzahl: 90
zehnte Punktzahl: None

▶ Selbst ausprobieren

Mach dir um [...], .get() und None noch keine Gedanken. Die lernst du richtig in Arrays und Option kennen. Wichtig ist jetzt nur: Eine ganze Klasse von Fehlern, bei denen Speicher gelesen wird, der tabu ist, wird entweder schon vor dem Start abgefangen oder zur Laufzeit sicher behandelt.

Ist Rust schwer zu lernen?

Ehrliche Antwort: Die ersten ein, zwei Wochen können frustrierend sein. Konzepte wie Ownership und Borrowing (Ausleihen) sind wirklich neu. Und der Compiler lehnt Code ab, von dem du glaubst, dass er funktionieren müsste. Aber genau dieser Widerstand bringt dir bei, sichereren Code zu schreiben – und es macht schneller „Klick“, als die meisten erwarten.

Dieser Kurs soll dir den Einstieg leichter machen: kleine Schritte, echte Beispiele und überall ein Button zum Selbst ausprobieren.

Übungen

1. Begrüße dich selbst

Ändere das Programm aus dem „kleinen Vorgeschmack“ so, dass es dich mit deinem Namen begrüßt. Füge eine zweite Zeile hinzu, die Willkommen bei Rust! ausgibt. Tipp: Jedes println! gibt eine Zeile aus – du brauchst also zwei davon.

Lösung anzeigen

fn main() {
    let name = "Sam";
    println!("Hallo, {name}!");
    println!("Willkommen bei Rust!");
}

Ausgabe:

Hallo, Sam!
Willkommen bei Rust!

▶ Selbst ausprobieren

2. Ein Fakt über Rust

Speichere das Wort Rust und die Jahreszahl 2015 unter zwei Namen. Gib dann mit beiden den Satz Rust 1.0 wurde 2015 veröffentlicht. aus. Tipp: Du kannst mehr als ein {name} in dasselbe println! schreiben.

Lösung anzeigen

fn main() {
    let language = "Rust";
    let year = 2015;
    println!("{language} 1.0 wurde {year} veröffentlicht.");
}

Ausgabe:

Rust 1.0 wurde 2015 veröffentlicht.

▶ Selbst ausprobieren

Zusammenfassung

• Rust ist eine schnelle, sichere Systemsprache – so schnell wie C, ohne Garbage Collector.
• Ownership verhindert Speicherfehler schon beim Kompilieren.
• Rust steckt in Browsern, Kerneln, Cloud-Diensten, Kommandozeilen-Tools und WebAssembly.
• Die Lernkurve ist real, aber kurz – der Compiler ist auf deiner Seite.

Als Nächstes installierst du Rust und startest dein erstes Programm auf deinem eigenen Rechner.

Kurzer Check

Kurzer Check

1. Wie erreicht Rust Speichersicherheit ohne Garbage Collector?

Es ruft free() automatisch für dich auf Es prüft die Sicherheit beim Kompilieren mit Ownership Es lässt zur Laufzeit im Hintergrund eine Sicherheitsprüfung laufen

2. Was haben Rust und Go laut der Vergleichstabelle gemeinsam?

Beide verwenden einen Garbage Collector Beide sind speichersicher Beide sind so schnell wie Python

3. Wie nennen sich Rust-Entwickler selbst?

Rustlings Crabbers Rustaceans

Punkte: 0 / 3

Weiterlesen

• Einführung – Die Programmiersprache Rust: für wen das offizielle Buch gedacht ist und wie es aufgebaut ist. Der beste kostenlose Begleiter zu diesem Kurs.
• rust-lang.org (auf Englisch): die offizielle Website mit dem „Warum Rust?“-Überblick (Performance, Zuverlässigkeit, Produktivität) und Erfahrungsberichten von Firmen, die Rust einsetzen.
• Learn Rust (auf Englisch): die offizielle Liste mit Lernmaterial, darunter Rust by Example und die Rustlings-Übungen.
• Announcing Rust 1.0 – Rust Blog (auf Englisch): der Beitrag von 2015, mit dem Rust als stabil galt – und was „Stabilität“ für deinen Code verspricht.
• Rust Foundation (auf Englisch): die gemeinnützige Organisation, die das Rust-Projekt und seine Maintainer unterstützt.