Rust/Grundlagen/Installation

Hallo! Schön, dass du da bist. Hast du dich schon mal gefragt, wie man einem Computer sagt, was er tun soll? Genau das machen Programmierer! Heute lernen wir gemeinsam eine richtig coole und schnelle Programmiersprache: Rust.

Du kannst dir Rust wie eine Werkstatt vorstellen, in der du kleine, nützliche und super-sichere Roboter baust. Damit wir unsere Roboter (also unsere Programme) bauen können, müssen wir unsere Werkstatt aber erst einmal einrichten.

Deine Lernziele für heute

• Du kennst die drei wichtigsten Helfer in der Rust-Werkstatt: `rustup`, `rustc` und `cargo`.
• Du weißt, wie du ein schwarzes Fenster (das Terminal) öffnest und einem Computer einen Zauberspruch sagst.
• Du schreibst dein allererstes kleines Kommando und startest dein eigenes Mini-Projekt.

Lektion 1: Lerne deine neuen Helfer kennen

Um Rust zu sprechen, brauchen wir drei wichtige Helferlein. Ohne sie geht in unserer Werkstatt nichts!

1. `rustup`: Das ist dein Werkstatt-Manager. Er besorgt dir immer automatisch die neuesten Schraubendreher und Hämmer (Werkzeuge), die du brauchst, ohne dass du danach mühsam im Internet suchen musst.
2. `rustc`: Das ist der Übersetzer. Du schreibst bald echte, spannende Wörter auf deinen Bildschirm. Der Computer versteht aber eigentlich nur Einsen und Nullen. `rustc` übersetzt das, was du schreibst, pfeilschnell in eine Sprache, die der Computer direkt versteht (die sogenannte Maschinensprache).
3. `cargo`: Das ist dein persönlicher Roboter-Assistent! `cargo` ist ab heute dein bester Freund. Wenn du ihm sagst: "Cargo, mach mein Programm fertig!", dann holt er alle Teile, baut dein Programm zusammen, packt es als nettes Geschenk ein und hilft dir sogar später beim Aufräumen. Praktisch, oder?

Lektion 2: Wie man die Helfer ins Haus holt (Installation)

Stell dir vor, du bist ein Magier und bestellst per Zauberspruch deine fleißigen Helfer herbei.

So geht's auf dem Computer: Wenn du unter Linux oder macOS arbeitest, öffnest du ein Programm auf deinem Computer, das meistens nur ein schwarzes Fenster ist. Es nennt sich das Terminal. Dort tippst du einfach folgende magische Buchstabensuppe ein:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Was macht dieser Zauberspruch genau?

• `curl`: Heißt auf Englisch so viel wie "heranholen" oder "ziehen" – es ist wie ein magnetischer Lasso-Wurf ins weite Internet.
• `https://sh.rustup.rs`: Das ist die magische Internet-Adresse, wo unser zukünftiger Werkstatt-Manager (`rustup`) wohnt.
• `| sh`: Dieser kleine Strich (das Rohr) schickt alles direkt zu deinem Computer und sagt: "Bitte führe diesen Manager jetzt auch wirklich aus!"

Sobald du auf deiner Tastatur auf Enter drückst, passiert viel Magie auf dem Bildschirm und `rustup`, `rustc` und `cargo` ziehen dauerhaft bei dir ein.

Lektion 3: Dein erstes eigenes Projekt (Bottom-Up-Lernen)

Bottom-Up bedeutet: Wir fangen ganz unten bei den ganz kleinen Dingen an und bauen darauf nach und nach auf!

Sobald alles komplett installiert ist, wollen wir direkt testen, ob dein Roboter-Assistent `cargo` auch sofort aufgewacht ist.

Schritt 1: Ein neues Projekt starten Tippe im dunklen Terminal einfach:

cargo new mein_erster_roboter

Das sagt `cargo` im Grunde: "Hey, baue mir eine frische, saubere Kiste für einen tollen neuen Roboter namens 'mein_erster_roboter'!"

Schritt 2: In die Kiste springen Mit dem speziellen Befehl `cd` (das steht für "change directory", also "wechsle den Ordner") springen wir nun in die frisch gebaute Kiste:

cd mein_erster_roboter

Schritt 3: Den Roboter einschalten Um das kleine Programm, das Cargo für dich wie von Zauberhand schon mal testweise vorgeschrieben hat, lustig zum Leben zu erwecken, sagst du:

cargo run

Auf dem Bildschirm steht dann auf einmal wie ein kleines Wunder: Hello, world!

Wow! Du hast soeben dein allererstes echtes Computer-Programm aufgerufen!

Die Code-Erklärung (Besonders für Zehnjährige und Anfänger)

Als du vorhin `cargo new` getippt hast, hat Cargo für dich heimlich schon eine kleine Datei geschrieben. Sie heißt passend `main.rs` und ist im Ordner `src` (Source, also Quellcode) versteckt. Wenn wir die Datei mutig aufmachen, sehen wir folgenden fremden Text:

