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.

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.

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

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.

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.

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.

• What is efficient learning?
• What are the common pitfalls in learning Rust?
• Learn from Rust’s ten recommendations.

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.

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.

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.

• 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.

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.

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.

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.

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

1. Introduction to the Prometheus and the rust-prometheus client
2. Using rust-prometheus to collect different kind of metrics
3. Exposing collected metrics to Prometheus and using Grafana to visualize
4. The performance impact of the metrics and different ways to greatly improve performance

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

Rust + Blockchain: What can be more cutting edge than that combo? In this workshop learn to build your own blockchain using Rust with the Parity Substrate framework. The workshop helps Rust developers in getting started on the Substrate framework. Substrate allows you to build custom, highly efficient and modular blockchains using the Rust programming language.

The workshop includes the following:

• Introduction to the Substrate framework
• Getting started with blockchain development using Substrate
• Building a sample Substrate runtime