Rust Programming Language / FOSDEM Rust Devroom 2018

Insights into a modern, safe, fast language

Today, many new programming languages have been created in order to simplify at the extreme the art of programming (Golang), to boost the performance of their human readable application (Nim), to secure the way to make and run programs with zero-cost abstraction (Rust), or just to propose a new exiting way to write programs (Scala, Swift), etc. Each of those new programming languages has its own features, goals, attendance, and community.

Today, it may become hazardous to develop with a new programming language, especially for a company or for a full-time personal project, due to the lack of stability, libraries, IDE features for this programming language, a too small or strict community, or many other obvious reasons.

The goal of this presentation is to introduce the concepts of Rust, its pros and cons, and how Rust differs from the others programming languages. The target audience is mainly for developers who are reluctant to launch themselves into Rust, or project managers and CTOs who are looking for stable and exciting new technologies.

This talk is intended to emphasize Rust rationale, and will explain clearly and precisely why Rust wants to be the programming language of the next ten years.


I am PhD student in Machine Learning and Natural Language Processing, working on Automated Documents Processing, at University of Luxembourg. I am interested in Machine Learning, programming languages and compiler design. My main programming languages are Python, and Rust. Open Source lover

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_introduction/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

A Primer in Testing and Mocking

Rust is designed for building low-level systems processes that are reliable and safe. Nevertheless, it is still important for developers to ensure their code is doing the right thing. To achieve this, Rust has a rich set of built-in testing tools for writing unit tests.

In this talk we cover general unit testing techniques for Rust. We will also demonstrate how to mock out complex dependencies using the double crate. Examples will range from simple cases to complex cases that you'll often see when testing real world systems.

The talk is suitable for both novice and experienced Rust developers, as well as non-Rust developers who are interested in learning more about the language.

Donald Whyte is a software engineer at a leading quant hedgefund. He has thorough experience in distributed systems and machine learning. Previously, he worked at Bloomberg where he built core infrastructure technology that is still used across the firm globally.

A Rust and distributed systems enthusiast, Donald has given many talks about software infrastructure and distributed systems around the world.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_testing_mocking/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Bringing Vulkan everywhere with gfx-rs

Graphics abstraction is an important part of maturing Rust ecosystem. gfx-rs has been the basis of many graphics applications since 2013, but as of this year it undergoes a total rewrite with the new vision, set of goals, and talented contributors. In this talk, I want to explain what this means to existing users, Mozilla, and the world.

Intended audience: people interested in Rust ecosystem foundational libraries, graphics and game development, Vulkan.

Dzmitry Malyshau
Lots of computing and gaming in childhood. Graduated with math and computer science in Belarus, then migrated to Canada to work in game development. Now working with Rust on graphics at Mozilla.

Markus Siglreithmaier
I'm a Computer Science student focusing on Computer Graphics (including Real-time rendering and physically-based animations). I'm mainly working on gfx-rs and associated projects in my spare time at the moment among other smaller Rust projects.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_vulkan_gfx_rs/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

An introduction to Neon

There's always some use cases where you need a systems language inside your node.js application. Neon is Rust bindings for writing safe and fast native Node.js modules. This talk is mainly about Neon, I'll go through the current state of project, a few examples, problems and also the future of the project.

I'm a software engineer with a web development background and a hint of DevOps.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_nodejs_neon/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

WebAssembly in non-Javascript environments

Rust is associated with performance, memory safety and control of memory usage. Embedding dynamic runtimes such as for Lua or Javascript for dynamic scripting within the Rust-App would introduce an huge overhead. A WebAssembly-engine seems to be a good choice as compact and portable runtime environment. JIT-compiler may be used in future to transform WASM files to native code.

The talk will present WebAssembly technology and the benefits and pitfalls integrating it into a Rust-app. Small routines are implemented in C++/Rust and compiled to Wasm. The Rust-App is loading the wasm-code as plugin at runtime to execute dynamic tasks.

Frank is Software Consultant with the focus onto back ends, messaging, security, automotive, embedded and CI. Already having experience with various programming languages in small and large development projects, Frank is enthusiastic about the combination of features of the programming language of Rust. Hands-on projects permit the evaluation of these features.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_embedding_wasm/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Making the unsafe safe

