Rust/Installation von `rustup`, `rustc` und `cargo`

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

---

Hallo! Willkommen in der Werkstatt der Rust-Programmierung. Stell dir vor, du möchtest ein tolles Baumhaus bauen. Dafür brauchst du Werkzeuge: Einen Hammer, eine Säge und vielleicht einen Bauleiter, der dir hilft, alles richtig zusammenzusetzen. Beim Programmieren mit der Sprache **Rust** ist das genauso!

In diese Lektion schauen wir uns die drei wichtigsten Werkzeuge an, die du brauchst, um eigene Programme zu bauen:

• `rustup` (Der Werkzeugkasten-Manager)
• `rustc` (Der Übersetzer)
• `cargo` (Der schlaue Bauleiter)

Lernziele

Nach dieser Lektion kannst du:

1. Erklären, wofür `rustup`, `rustc` und `cargo` da sind.
2. Eigene Projekte mit Cargo erstellen und starten.
3. Werkzeuge wie Dokumentationen und Tests selbst nutzen.
4. Dein erstes eigenes kleines Programm fehlerfrei "bauen".

Lektionen

Lektion 1: `rustup` – Der Installateur und Werkzeugpfleger

Wenn du anfangen willst, musst du Rust auf deinem Computer installieren. Das macht `rustup`. Stell dir `rustup` wie einen flinken Helfer vor, der losrennt und dir genau die Rust-Werkzeuge besorgt, die du brauchst. Wenn es eine neue Version von Rust gibt, sagst du einfach `rustup update`, und der Helfer holt dir die allerneuesten und besten Werkzeuge!

• Merksatz: `rustup` sorgt dafür, dass Rust auf deinem Computer installiert und immer auf dem neuesten Stand ist.

Lektion 2: `rustc` – Der fleißige Übersetzer

Dein Computer versteht kein Deutsch, und auch keinen Rust-Code! Er versteht nur Maschinensprache (Nullen und Einsen: 010101). `rustc` (kurz für Rust Compiler) ist dein persönlicher Übersetzer. Du schreibst deinen Text in Rust, und `rustc` übersetzt ihn so, dass der Computer das Programm ausführen kann. Meistens müssen wir `rustc` gar nicht direkt benutzen, weil unser Bauleiter (Cargo) ihm die Befehle gibt!

• Merksatz: `rustc` übersetzt deinen lesbaren Code in ein echtes Computerprogramm.

Lektion 3: `cargo` – Der schlaue Bauleiter

`cargo` wird dein bester Freund! Cargo macht fast alles für dich:

• Es erstellt dir neue leere Projekte (`cargo new mein_projekt`).
• Es lädt Bauteile von anderen Programmierern herunter (sogenannte "Crates" oder "Abhängigkeiten").
• Es befiehlt dem Übersetzer (`rustc`), dein Programm zu übersetzen (`cargo build`).
• Es startet dein Programm für dich (`cargo run`).

• Merksatz: `cargo` organisiert dein Projekt und nimmt dir die meiste Arbeit ab, damit du dich auf das Entwickeln und Spielen konzentrieren kannst!

Übungen für kleine Programmierer

Beantworte diese Fragen in deinem Kopf (oder auf einem Blatt Papier):

1. Welches Werkzeug brauchst du, um Rust auf die neueste Version zu aktualisieren?
2. Wie heißt der Befehl, mit dem Cargo ein neues Projekt für dich anlegt?
3. Warum können wir nicht unsere Rust-Dateien einfach direkt speichern und dem Computer sagen: "Los, mach!"? Welches Werkzeug fehlt dann?

---

50 Mini-Projekte (Projektbasiertes Lernen)

Hier sind 50 schnelle Mini-Projekte. Die ersten dauern nur Sekunden, spätere dauern ein paar Minuten. Probier sie alle aus, um ein richtiger Cargo-Meister zu werden!

