RustFest Paris 2018 Talks

The Quintessential Rust Bard Returns to RustFest!

Ever wondered what makes Rust successful? This talk is about growing Rust communities worldwide and emulating values and ideals that have made the Rust project a success. Come and learn how these values and ideals have influenced Rust Nairobi’s journey and how you can use them as guidelines for your community.

A good education can take many different shapes, sizes, forms. Oftentimes, the most profound educations don’t even happen in a classroom. And yet, they all seem to have one thing in common: they teach you how to learn. Being able to learn new things is an empowering skills, especially for those of us working in the ever-changing, fast-paced tech industry. But how can we teach ourselves this skill? Together, we’ll explore one of the world’s most well-known and deeply-loved techniques, which we can use to learn many new things, tech-related and not!

What is even sketchnoting? It is a way to take visual notes of conference talks and provide them to the attendees and people outside of the conference by sharing them online. People have found them helpful and inspiring.

This is a talk about the architecture of yew — a Rust framework for frontend development, inspired by Elm and ReactJS and designed for creating single-page webapps with Rust. You will get to know how it was created: wasm compilation issues, JSX-like templates created with a pure Rust macro, how lifetime rules helps to avoid copying of the model, and how to create a framework without a garbage collector to compete in the JavaScript world.

Real-time networking applications becoming more popular, but building backend systems is challenging in terms of memory and cpu efficiency. This is a story about how at TreeScale (github.com/treescale) we got 10X+ memory and cpu efficiency using Rust MIO as a main network TCP/UNIX handling system with thread pools.

rustls is an open-source Transport Level Security (TLS) stack written in safe Rust. This talk reviews the current state of TLS support in the Rust ecosystem, and the design choices taken in rustls.

In Firefox 56, the encoding_rs character encoding conversion crate replaced Firefox’s previous encoding conversion library that was written in C++. This talk examines the API design characteristics that allowed the Rust API of encoding_rs to be mapped to an idiomatic C API and how it was possible to re-create an almost exact modern C++ analog of the Rust API on top of the C API. Rather than trying to cover the mapping of an arbitrary Rust API to C++, this talk focuses on patterns that are easy to map to C++ to help others to aim for such patterns when bringing Rust to C++ code bases.

I missed the simplicity of of computers like the C64 and the Apple 2 and I wondered if I could recreate something like that, but using the Cortex M4 devboard on my desk and a handful of resistors. Can you generate VGA without a video chip? Can you render text without enough RAM for a framebuffer? Can you read from a PS/2 keyboard? Can you do it all in Rust, and run tests on an actual PC? Will it run fast enough to be useful?

Meet Monotron — an excercise in doing things the hard way.

In this talk, we introduce Rust SGX SDK (future code name MesaLock SGX), which can protect secrets from most attacks by combining the power of Intel SGX and Rust.
Intel SGX is the next generation trusted computing technique supported in almost all recent Intel CPUs. It provides strong security guarantees and uses a completely different os/threading model, but lacks memory safety guarantees. We show how we ported Rust std and a series of fundamental and popular Rust crates into the Rust-SGX world. What’s more, we support Xargo by providing a new target platform as x86_64-unknown-linux-sgx.

Lyon is a collection of low level tools to render 2D vector graphics on the GPU, useful for games as well as other applications benefiting from vector graphics (map renderers, web browsers, graphical user interfaces, creative coding, etc.).
This presentation will start with a very short overview of the type of functionalities lyon provides, followed by a deep dive into how lyon approaches rendering and how it relates to other GPU based vector graphics rendering tools.

There’s a discrepancy between the careful attention to mutability and immutability in Rust itself and the data structures available in the standard library. The only way to update a Vec with an immutable ref is to clone it first, which could get expensive. But what else can you do?
Turns out there’s a number of data structures out there that make it cheap and easy to do immutable copies and updates. Some are so simple it’s ridiculous, some are anything but, and we’re going to dive into some of the more useful ones, how they work, why you should care, and how to best implement them in Rust.

The wild success of testing tools like Jepsen is a wake-up call that we’re approaching systems engineering from a fundamentally bug-prone perspective. Why don’t we find these devastating bugs on our laptops before opening pull requests? Rust’s compiler gives us wonderful guarantees about memory safety, but as soon as we open files or sockets, all hell seems to break loose.

This talk will show you how to apply techniques from the distributed systems and database worlds in a way that maximizes the number of bugs found per cpu cycle, and reduce the amount of bias that we hardcode into our tests.

Once HTTP/2 was standardized in 2015, the IETF started work on an even faster iteration of HTTP, based on QUIC: the Quick UDP Internet Connections protocol. The QUIC community is getting ever closer to standardizing it. While we have great HTTP and HTTP/2 implementations in Rust already, this talk discusses an effort to implement QUIC in pure Rust, based on the futures ecosystem.