The goal of this talk is to provide an introduction to the gtk bindings in Rust through the gtk-rs organization. It'll be mainly about how we made it and how we keep making it better.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_gtk_rs/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Programming a self-balancing robot in Rust

Are we embedded yet? I'd say yes! In this talk I'll show you how I programmed a self-balancing robot from scratch. I'll cover IO abstractions, motion sensors, motor drivers, filters, control stuff, bare metal multitasking, logging, etc. And I'll explain how some of Rust features made development easier and made the program more correct.

Jorge (@japaric) has been part of the Rust community for over three years. Over that time he has contributed to the Rust compiler, standard library and other official Rust projects like Cargo. With his background in mechatronics engineering and the help of the vibrant embedded Rust sub-community he's working towards making Rust a great language and ecosystem for embedded development.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rusty_robots/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Rust Qt Binding Generator

Build a graphical application with Qt and Rust. Qt is a mature GUI library. Rust is a new, exciting and strict programming language. You can build most of your application logic in Rust and write the GUI in QML or Qt Widgets.

This talks will walk through how to do this with Rust Qt Binding Generator.

Jos van den Oever represents the Dutch government on the ODF Technical Committee. He has worked in the Free Software community for over a decade. He created WebODF, an ODF editor for the browser. He is active in the KDE community.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_qt_binding_generator/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

A pure-Rust approach to multimedia

Multimedia development is mainly done in C+assembly since speed is important and such combination of languages traditionally gives the best control over the hardware.

Rust is considered a mature system language that provides strong warranties about memory access (and more) without sacrificing runtime speed.

Multimedia libraries are plagued by classes of bugs that Rust actively prevents at compile time, thus this talk is about leveraging Rust to have a multimedia framework that is nice to use and at the same time more trustworthy.

Target audience is people with some Rust knowledge and some experience with multimedia libraries and concepts.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_av/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Writing concise and elegant Rust code

Rust is a big language and it gets bigger every day. Many beginners ask: "What is idiomatic Rust?". This talk will highlight simple tips to make your Rust code more elegant and concise, and introduce you to my peer-reviewed collection of articles/talks/repos for writing idiomatic Rust code.

Coming from dynamic languages like Python, JavaScript or Ruby, many Rust beginners are missing some guidelines on how to write elegant and concise Rust code. For this purpose, I started a project called "Idiomatic Rust", which is a peer-reviewed collection of articles/talks/repos which teach the essence of good Rust.

In this talk I will introduce the project and show you some quick tips on how to make your Rust code more idiomatic. I will cover error handling (e.g. Option to Result conversions, the failure crate), efficiently working with (built-in) traits, and some more.


Matthias is a Backend Engineer located in Düsseldorf, Germany. His interests are scalability, performance and distributed systems. At work he improves the infrastructure at trivago by making it faster and more reliable. When not on his laptop he plays guitar and drinks hot chocolate.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_idiomatic/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Language parsing and automatic binding generation



Usually, the topic of parsing the Rust source code is associated with the Rust compiler itself, which for many is an uncharted territory. However, parsing by itself can (and should) be used out of the context of the Rust compiler: given the wealth of information that we can extract out of the code, we can do a lot of thing with it.

In this talk, we'll discuss several interesting applications for the Rust parser and the abstract syntax trees it produces, with practical examples of Mozilla bindgen (automatic generation of Rust library bindings based on C source code) and a Java binding generator written by the author for a large-scale open source library.

Some prior basic knowledge of compilers and parsing is expected.

The intended audience is Rust developers who want to learn more about the internal implementation of the Rust compiler and to practically apply this knowledge in their projects.

Nikita is a Mozilla Tech Speaker and a Rust engineer at MaidSafe, developing an open source peer-to-peer network technology and contributing to other open-source projects, including the Rust compiler. He's enthusiastic about the Rust programming language, also interested in low-level development, P2P networks, and alternative operating systems (like e.g. BSD/Illumos).

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_demystifying_parsing/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

An introduction into miri and Rust's const evaluation

