Systemnahe Programmierung in Rust

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.

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/ws23. 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. Durch gute Lösungen bei den Übungen und durch kleine Projekte kann man bis zu 25% Bonuspunkte für die Klausur erzielen.

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.

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

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

  Kompilieren mit rustc main.rs. Ausführen mit ./main. Formatieren mit rustfmt main.rs.

Erstes Treffen

6.10.23

Erstes Treffen im M3.03.

Was wir gemacht haben:

• Wozu Rust? Siehe Foliensatz "Intro" https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/Folien/intro.pdf

  Wer es noch genauer wissen will, der liest das freie Kapitel "Why Rust?" von Jim Blandy (60 Seiten): https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/why-rust.pdf

• Anregung: Verwenden Sie Werkzeuge, die in Rust neu geschrieben wurden: https://hhoegl.informatik.hs-augsburg.de/hhwiki/RustTools

  Zumindest sollte man rg (ripgrep) und fd (find) ausprobieren.

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

• Simple "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?

• Gruppenwahl in Moodle
• Arbeitsumgebung einrichten (Linux, WSL2)
• Rust installieren: https://www.rust-lang.org/tools/install
• Sich mit Linux anfreunden
• Kapitel 1 bis 3 in "The Book" lesen
• Übungsblatt 1 (bis Do 12.10, 18 Uhr)
• Überlegen Sie sich mögliche Themen für Miniprojekte. Sie sollten zwei bis drei dieser Programme im Oktober, November und Dezember machen.

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.

   Hier ist noch eine interaktive Version (ein "Experiment" der Brown University): 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 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

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

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/

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

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/

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

Anregungen für kleine Projekte

• Shing Lyu, Practical Rust Projects: Building Game, Physical Computing, and Machine Learning Applications, Apress 2020. Z.B. Kapitel 5, Physical Computing in Rust, ein simples Experiment für Raspberry Pi 3 mit LED und Taster auf einem Steckbrett.

  https://learning.oreilly.com/library/view/practical-rust-projects/9781484255995/

• Shing Lyu, Practical Rust Web Projects: Building Cloud and Web-Based Applications, Apress 2021.

  https://learning.oreilly.com/library/view/practical-rust-web/9781484265895/

• Carlo Milanesi, Creative Projects for Rust Programmers, Packt Publishing 2020.

  https://learning.oreilly.com/library/view/creative-projects-for/9781789346220/

• Ken Youens-Clark, Command-Line Rust, O'Reilly 2022.

  https://learning.oreilly.com/library/view/command-line-rust/9781098109424/

• Python Module in Rust erstellen

  https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/ix.11.2022-Python-Module-mit-Rust.pdf

• Dateiverschlüsselung, von Go nach Rust übertragen

  https://hhoegl.informatik.hs-augsburg.de/sysprog/Rust/LM-12-2022-Age.pdf

• 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://link-springer-com.ezproxy.hs-augsburg.de/book/10.1007/978-1-4842-5860-6

Status der Abgaben

Stand: 10. Dezember 2023

Deadline: 12. Januar 2024

T1

• Viele Abgaben fehlen
• Keine Miniprojekte

T2

• Miniprojekte
  • SIBAUTTA - "Should I bring an umbrella to the airport" (TJ)
  • ESP32 Rust Devkit 1 & WS2812 LED, Neopixel Driver (TJ)
  • Task-Management OpenAPI-Webapp mit axum, utoipa, diesel (SJ)

T3

• Einige Abgaben fehlen
• Keine Miniprojekte

T4

• Miniprojekte
  • rusty-journal MS-Demo (JK)
  • subnetkalker (JK)
  • py_montecarlo (JK), Python Erweiterungsmodul in Rust mit https://pyo3.rs

T5

• Miniprojekte
  • Platformer2D (MH)

T6

• Miniprojekte
  • Nonogramm (RS)
  • quiz_cli (RS)
  • Monte Carlo Pi (FR)

T7

• Einige Abgaben fehlen
• Keine Miniprojekte

T8

• Miniprojekte
  • Webserver aus Kap. 20 (TM)
  • Cowsay (TM)
  • Kernel OS (MS)
  • Backup Util (DK, AW)
  • Temperature Converter (TM, AW)

T9

• Projekte
  • Late Runner Game (JK)
  • Password Manager (NH)

T10

• Viele Abgaben fehlen
• Projekte
  • Diverse Embedded Rust Projekte für STM32F3 Discovery.

T11

• Projekte
  • Unit Converter (TM)
  • Minesweeper (TG, TM)

T12

• Einige Abgaben fehlen
• Projekte
  • Flocking (TK)

T13

• Einige Abgaben fehlen
• Projekte
  • Diary (LK)

T14

• Projekte
  • Vier gewinnt
  • Hangman
  • Game of Life

T15

• Projekte
  • Cipher Cracker (AT)
  • Tic Tac Toe (SR)
  • Tic Tac Toe mit Slint (SI)

T16

• Projekte
  • Oxo (PD)
  • Snake (PD)
  • Todo (PD, LR)

T17

• Projekte
  • LED compass with STM32 F3 Discovery Board
  • esp-adc (?)

Material vom Tutor

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:

cargo generate --git ssh://git@gitlab.informatik.hs-augsburg.de:2222/snp-rust/ws23/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/ws23/simple-cli-template
• https://gitlab.informatik.hs-augsburg.de/snp-rust/ws23/subcommand-cli-template