VLC media player has a nice goal for users: handle almost any file or protocol you throw at it. Unfortunately, this results in a lot of parser vulnerabilities, because most of the parsing code is handwritten in C. By leveraging Rust and the nom parser combinators library, could we replace some security critical parts of VLC?
One of the core building blocks of any library is the I/O abstraction it works with, but unfortunately they isn't always composable to plug libraries together. The concept of futures is tried and true in frameworks like Scala's Finagle, and provides an ergonomic solution to composing multiple I/O libraries together. This talk will explore the implementation of a cross-platform futures library in Rust backed by the full power of mio and leveraging many aspects of Rust to make futures programming even easier.
Good news! I have already gone down this road and am now prepared to share my adventure with you. Luckily, I was able to capture much of the flora and fauna of Rustlandia with my primitive pictorial devices (paper and pen).
Do you ever think “Ok, I'm definitely not a beginner at programming anymore, but how do I get WAY BETTER?” I have. It turns out that there are a lot of amazing things you can learn about programming by learning a little bit of Rust and systems programming, and I'm going to talk about some of my favorites.
Traits and type parameters are the core mechanism for abstraction in Rust. Other languages also have features like these, but few leverage them nearly as much as Rust does. This talk will describe the many powerful uses for Rust's generics system, how generics can be used as a replacement for tools like inheritance and duck typing, and how to leverage this system to write good, clean code.
Users of Rust for systems programming rely heavily on its exceptional support for FFI. Many systems APIs involve unions, and macros and transmute produced unmaintainable solutions. 16 months, 3 RFCs, and a half-dozen possible syntaxes later, RFC1444 added union to the Rust language, ready for implementation.
This talk will present unions as a case study of the Rust RFC process, show the kinds of iterative refinements that take place, review corner cases and interactions that arise when attempting to extend Rust, and discuss the next steps forward for union implementation.
This talk will present XIeditor, a new project to build a high-performance text editor primarily in Rust. In addition to a deep dive into technical details, the talk will touch on aspects of building polished GUI apps and running a community-focused open source project.
Modern machine learning systems require scalable, real-time processing to analyze massive datasets. Rust is an attractive tool to help drive low-cost, high performance data science. But what's it like to use Rust to solve machine learning problems in practice?
To evaluate Rust as a foundation for machine learning services, we built a classification system, entirely in Rust, that detects /r/playrust posts mistakenly published on the Rust subreddit. We'll present Rust's strengths and weaknesses at each step of the process, inspiring discussion on its role in the future of data science pipelines.
This is a two-speaker talk, also delivered by Colin O'Brien.