Rust Search

The idea of smart robots automating away boring household chores sounds enticing, yet these devices rarely work as advertised: they get stuck, they break down, or are security nightmares. And so it's refreshing to see a company like Matic taking a different approach by attempting to build truly smart, reliable, and privacy-respecting robots. They use Rust for 95% of their codebase, and use camera vision to navigate, vacuum, and mop floors. I sit down with Eric Seppanen, Software Engineer at Matic, to learn about vertical integration in robotics, on-device sensor processing, large Rust codebases, and why Rust is a great language for the problem space.

There are probably only a handful of open-source projects that had a bigger impact on the world than Mozilla Thunderbird. The email client has been around for over two decades and has been a staple for many users (me included). Dealing with a legacy codebase that servers millions of users is no easy feat. The team at MZLA, a subsidiary of Mozilla, has been working hard to modernize the core of Thunderbird by writing new parts in Rust. In this episode, I talk to Brendan Abolivier, a software engineer at MZLA, about the challenges of working on a legacy codebase, the new Rust-based Exchange protocol support, which is the first new protocol in Thunderbird in over a decade, and the future of Thunderbird.

Imagine you're faced with the challenge to build a system that can handle billions of recyclable items per year with the goal of being better than a human at identifying what can be recycled. Material classification is a complex problem that requires a lot of data and a lot of processing power and it is a cutting-edge field of research. Carters Schultz and his colleagues at AMP chose Rust to build the core of this system -- and it worked "shockingly well". In this interview, Carter, charismatic and witty, shares his experience of getting your hands dirty with Rust, and building a cutting-edge production-ready system, which can be now replicated across the world.

In the season premier we talk to none other than Daniel Stenberg! We focus on integrating Rust modules in curl, their benefits, ways in which Rust and Rust crates helped improve curl, but also how curl helped those crates, and where curl is used in the official Rust toolchain. Along the way we also learn about the early history of curl and Rust, which section of your car's owner's-manual you should "re"-read, some weird HTTP edge-cases, and Daniel's experience in open-source maintainership. And don't forget: have fun!

In this episode of Rust in Production, we reflect on the inaugural season, sharing insights from companies pioneering with Rust to shape the future of infrastructure. Starting with Rust's early days before the stable compiler, we chart the language's evolution and its growing adoption in production by leading companies. The episode explores why companies choose Rust, highlighting its unparalleled safety features, concurrency management, and performance that not only drives down costs but significantly enhances user experience. The narrative then shifts to the practicalities of adopting Rust, including learning resources, the importance of community support, and integrating Rust into existing codebases. We discuss the surprisingly positive experience of hiring Rust developers, thanks to the language's appealing prospects. Moreover, the episode delves into Rust's explicit approach to handling complexity, offering a steeper yet rewarding learning curve. We also address the misconception of Rust's limited adoption, revealing its widespread use across various industries and the consensus around certain Rust patterns and libraries. Despite the challenges in showcasing Rust's adoption due to the reticence of some companies to share their stories, the positive feedback from the podcast's audience underscores a keen interest in Rust's real-world applications. Concluding the season, we extend a heartfelt thanks to all guests and listeners, emphasizing the value of sharing Rust experiences and the potential for further growth in the Rust ecosystem. We share a wishlist for the Rust community, including expanded learning resources, improved tooling for production environments, and more public discussions of Rust's benefits. As the show gears up (see what we did there?) for its second season, listeners are encouraged to engage and suggest topics or guests, which could broaden our common understanding of Rust in production.

In an ever-expanding world of microservices, APIs, and devices, maintaining an overview of application states and the myriad errors that can occur is challenging. For years, Sentry has been a go-to choice for developers to monitor their applications and receive notifications about issues within their code. Traditionally, Sentry was predominantly a Python shop, but they became one of the early adopters of Rust in their technology stack. They have been utilizing Rust for a few years now (since at least 2017), starting with sentry-cli, a command-line utility to work with Sentry, and continuing with their source map parsing pipeline, which reduced processing times from 20 seconds to less than 500 milliseconds. More recently, they have been developing two new projects in Rust: relay and symbolicator. Relay acts as a proxy for sending events to Sentry, while symbolicator is a service for handling the symbolication of stack traces. Both projects are open source and available on GitHub. Arpad Borsos (swatinem), Senior Native Platform Engineer at Sentry, sat down with me to discuss their journey with Rust and how it has enabled them to build a cutting-edge monitoring platform for large-scale applications. Our conversation covered topics such as 100x speedups, the Rust-Python interface, and the comparison between actor-based and task-based concurrency.

