Systemnahe Programmierung in Rust ================================= .. contents:: Inhalt Prof. Dr. Hubert Högl, Wintersemester 2024/2025 Einführung in die Programmiersprache Rust mit Anwendungen aus der Systemprogrammierung. Die Veranstaltung hat 5 SWS / 6 CP. Beginn ab Freitag den 4. Oktober 2024, W3.03, 8:15 Uhr. Moodle (bitte selber als TeilnehmerIn eintragen): https://moodle.hs-augsburg.de/course/view.php?id=8552 Foliensätze ``_ **News** .. Die **Prüfung ist am XXX um XXX**. Es ist eine Fernklausur über Moodle und Zoom. .. **Deadline für Abgaben und Miniprojekte: 12. Januar 2024, 18 Uhr**. Die Teams die noch kein Miniprojekt gemacht haben können also gerne noch über die Weihnachtsferien was machen. * Übungsaufgaben (es gibt jede Woche ein neues Übungsblatt, bis Weihnachten sind es 10 Stück) - https://gitlab.informatik.hs-augsburg.de/snp-rust/aufgaben * Quizzes - Fragen zu "The Book": ``_ - Fragen aus dem "Experimental Rust Book": ``_ * Beispielcode - https://gitlab.informatik.hs-augsburg.de/snp-rust/snpws * Im Wintersemester 2021/2022 hatte ich den ersten Rust Kurs: ``_, Evaluierung: `Auswertung `_. * Vergangene Projekte (VPN!): - WS21/22 ``_ - WS22/23 ``_ - WS23/24 ``_ Ablauf am Freitag ----------------- .. In diesem Semester möchte ich auf die "Frontalvorlesung" in den ersten beiden Blöcken verzichten und in etwa im Halbstunden-Takt mit wechselnden Gruppen mehr das Gespräch suchen. Die nächsten Lerninhalte und Aufgaben gebe ich immer eine Woche im Voraus bekannt. Die Anregungen, Tipps und Ideen die wir im Gespräch in den Gruppen finden möchte ich für alle wöchentlich zusammenfassen. Es wird in der Regel einen bis zwei Erzählblöcke geben, in denen ich auf "The Book" (siehe unten) eingehe und Rust an Hand von Code-Beispielen vorstelle. Es ist auch möglich, dass ich im zweiten Block über den aktuellen Stand der Übungsaufgaben spreche. Die restliche Zeit von 11:40 bis 15:30 Uhr ist als Zeit für den persönlichen fachlichen Austausch bei allen Belangen zur Vorlesung und zu den Übungen reserviert. Es gibt keine Anwesenheitspflicht und keine festen Zeiten für die Teams. Ich bin entweder im Vorlesungsraum anwesend oder über Zoom verfügbar. Sie können bei Bedarf gerne einzeln oder im Team vorbeischauen. Sie können sich gerne vorher anmelden, müssen das aber nicht. Die Veranstaltung hat 5 SWS und bringt 6 CP. Der Gesamtaufwand von 180 Std. teilt sich auf in 75 Std. Präsenzzeit und 105 Std. Selbststudium (inkl. Übungen und Vorbereitung auf die Prüfung). Übungen ------- Die wöchentlichen Übungsaufgaben bearbeiten sie in Gruppen (bzw. "Teams") zu Hause. Jede Gruppe hat ein Repository zur Abgabe im Gitlab: https://gitlab.informatik.hs-augsburg.de/snp-rust/ws24. Der Name ist einfach die Nummer des Teams (1, 2, 3, ...). Die Abgabe muss immer bis zum Donnerstag Abend 18 Uhr in der folgenden Woche sein. Moodle benötigen wir zur Abgabe der Aufgaben nicht. Die Gruppeneinteilung erfolgt in Kürze über Moodle. Sobald diese erledigt ist, trage ich eine Person aus jeder Gruppe als Maintainer in Gitlab ein, der dann die anderen Gruppenmitglieder eintragen kann. Allgemein gilt für die Übungen: Versuchen Sie die Aufgaben selbst zu lösen. Wenn Sie Codestücke im Internet finden und verwenden, dann **kennzeichnen Sie die Stellen in ihrem Programm** z.B. durch einen Kommentar mit dem Link, an dem Sie den Code gefunden haben. Auch wenn Sie mit ChatGPT Code erzeugt haben, müssen Sie das kennzeichnen. Es muss immer klar sein, welchen Code Sie geschrieben haben und welcher Code nicht von Ihnen stammt. Ausserdem müssen Sie den gefundenen Code **verstehen** und **erklären** können. Zusätzlich sollen zur Übung noch kleine Projekte gemacht werden. Diese fliessen als "Bonuspunkte" mit bis zu 25% in die Bewertung der Prüfung ein. Prüfung ------- Zum Semesterende wird es eine Prüfung geben, die Online über Moodle stattfinden wird. Wie schon gesagt, durch gute Lösungen bei den Übungen und durch kleine Projekte kann man bis zu 25% Bonuspunkte für die Klausur erzielen. Erstes Treffen -------------- Wir sind im Raum **W3.03**. - Wozu Rust? Siehe Foliensatz "Intro" ``_. Wer es noch genauer wissen will, der liest das freie Kapitel "Why Rust?" von Jim Blandy (60 Seiten): ``_. - Anregung: Verwenden Sie bekannte CLI Werkzeuge, die in Rust neu geschrieben wurden, zum Beispiel ``find`` und ``grep``. Die neu geschriebenen Tools heissen in dem Fall ``rg`` (ripgrep) und ``fd`` (fd-find). Ich führe seit ein paar Jahren eine Liste von in Rust geschriebenen Werkzeugen unter ``_. - Meine persönliche Arbeitsumgebung: Linux, Shell, `tmux `_ Terminal Multiplexer (Alternative *Zellij* in Rust https://github.com/zellij-org/zellij), Helix Editor (auch in Rust, https://helix-editor.com). Der Helix Editor und der Rust Language Server (``rust-analyzer``) ergeben bereits eine komfortable Rust Programmierumgebung. - Simples "Hello, World" in einer ``hello.rs`` Datei, die mit ``rustc hello.rs`` in eine ausführbare Datei ``hello`` übersetzt wurde. - Mit ``cargo new hello`` ein neues Projekt (crate) anlegen. Darin ``cargo build``, ``cargo run``, ... - Die erzeugten Programme sind klein, schnell und haben keine Abhängigkeiten. Sie enthalten alles, was zur Ausführung benötigt wird. Was ist zu tun bis nächste Woche? - Gruppenwahl in Moodle - Arbeitsumgebung einrichten (Linux, Windows-User nehmen WSL2) - Rust installieren: https://www.rust-lang.org/tools/install - Kapitel 1 bis 3 in `The Book `_ lesen - `Übungsblatt 1 `_ (bis Donnerstag in einer Woche, 18 Uhr) - Überlegen Sie sich mögliche Themen für Miniprojekte. Sie sollten mindestens in jedem Monat eines machen, also drei Stück (Oktober, November und Dezember). Das erste Thema für ein Miniprojekt haben Sie bereits nächste Woche parat. Installation ------------ * Anleitung zur Installation der Rust Werkzeuge: https://www.rust-lang.org/tools/install - Linux: einfach - Windows: Ich rate zu WSL2, also im Endeffekt auch hier Linux Man kann bequem auf der Kommandozeile arbeiten, ein simpler Editor genügt. Ein Shell-zentriertes Arbeiten ist zu bevorzugen, da man damit auch besser lernt, mit Kommandozeilenwerkzeugen umzugehen. * Integrierte Entwicklungsumgebung (IDE): brauchen wir eigentlich nicht, da das Wichtigste beim Programmieren in Rust die Ausgaben (Fehlermeldungen, Warnungen, Tipps) des Rust Compilers sind. Diese kann man sehr gut auf der Kommandozeile lesen. Ich habe auch schon davon gehört, dass IDEs diese Fehlermeldungen nicht mehr so schön zugänglich machen, was natürlich kontraproduktiv wäre. Sie können aber natürlich trotzdem eine der üblichen IDEs wie VSCode verwenden. * Test der Installation mit einem Beispielprogramm. Modul ``main.rs`` anlegen: .. code-block:: rust fn main() { println!("Hallo, Welt"); } Kompilieren mit ``rustc main.rs``. Ausführen mit ``./main``. Formatieren mit ``rustfmt main.rs``. Literaturangaben ---------------- (Tipp: Um die Bücher auf "learning.oreilly.com" lesen zu können, muss man sich zunächst auf https://go.oreilly.com/fachhochschule-augsburg einloggen.) Für Anfänger geeignet 1. Steve Klabnick, Carol Nichols, **The Rust Book**, 2018 (auch kurz "The Book" genannt). **Dieses freie Buch werden wir als verbindlichen Text in der Veranstaltung verwenden. Man kann das Buch auch sehr gut auf dem Smartphone lesen.** https://doc.rust-lang.org/book/ Es gibt auch eine deutsche Übersetzung unter https://rust-lang-de.github.io/rustbook-de. Davon gibt es auch eine Variante die sich **Experimental Rust Book** nennt. Dieses Buch geht bei manchen Themen viel weiter in die Tiefe als es das originale Rust Book tut. Zum Beispiel in Kapitel 4 (Ownership), ausserdem gibt es interaktive Quizze: https://rust-book.cs.brown.edu #. Carlo Milanesi, **Beginning Rust: Get Started with Rust 2021 Edition**, Apress 2021. Dieses Buch kann man entweder unter folgendem Link online lesen https://learning.oreilly.com/library/view/beginning-rust-get/9781484272084/ oder im PDF/EPUB Format vom Springer Link herunterladen: https://link-springer-com.ezproxy.hs-augsburg.de/book/10.1007/978-1-4842-7208-4 #. Dumindu Madunuwan, **Learning Rust**, 2021 (freier Text) https://learning-rust.github.io #. David MacLeod, **Easy Rust** (freier Text), https://dhghomon.github.io/easy_rust/ Aus dem freien Buch ist nun ein Buch vom gleichen Autor entstanden, `Learn Rust in a Month of Lunches `_ im Manning Verlag. #. Malte Luttermann, **Programmierung sicherer Systeme mit Rust**, Amazon Media, 2020 (Taschenbuch, 253 Seiten, 13,95 Euro). Das Buch ist eine sehr leicht verständliche Einführung in Rust, enthält aber deutlich weniger Stoff als das freie *The Rust Book*. Es reicht daher nicht für unsere Veranstaltung. https://www.amazon.de/Programmierung-sicherer-Systeme-mit-Rust/dp/B086PQXH3N Für Fortgeschrittene 1. Jim Blandy, Jason Orendorff, Leonora F.S. Tindall, **Programming Rust**, 2nd Edition, 2021 (655 pages). Sehr gründliche Einführung in Rust, die aber den Anfänger überfordert. Das Buch wendet sich auch an Leute, die bereits mit Systemprogrammierung zu tun hatten. https://learning.oreilly.com/library/view/programming-rust-2nd/9781492052586 .. 3. Marco Amann, Joachim Baumann, Marcel Koch, **Rust. Konzepte und Praxis für die sichere Anwendungsentwicklung**, dpunkt Verlag 2022. https://learning.oreilly.com/library/view/rust/9781098141226/?ar= Systemprogrammierung 1. Jim Blandy, Jason Orendorff, Leonora F.S. Tindall, **Programming Rust** (siehe oben). 2. Ken Youens-Clark, **Command-line Rust**, Apress 2022 https://learning.oreilly.com/library/view/command-line-rust/9781098109424 Code: https://github.com/kyclark/command-line-rust 3. Prabhu Eshwarla, **Practical System Programming for Rust Developers**, Packt, Dec 2020. https://learning.oreilly.com/library/view/practical-system-programming/9781800560963/ 3. Tim McNamara, **Rust in Action**, Manning Publications, 2021. https://learning.oreilly.com/library/view/rust-in-action/9781617294556/ Embedded Programmierung (Hallo TI-Studis!) 1. The Embedded Rust Book https://docs.rust-embedded.org/book/ Die Beispiele im Buch laufen auf dem *STM32F3 Discovery* Board. Ich habe mehrere solche Boards im Rechnertechnik-Labor G2.16. 2. Discovery Book (mit praktischen Übungen auf Mikrocontrollern) Es gibt zwei Varianten dieses Buches, die man unter https://docs.rust-embedded.org/discovery/index.html findet. Die ältere Variante ist für das F3 Discovery Board von ST Micro, die jüngere Variante ist für das BBC `micro:bit `_ Board V1 oder V2. Sammlungen von Projekten (mal hinein schauen für Miniprojekt-Anregungen) 1. Carlo Milanesi, **Creative Projects for Rust Programmers**, Packt 2020. https://learning.oreilly.com/library/view/creative-projects-for/9781789346220/ 2. Shing Lyu, **Practical Rust Projects: Building Game, Physical Computing, and Machine Learning Applications**, Apress 2020. Das Buch kann im PDF Format beim Springer Link (https://link-springer-com.ezproxy.hs-augsburg.de) heruntergeladen werden. https://learning.oreilly.com/library/view/practical-rust-projects/9781484255995/ Z.B. Kapitel 5, *Physical Computing in Rust*, ein simples Experiment für Raspberry Pi 3 mit LED und Taster auf einem Steckbrett. 3. Shing Lyu, Practical Rust Web Projects: Building Cloud and Web-Based Applications, Apress 2021. https://learning.oreilly.com/library/view/practical-rust-web/9781484265895/ 4. Ken Youens-Clark, Command-Line Rust, O'Reilly 2022. https://learning.oreilly.com/library/view/command-line-rust/9781098109424/ 5. Rust Language exercises on **Exercism** https://exercism.org/tracks/rust/exercises Sonstige Hilfen 1. **Rust by Example**, https://doc.rust-lang.org/rust-by-example 2. **Rust Cookbook**, https://rust-lang-nursery.github.io/rust-cookbook 3. **Rustlings**, https://github.com/rust-lang/rustlings 4. **Rust by Practice**, https://practice.course.rs Status der Abgaben ------------------ Siehe https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/Uebersicht.txt Material vom Tutor ------------------ (stammt noch vom WS23/24) Hr. Knoll schreibt gerade und in nächster Zeit noch ein paar Zusammenfassungen, im Folgenden habe ich einige Links darauf (*work in progress*), gerne mal ein wenig stöbern: * Webseiten, Videos, Blogs https://tha.de/homes/knolljo/sysprog-tut/index.html * https://tha.de/homes/knolljo/sysprog-tut/1_Systems.html (Schwachstellen von `C/C++ `_) * Infos zu CLI-Programmen https://tha.de/homes/knolljo/sysprog-tut/Appendix/CLI.html CLAP https://tha.de/homes/knolljo/sysprog-tut/Appendix/Clap.html * Cheatsheet https://tha.de/homes/knolljo/sysprog-tut/Cheatsheet.html Er hat auch ein paar Templates geschrieben, mit denen man Projekte mit ``cargo generate`` initialisieren kann. Dazu installiert man zunächst ``cargo-generate`` mit ``cargo install cargo-generate``. Danach kann man neue Projekte über ein Template anlegen, z.B. so: .. code-block:: cargo generate --git ssh://git@gitlab.informatik.hs-augsburg.de:2222/snp-rust/simple-cli-template.git Das Kommando fragt ein paar Sachen interaktiv ab und legt dann das Projekt an. Bitte selber ausprobieren! Hier sind alle aktuellen Templates: * https://gitlab.informatik.hs-augsburg.de/snp-rust/simple-cli-template * https://gitlab.informatik.hs-augsburg.de/snp-rust/subcommand-cli-template Projektideen ------------ Wie gesagt, nur Ideen, Sie können auch ihre eigenen Ideen in die Praxis umsetzen. * Einige der Bücher in den Literaturangaben enthalten viele Projektideen. * Ein Python Erweiterungsmodul in Rust schreiben ``_ * Artikelserie "Snapshot" von Mike Schilli, in der er jeden Monat im `Linux Magazin `_ ein kleines Programm in der Sprache Go entwickelt. Die Projektidee ist, seine kleinen Programme nach Rust zu übertragen. Hier ist eine kleine Auswahl seiner Artikel: - Dateiverschlüsselung ``_ - Körpergewicht überwachen ``_ - Kurvenfahrt ``_ - Fotos ins Netz stellen ``_ * Aus der Serie "Planet Rust" im `Linux Magazin `_ Teil 9: Einen Chatbot in Rust bauen (verwendet ChatGPT), ``_ * Die C Programme aus der Betriebssystemvorlesung vom Sommer 24 nach Rust übertragen (siehe weiter unten). * WASM mit Rust ``_ * Joseph F. Nusairat, Rust for the IoT. Building Internet of Things Apps with Rust and Raspberry Pi, z.B. Kapitel 9, *Raspberry Pi Sense Hat*. https://learning.oreilly.com/library/view/rust-for-the/9781484258606/ .. File-IO ``_ .. Auch interessant: Go Buecher zu Systemnaher Programmierung Beispiel: Alex Guerrieri, Hands-On System Programming with Go, Packt 2019 (mit Aufgaben im Anhang). https://learning.oreilly.com/library/view/hands-on-system-programming/9781789804072/ Notizen ------- 10. Oktober 2024 * CSV Datei auswerten https://gitlab.informatik.hs-augsburg.de/snp-rust/bsp-mix/-/tree/main/zeit_feedback * Kommandozeilenoptionen mit Seahorse https://gitlab.informatik.hs-augsburg.de/snp-rust/bsp-mix/-/tree/main/seahorse-cli * Programme prüfen mit ``cargo clippy`` * Programme formatieren mit ``cargo fmt`` * Abhängigkeiten baumförmig ausgeben: ``cargo tree`` 15. Oktober 2024 * Essentielle Linux Kommandos anwenden können (zur Erinnerung: Sie sollten sich an das Arbeiten in der Shell gewöhnen): ``ls``, ``cd``, ``cp``, ``mv``, ``mkdir``, ``rmdir``, ``rm``, ``touch``, ``less``, ``hx``, ... Ein paar Beispiele: - ``ls`` - Inhalt des aktuellen Verzeichnisses anschauen - ``ls -a`` - Wie ``ls``, jedoch auch versteckte Dateien oder Verzeichnisse anzeigen. Diese beginnen mit einem Punkt, z.B. ``.bashrc``, ``.git``, ``.config`` und so weiter. - ``mkdir ordner`` - Lege Verzeichnis ``ordner`` an - ``cd ordner`` - Gehe in das Verzeichnis ``ordner`` - ``cd ..`` - Gehe aus dem Verzeichnis ``ordner`` heraus - ``rmdir ordner`` - Lösche das Verzeichnis ``ordner`` - ``cd ~`` - Gehe in das Home-Verzeichnis - ``touch datei`` - Lege eine neue leere Datei ``datei`` an - ``rm datei`` - Lösche Datei. Vorsicht, die ist danach wirklich weg, nicht erst im Papierkorb! - ``mkdir ordner`` - ``ls > ordner/liste.txt`` - Umlenkung der Ausgabe von ``ls`` in Datei - ``less ordner/liste.txt`` - Betrachten der Datei im Pager ``less`` - ``rm -rf ordner`` - Löscht das Verzeichnis ``ordner``. Alles was drin war ist weg! - ``hx text.md`` - Eine Textdatei (Markdown) in Helix öffnen Alle Namen von Dateien und Ordnern können in der Shell mit der TAB-Taste vervollständigt werden. Mit ``Strg-R`` können Sie in früher eingegebenen Kommandos ("History") suchen. Als Editor in der Shell empfehle ich Helix (``hx``), er ist ähnlich wie Vim zu bedienen, jedoch deutlich "aufgeräumter", moderner und unterstützt direkt Sprachserver wie den ``rust-analyzer``. Ich empfehle ``hx --tutor`` durchzuarbeiten. Siehe https://helix-editor.com. Wer mit Vim/Helix nichts anfangen kann und einen sehr einfach zu bedienenden aber trotzdem mächtigen Editor für die Shell sucht dem empfehle ich *Micro*, siehe https://micro-editor.github.io. Wer auch Micro nicht mag muss mit ``nano`` auskommen. Der sollte unter jedem Linux sofort auf der Shell verfügbar sein. Beliebte Rust Tools, natürlich auf der Kommandozeile: ``fd`` ("fd find") - https://github.com/sharkdp/fd Aufrufbeispiele: - ``fd main`` - Finde alle Dateien im aktuellen Verzeichnis und darunter die ``main`` im Dateinamen enthalten. - ``fd -e rs`` - Gib alle Dateien aus die mit ``.rs`` enden - ``fd --help`` -- Gibt Hilfe zum Programm aus ``rg`` ("ripgrep") - https://github.com/BurntSushi/ripgrep Aufrufbeispiele: - ``rg fn`` - Sucht in allen Dateien (rekursiv) nach dem String ``fn``. Gibt jeweils Zeilennummer und die Zeile aus - ``rg -i swap`` - Sucht in allen Dateien nach dem String ``swap``, egal ob Gross- oder Kleinbuchstaben. - ``rg --help`` - Gibt Hilfe zum Programm aus Ich führe eine Liste unter https://tha.de/~hhoegl/home/RustTools.html. Gerne dort mal ein wenig umsehen. Als Literatur zum Einstieg in das Arbeiten unter Linux in der Shell empfehle ich das freie "Linux Essentials" Buch unter https://www.tuxcademy.org/product/lxes/. * Helix Editor (https://helix-editor.com) - Doku: https://docs.helix-editor.com - Installation: Von https://github.com/helix-editor/helix/releases entweder das tar Archiv (helix-24.07-x86_64-linux.tar.xz) oder das AppImage (helix-24.07-x86_64.AppImage) holen. Nach dem Entpacken des tar Archivs (Tipp: ``tar Jxvf ...``) hat man die ausführbare Datei ``hx`` und den Ordner ``runtime``. Den Ordner muss man in ``~/.config/helix/`` verschieben. - Konfigurationdateien holen von https://gitlab.informatik.hs-augsburg.de/config/helix und in ``~/.config/helix/`` schieben. Da sind aktuell meine Einstellungen drin, sie dürfen diese gerne nach ihren Vorstellungen ändern. - Im WSL2-Linux war noch folgende Umgebungsvariable nötig: ``export COLORTERM=truecolor``. Diese am besten dauerhaft in ``~/.bashrc`` setzen. - Abschliessend prüfen: ``hx --health``. Damit sieht man z.B. welche "Language Server" installiert sind. Für Rust den ``rust-analyer`` holen von https://github.com/rust-lang/rust-analyzer/releases und installieren. Helix nutzt ihn sofort beim Editieren von Quelltext in einem Crate. - Tutor öffnen: ``hx --tutor`` * Im Betriebssystemkurs vom Sommer 2024 gab es viele kleine C Programme. Es wäre eine schöne Übung (auch gerne als Miniprojekt), manche davon nach Rust zu übertragen. Folgende Datei enthält alle Dateinamen (VPN nötig): https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/Betriebssysteme-SS2024-C-Beispiele.txt Im Archiv https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/Betriebssyteme.tar.gz finden Sie alle diese Programme. Empfehlung für den Anfang: - ``Praktikum0_Code-Beispiele/_5_ptr_ptr.c`` - ``Praktikum0_Code-Beispiele/_6_ptr_func0.c`` - ``Praktikum0_Code-Beispiele/_7_ptr_func.c`` - ``Praktikum0_Code-Beispiele/_8_main_params.c`` * Unter https://tha.de/homes/knolljo/sysprog-tut/1_C.html finden Sie eine Zusammenstellung von typischen Fehlerursachen der Sprache C. Der Text stammt von meinem Tutor vom WS23/24. * Meine Liste der besten Tutorials/Beispielsammlungen für Rust: - https://google.github.io/comprehensive-rust/index.html - https://practice.course.rs - https://doc.rust-lang.org/rust-by-example/ - https://github.com/rust-lang/rustlings - https://exercism.org/tracks/rust/exercises * Projekt-Template mit ``cargo generate`` Mein Tutor vom letzten Jahr hat zwei Projekt-Templates angelegt, die sie unter den folgenden Links finden: - https://gitlab.informatik.hs-augsburg.de/snp-rust/simple-cli-template - https://gitlab.informatik.hs-augsburg.de/snp-rust/subcommand-cli-template Die Idee hinter den Templates ist, dass man sofort daraus ein initiales Projekt erzeugen kann. Zunächst muss man cargo um das Kommando ``generate`` erweitern mit ``cargo install cargo-generate``. Dann gibt man z.B. folgende Kommandozeile ein: .. code-block:: bash $ cargo generate ssh://git@gitlab.informatik.hs-augsburg.de:2222/snp-rust/simple-cli-template.git ⚠️ Favorite `ssh://git@gitlab.informatik.hs-augsburg.de:2222/snp-rust/simple-cli-template.git` not found in config, using it as a git repository: ssh://git@gitlab.informatik.hs-augsburg.de:2222/snp-rust/simple-cli-template.git 🤷 Project Name: supacool 🔧 Destination: /home/hhoegl/SNP/supacool ... 🔧 project-name: supacool ... 🔧 Generating template ... 🔧 Moving generated files into: `/home/hhoegl/SNP/supacool`... 🔧 Initializing a fresh Git repository ✨ Done! New project created /home/hhoegl/SNP/supacool Damit wurde das Projekt ``supacool`` angelegt. Natürlich nun hineinschauen, um zu sehen was es macht. Das gleiche auch mit dem zweiten Template ausprobieren! Sie können sich gerne selber Templates für Ihre Projekte anlegen.