Day 1: April 20

08:00 Check In

8:50 9:00 Opening & Welcome

9:00 9:10 Opening talk: Rust in PingCAP

9:10 9:20 Opening talk: Why RustCon Asia

9:20 9:30 Opening talk: Rust in Baidu X-Lab

09:35 10:05 Making Rust Delightful

Nick Cameron Rust strives to be an ergonomic language: easy to read, easy to write, and easy to maintain. We want it to be a language which delights! But what does that mean? How do the language and library designers decide what makes a feature ergonomic? And how do we consider the trade-offs between ergonomics and other design pressures such as safety and performance? I’ll cover Rust’s design philosophy, some case studies on ergonomics from the language, libraries, and tools, and talk about how design decisions are made by the language team and others. I’ll talk about issues such as ‘explicit vs implicit’, syntactic sugar, and consistency.

10:10 10:40 Linux From Scratch in Rust

Mingshen Sun

10:40 10:55 Break

10:55 11:10 Rust for competitive programming

bhuztez

11:15 11:30 Implementing a secp256k1 library in pure Rust

Wei Tang

11:35 12:05 How Rust taught me to think about systems

Ravi Shankar

13:00 13:30 Futures in TiKV

Qu Peng

13:35 14:05 Implementing a p2p network framework

driftluo Library: https://github.com/driftluo/p2p I will probably talk about the development of this library, the problems encountered, and so on, and explain the implementation of each small library. This library is a small supplement to the Rust network ecosystem. I hope that more people will participate in the Rust ecosystem. Such a good language should have a better ecological support.

14:10 14:40 Stackful coroutine based rust async story