Have you ever wondered how computers stay in sync with the time? That is the responsibility of the Network Time Protocol (NTP). Around since 1985, NTP is one of the oldest protocols still in use on the internet and its reference implementation, ntpd, written in C, is still widely used today. That's a problem. C is a language that is not memory safe, and ntpd has had its share of security vulnerabilities. Here is a list of CVEs. As part of Project Pendulum, Folkert de Vries and his colleagues from Tweede Golf have been working on a Rust implementation of NTP. I sit down with Folkert to talk about the project, the challenges they faced, and the benefits of using Rust for this kind of project. Along the way, we learn about funding open source projects, the challenges of establishing a new implementation of a protocol, and all sorts of other interesting things that might or might not be related to NTP.

In this episode, we have Micah Wylde from Arroyo as our guest. Micah introduces us to Arroyo, a real-time data processing engine that simplifies stream processing for data engineers using Rust. They explain how Arroyo enables users to write SQL queries with Rust user-defined functions on top of streaming data, highlighting the advantages of real-time data processing and discussing the challenges posed by competitors like Apache Flink. Moving on, we dive into the use of Rust in Arroyo and its benefits in terms of performance and memory safety. We explore the complementarity of workflow engines and stream processors and examine Arroyo's approach to real-time SQL and its compatibility with Postgres. Micah delves into memory and lifetime concerns and elaborates on how Arroyo manages them in its storage layer. Shifting gears, we explore the use of the Tokyo framework in the Arroyo system and how it has enhanced speed and efficiency. Micah shares insights into the challenges and advantages of utilizing Rust, drawing from their experiences with Arroyo projects. Looking ahead, we discuss the future of the Rust ecosystem, addressing the current state of the Rust core and standard library, as well as the challenges of interacting with other languages using FFI or dynamically loading code. We touch upon Rust's limitations regarding a stable ABI and explore potential solutions like WebAssembly. We also touch upon industry perceptions of Rust, investor perspectives, and the hiring process for Rust engineers. The conversation takes us through the crates used in the Arroyo system, our wishlist for Rust ecosystem improvements, and the cost-conscious nature of companies that make Rust an attractive choice in the current macroeconomic environment. As we wrap up, we discuss the challenges Rust faces in competing with slower Java systems and ponder the potential for new languages to disrupt the trend in the future. We touch upon efficiency challenges in application software and the potential for a new language to emerge in this space. We delve into the increasing interest in using Rust in data science and the promising prospects of combining Rust with higher-level languages. Finally, we discuss the importance of fostering a welcoming and drama-free Rust community. I would like to thank Micah for joining us today and sharing their insights. To find more resources related to today's discussion, please refer to the show notes. Stay tuned for our next episode, and thank you for listening!

In this episode, Nicolas, a staff software engineer at Apollo GraphQL, discusses the company's use of GraphQL API technologies. Apollo GraphQL specializes in open-source libraries for both client and server-side applications, with a focus on integrating Rust into their main offerings: the Apollo router and GraphOS cloud. Nicolas explains how the Apollo router consolidates multiple microservices into a single API, efficiently routing requests to appropriate services. He delves into GraphQL's role as an effective query language for APIs, highlighting its ability to provide a comprehensive description of API data and its compatibility with existing data systems. The shift from the JavaScript-based Apollo Gateway to the Rust-based Apollo Router is a key topic, with an emphasis on the performance and safety improvements Rust brings to the table. The conversation covers the use of Rust for the router and GraphQL parser, alongside Kotlin for the management plane and GraphQL for the API. Challenges in stability and reliability are discussed, as well as Rust's advantages in safety and type system consistency. Nicolas shares insights on Async Rust, particularly its impact on productivity and application in CLI tools like Rover. The episode also addresses learning Rust in stages, from basic language concepts to advanced internal mechanisms. It touches on functional patterns in Rust and strategies for effective dependency management. Closing the discussion, Nicolas highlights the inclusive and supportive nature of the Rust community.