The Rust interpreter miri has been merged into rustc to be its new const evaluator. This merge not only fixed various bugs in the old const evaluator, it opened up the avenue for many new features. Ever wanted to do a for loop in a constant? Want to parse a toml file into a static Config struct and report parsing errors as compile-time errors? Well, now you can do all that (pending RFCs for the details). In this talk I will present miri's design, its usage in the compile-time evaluator as well as future features that are enabled by it

PhD Student in Software Engineering for Safety and Security Critical Software at the Karlsruhe Institute for Technology since 2014. Rust tools peer (clippy, miri) since 2017. Likes books, embedded development, programming languages and dogs.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_miri_const_evaluation/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

…and the journey to getting better code automatically

Rust programmers often seem happy to get compiler errors. Understandably so, the compiler is known to not just catch what would in other languages become a run time bug, but also to be quite helpful. On top of that, the clippy project adds more than 200 additional lints, to catch even more errors, but also help guide users towards writing more idiomatic code. This talk is about the dream of automatically fixing many of these errors (based on compiler-provided suggestions) with rustfix.

Pascal Hertleif has been writing code professionally for the last seven years and is active in the Rust community since 2014. He is the author of multiple open source libraries and co-organizer of Rust Cologne. Currently, he is studying computer science at the university of Bonn, Germany, as well as working as freelance software developer.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_rustfix_automatic_fixes/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

Fast, safe and productive multimedia software

GStreamer is a highly versatile, cross-platform, plugin-based multimedia framework that caters to the whole range of multimedia needs. It can be used basically everywhere, from embedded devices like phones, TVs or drones to desktop applications or on huge server farms.

This talk will focus on how and why Rust looks like the perfect programming language for evolving GStreamer and provide a safer but still performant and even more productive development environment than C. Both GStreamer application development in Rust, and GStreamer plugin development will be covered. What is possible today already, for which applications can Rust be perfectly used already and which parts are still missing? How does it feel like to write an application in Rust compared to doing it in C? And how and why would one write GStreamer plugins in Rust to extend the framework and all applications with support for new codecs, filters or anything else?

Afterwards there will be a short outlook into the future of Rust in the GStreamer project itself and for GStreamer application and plugin development.

Sebastian Dröge (slomo) is a Free Software developer and one of the GStreamer maintainers and core developers. He has been involved with the project since more than 10 years now. He also contributes to various other Free Software projects, like Debian, Rust, GNOME and WebKit. While finishing his master's degree in computer sciences at the University of Paderborn in Germany, he started working as a contractor for GStreamer and related technologies. Sebastian is one of the founders of Centricular, a company providing consultancy services, where he's working from his new home in Greece on improving GStreamer and the Free Software ecosystem in general.

Apart from multimedia related topics, Sebastian has an interest in digital signal processing, programming languages, machine learning, network protocols and distributed systems.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_gstreamer/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

A transactional key-value store powered by Raft

It’s not an easy thing to build a modern Key-Value database which supports the distributed transaction, horizontal scalability, etc. But this is exactly what we are doing and we have built such a database from scratch using Rust. The database is named TiKV. In this talk, I will share how we use Rust to build the storage, to support replication across geographically distributed data networks, to implement an RPC framework, to inject failure for tests, and to monitor the key metrics of the whole cluster.

To build a distributed Key-Value store from scratch, we need to consider many things. In this talk, I will share with you the following experiences when we build TiKV.

Siddon Tang is the Chief Engineer of PingCAP. He has been working on TiDB, the next generation HTAP database, and TiKV, a distributed key-value store. He is an open source lover and has developed quite a few Rust libraries like rust-prometheus, rust-grpc, rust-rocksdb, etc.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_distributed_kv_store/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en

A short intro

A quick introduction to the unique memory management concepts of Rust.

Rust is a systems programming language that focuses on safety and performance at the same time. Most people new to Rust, often struggle with memory management. The goal of this talk is to give a very quick overview of Rust's memory management.


Developer, helicopter pilot and cat lover.
I'm a software developer with many years of C and Vala experience but more recently I've been in love with Rust language. I work for Kinvolk GmbH in Berlin. I've a private pilot license for helicopters and a very loving and lovely cat.

Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_memory_management_intro/

These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en