Andrew Stone

Building Actor Systems in Rust: Techniques and Tradeoffs

Distributed Systems Connoisseur @ VMware

Building Actor Systems in Rust: Techniques and Tradeoffs

Rust is a statically typed programming language focused on safety, speed and concurrency.

Rust provides many features of modern programming languages such as abstract data types, pattern matching, lazy iterators, type inference and generics. It provides memory safety and prevents data races at compile time via its unique ownership system, which allows building zero-cost abstractions without garbage collection.

While Rust allows writing clear, concise, and correct code with excellent performance, the nature of its type system provides many choices when implementing an actor system. There are many obstacles that must be overcome when implementing an actor system in a language such as Rust, and many tradeoffs that must be considered along the way. The number of obstacles and tradeoffs grows when we talk about location-transparent actor systems that span multiple nodes and don't run inside a single process.

This talk will discuss the key obstacles to be overcome when building a location-transparent actor system in Rust. It will progress by choosing specific forks in the road, all the while describing the tradeoffs in terms of performance, flexibility, ergonomics, extensibility, and testability of
the actor library being constructed. Along the way, the listener will learn just enough Rust to understand the capabilities and challenges the language provides for building actor systems.

Talk Objectives

Audience members will learn the key constraints and mechanisms for implementing an actor system in Rust

Target Audience

  • Anyone who is curious about how actor systems are implemented in Rust
  • Anyone who has the desire to build their own actor system in Rust
  • Users of other strongly typed programming languages that want tips for constructing actor systems

About Andrew

Andrew has a long history of quickly learning new technologies when they suit his needs and applying them to solve the problems at hand. His interests include distributed systems availability, scalability, reliability, testing and verification. He enjoys implementing the hard stuff with minimal accidental complexity and opportunity for misuse or confusion by users. He works mostly in Rust these days, but still holds dear the actor driven elegance of Erlang.

Github: andrewjstone

Twitter: @andrew_j_stone

Back to conference page