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.
Audience members will learn the key constraints and mechanisms for implementing an actor system in Rust
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.