1. Das Versions-Geheimnis: Tippe `cargo --version` ins Terminal, um zu sehen, welche Version der Bauleiter hat.
2. Der Übersetzer-Check: Tippe `rustc --version` ein.
3. Der Helfer-Check: Tippe `rustup --version` ein.
4. Dein erstes Baumhaus: Erstelle ein Projekt mit `cargo new baumhaus`.
5. Der Schnellstart: Gehe in den Ordner (`cd baumhaus`) und tippe `cargo run`.
6. Der vorsichtige Prüfer: Nutze `cargo check` (Prüft auf Fehler, ohne das Programm ganz aufzubauen).
7. Großes Aufräumen: Tippe `cargo clean`, um alle gebauten Sachen zu löschen (mach danach nochmal `cargo run`).
8. Das offline Handbuch: Gib `rustup doc` ein, um das Rust-Handbuch in deinem Browser zu öffnen!
9. Zweite Bibliothek: Erstelle ein Werkzeug-Projekt für andere mit `cargo new werkzeuge --lib`.
10. Bauen ohne Starten: Nutze `cargo build` in deinem Baumhaus-Projekt.
11. Die Suche: Gib `cargo search rand` ein, um fremde Code-Pakete ("Crates") für Zufallszahlen zu finden.
12. Hilfe gesucht: Tippe `cargo help` um alle Befehle von Cargo zu sehen.
13. Mehr Hilfe: Tippe `cargo help run`, um zu sehen, was "run" alles kann.
14. Der Handwerker-Code: Nutze `cargo fmt` um deinen Code superschön und ordentlich formatieren zu lassen.
15. Die kluge Büroklammer: Nutze `cargo clippy`, Cargo gibt dir Tipps, wie dein Code noch besser wird!
16. Zukunftswerkzeug: Tippe `rustup install nightly` (lädt die Beta-Testversion von Rust herunter).
17. Der Werkzeugwechsel: Tippe `rustup default nightly`, um die Testversion auszuprobieren.
18. Sicher ist sicher: Tippe `rustup default stable`, um zur normalen stabilen Version zurückzukehren.
19. Zeig mir alles: Tippe `rustup show`, um zu sehen, welche Werkzeuge gerade genau benutzt werden.
20. Wo bin ich: Gib `rustup which rustc` ein, um zu sehen, auf welchem Ordner der Übersetzer wohnt.
21. Der blitzschnelle Rennwagen: Baue dein Programm extra schnell mit `cargo build --release`.
22. Das Versteck: Finde im Dateiexplorer den Ordner `target/release`. Dort ist dein fertiges Programm!
23. Abhängigkeit zufügen: Tippe `cargo add rand` um eine Zufallsfabrik in dein Projekt zu laden.
24. Die Baupläne lesen: Schaue dir die Datei `Cargo.toml` an. Siehst du das Wort "rand" dort?
25. Alles aktualisieren: Benutze `cargo update`, um die neuesten Pakete aus dem Internet zu laden.
26. Der rohe Übersetzer: Erstelle ganz ohne Cargo eine Datei `hallo.rs` auf dem Desktop.
27. Handarbeit: Tippe `rustc hallo.rs`.
28. Handarbeit starten: Führe das entstandene Programm aus (unter Windows: `hallo.exe`, unter Linux/Mac `./hallo`).
29. Baum-Struktur: Nutze den Befehl `cargo tree`, um alle eingebauten Pakete als coolen Baum zu sehen.
30. Tests ausführen: Gib `cargo test` in deinem Projekt ein. Er wird sagen "0 Tests".
31. Den Computer kaputt machen: Mache absichtlich einen Tippfehler in `src/main.rs` und starte `cargo build`. Schau dir die rote Fehlermeldung an!
32. Fehler reparieren: Repariere den Fehler wieder und sei stolz, wenn es wieder grün ist.
33. Das Standard-Buch: Tippe `rustup doc --book`, um das offizielle Handbuch direkt zu öffnen.
34. Die Bibliothek-Doku: Tippe `rustup doc --std`, um das Wörterbuch aller Rust-Befehle zu öffnen.
35. Das Init-Geheimnis: Erstelle einen leeren Ordner, gehe hinein und tippe `cargo init` (anstatt `new`).
36. Deine eigene Doku: Schreibe `/// Hallo` in deinen Code und tippe `cargo doc --open`. Cargo baut dir eine Website!
37. Internet kaputt: Schalte dein WLAN/Internet aus und probiere `cargo build --offline`.
38. Der Pfad-Erkunder: Schaue dir den `src/` Ordner an. Was ist der Unterschied zur `Cargo.toml` Datei?
39. Projekt umbenennen: Ändere den Namen in der `Cargo.toml` manuell zu "superhaus" und baue es neu.
40. Zweite Startdatei: Lege einen Ordner `src/bin` an, tue eine `zweites.rs` hinein und probiere `cargo run --bin zweites`.
41. Ein neuer Account: Gehe auf `crates.io` im Browser. Da holt Cargo seine Bausteine her.
42. Ein Beispielprojekt: Lege einen `examples` Ordner an und starte etwas mit `cargo run --example`.
43. Lies die Lock-Datei: Öffne die `Cargo.lock` Datei. Staune über die vielen Zeilen (und ändere nichts daran!).
44. Neuer Workspace: Erstelle das Wort `[workspace]` in einer ganz neuen `Cargo.toml`.
45. Komponentenliste: Finde heraus, was `rustup component list` ausgibt.
46. Alte Version checken: Versuche `rustup install 1.60.0`, um eine ganz alte Rust-Version herbeizuzaubern.
47. Lokal überschreiben: Setze im Projektordner `rustup override set 1.60.0` ein.
48. Zurück zum Standard: Nutze `rustup override unset`.
49. Das Cargo Login: Gib `cargo login` ein. Er wird nach einem Token fragen (brich mit STRG+C ab).
50. Alles up to date: Gib noch einmal fröhlich `rustup update` ein, zum Abschluss!