Xudong Huang While the official future based asynchronous system is under way of building and maturing, I’d like to talk about another asynchronous story that based on stackful generators and coroutines. I’m the author of May(https://github.com/Xudong-Huang/may). I could talk the designs and implementations of it, give some fundamental concept about generator and coroutine, the overall structure of coroutine scheduling, the sub IO system, the sub sync preemptive system, the cancellation mechanism, and and compare it with current future based systems

14:40 14:55 Break

14:55 15:25 Improving web app with Rust and WASM

Ilya Baryshnikov

15:30 16:00 Cargo meets Autotools

Yiming Jing Since 1.10, rustc can generate a dynamic library that is intended to be used from C or C FFI, as long as the cdylib crate type is specified in Cargo.toml. While the cargo install command makes it a breeze to distribute executables (e.g. ripgrep), it does NOT work with cdylib dynamic libraries. Back in 2018 we had struggled a long way to get a working build infrastructure, just to build and distribute our dynamic library written in Rust. Eventually, we made autotools work happily together with the rust toolchain. Now a user can just download our source tarball, uncompress, and run ./configure && make && make install, just like old times. In this talk we’d like to share our story and hopefully this will be useful for the community.

16:05 16:35 Re:Zero - writing a custom derive

Xidorn Quan

16:40 17:10 Distributed Actor System in Rust

Zimon Dai

17:10 Networking

Day 2: April 21

08:30 Check In

08:40 09:10 Be Fearless Using Rust in Production

RobotXY We need a high performance and stability image rendering web server to handle creative real-time generation for Taobao Wireless focus picture. The service requires algorithms to select products, copywriting and creative templates according to different users, and then generate creative to be displayed in real-time. At the beginning of our development with Node, but unable to meet performance requirements soon. Our team replace Node version server with Rust version since 2016, and got greatly increase of RT and QPS. This server is running over two years, and have stood the test of two “Double 11”. This topic will share our experience on how we use Rust in production.

09:15 09:45 Rust at Bilibili

WaySLOG & hawkingrei Bilibili is an online video barrage website. We are happy to try new technology, and Rust is also the language I am optimistic about. Today we will introduce to you three of our components that use Rust: Caching proxy component

Image processing component

Compile the remote cache component I would like to introduce you to some of the problems we encountered when using Rust and a little experience, I hope to help everyone.

09:50 10:05 How to learn Rust efficiently

Alex What is efficient learning?

What are the common pitfalls in learning Rust?

Learn from Rust’s ten recommendations.

10:05 10:20 Break

10:20 10:50 Search Engine in production with Rust

Xiaoguang Sun

10:55 11:25 Closing Project Update

11:35 Networking

Day 3: April 22

09:00 12:00 Introduction to IoT using Blynk, Rust and your Smartphone - Room A

Rahul Thakoor Do you want to leverage your smartphone’s sensors and actuators? Do you want to learn the basics of IoT, and bridge the virtual and physical world? And do you want to do it all using Rust?! In this workshop, you can get a taste of the embedded world without breaking the bank. We are going to use Blynk, which is a free smartphone app providing drag-and-drop widgets for your IoT projects. You will need a smartphone (iOS or Android) and a laptop running Linux, macOS or Windows. We will introduce the basics of IoT. You will configure virtual LEDs and buttons, collect sensor data like GPS stream or Accelerometer or send events and data to your phone. By the end, you will be able to use your skills learned prototyping to make more creative and fun projects and blaze your own trail. You will also get a better understanding of IoT projects and be inspired to get started with embedded Rust on microcontrollers or other hardware.

09:00 12:00 Rust at Cryptape - Room B

Zhiwei Ning At this workshop you will learn: How Clippy works

How to contribute to Clippy

Two useful tools inspired by Clippy

Relationship between Blockchain fork and Expression Problem

How to slove Expression Problem in Rust All level are welcomed! If you familiar with Blockchain, we can discuss more about it after above contents.

10:00 18:00 RustBridge - Room C

Olivia Hugger

13:00 17:00 WebAssembly with wasm-bindgen - Room A

Ilya Baryshnikov Advanced details about Rust and WebAssembly. We will discuss two major topics: moving computations to wasm and DOM manipulations. At this workshop you will learn: how to compile Rust to wasm using rustc

why communications between Rust and JS could be hard

how wasm-bindgen simplifies development

how to build module with wasm-pack

how to use wasm from various environments: webpack, node.js, plain html (without bundlers)

any additional topics, suggested by attendees After this workshop you will be ready to start using Rust in your web app. If you already familiar with Rust and wasm-bindgen, we can still try to discuss more advanced problems and how to deal with pain points.

13:00 17:00 Rapid Development of RESTful microservices using actix-web and diesel - Room B

Alex Introduction to Actix/Actix-web and Diesel.

How to organize the code using Actix-web.

Preliminary practice.

How to use abstract tool code refactoring such as generics, traits, etc. And how to use macros to Don’t Repeat Yourself.

How to package the service into a 10M Docker image for deployment.

Day 4: April 23

09:00 12:00 Build a Secure and Trusted Framework in Rust - Room A

Yu Ding & Mingshen Sun This talk intends to be a long talk (~4 hrs) introducing the Rust TEE ecosystem. Rust SGX SDK has become the most popular SGX development environment. Previous talks at RustFest, QConSF and QConBJ are all brief talks within 30 minutes and limited Q&As. This time I’d like to present its details and current ecosystems. In addition, we’ll include the Rust-trustzone part. The talk would guide the audience to play Rust on two TEEs: SGX and Trustzone. In the beginning, we’ll talk about the trusted computing theory and hardware-assisted trust execution engines. Then we assist the audience with hands-on experiments on Rust+SGX and Rust+Trustzone platforms. At last, we’ll discuss about the internals and ecosystems.

09:00 12:00 Thinking In Rust - Room B

Nick Cameron Learning a new programming language is hard. Even after mastering the syntax and type system, learning the libraries and techniques can take years. If you’ve read or written Rust and want to improve, this talk will give you a turbo boost! This will be a very practical tutorial, aimed at taking your Rust programming to the next level. We’ll teach some core Rust design principles by covering a few key topics in depth. The tutorial will start with programming ‘in the small’: we’ll explore some key library types (Option, Result, and Iterator) and cover practical error handling. Putting these together we’ll see how to structure your control flow to write clear, succinct programs. We’ll then cover some larger-scale design issues - using ownership as a primary architectural principle, and abstraction using traits. You’ll learn how to be more productive in Rust by writing clean and idiomatic code. You’ll learn to work with the language rather than fighting against it.

09:00 10:30 Learning Rust FFI - Room C

hawkingrei This workshop teaches developers about compiling rust FFI - from a beginner to a master. This course can help you to bindgen any C/C++ library, and package C/C++ to a certain extent. learn about bindgen,build.rs, initially work with libwebp ffi

implement libwebp wrapper, and turn png into libwebp

implement in-library libwebp version, refer libwebp without libwebp This course requires you to have some basic knowledge about Rust language(no knowledge base is also okay), no requirement for c/c++. In this course, you can use Linux/Mac OS in order to do some experiment, for those using Windows you should set a virtual machine first.

10:30 12:00 Building a simple RESP parser - Room C

WaySLOG This workshop opens to those developers who are experienced in Rust, especially for those who were once a beginner, then gave up and finally became a beginner again! We will focus on redis’ RESP protocol, and work together to optimize this parser walking through the definition of redis RESP protocol(https://redis.io/topics/protocol)

implement simple parser with single pass backtracking

use simd to accelerate specific environment of parser

use tools like cargo flamegraph/dtrace/perf to generate flame graph, also to generate diff flame graph

13:00 17:00 Integrate rust-prometheus into your application - Room A

Wish (施闻轩) & Shirly (吴雪莲) Introduction to the Prometheus and the rust-prometheus client Using rust-prometheus to collect different kind of metrics Exposing collected metrics to Prometheus and using Grafana to visualize The performance impact of the metrics and different ways to greatly improve performance

13:00 17:00 Build a Decentralized app on Blockstack Chain V2 - Room B

Su Bo Blockstack is a full-stack decentralized computing network that enables a new generation of applications where developers and users can interact fairly and securely while curing the ills of centralized Internet design. Blockstack builds protocols and developer tools designed to enable a fair and open Internet that returns digital rights to developers and consumers. Led by some of the world’s foremost experts on distributed systems, Blockstack allows users to own their own data that they can take with them from app to app in the ecosystem, along with their Blockstack ID that eliminates the need for password-based logins. The end result is privacy, security, and freedom. Stacks blockchain v2 is planned for late 2019 and will introduce two big changes/features. A new consensus algorithm

A full smart contract system The proposed consensus system aims to combine the best of classic distributed systems consensus algorithms and proof-of-work. The aim is an open membership system (unlike classic distributed consensus algorithms) but wants better scalability and throughput than proof-of-work blockchains like Bitcoin. Stacks blockchain v2 is being written in Rust. You can follow the development here. The new consensus algorithm and the new smart contract system are proposed as Stacks Improvement Proposals (SIPs) and can be found as SIP-001 38 and SIP-002 27. This workshop includes the following: * Setup Blockstack Chain V2 with Rust * Build a Decentralized app * Run your Dapp

13:00 17:00 Building a blockchain using Rust with Parity Substrate - Room C