Opening Keynote

by Aaron Turon and Niko Matsakis

photo by: @eigenrick

175 new features since 1.0

New features underway

Specialization

impl Trait

The ? operator

operator Macro 1.1 offers custom derive

Compiler internals redesigned

Mir in orbit

Dynamic drop flags

Incremental comp

Error messages

Challenges in the Rust survey

1 in 4 Learning curve (First 3 weeks is rough)

1 in 7 More libraris

1 in 9 “Maturity”

1 in 19 IDEs

1 in 20 Compiler Perf

Speed and reliability are core values of rust, but for 2017, productivity should as well.

Potential areas for new/improved libs

Rust on the server

Futures for async I/O

Tokio for protocols

Middleware ecosystem

Parallelism & Concurrency

Deliver on Rust’s potential

Serialization

Stable serde

Rust numerics/ML

Establish foundations?

serde is pronounced serdy not serd .

Discoverability

A tricky balance:

Make it easy to find the “best”

… but allow newcomers to take root

… but incentivize the right things

Tools

rustup NDK support Emscripten/wasm

cargo Private/shared Build system integration

rustfmt Strike team for the format The bike shed of bike sheds



Racer for code completion in editors.

The Illustrated Adventure Survival Guide

by Liz Baillie

photo by @QEDunham

Classes vs Traits

Error handling

Stack & Heap

Integrating Rust and VLC

by Geoffroy Couprie

photo by @nathanaeljones

VLC has C code and is now using Rust to replace the C code.

Autotools with Rust.

The RustPlay Classifier

by Suchin Gururangan and Colin O’Brien

Technical Debt in Data Science

Siloed teams

Pipeline junkgles

Unscalable Experiments

…and all the normal engineering tech debt

“A mature system might end up being (at most) 5% learning code.”

Service oriented Machine Learning

Data Collection

Data Inventory

Feature Extraction

Model Generation

Prediction

Vagga: a containerization tool without daemons

Rayon: A data parallelism library for Rust

Using Generics Effectively

by Without Boats

How will I know when it’s a good idea to use a Trait or an Enum ?

A Pattern Language Book

“Design patterns are a sign your language itsn’t powerful enough.”

Patterns don’t have to be template of classes.

Back to the Futures

by Alex Crichton

What’s a Future?

DB query

RPC Request

Timeouts

CPU Intensive Work

Socket Readiness

The fastest server

mio is state of the art

Primarily using state machines

Avoids unnecessary allocation/synchronization

Futures must “compile down” to the same code

Zero-cost futures

No allocations in combinators

No synchronization in combinators

One dynamic dispatch per event

One allocation per connection

Tokio: Asynchronous I/O for Rust

A Modern Editor in Rust

by Raph Levien

The Xi Editor: A modern editor with a backend written in Rust

Main goal: performance

How to make a fast editor:

Use a fast language

Exploit multicore parallelism

Use advanced algorithms and data structures Ropes Minimal incremental algorithms

Asynchrony Don’t block slow operations



Operation Transformation

Request to plugin is async

User may edit while plugin is thinking

Transform results from plugin

Xi-rope internals

Rope is a specialization of a generic tree

Parametrized on Leaf and NodeInfo

and 3 different specializations of generic tree Rope (Leaf = String) Line breaks (Lead = vec of line breaks offsets) Rich text spans (Leaf = vec of spans; interval)



Xi-rpc today

JSON-RPC Why? JSON implementations are fast An easy dep to satisfy

Threaded design Separate thread blocking on input Inter-thread communication with channels Arc<Mutex<>> to acquire state.



RFC: In Order to Form a More Perfect union

by Josh Triplett

Linux Kernal Virtual Machine

/dev/kvm

Floppy drive, vm security issue.

Unions

Multi storage variables

Different types

Overlapping types

Rust RFC

Community process

Lightweight but not to light

Shepard

Rust team makes approval decisions

#[repr(C)] struct

Crater takes a proposed change to the language, loads the entire cargo env base, and checks for breakage.

Improvements through the RFC process by way of multiple person interaction.

Closing Keynote - Systems Programming with Rust

by Julia Evans

photo by @TedMielczarek

Rules of programming experiments

it doesn’t have to be good

it doesn’t have to work

you have to learn something

photo by _lizbaillie

libdrawf

no idea how it works

terrible API

slow

linker problems

Gimli: A lazy, zero-copy parser for the DWARF debugging format

RustConf 2016 Conclusion

The year the Rust conferences started! The overall vibe was excellent. Everyone was just excited to be there. For me personally the hallway track was very different then the conferences I’m used to. I’m used to hallway chat about apps and gems and web development. The general chatter here was system performance which is out of my normal space. So I learned a lot. As well as sat in on conversations I considered a little over my head.