Rust/IDE-Setup

Herzlich willkommen! In diesem Kurs lernst du, wie du deine **Rust IDE (Integrierte Entwicklungsumgebung)** perfekt einrichtest. Eine gute IDE ist wie eine magische Werkstatt für Programmierer. Wir nutzen hierfür **VS Code (Visual Studio Code)** zusammen mit der Erweiterung **rust-analyzer**. Das ist das beliebteste und beste Werkzeug, um Rust-Code zu schreiben!

Alles wird ganz einfach und Schritt für Schritt erklärt, damit du sofort loslegen kannst.

Lernziele

• Du verstehst, was eine IDE ist und warum sie dir beim Programmieren hilft.
• Du kannst VS Code herunterladen und auf deinem Computer installieren.
• Du kannst Erweiterungen (Extensions) in VS Code finden, vor allem den **rust-analyzer**.
• Du lernst, wie man ein neues Rust-Projekt im Editor öffnet und bearbeitet.
• Du lernst, wie du deinen Code ausführt, Fehler suchst (Debugging) und deinen Arbeitsplatz anpasst.

Lektionen

Lektion 1: Was ist eine IDE?

Stell dir vor, du möchtest ein Buch schreiben. Du könntest einen einfachen Notizblock nehmen (wie den normalen Texteditor auf deinem PC), aber das wäre mühsam. Eine IDE (Integrierte Entwicklungsumgebung) ist wie ein Super-Schreibprogramm für Code. Sie hebt Wörter farbig hervor (Syntax-Highlighting), schlägt dir Code vor (wie Autokorrektur am Handy) und zeigt dir Fehler, bevor du das Programm überhaupt startest.

Lektion 2: VS Code installieren

VS Code ist kostenlos und von Microsoft. Um es zu bekommen: 1. Gehe im Internet auf `code.visualstudio.com`. 2. Klicke auf den großen "Download"-Button. 3. Öffne die heruntergeladene Datei und folge den Anweisungen (einfach immer auf "Weiter" klicken). 4. Starte VS Code!

Lektion 3: Den rust-analyzer installieren

Damit VS Code die Sprache Rust versteht, braucht es ein Wörterbuch und einen Lehrer: den **rust-analyzer**. 1. Klicke in VS Code links an der Seite auf das Symbol, das wie vier kleine Quadrate aussieht (das sind die "Extensions" oder "Erweiterungen"). 2. Tippe oben in die Suchleiste "rust-analyzer" ein. 3. Klicke auf "Install" (Installieren) beim ersten Treffer. Das war's! Deine IDE ist nun bereit für Rust.

Lektion 4: Ein Projekt öffnen

Wenn du mit `cargo new mein_projekt` ein Rust-Projekt erstellt hast, kannst du es in VS Code öffnen, indem du auf "File" (Datei) -> "Open Folder" (Ordner öffnen) klickst und deinen Projektordner auswählst. Alternativ kannst du im Terminal `code .` in deinem Projektordner eingeben.

Übungen

• Übung 1: Lade dir ein Farb-Theme herunter (z.B. "One Dark Pro" oder "Dracula") und aktiviere es.
• Übung 2: Erstelle ein neues Projekt mit Cargo, öffne es in VS Code und schau dir an, wie farbig die `main.rs` Datei aussieht.
• Übung 3: Schreibe einen absichtlichen Fehler in deinen Code (z.B. lass ein Semikolon `;` am Ende weg) und schaue, wie der `rust-analyzer` dir eine rote Wellenlinie anzeigt. Fahre mit der Maus über die Linie, um die Fehlermeldung zu lesen!

75 Mini-Projekte: Praxisbezug und Wissenstransfer

Hier sind 75 kleine Aufgaben, die dir helfen, jeden Winkel deiner neuen Werkstatt kennenzulernen. Jedes Projekt dauert nur wenige Minuten!

