Accepted Talks
Beyond Memory Safety
Rust’s ownership model promises to solve memory safety and data races. However, research shows this model enables much more: it provides an excellent foundation for building tools that help us write correct software. In my talk, I will explain why researchers are so excited about Rust and how new tools could help prevent bugs in your software tomorrow.
Developing a computer algebra system in Rust
In this talk I will introduce Symbolica, a novel, blazing-fast computer algebra system (CAS, e.g. sympy, Mathematica) written in Rust, which is currently in use by several universities.
Ferris wins a Folkrace!
Rust shines in embedded systems!
One of the last robots I built is a small autonomous car that ultimately won a “folkrace” competition: a contest where up to five vehicles race together inside a closed track, where they must be able to avoid opponents and obstacles while completing laps as fast as possible, like in an actual car race.
High performance code and the cost of safe code
It is generally accepted that the increase in safety of Rust’s safe code is worth the minimal performance hit that it incurs. This talk explores the specific case of very high performance code, and specifically a high-performance Brotli encoder, where safe code can be up 20-30% slower than unsafe code - even when using std::simd (and more if not), and discusses possible ways to bridge this gap.
How to build a Linux Kernel Module in Rust? A brief introduction
The introduction of Rust as a second programming language in the Linux Kernel caused noticeable attention in the software developer community and beyond, as it promises a safer and more accessible way to write Kernel modules compared to good old plain C.
Interactive Exploration of Nonlinear Ray Casting with Rust and wgpu
Light is commonly assumed to travel linearly from source to destination. There are however cases where the path of light can be bent or distorted. In the case of black holes for example, the light is attracted by a very strong gravitational center. Heated air can change the direction of light through the varying refraction caused by the temperature transition from heat source to environment. Creating an interactive environment for exploration of such phenomena may help in understanding the images they bring to life.
Making Go Talk to Rust: Simplifying Cross-Language Communication with UniFFI
In this talk, we will generate Go bindings effortlessly for Rust libraries using uniffi-bindgen-go.
Miri: checking your unsafe code for Undefined Behavior
In this talk I will explain what Miri is and how it can find bugs in your unsafe code. I will also briefly discuss some of the common cases of Undefined Behavior that you should be aware of when writing unsafe code.
Modern Game Development using the Bevy Engine
The Bevy engine uses a novel purely data driven approach called “Entity-Component-System” (ECS) that makes development different from other game engines of the past. In this talk, I will explain what an ECS is, present the Bevy engine and show how to code simple games.
Profile-Guided Optimization (PGO) in Rust: unknown parts
Profile-Guided Optimization (PGO) is a compiler optimization technique that helps with optimizing software based on a collected in runtime profile. This optimization is available for a long time in the Rustc compiler. But how smooth will be your experience when you try to adopt PGO in practice?
Switching from C++ to RUST (from embedded devices perspective)
In this talk, I will share my journey of transitioning from 7 years of embedded software engineering experience in low-level C/C++ to embracing Rust in a commercial project.
Targets Acquired: Rust builds for everyone, courtesy of GitHub Actions
Rust, with its ability to compile directly into native binaries, leverages LLVM to achieve remarkable efficiency across diverse computing environments. However, the wide range of architectures and operating systems presents a significant challenge: ensuring that Rust applications run smoothly on all platforms.
Towards Zero-Copy Binary (De)Serialisation: TypeScript <-> Rust
JSON is the de facto standard for sharing data between backend services, but it’s neither type-safe nor cheap to parse. Enter the world of zero-copy binary protocols for Rust and TypeScript applications. Starting from non trivial datatypes you may find in your codebase - plus their JSON schema definition - we’ll discuss how to model them with Cap’n’Proto: a proven, zero-copy binary protocol used at Cloudflare, and crafted by the creator of Protobuf 2. Ready to level up your cross-language data handling process?
Using Rust for Playing Soccer With Robots at RoboCup
The goal of the RoboCup is to play humans vs. autonomous robots in soccer matches by the year 2050. To drive progress toward this ambitious goal, annual competitions and conferences across various robotics sub-fields are held, to encourage research and development. Traditionally, robot programming has been dominated by languages like C++ and Python. However, first teams are adopting Rust for its benefits in safety, reliability, and performance.
When cargo test is not enough
By the end of the talk, you’ll know how cargo test works under the hood, how to write a custom test harness and when it’s a good (or a bad!) idea to reach for one.