---

10 Große Projekte (Top-Down-Lernen)

Jetzt schnappen wir uns die Werkzeuge und machen 10 richtig coole, größere Projekte.

1. Text-Adventure: "Die Höhle des Cargo"

Erstelle mit `cargo new hoehle` ein Text-Abenteuer. Lass dir vom Computer mit `println!` Sätze ausgeben. Führe das Abenteuer mit `cargo run` aus.

• Fokus: Lernen, wie man Projekte startet und Dateien ausführt.

2. Der Zahlen-Rater (mit fremden Paketen)

Baue das "Zahlen-Raten" Spiel aus dem Rust-Buch. Füge mit `cargo add rand` ein Modul hinzu, welches sich Zufallszahlen ausdenkt.

• Fokus: Andere "Crates" in die `Cargo.toml` einbinden und nutzen.

3. Die Bücher-Wand (Cargo Doc)

Erstelle eine Bibliothek mit `cargo new buecherei --lib`. Schreibe viele Kommentare, die mit `///` beginnen. Danach führe `cargo doc --open` aus und bestaune deine eigene, selbst-generierte professionelle Webseite.

• Fokus: Kennenlernen des automatischen HTML-Dokumentations-Werkzeugs von Cargo.

4. Zwei Spiele in einem (Der Cargo Workspace)

Anstatt für jedes Spiel einen neuen Ordner tief irgendwohin zu stecken, erstellst du einen "Workspace". In einer Haupt-`Cargo.toml` verwaltest du ein "Tic-Tac-Toe" und ein "Schere-Stein-Papier".

• Fokus: Große Projektstrukturen für Fortgeschrittene bändigen.

5. Der kleine Roboter-Prüfer (Cargo Test)

Schreibe ein Mathe-Hilfs-Programm (das plus und minus rechnet). Ganz unten schreibst du so genannte "Tests" (kleine Mini-Roboter), die prüfen ob 1+1 wirklich 2 ist. Führe alle Tests mit `cargo test` aus.

• Fokus: Automatisierte Tests ausführen.

6. Die Zeitmaschine (Rustup Toolchains)

Dein Code von heute funktioniert wunderbar. Aber was ist, wenn du probieren willst, ob er auch noch in einer richtig alten Rust-Version aus dem Jahr 2020 läuft? Lerne, wie du mit `rustup` zwischen neuen und alten Compilern durch die Zeit springst!

• Fokus: Die Macht von `rustup` verstehen.

7. Das Geschwindigkeits-Wettrennen (Release Mode)

Schreibe ein kleines Programm, das von 1 bis 1 Milliarde zählt und dabei Sekunden misst. Das dauert mit `cargo run` erstaunlich lang. Starte es danach mit `cargo run --release` und staune, wie unfassbar schnell Rust wird!

• Fokus: Den Unterschied zwischen "Debug" (Entwickeln) und "Release" (Fertigmachen) lernen.

8. Der Perfekte-Code-Polizist (Clippy & Fmt)

Schreibe absichtlich komplett chaotischen Code. Zitate an den falschen Stellen, alles in eine Zeile und benutze veraltete Schreibweisen. Nutze danach `cargo fmt` und `cargo clippy`. Das sind deine Polizisten, die automatisch alles für dich auf Hochglanz polieren!

• Fokus: Sauberen Code für Profis erzeugen.

9. Der Bunker (Offline Coden)

Erstelle ein neues Spiel, das Dinge ausgeben soll. Lade ein paar Coole Crates (wie "colored" für farbige Texte) herunter (`cargo fetch`). Danach ziehst du den Internet-Stecker und musst versuchen, dein Spiel komplett offline fertigzustellen! Nutze dafür `cargo build --offline` und `rustup doc`.

• Fokus: Ohne Internet programmieren, wenn man mal im Zug sitzt.

10. Dein eigenes Crate (Cargo Publish)

Du hast ein richtig tolles Werkzeug in Rust gebaut. Nun möchtest du es mit der ganzen Welt teilen! Du lernst, wie du dich auf der Website `crates.io` anmeldest, wie `cargo login` funktioniert und was passiert, wenn du `cargo publish` eintippen würdest, um dein Paket offiziell ins weite Internet zu schicken.

• Fokus: Ein eigenes Open-Source Paket vorbereiten.

---

Viel Spaß auf deiner Reise mit dem Installateur `rustup`, dem Übersetzer `rustc` und dem besten Bauleiter der Welt: `cargo`!

---

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).