# Systemnahe Programmierung in Rust

```{contents} Inhalt
:depth: 2
```

<p>

<img src="_static/img/ferris.png" alt="ferris" width="30px">

<p>

Prof. Dr. Hubert Högl, <Hubert.Hoegl@tha.de>

Wintersemester 2025/2026

Einführung in die Programmiersprache Rust mit Anwendungen aus der
Systemprogrammierung. 

Nach der neuen SPO ist diese Veranstaltung kein Pflichtfach mehr, sondern
ein FWP-Fach. Auch Studierende der Technischen Informatik können das Fach als
Wahlfach belegen.

Beginn ab Freitag den **10. Oktober 2025, W3.03**, 8:15 Uhr. 

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).

<p>

Moodle (bitte selber als TeilnehmerIn eintragen): <https://moodle.hs-augsburg.de/course/view.php?id=9801>

Website vom Tutor Johannes Knoll <https://tha.de/homes/knolljo/rust> (cool!)

Übungsaufgaben (es gibt jede Woche ein neues Übungsblatt, bis Weihnachten 
sind es 10 Stück) <https://gitlab.com/hhoegl-tha/snp-rs/aufgaben>
Wer welche Blätter/Aufgaben abgegeben hat sieht man in [dieser
Datei](https://gitlab.com/hhoegl-tha/snp-rs/sysprog-tut/-/tree/main/assignments/report?ref_type=heads){.external}. Diese wird von einem Programm erstellt,
halten sie sich also an die vorgegebenen Namen für die Blätter und Aufgaben.


Quizzes 
- [Fragen zu "The Book"](local:sysprog/Quiz/index.html)
- [Fragen aus dem "Experimental Rust Book"](local:sysprog/ERB-Quiz/index.html)
- Auch unter dem Link vom Tutor finden Sie den interaktiven Quiz aus dem
  Experimental Rust Book.


[Folien](local:sysprog/Folien) 


Beispielcode

* <https://gitlab.com/hhoegl-tha/snp-rs/snpws>
* <https://hhoegl.informatik.hs-augsburg.de/rust>


Im Wintersemester 2021/2022 hatte ich den ersten Rust Kurs, siehe
die Seite [SysProgRust21](SysProgRust21). Es gab damals auch eine 
[Evaluierung](local:Evaluierung/sysprog-ws2122/Auswertung.pdf).

Vergangene Projekte:
- WS21/22 <https://gitlab.com/hhoegl-tha/snp-rs/projekte-2021>
- WS22/23 <https://gitlab.com/hhoegl-tha/snp-rs/projekte-2022>
- WS23/24 <https://gitlab.com/hhoegl-tha/snp-rs/projekte-2023>
- WS24/25 <https://gitlab.com/hhoegl-tha/snp-rs/projekte-2024>


Vergangenes WS24/25: [SysProgRust2425](local:SysProgRust2425)


<!--
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.
-->


<!--
## Ablauf am Freitag
       
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.

-->

## Übungen

In diesem Semester möchte ich die Übungen anders organisieren als in den
letzten Semestern. Da ich oft schlechte Erfahrungen mit der Organisation
der Übungen in Gruppen gemacht habe sollen alle die wöchentlichen Übungsblätter
einzeln bearbeiten. 

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.

## Projekte

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. Bei den
Projekten ist die Idee, dass sie sich selbst in Gruppen organisieren oder
einzeln arbeiten, wie sie möchten.  


## Prüfung

Zum Semesterende wird es eine Prüfung geben, die vermutlich Online über Moodle
stattfinden wird. Wie schon gesagt, durch gute Lösungen bei den Übungen und
durch ein paar kleine Projekte kann man bis zu 25% Bonuspunkte für die Klausur
erzielen.


## Meine Arbeitsumgebung

Ich verwende zum Vorführen in der Veranstaltung (und auch sonst)

* Mint Linux (<https://linuxmint.com>), das direkt auf dem Notebook
  installiert ist.

* Eine Terminal-Fenster in dem der Zellij Terminal Multiplexer läuft
  (<https://zellij.dev>). Das Hauptfenster ist in zwei "Panes" geteilt. In
  der Linken läuft der Helix Editor (<https://helix-editor.com>), in der
  Rechten ist die Bash Shell zum Aufrufen von `cargo`.  Dieses Setup ist
  sehr übersichtlich und eignet sich dadurch auch gut um auf älteren
  Beamern im Hörsaal projeziert zu werden. 

  ![Sysprog Tools](_static/sysprog-ide.png)


* Ansonsten verwende ich noch viele weitere Rust Tools (die vorher Genannten
  sind auch in Rust geschrieben), die wichtigsten für die tägliche Arbeit
  sind

  - fd (Dateien finden) - <https://github.com/sharkdp/fd>
  - rg (Text in Dateien finden) - <https://github.com/BurntSushi/ripgrep>

  Eine Liste mit vielen weiteren Rust-Tools finden Sie unter
  <https://tha.de/homes/hhoegl/home/RustTools.html>.
  

<!--
## Erstes Treffen

- Wozu Rust? Siehe Foliensatz [Intro](local:sysprog/Folien/intro.pdf).
  Wer es noch genauer wissen will, der liest das freie Kapitel "Why Rust?" von
  Jim Blandy (60 Seiten): [sysprog/why-rust.pdf](local:sysprog/why-rust.pdf).

- 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
  [RustTools](RustTools).

- Meine persönliche Arbeitsumgebung: Linux, Shell,
  `tmux` Terminal Multiplexer <https://github.com/tmux/tmux/wiki>,
  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.
-->


## 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:

  ```rust
  fn main() {
     println!("Hallo, Welt");
  }
  ```
   
  Kompilieren mit `rustc main.rs`. Ausführen mit `./main`. Formatieren mit
  `rustfmt main.rs`.


## Wochenplan

<!--
Folgende Kapitel sind noch offen:

-  7 - Packages, Crates, Modules
- 14 - Cargo and crates.io
- 16 - Fearless Concurrency
- 17 - Async Programming
- 18 - OO
- 19 - Patterns and Matching
- 20 - Advanced Features
- 21 - Final Projekt
-->


**#1 10.10.25**
: Bis nächste Woche
  - Arbeitsumgebung einrichten (Linux, WSL2)
  - Rust installieren: <https://www.rust-lang.org/tools/install>
  - [The Book](rust-book:), Kap. 1 (Getting Started), 2 (Guessing Game),
    3 (Common Concepts) 
  - [Übungsblatt 1](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} (bis Donnerstag in einer Woche, 12 Uhr)
  - [Intro Folien](local:sysprog/Folien/intro.pdf)
  - Ideen für Miniprojekte sammeln

**#2 17.10.25**
: Bis nächste Woche
  - [Übungsblatt 2](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 

**#3 24.10.25**
: Bis nächste Woche
  - [The Book](rust-book:), Kap. 4 (Ownership), 5 (Structs) 
  - [Übungsblatt 3](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 

**#4 31.10.25**
: Bis nächste Woche
  - [The Book](rust-book:), Kap. 6 (Enums and Pattern Matching), 8 (Common Collections) 
  - [Übungsblatt 4](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#5 07.11.25**
: Bis nächste Woche
  - [The Book](rust-book:), Kap. 9 (Error Handling) 
  - [Übungsblatt 5](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#6 14.11.25**

Code "Traits" in Python und Rust von J. Knoll <https://hhoegl.informatik.hs-augsburg.de/rust/traits>

Bis nächste Woche
  - [The Book](rust-book:), Kap. 12 (I/O Project) 
  - [Übungsblatt 6](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#7 21.11.25**
: Bis nächste Woche
  - [The Book](rust-book:), Kap. 13 (Iterators and Closures)
  - [Übungsblatt 7](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#8 28.11.25**

Code "Iterator Challenge" von J. Knoll: <https://gitlab.com/hhoegl-tha/snp-rs/iterator-rust-challange>

LM-05-2024-Planet-Rust-8-Iteratoren.pdf, siehe
<https://tha.de/homes/hhoegl/home/sysprog/doc/> (THA Login)


Bis nächste Woche
  - [The Book](rust-book:), Kap. 15 (Smart Pointers)
  - [Übungsblatt 8](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#9 05.12.25**
: Bis nächste Woche
  - [The Book](rust-book:), Kap. 16 (Concurrency)
  - [Übungsblatt 9](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 


**#10 12.12.25** (Concurrency)

[Folien](local:sysprog/Folien) zu Kap. 16

Programmsammlung
<https://hhoegl.informatik.hs-augsburg.de/rust/Concurrent-Progs>

Lesestoff: [The Book](rust-book:), Kap. 18 (OO), Kap. 20.5 (Macros),
Kap. 21 (MT-Webserver)

Das [Übungsblatt 10](https://gitlab.com/hhoegl-tha/snp-rs/aufgaben){.external} 
bis 7. Januar 2026 bearbeiten. 


**#11 19.12.25**
: todo

<!--

 Kap. 10 (Generic Types, Traits, Lifetimes),
 Kap. 11 (Automated Tests)

-->




## Literaturangaben

Die Links auf `learning.oreilly...` funktionieren nicht mehr, da die
Hochschule den Dienst Ende 2024 nicht mehr verlängert hat.

Einige der Bücher finden Sie auf unserer Nextcloud. Der Link steht
im Moodle Kurs. 

Für Anfänger geeignet

1. Steve Klabnick, Carol Nichols, **The Rust Book**, 2022 (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>

2. 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>
   
3. Dumindu Madunuwan, **Learning Rust**, 2021 (freier Text)
   <https://learning-rust.github.io>

4. 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](https://www.manning.com/books/learn-rust-in-a-month-of-lunches)
   im Manning Verlag.
  
5. 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>

6. David Drysdale, **Effective Rust**, April 2024.

   <https://effective-rust.com/title-page.html>


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>

4. 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](https://microbit.org){.external}
   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 (download von Springer möglich).

   <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>




## 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
  (ix.11.2022-Python-Module-mit-Rust.pdf)

  <https://tha.de/homes/hhoegl/home/sysprog/doc> (nur mit THA Login)

* Artikelserie "Snapshot" von Mike Schilli, in der er jeden Monat im [Linux
  Magazin](https://www.linux-magazin.de){.external} 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:

  <https://tha.de/homes/hhoegl/home/sysprog/doc> 

  - Dateiverschlüsselung (schilli-12-22-age.pdf)

  - Körpergewicht überwachen (schilli-11-23-waage.pdf)
  
  - Kurvenfahrt (schilli-7-23-kurve.pdf)

  - Fotos ins Netz stellen (schilli-11-24-fotos.pdf)

* Aus der Serie "Planet Rust" im
  [Linux Magazin](https://www.linux-magazin.de){.external}

  Teil 9: Einen Chatbot in Rust bauen (verwendet ChatGPT)

  [LM-09-2024-Planet-Rust-9-Chatbot.pdf](https://tha.de/homes/hhoegl/home/sysprog/doc){.external}


* Die C Programme aus der Betriebssystemvorlesung vom Sommer 24 nach Rust übertragen (siehe weiter unten).

  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/rust/Betriebssysteme-SS2024-C-Beispiele.txt>
  
  Im Archiv
  <https://hhoegl.informatik.hs-augsburg.de/rust/Betriebssysteme.zip>
  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`


* WASM mit Rust (ix.2024.09.102_107.Web-Apps-mit-Rust-und-Webassembly.pdf)

  <https://tha.de/homes/hhoegl/home/sysprog/doc> 

* 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
`<sysprog/rust-lj-10-2018.pdf>`_
-->

<!-- 
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/
-->


## Tutorials im Netz

Meine Liste der besten Tutorials/Beispielsammlungen für Rust:

1. *Rust by Example*, <https://doc.rust-lang.org/rust-by-example>

2. *Rust Cookbook* (stellt Crates vor), <https://rust-lang-nursery.github.io/rust-cookbook>

3. *Rustlings*, <https://github.com/rust-lang/rustlings>

4. *Rust by Practice*, <https://practice.course.rs>

5. *100 Exercises to learn Rust*
   (von [Mainmatter](https://mainmatter.com){.external}, Luca Palmieri)

   - <https://rust-exercises.com>
   - <https://rust-exercises.com/100-exercises> 

6. *Exercism*, <https://exercism.org/tracks/rust/exercises>

7. *Comprehensive Rust* <https://google.github.io/comprehensive-rust/index.html>


## Notizen


* Projekt-Template mit `cargo generate` 

  Mein Tutor J. Knoll vom WS23/24 hat zwei Projekt-Templates angelegt, die sie
  unter den folgenden  Links finden:

  * <https://gitlab.com/hhoegl-tha/snp-rs/simple-cli-template>
  * <https://gitlab.com/hhoegl-tha/snp-rs/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:

  ```
  $ cargo generate --git https://gitlab.com/hhoegl-tha/snp-rs/simple-cli-template.git
  🤷   Project Name: neues_projekt
  🔧   Destination: /home/hhoegl/neues_projekt ...
  🔧   project-name: neues_projekt ...
  🔧   Generating template ...
       [1/7]   Done: Cargo.toml
       [2/7]   Done: LICENSE
       [3/7]   Done: README.md
       [4/7]   Done: src/cli.rs
       [5/7]   Done: src/lib.rs
       [6/7]   Done: src/main.rs
       [7/7]   Done: src
  🔧   Moving generated files into: `/home/hhoegl/neues_projekt`...
  🔧   Initializing a fresh Git repository
  ✨   Done! New project created /home/hhoegl/neues_projekt
  ```    

  Damit wurde das Projekt ``neues_projekt`` 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.