Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
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.
Rust-hawktracer allows you to do in-depth profiling for your Rust projects.
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.
Implementing network protocols is a hard task, especially considering the support of conflicting implementations, or long term maintenance. And it does not help that testing them often requires complex client or server setups. By removing IO from the equation, and instead working directly with buffers, we’ll see that testing instantly becomes easier to setup, the core implementation becomes completely deterministic, and the protocol gets more reusable. This talk draws heavily from experience implementing protocols such as HTTP or AMQP. It will show how to build protocols in such a way, using the nom parsing library, cookie-factory serialization library, and a new state machine development library. And we will see how to reuse the resulting protocols, by swapping out the underlying transport (TCP, various TLS libraries, unix sockets…) or wrapping it in a nice futures based API.
There is plenty of content available to teach you the first steps in Rust… But what about after? What are good resources? how can you leverage generated documentation instead of just tutorials and books? How can you manage the trade-offs in API design? We’ll look at some content and examples, both old and new, worth consuming and talk about their key ideas. Then, we’ll spend some time talking about some ways to refine your APIs, measure the impact of optimizations, reduce mental overhead on your developers, and tools to help you dig into the heart of your code (flamegraphs, metrics, failure injection, debugging).
Which crates call a vulnerable function? Which deprecated functions are central to crates.io and should not be deleted? Am I breaking important clients and their dependencies with my new release? These are questions that package publishers and owners of package repositories crave for answers to. To solve this problem, we created RustPräzi: a call-based dependency network that represents a gigantic single large versioned call graph of all crates.io packages. In this talk, I will describe how RustPräzi is developed, the challenges we faced while compiling the entire crates.io and the future directions. Our goal is to make RustPräzi a community effort that can help in maintaining the stability of crates.io. For example, bad releases which may negatively impact crates.io can be detected and avoided.
This is an hands-on talk, showing a journey from code with a lot of syntactic sugar to plain, veeery explicit Rust code.
Rust is a relatively new programming language aimed as a safe competitor of C. There are already attempts to write extension modules in rust and load them into CPython. A whole new approach would be to re-implement the Python language in rust. This is what RustPython is about.
ABSTRACT 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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
"I'll know ide support is mature when the flame wars start."
— Unnamed friend of arthrowpod