1. Einen Projektordner für Rust-Übungen anlegen.
2. VS Code aus dem Startmenü heraus öffnen.
3. VS Code auf Vollbild stellen.
4. Ein neues Editor-Fenster (Tab) öffnen.
5. Die Einstellungen (`Strg` + `,` / `Cmd` + `,`) im Editor aufrufen.
6. Die Schriftgröße des Editors auf 16 stellen.
7. Das Farbschema auf "Dark (Visual Studio)" wechseln.
8. Das Farbschema probehalber auf ein helles Theme wechseln.
9. Ein spezielles neues Theme aus dem Extensions Marketplace herunterladen.
10. Das Language Pack "German" suchen und installieren.
11. Die Seitenleiste (Explorer-Ansicht) ein- und wieder ausblenden.
12. Die Tastenkombination zum Speichern (`Strg` + `S`) ausprobieren.
13. Einen Text schreiben und die Änderung rückgängig machen (`Strg` + `Z`).
14. Die rückgängig gemachte Änderung wiederherstellen (`Strg` + `Y`).
15. Die Erweiterung "rust-analyzer" im Marketplace suchen.
16. "rust-analyzer" installieren und warten, bis es fertig ist.
17. Die Erweiterung "CodeLLDB" für Debugging in Rust suchen.
18. "CodeLLDB" installieren.
19. Die Erweiterung "Error Lens" für bessere Fehleranzeigen installieren.
20. Das integrierte Terminal in VS Code via Menü ("Terminal" -> "New Terminal") öffnen.
21. Eine leere Textdatei als `test.rs` speichern.
22. Im Terminal `cargo --version` eintippen, um die Rust-Installation zu überprüfen.
23. Im Terminal `cargo new ide_test` ausführen.
24. "Ordner öffnen" wählen und den neuen Ordner `ide_test` laden.
25. Den Ordner `src` im Explorer ausklappen.
26. Die Datei `main.rs` durch Anklicken im Editor öffnen.
27. Mit der Maus über `println!` fahren, um die Erklärung zum Makro zu lesen.
28. Über der `main`-Funktion auf "Run" klicken, um den Code auszuführen.
29. Das Ausrufezeichen bei `println!` löschen, um absichtlich einen Fehler zu machen.
30. Den Fehler anhand der roten Schlangenlinie erkennen.
31. Mit der Maus über die rote Linie fahren, um die rust-analyzer Fehlermeldung zu lesen.
32. Die "Quick Fix" (Schnelle Aktion)-Glühbirne anklicken.
33. Den Vorschlag des rust-analyzers übernehmen, um den Fehler zu beheben.
34. Nach "Format On Save" in den Einstellungen suchen.
35. Den Haken bei "Format On Save" setzen.
36. Den Code in `main.rs` unordentlich einrücken.
37. Die Datei speichern (`Strg` + `S`) und beobachten, wie rustfmt alles wieder ordentlich macht.
38. Das Terminal nach oben oder unten ziehen, um die Größe zu verstellen.
39. Eine neue Datei `hallo.rs` im Ordner `src` über die Seitenleiste erstellen.
40. Die Datei `hallo.rs` durch Rechtsklick wieder löschen.
41. Einen Tab im Editor anklicken und nach rechts ziehen, um den Bildschirm zu spalten.
42. In der linken Hälfte `main.rs` und in der rechten Hälfte `Cargo.toml` anzeigen.
43. Die Explorer-Ansicht mit dem Symbol oben links verstecken, um mehr Platz zu haben.
44. Mit `Strg` + `F` das Wort "Hello" in der Datei suchen.
45. Das Wort "Hello" durch "Hallo" mittels der Suchen/Ersetzen-Funktion tauschen.
46. Einen neuen Abschnitt im integrierten Terminal öffnen (Symbol `+`).
47. Alle laufenden Terminals über den Mülleimer-Button schließen.
48. Einen Editor-Tab mit `Strg` + `W` (oder `Cmd` + `W`) schließen.
49. Code-Zeilen markieren und das Kürzel für das Auskommentieren (`Strg` + `#` oder `/`) drücken.
50. Die Kommentare mit derselben Tastenkombination wieder entfernen.
51. Mit Rechtsklick auf eine Variable -> "Rename Symbol" den Namen überall gleichzeitig ändern.
52. Auf die "Minimap" (kleine Karte am rechten Rand) klicken, um schnell nach unten zu springen.
53. An der linken Seite auf den Pfeil neben einer Klammer `{` klicken, um die Funktion einzuklappen (Fold).
54. Die Funktion durch Klicken auf denselben Pfeil wieder ausklappen.
55. Die Erweiterung "Material Icon Theme" installieren.
56. Die schönen neuen Icons für deine Rust-Dateien im Explorer betrachten.
57. Das Wort `for` tippen und das Snippet (die Vorlage) aus der Vorschlag-Liste mit `Enter` wählen.
58. Die Ansicht auf "Zen-Modus" (Ablenkungsfreies Programmieren) umschalten.
59. Den Zen-Modus durch Drücken von `Esc` zweimal verlassen.
60. Im "Problems" (Probleme)-Fenster unterhalb des Editors nachsehen, ob momentan Fehler vorliegen.
61. Eine Zeile Code kopieren und duplizieren mit `Alt` + `Shift` + `Pfeil Runter`.
62. Eine Zeile nach oben verschieben mit `Alt` + `Pfeil Hoch`.
63. Die Erweiterung "Even Better TOML" suchen und installieren.
64. Die Datei `Cargo.toml` öffnen und sehen, wie diese nun noch besser hervorgehoben wird.
65. Einen Breakpoint (Haltepunkt) setzen, indem in der `main.rs` links neben die Zeilennummer geklickt wird (roter Punkt).
66. Über der `main`-Funktion auf "Debug" klicken.
67. Im Debugging-Statusfenster (links) ansehen, welchen Wert die aktuellen Variablen haben.
68. Mit dem Button "Step Over" in der kleinen Leiste oben einen Schritt weiter im Code gehen.
69. Programm fortsetzen durch einen Klick auf "Continue" in der Debug-Leiste.
70. Die Debugging-Sitzung per rotem Quadrat-Icon beenden.
71. Über `Strg` + `P` nach der Datei `Cargo.toml` im Projekt suchen und sie blitzschnell so öffnen.
72. Über `Strg` + `Shift` + `O` nach der `main` Funktion suchen und direkt dorthin springen.
73. Im Terminal noch einen Test ausführen (`cargo test`).
74. `cargo clippy` im Terminal laufen lassen und schauen, ob es Tipps für deinen Code gibt.
75. Lerne das VS Code Icon in deiner Taskleiste oder auf dem Desktop anzupinnen, um es schnell griffbereit zu haben.

