Everything open source
May 16–17, 2016: Training & Tutorials
May 18–19, 2016: Conference
Austin, TX

Rust: Fearless systems programming for the modern developer

Ben Striegel (The Rust Programming Language)
9:00am–12:30pm Tuesday, 05/17/2016
The New Stuff
Location: Ballroom G Level: Intermediate
Average rating: ***..
(3.73, 11 ratings)

Prerequisite knowledge

Attendees should be experienced programmers. Prior exposure to systems-level programming concepts (e.g., C, C++, Go, Swift) is a plus though not absolutely required; Rust is a superb introduction to systems programming for those coming from high-level languages (e.g., JavaScript, Python, Ruby). Feel free to show up in advance if you would like a systems-level primer prior to the tutorial.

Materials or downloads needed in advance

Attendees need a laptop running Linux, Windows, or OS X. Copies of the Rust compiler and Cargo should be installed in advance. Note that WiFi during the conference may be slow, so please begin downloads with ample time before the session. Feel free to show up prior to the beginning of the session if you would like assistance in installing the Rust compiler or in troubleshooting your installation. Local copies of the compiler will be on-hand in case you are unable to access the Internet during the conference.


Originally designed by Mozilla Research for writing the next generation of web browsers, the Rust programming language offers the same degree of control over memory and performance as C and C++, all while ensuring memory safety (at compile time) without resorting to a garbage collector or a managed runtime. Rust programs are free of bugs such as dangling pointers, NULL pointer dereferences, buffer overruns, use-after-frees, double-frees, and iterator invalidation.

These safety guarantees make Rust well-suited for security-sensitive applications, but they also make multithreaded programming much less fraught with peril: Rust ensures (again, at compile time) that threads can never accidentally alias shared mutable state, even as they share data structures among themselves or as they take references to data in other stack frames.

The price, you ask? By moving so many classes of bugs from runtime to compile time, Rust forces you to think hard up front about the use of pointers within your program. Understanding Rust’s concept of ownership can be daunting for newcomers. Ben Striegel leads an active, hands-on introduction to Rust, explaining Rust’s novel characteristics and demonstrating how you can put them to work in your own projects.

Topics include:

  • The principles behind Rust’s novel memory-safety system: ownership, borrowing, and lifetimes
  • Traits—Rust’s principal method of code reuse—and their implications both as interfaces and for type-safe generic programming
  • An introduction to the standard library, with an emphasis on the pieces that are used pervasively in Rust code: iterators, fundamental data structures, error-handling components, and more
  • Rust’s novel and adaptable concurrency features and how to fearlessly scale workloads without the hard-to-debug errors that one typically expects of concurrent programming
  • Standard Rust tooling with a particular focus on the Cargo package manager, which helps you build and test your code, manage dependencies, and publish your libraries to Rust’s central package host
  • How to make cautious and careful use of Rust’s “safety escape hatch” for tasks such as calling into C libraries, writing assembly code, and expressing low-level idioms that are beyond the reach of Rust’s type system
Photo of Ben Striegel

Ben Striegel

The Rust Programming Language

Ben Striegel is one of the earliest members of the Rust community, having stumbled across the language in 2011, and has been an active contributor to the project ever since. Today, Ben is a member of Rust’s official community outreach team and focuses on teaching and mentoring newcomers and interfacing with other open source communities.