Rust Search

This talk is to give a brief introduction to the rust-prometheus library, which is a Rust client for Prometheus, a monitoring and alerting toolkit. After a brief look at basic usage, this talk will dive into how Rust features make the library safe and fast. Finally, we will discuss some ways to use Procedural Macros to reduce metric lookup by over 10x via generated static lookups.

Rust-hawktracer allows you to do in-depth profiling for your Rust projects.

A tour through out the adoption of Rust in the GNOME and Freedesktop communities. Showcasing existing projects that adopted Rust like Librsvg and Gstreamer, but also desktop applications from scratch, new infrastructure tooling, and the challenges of integrating Rust with the rest of the ecosystem.

A tour on newest and future developments for gtk-rs, the Rust bindings to GTK+.

Many commonly used libraries from other languages, especially GUI toolkits, make use of Object Oriented Programming (OOP). While Rust has support for many of the OOP concepts in one way or another, there is no easy way for implementing subclassing or inheritance. The topic of this talk will be how to implement subclassing and inheritance in safe Rust, based on the GObject C library. The GObject library is providing Java/ObjectiveC-style OOP features to C. It is used by the GTK+ UI toolkit, the GStreamer multimedia framework and various GNOME libraries. Apart from reasons why you would want to do this in Rust, this talk will cover the new implementation for subclassing that was recently integrated into the existing GLib/GObject, GTK+ and GStreamer bindings. These bindings allowed usage of existing GObject types before, but didn't provide any features to create new GObject types. In addition to usage of the subclassing implementation, a couple of details about the implementation will also be explained. Last but not least, an outlook in the future will be given for how one can take this even one step further with procedural macros to allow writing code that looks very close to Java or C#. This talk will not only be interesting for those who want to make use of GTK+ or GStreamer and extend those libraries, but will also cover various aspects about safely interfacing with C libraries from Rust and all kinds of type tricks to teach the Rust type-system about subclassing and making use of the type-system for enforcing various invariants at compile-time.

There is a lot of existing code and libraries written in C++. The cpp crates allow to embed easily C++ within your rust code so you can call interoperate with the existing C++ code. In this talk, we will see how to use this create and how it works behind the scenes. As an example, we will look at the qmetaobject which expose Qt api to Rust.

This talk is an experience report on my safe rust wrapper for a c++ RDMA library^1. RDMA enables the network hardware to directly read and write to memory, without the cpu's involvement. My rust implementation ensures that memory regions are exclusively either owned by client code, or enqueued for use by the underlying RDMA stack. This makes sure that data cannot be changed by hardware while owned by safe rust code, and that user logic cannot mutate data while it is being read by the card. In this talk, I'll go over the design of the library and how it embraces rust's ownership transfer semantics. In rust's safe/unsafe model, the burden of upholding safety guarantees at the unsafe boundary is entirely up to the programmer who's writing the wrappers. These guarantees are not formally specified, which makes it harder to reason about the safety of the wrapped unsafe logic; this issue is compounded by the fact that undefined behaviour can seep into safe rust from unsafe code that doesn't match rust's expected semantics. I'll discuss how this improves ergonomics in safe code, but requires careful engineering of unsafe code because it doesn't allow the programmer to reason locally.

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.

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.

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

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. Presentation of gtk-rs (before it was even an organization) Beginning: rust <-> C direct binding, no indirection, almost no safety Generation of signals through (old) macro system Old closures system to allow callbacks Short (old) code demonstration Creation of gtk-rs multi-repository easier to maintain, more difficult to release licensing issues: keeping docs in their own repository and write a tool to put it back New gtk-rs era: automatic generation GIR crate Parsing gir files and automatically generate as much as possible Presentation of the crate, how it works and the hierarchy A lot of things are simplified: doc generation, website, releases gtk-rs growth more members (semi) automatic release process a lot more of bindings (sourceview, pangocairo, webkit...) gtk-rs environment a few projects (process viewer, EDI, tools...) relm crate to easily write GTK UIs GNOME-class gstreamer-rs Future of gtk-rs async tutorials more projects more rust in GNOME libraries (librsvg already started this port)

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.

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.

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.

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.

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.

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.

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.

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.