What’s Next For Rust? Discover – and Debate – at P99 CONF

Rust has been a trending topic at P99 CONF since day 1 – literally. From Brian Martin opening up the first-ever P99 CONF with, Whoops! I Wrote it in Rust!, to Glauber Costa’s enlightening session Rust Is Safe. But Is It Fast?, to Brian Cantrill’s turbocharged take on Rust, Wright’s Law, and the Future of Low-Latency Systems, Rust has earned and defended its position as a top topic. And given the conference’s focus on low-latency engineering strategies, that’s not surprising.

But what is surprising is the amazing lineup of Rust speakers and topics we’ll be sharing with the community at P99 CONF 2023. In case you’re new to P99 CONF, it’s a free 2-day community event for engineers obsessed with low-latency engineering strategies and performance optimization. It’s intentionally virtual, highly interactive, and purely technical.

Watch P99 CONF Rust Talks On Demand

We’re still figuring out how to fit the 50+ tech talks into an agenda spanning two half days. But we want to share a sneak peek into some of the Rust-focused talks we’ll be featuring – as well as several other (Zig, C++, Go….) talks that might be interesting to even crabby Rustaceans.

Rust Tech Talks

Here’s a look at some of the Rust tech talks you can expect at P99 CONF 2023.

Expanding Horizons: A Case for Rust Higher Up the Stack

Carl Lerche, Principal Engineer at AWS [and Tokio developer]

Historically associated with systems programming due to its roots in Mozilla, Rust’s promise of safety, speed, and concurrency has led to its widespread adoption at the infrastructure level. This rise to prominence raises an intriguing question: Does Rust have a place higher up the stack, an area traditionally dominated by dynamic languages? Conventional wisdom suggests that these upper-tier domains prioritize productivity over raw performance. However, this talk will challenge this notion and explore Rust’s potential benefits to application backend development.

Ingesting in Rust

Armin Ronacher, Principal Architect at Sentry [and Flask framework creator]

At Sentry we handle hundreds of thousands of events a second — from tiny metric to huge memory dump. What started as a small Django application had to be scaled up to support global points of presence, lower latency and significantly higher throughput. This talk walks through our experience building a Rust based ingestion service to replace our Python one, the lessons we have learned and where we made changes from the original design.

Less Wasm

Piotr Sarna, Staff at Turso

The presentation explains why getting rid of WebAssembly is good for your latency. More specifically, it’s a short case study on how to make sure that your WebAssembly code compiled with the Rust toolchain is as small as possible so that it can load faster and consume less resources.

High-Level Rust for Backend Programming

Adam Chalmers, Systems engineer at KittyCAD

Some people say you should only use Rust where you can’t afford to use garbage collection. I disagree — Rust is a great language for writing API servers and backends, due to its high-level libraries, type system, and macros.

5 Hours to 7.7 Seconds: How Database Tricks Sped up Rust Linting Over 2000X

Predrag Gruevski, Querying (Almost) Everything

This is a case study about using database ideas to build a linter that looks for breaking changes in Rust library APIs. Maintainability and performance are key: new Rust releases tend to have mutually-incompatible ways of representing API information, and we cannot afford to reimplement and optimize dozens of rules for each Rust version separately. Fortunately, databases don’t require rewriting queries when the underlying storage format or query plan changes! This allows us to ship massive optimizations and support multiple Rust versions without making any changes to the queries that describe lint rules.

Making Python 100x Faster with Less Than 100 Lines of Rust

Ohad Ravid, Team Lead at Trigo

Python isn’t known as a low latency language. Can we bridge the performance gap using a bit of Rust and some profiling? Learn how the Trigo team was able to bridge the Python-Rust performance gap using just a bit of Rust and some profiling – ultimately improving performance 100x.

But Maybe Rust Isn’t Always the Answer?

Of course, Rust isn’t the only option for low-latency programming. P99 CONF will also feature sessions on rising Rust contender, Zig, as well as low-latency C++, Go, and even Java. For example:

• Running a Go App in Kubernetes: CPU Impacts – Teiva Harsanyi, SRE at Google
• 3 Gb/s L7 Egress Traffic Inspection at TikTok Using Squid & Go on K8s – Daniel Haimanot, Lead Software Engineer at ByteDance / TikTok US
• Practical Go Memory Profiling – William Kennedy, Managing Partner at Ardan Labs
• Low-Latency Programming Tools in Standard C++20 and C++23 – Timur Doumler, Member of the ISO C++ standard committee and JetBrains C++ Dev Advocate
• A Deterministic Walk Down TigerBeetle’s main() Street with Zig – Aleksei Kladov, Staff Software Engineer at TigerBeetle
• Reducing P99 Latencies with Generational ZGC – Stefan Johansson, HotSpot GC Engineer, OpenJDK at Oracle

Join these sessions for a bit of discovery, not to mention friendly debate. 😉

Watch All P99 CONF Talks On Demand