Rust Programming Language / Rust Zürichsee

Would you like to chat, ask questions or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Support the Zürich community: https://estada.ch/support-my-work/

Follow us on https://rust-zürisee.ch/

Join us on our next event:
https://www.meetup.com/de-DE/rust-zurich/

Topics:
* Rust in the Kernel
* IDE level configuration

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-07-03_rust-in-the-linux-kernel

Would you like to chat, ask questions or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Support the Zürich community: https://estada.ch/support-my-work/

Follow us on https://rust-zürisee.ch/

Join us on our next event:
https://www.meetup.com/de-DE/rust-zurich/events/293322905/

Rust programmers care about the correctness of their code and, while the Rust type system and its memory safety are excellent foundations, they aren’t sufficient to ensure correctness. “Full functional verification" of code is an alternative (or a complement) to tests that uses formal methods to prove that the behaviour of a complex program corresponds to a desired specification, i.e. to prove that the program is "correct".

We are building our new tool, Verus, to efficiently verify full functional correctness of low-level systems code written in a safe Rust dialect that supports expressing specifications and proofs. In this talk I'll introduce the basics of functional verification, the verification technique used by Verus, and I'll demonstrate how the tool, with the programmer's help, can ensure that programs are bug-free (or how it catches bugs, if they are any).

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-06-08_miri-simd-hir
Guillaume's Blog: https://andrea.lattuada.me/

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Support the Zürich community: https://estada.ch/support-my-work/

Chapters:
00:00 Introduction
01:19 Examples
38:40 Questions

SIMD instructions have become increasingly important to speed up algorithms, and Rust now exposes them as intrinsics in the standard library.
However, SIMD presents unique challenges, among others: portability, testability, usability, and making sure the compiler indeed generated optimized code.
In this talk, I'll take the angle of using Rust on Android to discuss how to approach and solve these challenges.

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-06-08_miri-simd-hir
Guillaume's Blog: https://gendignoux.com/blog/
Guillaume's Github: https://github.com/gendx

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Support the Zürich community: https://estada.ch/support-my-work/

Chapters:
00:00 Introduction
03:10 Building Blocks of SIMD
07:22 Calling SIMD from Rust
12:39 Writing cross-platform algorithms
20:43 Detecting supported SIMD instructions
30:36 Performance pitfalls in practice
38:40 Questions

Memory safety is one of the key selling points of Rust. However, even the Rust compiler is not omniscient, so sometimes programmers need to resort to "unsafe" code and take on the responsibility of ensuring memory safety themselves. In this talk I will introduce key terms surrounding unsafe code such as "undefined behavior" and "soundness", and explain how to write unsafe code in a systematic way that reduces the chance of getting it wrong. I will also demonstrate how you can use Miri to check your unsafe code for otherwise hard-to-detect bugs.

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-06-08_miri-simd-hir
Ralf's Blog: https://ralfj.de/blog/

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Chapters:
00:00 Introduction
01:45 Rust is a memory-safe language
08:49 Common misconceptions with unsafe code
18:12 Examples of Undefined Behavior
44:28 Questions

End-to-end encryption provides an increased security layer when sharing data over the network by ensuring that only the intended recipient(s) of a message can read it.
Protecting data privacy is especially important when personal human data is involved, such as genomic sequences. To facilitate secure data transfers between hospitals and academia, we developed `sett`: a tool for data compression, encryption, and transfer. Its primary goals are to ensure a smooth user experience, speed, and data transfer auditability. `sett` is a cross-platform tool (Linux, Windows, MacOS) with both CLI and GUI interfaces.
The initial version of `sett` was implemented in Python. However, due to its many limitations, we decided to port the application to Rust. In this talk, we will present how we gradually transit from Python to Rust (without breaking production) with the ultimate goal of shipping a pure Rust implementation to the end users.

Interactive Slides: https://biomedit.gitlab.io/presentations/sett-zurich-2023/
Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-04-19_sett

Watch more of our meetup: https://www.youtube.com/playlist?list=PL85XCvVPmGQipj690WrVgsnU4K4x7qFGy
Join us next time: https://www.meetup.com/de-DE/rust-zurich/

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Chapters:
00:00 Intro
01:51 Big Picture
08:00 Python implementation 🐍
15:00 Rust rewrite 🦀
19:15 SequoiaPGP
21:46 Python bindings with PyO3 & Maturin
23:30 High level code
28:25 Code Maintenance, CI, & Releases
33:29 Stay up-to-date with renovate bot
36:08 Performance improvements
42:57 Questions
https://youtu.be/XKODaZgKcnE

Writing performant concurrent data structures in Rust can be challenging, and often requires subversion of Rust's ownership guarantees. In this talk I'll be using a multi-producer single-consumer queue as a case study for writing performant code, crafting safe abstractions, sniffing out undefined behaviour & concurrency issues, and avoiding pitfalls during benchmarking.

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-03-28_embedded-hpc
Adrian's Blog: https://alic.dev/

Watch more of our meetup: https://www.youtube.com/playlist?list=PL85XCvVPmGQipj690WrVgsnU4K4x7qFGy
Join us next time: https://www.meetup.com/de-DE/rust-zurich/

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Chapters:
00:00 Intro
01:39 Motivation
04:53 The Ideas for more speed
10:47 The Memory Model
18:48 Implementation in Rust
33:43 Crafting Safe Abstractions
45:41 Runtime Analysis with Miri
48:32 Conclusion
53:16 Questions

In this talk we will look at embedded Rust programming, specifically communication between the host and the microcontroller, and how Mike builds software on and with the Raspberry Pi Pico (RP2040). There will be a demo so let us all send good vibes to the live demo gods.

Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-03-28_embedded-hpc