20 Große Projekte: Top-Down-Lernen in der IDE

Diese Projekte sind etwas umfangreicher und bringen dir bei, wie Profis ihre Werkstatt für große Aufgaben nutzen.

1. Das perfekte Profil: Richte dir ein VS Code "Profil" ("Profiles") nur für Rust ein, und installiere alle Erweiterungen nur dort. So bleibt VS Code clean, wenn du mal andere Dinge tust.
2. Git Integration meistern: Initialisiere ein Git-Repository aus VS Code heraus, mache deinen ersten Commit direkt über das Menü "Quellcodeverwaltung" an der Seite.
3. Unit-Tests in der IDE steuern: Schreibe Unit-Tests (`#[test]`). Lerne, wie man in VS Code mit einem Klick neben dem Test (im Rust-Analyzer Menü) einen bestimmten Test startet, ohne das Terminal zu öffnen.
4. Debugging-Meisterstück: Schreibe ein kleines Programm mit einer kniffligen Schleife. Setze Breakpoints, navigiere mit "Step Into" und beobachte, wie sich Variablen bei jedem Schleifendurchlauf verändern.
5. Workspace-Architektur: Baue einen Cargo-Workspace mit mehreren Modulen. Öffne den obersten Ordner in VS Code und sorge dafür, dass der rust-analyzer in allen Unterordnern richtig funciona.
6. Snippets für Profis: Erstelle eigene "Code Snippets" für VS Code. Speichere einen Code-Block, z.B. eine Spiel-Vorbereitung (Boilerplate). Immer wenn du "game" tippst, soll der Block automatisch generiert werden.
7. Remote Development im Container: (Für Fortgeschrittene) Installiere die "Dev Containers" Erweiterung. Starte dein Projekt im Container, sodass dein System perfekt sauber bleibt.
8. Clippy in Echtzeit zähmen: Konfiguriere rust-analyzer (in den Einstellungen), dass er automatisch `cargo clippy` beim Speichern laufen lässt. Repariere alle gelben Unterstreichungen im Editor.
9. Makro-Expansion verstehen: Schreibe ein längeres Makro (z.B. `vec![]`). Nutze in der Befehlspalette (`Strg`+`Shift`+`P`) das Kommando "rust-analyzer: Expand macro", um zu sehen, was Rust im Hintergrund daraus baut.
10. Die Cargo-Abhängigkeiten updaten: Installiere die VS Code Erweiterung "crates". Öffne deine `Cargo.toml` Datei und aktualisiere deine Pakete mit nur zwei Klicks, die die Erweiterung dir anbietet.
11. Formatierung purist: Erstelle im Root-Verzeichnis eine Datei namens `rustfmt.toml`. Schreibe Regeln wie `max_width = 80` hinein und beobachte das Verhalten von "Format On Save".
12. Tastatur Ninja: Setze dir zum Ziel, 30 Minuten lang in VS Code komplett ohne Maus zu programmieren. Nutze Kommandos, Suchen und Shortcuts.
13. Multi-Root Workspaces: Öffne zwei unterschiedliche, unabhängige Rust-Projekte parallel über "Add Folder to Workspace", und speichere dieses Set-Up als `.code-workspace` Datei.
14. Ein eigenes Task-Build-System: Öffne die Aufgaben-Konfiguration (`tasks.json`) in VS Code und baue einen Shortcut, um dein Projekt bauen, das Terminal leeren und es starten zu lassen.
15. Dokumentation lesen und anschauen: Generiere Dokumentation für dein Projekt (`cargo doc`) und installiere die "Live Server" Erweiterung in VS Code, um dir deine frisch erstellte HTML-Dokumentation direkt anzeigen zu lassen.
16. Refactoring wie ein Profi: Erstelle ein Projekt mit nur einer riesigen `main.rs`. Nutze das rust-analyzer Werkzeug "Extract Function" / "Extract into module" (bei der Glühbirne), um den Code blitzschnell auf Dateistrukturen zu verteilen.
17. Code Review – Pull Requests: Installiere die GitHub Pull Requests Erweiterung. Zieh dir ein Open Source Rust Projekt und lies dir die Code-Änderungen von anderen als "Diffs" (Unterschiede) in VS Code durch.
18. Live Share verwenden: Installiere "Live Share", starte eine Session und teile den Web-Link mit einem Freund (oder öffne ihn testweise in deinem Browser). Coded zusammen im selben Projekt.
19. Integrierte Todo-Listen: Installiere die Erweiterung "Todo Tree". Schreibe `// TODO: das muss ich noch machen` in deinen Code und lass sie dir alle übersichtlich in einem eigenen Panel des Explorers anzeigen.
20. Dein ultimatives Cheat-Sheet: Erstelle in VS Code eine Datei `cheatsheet.md` mit deinen wichtigsten Kürzeln, pinnen sie im Split-Screen rechts an, öffne die Markdown-Vorschau und lasse sie als Nachschlagewerk beim Programmieren links daneben offen.