Program - RustRush 2018


Ashley Williams 🔗

Ashley is Rust Core Team Member, Team Lead and Rust Community Team Lead. She's the director or Increasing Rust's Reach Project, RustBridge Lead Instructor, and a member of Rust/WebAssembly Working Group. Ashley previously was Registry Engineer at npm, and on Node.js Board of Directors. She's also Community Comittee Founder, TC-39 Invited Expert and NodeTogether Founder and Lead Instructor.

Rust/WASM Workshop

Ashley Williams & Steve Klabnik 🔗

Steve leads the documentation team of Rust at Mozilla. He's frequent conference speaker and active open source contributor. Steve previously worked on Ruby and Ruby on Rails.

Rust’s approach of getting things right

Pascal Hertleif 🔗

Pascal is the lead of CLI Working Group in Rust project. He's author and contributor of many Rust crates. Pascal also is co-organizer of Rust Cologne meetup.

This is a talk on how Rust doesn't invent a lot of new stuff. Rust itself isn't a new invention, really. It borrowed (pun intended!) a lot from Cyclone and ATS. And that set the tone for the community. Don't let "Not Invented Here" rule your decisions. Instead, take something academic, or something good but unergonomic, or something just not widely known, adapt it for mainstream - and it's golden!

An Async Story

Katharina Fey 🔗

Katharina lives in Berlin and works as a software engineer at Ferrous Systems. She’s been writing Rust actively since 2017, is author of many crates and is an active community member. Currently she’s part of the CLI working group, the community team, and generally interested in making developer experiences in Rust more ergonomic.

Async network programming has become a big deal in the modern day and age. The Rust community is no exception. Especially considering the rising popularity of the language for network and distributed systems development, having a solid async story is important. This was the goal of the networking WG for Rust 2018. And while not all goals were met for the end of the year release, there have been significant changes and movement in both the core syntax and the ecosystem around it. In this talk, we will examine both development that has already happened as well as things still on the roadmap.

Libp2p, a Rust peer-to-peer library

Pierre Krieger 🔗

Pierre is a Rust programmer at Parity. He previously worked on graphics programming, including several Rust crates for Vulkan and OpenGL. He is now working on peer-to-peer networking.

The Rust libp2p library is the Rust implementation of the libp2p protocol initially created by Protocol Labs. Based on futures and tokio, it allows one to easily create a decentralized peer-to-peer network. This talk will introduce you to the main concepts of a peer-to-peer network, and how to use libp2p."

Building Safe and Secure Systems in Rust

Mingshen Sun 🔗

Mingshen Sun is a senior security researcher of Baidu X-Lab at Baidu USA. He received his Ph.D. degree in Computer Science and Engineering from The Chinese University of Hong Kong. His interests lie in solving real-world security problems related to system, mobile, IoT devices and cars. He maintains and actively contributes to several open source projects in Rust such as the MesaLock Linux project, MesaPy, and YogCrypt.

Rust is designed to be a system programming language which is fast and guarantees memory safety. However, building safe and secure systems is not simply using Rust to rewrite existing code. Still, there are many challenges such as the Rust language, unsafe Rust, foreign function interface (FFI), and designing systems with a hybrid memory model. In this talk, we will discuss some challenges in the view of security. We will demonstrate the challenges and lesson learned by using some real-world case studies. Finally, we will raise some open questions, initial ideas, and possible solutions.

Beyond blockchain: PARSEC, bringing consensus to the next level with Rust

Pierre Chevalier 🔗

Rust programmer and leader of the Routing team at Maidsafe, Pierre Chevalier participated in the invention of PARSEC: a next generation consensus protocol and is now overseeing its development in the open, in Rust.

Invented in 2018, PARSEC is a revolutionary algorithm that has the potential to disrupt the blockchain by offering a scalable, mathematically proven alternative for trustless consensus. It is open-source and written in rust. Co-inventor Pierre will blow your socks off by explaining its ins and outs.

Transparent proofs of data records in blockchain

Roman Shirochenko 🔗

Roman is a Rust programmer at Bitfury, he leads the Exonum Russia team. They develop blockchain applications built on the Exonum. He has experience in building and integration of enterprise and government blockchain solutions.

Exonum is a blockchain framework developed in Rust that allows building secure permissioned blockchain applications. Blockchain, as a technology that expands the capabilities of distributed databases, implies the possibility of auditing or validating stored information.
Exonum provides a “proofs mechanism”, based on cryptographic commitments via Merkle / Merkle Patricia trees. This mechanism allows verifying that a response from the full node has been really authorized by a supermajority of validators.
The talk will present how we develop the merkelized collections in Exonum and the tools to provide data auditability functionality for the web applications integration. The talk will be based on the auction blockchain application example.

Applied pure-Rust cryptography

Artyom Pavlov

Founder and maintainer of RustCrypto project. PhD student at Skolkovo Institute of Science and Technology. Interested in cryptography and robotics.

This workshop will cover the following topics:
‣ Hash functions: calculating hash (SHA-256 and BLAKE-2b) of file contents, calculating hash of the given length using SHA-3 XOF.
‣ Password based key derivation functions: pbkdf2 and argon2.
‣ Block ciphers and block modes: comparing ECB and CBC, paddings.
‣ Stream ciphers: CTR mode, XSalsa20.
‣ MACs: HMAC, Poly1305, PMAC; generically implementing Encrypt-then-MAC construct.
‣ Public key cryptography: ed25519 and x25519.
Participants will be provided by template crates and will be tasked with finishing them using designated pure-Rust crates. As a final task participants will implement a simplistic GPG-like tool for encrypting files.

Pest: Building a Language Server

Victor Lopez

Victor is a Brazilian ERP developer who currently works in Russia for the localization of a product. In his free time, he's a Rust enthusiast who aims to bring more companies to its benefits.

To build a language server, we need a very robust parser and some efficient JSON/RPC framework.
To achieve that, I used Pest (PEG-based) with a big TDD coverage for the parser, and Parity’s solution for the JSON/RPC interface.
Currently, I’m on beta; I expect to achieve a base of 10k users.

Developing web API DSL with macros

Konstantin Stepanov 🔗

Konstantin is Rust enthusiast, speaker and former Minsk community organizer. He's maintainer of several crates.

Async non-blocking code reviews

Frank Koornstra 🔗

Backender in an awesome team at Usabilla and obsessed with creating the perfect search engine with the help of Elasticsearch. Into DDD and BDD, not so much the TDD but can stomach people that are. Enthusiastic scuba diver and cyclist - obligatory when Dutch. Come talk to him about anything Elasticsearch!

“It’s not personal” but it so is! Code reviews are still one of the biggest sources of conflict in a team and can delay value delivery by days if not weeks. I’d like to tell you why that is but more importantly hand you a method that will let you focus on what’s important: the work. We briefly touch on the psychological mechanics at work during PRs, look at statistics to fuel decisions around commenting and then combine those two perspectives to create a solid code review etiquette for your team so you can achieve truly async non-blocking code reviews.