fn main() {
    println!("Hallo, Welt!");
}

Lass uns das wie schlaue Detektive Satz für Satz aufklären!

• `fn`: Das ist kurz für "Funktion". Eine Funktion in der Welt von Rust ist wie ein normales Rezept zum Kuchenbacken. Es gibt einfache, klare Befehle, wie man etwas macht.
• `main()`: Das ist die "Hauptfunktion". Jeder Roboter sucht zuerst wild nach dem dicken Start-Knopf namens "main", wenn er angemacht wird! Ohne main weiß das Programm absolut nicht, wo es anfangen soll.
• `{ ... }`: In diesen lustig geschweiften Klammern steht drin, was der Roboter tun soll, wenn du ihn startest (also wenn du den Startknopf drückst). Es ist quasi der Bauch der Funktion.
• `println!`: Das heißt auf Englisch "Drucke mir auf den Bildschirm (Print)" und "(ln) mache eine neue Leitung bzw. Zeile (Line)". Das Ausrufezeichen steht für etwas Besonderes: "Ich bin sooo laut und mächtig, ich bin ein sogenanntes Makro!". Es macht Dinge im Hintergrund sehr, sehr leicht, die ansonsten für dich echt kompliziert wären.
• `"Hallo, Welt!"`: Alles, was du zwischen "Gänsefüßchen" (Anführungszeichen) schreibst, wird exakt so und direkt auf dem Bildschirm angezeigt. So kannst du dir Text-Ausgaben für später aussuchen.
• `;`: Dieses winzig kleine Semikolon am Ende ist wie der Punkt am Ende eines ganz normalen Satzes! Es sagt dem klugen Übersetzer `rustc`: "Juhu, mein Befehl ist hier und jetzt fertig."

Interleaving (Vermischtes Lernen: Bunte Mini-Projekte zum Selbermachen)

Anstatt nur viel zu lesen, lassen wir jetzt verschiedene Themen bunt gemischt ineinander fließen. Probiere diese Dinge sofort mutig aus. Es ist total okay, wenn du dabei Fehler machst – Fehler sind schließlich deine allerbesten Raketen-Lehrer!

Projekt 1: Der freche Begrüßungs-Roboter

1. Öffne dein Terminal-Fenster.
2. Mache ein komplettes, super neues Projekt: `cargo new hallo_roboter`
3. Wechsle sofort hinein: `cd hallo_roboter`
4. Verändere den Code in der Datei `src/main.rs`. Ändere dabei den Text "Hello, world!" zu "Ich bin hier, räum dein Zimmer sofort auf!".
5. Starte es danach freudig mit deinem Lauf-Befehl: `cargo run`

Projekt 2: Aus den coolsten Fehlern lernen

Was passiert eigentlich genau, wenn man dem Übersetzer keinen Punkt am Ende lässt?

1. Nimm das kleine `;` (Semikolon) ganz am Ende des Codes einfach weg.
2. Speichere die Datei dann natürlich ab.
3. Tippe wieder entspannt `cargo run`.
4. Du wirst jetzt eine super nützliche Hilfe von Rust sofort sehen: Der Übersetzer (`rustc`) schimpft dich absolut nicht grundlos aus, sondern er zeigt dir super-lieb und schön farbig, wo genau du einen Fehler gemacht hast. Das ist deine erste echte Programm-Fehlersuche in der freien Natur! Repariere es sofort tapfer wieder, indem du das Semikolon wieder dahinsetzt!

Projekt 3: Der richtig laute Doppel-Mund

Was passiert eigentlich, wenn wir unseren kleinen süßen Roboter gleich zweimal hintereinander etwas freches sagen lassen wollen?

1. Kopiere im 'Bauch' der Start-Funktion (`{ ... }`) die gesamte Zeile mit dem `println!` und schreibe sie genau darunter extra nochmal fest auf.
2. Ändere den Text beim zweiten Mal in ein nettes `"Wie geht es dir heute?"`
3. Lass den Roboter jetzt mit `cargo run` richtig laut sprechen. Es fühlt sich total großartig an, zweimal Text zu sehen, oder?

Das große Rust-Quiz: Teste sofort dein Wissen!

Jetzt überprüfen wir gemeinsam, was du dir heute alles schon von den Aufgaben gemerkt hast! Finde fix die fehlenden Wörter für die tollen Lücken und meistere über 30 kleine Raten-Übungen auf einen Streich!