Watch more of our meetup: https://www.youtube.com/playlist?list=PL85XCvVPmGQipj690WrVgsnU4K4x7qFGy
Join us next time: https://www.meetup.com/de-DE/rust-zurich/

Would you like to chat or give a talk? Join us in our Matrix room:
https://matrix.to/#/#rust-zuerisee:matrix.coredump.ch

Chapters:
00:00 Introduction
01:49 Bare Metal Targets
10:56 Live Demo rp2048 Raspberry Pi Pico
14:27 Flashing the Pico with another Pico
28:55 Communications Protocol Host ↔ Pico
37:05 RTIC v2 & USB CDC
50:35 Live Demo interactive Commands over USB
53:23 Questions

How does one handle a secret with multiple keys?
Stefan presents us his master thesis where he solved that problem with his rust crate and built a basic virtual file-system that is fully encrypted and can be synced over multiple devices.

Follow/Hire Stefan: https://estada.ch/
Slides: https://github.com/rust-zurichsee/meetups/tree/master/2023-02-21_applied-cryptographics

-- Chapters --
00:00 Intro
01:11 Why encrypt in the application?
09:52 Master Key Management
18:55 File Content Encryption and Virtual FileSystem
27:01 Native Integration
35:27 Questions


Checkout our other videos: https://www.youtube.com/playlist?list=PL85XCvVPmGQipj690WrVgsnU4K4x7qFGy
Come to our events: https://www.meetup.com/Rust-Zurich/

Talk by Shane Carr (starts at 11:20, with some intros from the organizers first)

Across the world, people are coming online with smartphones, smart watches, and other small, low-resource devices. The technology industry needs an internationalization solution for these environments that scales to dozens of programming languages and thousands of human languages.

Enter ICU4X. Built from the ground up to be lightweight, portable, and secure, ICU4X learns from decades of experience to bring localized date formatting, number formatting, collation, text segmentation, and more to devices that, until now, did not have a suitable solution.

Shane Carr, chair of the ICU4X subcommittee at the Unicode Consortium, will introduce ICU4X and discuss a range of topics on how to write a fast, modular Rust library.

https://www.meetup.com/rust-zurich/events/289518586/

-- Chapters --
00:00 Rust Zürisee and Introduction by Stefan Schindler
04:44 Rust at Google by Martin Geisler
11:20 Next Generation i18n with Rust Using ICU4X by Shane Carr
39:39 Questions

Talk by Manish Goregaokar

Internationalization involves a lot of data. A Lot. And loading data can be slow.

ICU4X has dealt with this by going all-in on zero-copy deserialization, a technique that ensures that data loading involves fast validation as opposed to slow allocation. To help with this, we have built a suite of crates (yoke, zerovec, zerofrom, and databake) that make zero-copy deserialization easier to work with and more broadly applicable. This talk will tour through these crates, talking about what they do, how they work, and how they can be useful to you.

Slides: https://tinyurl.com/manishearth-zerocopy-talk
Meetup link: https://www.meetup.com/rust-zurich/events/289518586/

-- Chapters --
00:00 Supercharging Zero-Copy Deserialization by Manish Goregaokar
35:03 Questions

How coding a system with so many independently moving parts is less about the bits and bytes but more about the high-level capabilities rust offers.
In this talk Stefan Schindler @dns2utf8 focused on how he designed the whole system from concept to implementation including hosting it on a CO2 neutral server.

Join the Zürisee Community on Matrix:
#rust-zuerisee:matrix.coredump.ch


Checkout https://rustfest.global/

Recording of the Rust Zürisee Meetup on April 30th.

Christian (aka chrysn) talked about cargo-crev: «Don't waste time reviewing crates – make it count instead! With crev code reviews, we can mesh up our reviews to gain a level of review coverage on, and thus trust in, our dependencies that would be practically unobtainable alone. Let's join forces to cover our whole dependency trees.»
Slides: https://christian.amsuess.com/presentations/2020/crev/
Tool: https://crates.io/crates/cargo-crev

Tony Arcieri (aka tarcieri / bascule) talked about cargo-audit and the RustSec Advisory Database.
Tool: https://crates.io/crates/cargo-audit

This presentation was the first experiment with livestreaming of the Rust Zürisee meetup group in Switzerland.

Gerhard is sharing parts of his story migrating Pascal code from a research paper to a Rust module usable from Python.
How he was able to use Rust to improve the Python and C code to be included in a LCA software by Sustainable System Solutions (an ETH spinn-off) preventing segfaults while keeping up with the speed of the C solution.

https://www.meetup.com/Rust-Zurich/events/269771239/

Concurrent programming used to be hard. Stefan Schindler is talking about techniques to structure code using ThreadPool and Iterator with rayon.

This talk will teach you the basic building blocks to not get lost in a forest of threads and tasks.

Slides: https://estada.ch/2019/3/20/parallel-programming-in-amsterdam/
Examples: https://github.com/dns2utf8/thread-pools-and-iterators/tree/master/beispiele
ThreadPool: https://crates.io/crates/threadpool
Rayon: https://crates.io/crates/rayon

Questions start at 41:06

Stefan is talking about the Threadpool crate and how to synchronize offloaded work with channels, barriers and the brand new join operation.
Finishing the talks with a short section about cargo helpers (44:10).

Slides: https://github.com/rust-zurichsee/meetups/blob/master/2017-08-02_threadpool/slides.pdf
More meetups: https://www.meetup.com/de-DE/Rust-Zurich/