{Rust Einsteiger-Quiz 1: Wie heißen die Helfer? |type="{}"} Wir haben gelernt, dass wir drei wichtige { Helfer _6 } für unsere Werkstatt brauchen. Der Manager, der dir immer die neuesten Werkzeuge und Werkstätten holt, heißt { rustup _6 }. Der Übersetzer, der aus unserer Schrift etwas für den Computer macht, lautet { rustc _5 }. Er übersetzt unseren Text in eine für den Computer verständliche Sprache, die { Maschinensprache _16 } genannt wird. Dein bester Freund und persönlicher Assistent ist { cargo _5 }. Dieser Roboter-Assistent hilft dir, Programme zusammenzubauen, aber auch beim { Aufräumen _9 } oder Einpacken. Ohne ihn gäbe es kein einfaches Projekt.

{Rust Einsteiger-Quiz 2: Der Zauberspruch im Terminal |type="{}"} Du tippst alle Befehle nicht einfach in Word, sondern in ein schwarzes Fenster namens { Terminal _8 } ein. Möchtest du alles auf deinem Computer installieren (unter Linux oder macOS), gibst du dort einen tollen { Zauberspruch _12 } ein. Das Holen geschieht mit einem Befehl, der wie am Lasso ziehen klingt und { curl _4 } heißt. Der kleine Strich am Ende des Befehls (|) sorgt dafür, dass das Ganze danach sofort als Programm ausgeführt wird.

{Rust Einsteiger-Quiz 3: Cargo zaubert tolle Projekte! |type="{}"} Du willst ein superneues Projekt erstellen. Dafür tippst du die magischen Worte { cargo new _9 } ein. Wenn mein Projekt zum Beispiel "robby" heißt, schreibe ich "cargo new { robby _5 }". Anschließend müssen wir zwingend in das Verzeichnis hineingehen. Der Befehl zum "Ordner wechseln" lautet { cd _2 } (Change Directory). Wenn du das gemacht hast, kannst du deinen Code endlich wieder finden. Die Dateiendung von unserem Code lautet in Rust auf den Buchstaben genau immer " { .rs _3 } ". Unsere Hauptdatei, in der das Wichtigste überhaupt steht, heißt deshalb passend { main.rs _7 }.

{Rust Einsteiger-Quiz 4: Die Anatomie eines Codes |type="{}"} In der genialen Programmiersprache { Rust _4 } gibt es Abkürzungen. Eine Funktion wird immer stark mit den zwei zarten Buchstaben { fn _2 } abgekürzt. Jedes Programm braucht einen tollen Startknopf. Diese allererste Funktion heißt immer starr { main _4 }. Der Bauch der Funktion, also dort wo deine wahren Befehle drinstehen, ist zwischen zwei { geschweiften _12 } Klammern versteckt: { und }. Damit ein Wort auf dem Monitor direkt ausgegeben wird, verwenden wir voll den Befehl { println! _8 }. Vergiss am Ende dieses Wortes bloß nicht das laute { Ausrufezeichen _14 }, sonst funktioniert unser magisches Makro heute bestimmt nicht!

{Rust Einsteiger-Quiz 5: Der Rest vom Satz |type="{}"} Alles, was unser kluges Programm genauso auf dem Monitor zeichnen oder voll ausschreiben soll, steht zwischen { Anführungszeichen _15 } (oder Gänsefüßchen). Am Ende eines fertig geschriebenen Befehls müssen wir in Rust immer klugerweise ein winziges { Semikolon _9 } setzen. Es ist wie der Punkt am Ende eines echten Satzes! Will ich das frisch mühsam getippte Programm direkt verlässlich testen, wecke ich Cargo liebend gerne mit { cargo run _9 } auf. Cargo wird mein tolles Werk nun { bauen _5 }, liebevoll zusammenpacken und sofort munter loslegen lassen. Fehler im Code sind übrigens cool und überhaupt nicht schlimm! Fehler sind nämlich von nun an unsere allerbesten { Lehrer _6 } und helfen stark beim Erschaffen.

{Rust Einsteiger-Quiz 6: Wiederholung ist ganz wichtig |type="{}"} Lass uns nochmal von vorne alles klug nachdenken. Wir können superneue Projekte rasant erstellen mit { cargo new _9 }. Und dann danach? Um in den genauen Ordner vom neuen Programm rüber zu hüpfen, tippe ich flink { cd _2 }. Wo in dem dicken Ordner versteckt unser Cargo nun meinen geschriebenen Code? Er liegt in einem kleinen Unterordner, der immer genau { src _3 } heißt (das steht für Source / Quellcode). Wenn ich meinen geschriebenen Code sicher an den mutigen Übersetzer { rustc _5 } übergebe, macht er daraus grandios etwas, was der dumme Computer ohne unsere weitere Hilfe super liest. Das Tolle am täglichen Programmieren ist für uns, dass wir dem großen mächtigen Computer wie einem kleinen schlauen { Roboter _7 } Befehle erteilen können.

--- Glückwunsch, du hast das Modul 1 der Rust-Werkstatt als Meister-Roboter-Bauer erfolgreich und großartig bestanden! Mach dich auf jeden Fall gefasst auf Modul 2!