https://corrode.dev Friendly, professional Rust consulting and training. Writing content about idiomatic Rust. Zola en Sat, 14 Mar 2026 00:00:00 +0000 Fri, 27 Feb 2026 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/memory-safety/ https://corrode.dev/blog/memory-safety/ <p>If you are responsible for software that powers critical infrastructure, handles sensitive data, or ships to customers in regulated markets, you have to pay attention to the regulatory landscape around software security.</p> <p>Governments around the world are converging on a single message: <strong>memory-unsafe code is a liability</strong>. New regulations, executive guidance, and procurement requirements are making it clear that organizations that don’t act now will face increasing legal, financial, and reputational risk.</p> <p>Rust eliminates the most common class of security vulnerabilities at compile time. That’s not a marketing claim but a technical property of the language, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html">confirmed by Google</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://msrc.microsoft.com/blog/2019/07/we-need-a-safer-systems-programming-language/">Microsoft</a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bidenwhitehouse.archives.gov/oncd/briefing-room/2024/02/26/press-release-technical-report/">the White House</a>.</p> <p>This article lays out the evidence: the regulatory landscape, the mounting pressure from every direction, and why acting now, with expert guidance, is the smartest insurance policy your organization can buy.</p> Thu, 22 Jan 2026 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e09-gama-space/ https://corrode.dev/podcast/s05e09-gama-space/ <div><script id="letscast-player-0efbeff6" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/gama-space-with-sebastian-scholz/player.js?size=s"></script></div> <p>Space exploration demands software that is reliable, efficient, and able to operate in the harshest environments imaginable. When a spacecraft deploys a solar sail millions of kilometers from Earth, there’s no room for memory bugs, race conditions, or software failures. This is where Rust’s robustness guarantees become mission-critical.</p> <p>In this episode, we speak with Sebastian Scholz, an engineer at Gama Space, a French company pioneering solar sail and drag sail technology for spacecraft propulsion and deorbiting. We explore how Rust is being used in aerospace applications, the unique challenges of developing software for space systems, and what it takes to build reliable embedded systems that operate beyond Earth’s atmosphere.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-gama-space">About Gama Space</h3> <p>Gama Space is a French aerospace company founded in 2020 and headquartered in Ivry-sur-Seine, France. The company develops space propulsion and orbital technologies with a mission to keep space accessible. Their two main product lines are solar sails for deep space exploration using the sun’s infinite energy, and drag sails—the most effective way to deorbit satellites and combat space debris. After just two years of R&amp;D, Gama successfully launched their satellite on a SpaceX Falcon 9. The Gama Alpha mission is a 6U cubesat weighing just 11 kilograms that deploys a large 73.3m² sail. With 48 employees, Gama is at the forefront of making space exploration more sustainable and accessible.</p> <h3 id="about-sebastian-scholz">About Sebastian Scholz</h3> <p>Sebastian Scholz is an engineer at Gama Space, where he works on developing software systems for spacecraft propulsion technology. His work involves building reliable, safety-critical embedded systems that must operate flawlessly in the extreme conditions of space. Sebastian brings expertise in systems programming and embedded development to one of the most demanding environments for software engineering.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.satcat.com/sats/55084">GAMA-ALPHA</a> - The demonstration satellite launched in January 2023</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ada-lang.io/">Ada</a> - Safety-focused programming language used in aerospace</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://probe.rs/">probe-rs</a> - Embedded debugging toolkit for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hyper.rs/">hyper</a> - Fast and correct HTTP implementation for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://flutter.dev/">Flutter</a> - Google’s UI toolkit for cross-platform development</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Universal_asynchronous_receiver-transmitter">UART</a> - Very common low level communication protocol</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Hamming_code">Hamming Codes</a> - Error correction used to correct bit flips</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Rexus/Bexus">Rexus/Bexus</a> - European project for sub-orbital experiments by students</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://embassy.dev/">Embassy</a> - The EMBedded ASsYnchronous framework</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/libcsp/libcsp">CSP</a> - The Cubesat Space Protocol</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/num/struct.NonZero.html">std::num::NonZero</a> - A number in Rust that can’t be 0</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/ffi/struct.CString.html">std::ffi::CString</a> - A null-byte terminated String</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s04e07-ksat/">Rust in Production: KSAT</a> - Our episode with Vegard about using Rust for Ground Station operations</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s03e03-oxide/">Rust in Production: Oxide</a> - Our episode with Steve, mentioning Hubris</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/oxidecomputer/hubris">Hubris</a> - Oxide’s embedded operating system</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/zerocopy/latest/zerocopy/">ZeroCopy</a> - Transmute data in-place without allocations</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/mem/fn.transmute.html">std::mem::transmute</a> - Unsafe function to treat a memory section as a different type than before</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.gamaspace.com/">Gama Space Website</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/gamaspace/">Gama Space on LinkedIn</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.crunchbase.com/organization/gama-22d7">Gama Space on Crunchbase</a></li> </ul> Thu, 08 Jan 2026 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e08-radar/ https://corrode.dev/podcast/s05e08-radar/ <div><script id="letscast-player-7e84c99d" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/radar-with-jeff-kao/player.js?size=s"></script></div> <p>Radar processes billions of location events daily, powering geofencing and location APIs for companies like Uber, Lyft, and thousands of other apps. When their existing infrastructure started hitting performance and cost limits, they built HorizonDB, a specialized database which replaced both Elasticsearch and MongoDB with a custom single binary written in Rust and backed by RocksDB.</p> <p>In this episode, we dive deep into the technical journey from prototype to production. We talk about RocksDB internals, finite-state transducers, the intricacies of geospatial indexing with Hilbert curves, and why Rust’s type system and performance characteristics made it the perfect choice for rewriting critical infrastructure that processes location data at massive scale.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-radar">About Radar</h3> <p>Radar is the leading geofencing and location platform, trusted by companies like Uber, Lyft, and thousands of apps to power location-based experiences. Processing billions of location events daily, Radar provides geofencing APIs, geocoding, and location tracking that enables developers to build powerful location-aware applications. Their infrastructure handles massive scale with a focus on accuracy, performance, and reliability.</p> <h3 id="about-jeff-kao">About Jeff Kao</h3> <p>Jeff Kao is a Staff Engineer at Radar, where he led the development of HorizonDB, Radar’s geospatial database written in Rust. His work replaced Elasticsearch and MongoDB with a custom Rust stack built on RocksDB, achieving dramatic improvements in performance and cost efficiency. Jeff has deep experience with geospatial systems and previously open-sourced Node.js TypeScript bindings for Google’s S2 library. He holds a degree from the University of Waterloo.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://radar.com/blog/high-performance-geocoding-in-rust">Radar Blog: High-Performance Geocoding in Rust</a> - The blog post, which describes Radar’s migration from Elasticsearch and MongoDB to Rust and RocksDB</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://foursquare.com/">FourSquare</a> - The company Jeff worked at before</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ruby-lang.org/">Ruby</a> - The basis for Rails</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.pagerduty.com/">PagerDuty)</a> - Another company Jeff worked at. Hes’ been around!</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://coffeescript.org/">CoffeeScript</a> - The first big JavaScript alternative before TypeScript</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.scala-lang.org/">Scala</a> - A functional JVM based language</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/MapReduce">Wikipedia: MapReduce</a> - Distributed application of functional programming</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Algebraic_data_type">Wikipedia: Algebraic Data Types</a> - The concept behind Rust’s Enums, also present in e.g. Scala</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kotlinlang.org/">Kotlin</a> - Easier than Scala, better than Java</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lucene.apache.org/">Apache Lucene</a> - The core of ElasticSearch</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://discord.com/blog/why-discord-is-switching-from-go-to-rust">Discord Blog: Why Discord is switching from Go to Rust</a> - Always the #1 result in searches for Rust migrations</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://radar.com/blog/introducing-horizondb">Radar Blog: Introducing HorizonDB</a> - A really nice write up of Horizon’s architecture</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rocksdb.org/">RocksDB</a> - The primary storage layer used in HorizonDB</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/facebook/mysql-5.6">MyRocks</a> - A MySQL Storage Engine using RocksDB, written by Facebook</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mongodb-partners/mongo-rocks">MongoRocks</a> - A MongoDB Storage Layer using RocksDB</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.cockroachlabs.com/">CockroachDB</a> - PostgreSQL compatible, distributed, SQL Database</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxDB</a> - A timeseries database that used RocksDB at one point, and our very first guest in this Podcast!</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/spacejam/sled">sled</a> - An embedded database written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-rocksdb/rust-rocksdb">rocksdb</a> - Rust bindings for RocksDB</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://h3geo.org/">H3</a> - Uber’s Geo Hashing using hexagons</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://s2geometry.io/">S2</a> - Google’s Geo Hashing library</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Hilbert_curve">Wikipedia: Hilbert Curve</a> - A way to map 2 dimensions onto 1 while retaining proximity</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Finite-state_transducer">Wikipedia: Finite-State Transducer</a> - A state machine used for efficiently looking up if a word exists in the data set</li> <li><a href="/podcast/s04e03-astral/">Rust in Production: Astral</a> - Our episode with Charlie Marsh about tooling for the Python ecosystem</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/BurntSushi">burntsushi</a> - A very prolific Rust developer, now working at Astral</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/BurntSushi/fst">fst</a> - FST crate from burntsushi</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Trie">Wikipedia: Trie</a> - A tree-structure using common prefixes</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Levenshtein_distance">Wikipedia: Levenshtein Distance</a> - The number of letters you have to change, add, or remove to turn word a into word b</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/quickwit-oss/tantivy">tantivy</a> - A full-text search engine, written in Rust, inspired by Lucene</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/microsoft/LightGBM">LightGBM</a> - A gradient boosted tree, similar to a decision tree</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fasttext.cc/">fastText</a> - A text classification library from Meta</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Inverted_index">Wikipedia: Inverted Index</a> - An index used for e.g. full text search</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Okapi_BM25">Wikipedia: Okapi BM25</a> - The ranking algorithm used in tantivy</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Tf%E2%80%93idf">Wikipedia: tf-idf</a> - A classic and simple ranking algorithm</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/RoaringBitmap/roaring-rs">Roaring Bitmaps</a> - A very fast bitset library used in many places</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/blog/simple/">corrode.dev: Be Simple</a> - A sentiment right down Matthias’ alley</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://loco.rs/">loco-rs</a> - Rust on Rails</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://radar.com/">Radar</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://radar.com/blog">Radar Blog</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://radar.com/documentation">Radar Documentation</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/jeffreykao/">Jeff Kao on LinkedIn</a></li> </ul> Thu, 25 Dec 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e07-holiday/ https://corrode.dev/podcast/s05e07-holiday/ <div><script id="letscast-player-43310bc9" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/holiday-episode/player.js?size=s"></script></div> <p>As we close the chapter on 2025 and celebrate our second year of ‘Rust in Production’, it’s time to reflect on the highlights of the 17 episodes since our last holiday special. We looked at Rust from all angles, from cloud infrastructure to embedded systems, and from robotics to satellite technology. One thing that all these stories have in common is the passion and dedication of the Rust community to build faster, safer, and more reliable software.</p> <p>In this special episode, we look back at some of the memorable moments from the past year and celebrate Rust’s achievements. This goes beyond the case studies we’ve covered; it’s about the Rust community as a whole and the state of the Rust ecosystem at the end of 2025.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=AkBnXrKmcvw">Code.Talks Talk</a> - Matthias’ presentation on Rust case studies</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://survey.stackoverflow.co/2025/technology/#admired-and-desired">Stack Overflow Developer Survey 2025</a> - Rust as most admired language since 1.0 release</li> <li><a href="/podcast/s03e07-brave/">Brave with Anton Lazarev (S03E07)</a> - Rust as the go-to language</li> <li><a href="/podcast/s03e08-volvo/">Volvo with Julius Gustavsson (S03E08)</a> - Empowering engineers</li> <li><a href="/podcast/s04e03-astral/">Astral with Charlie Marsh (S04E03)</a> - Welcoming community leads to huge impact</li> <li><a href="/podcast/s05e02-scythe/">Scythe with Andrew Tinka (S05E02)</a> - Confidence in what you build</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lore.kernel.org/all/2025121614-CVE-2025-68260-558d@gregkh/">Rust4Linux CVE</a> - The first CVE in Rust for Linux</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://social.kernel.org/notice/B1JLrtkxEBazCPQHDM">Greg KH post</a> - Context on kernel CVE statistics</li> <li><a href="/podcast/s02e01-curl/">curl with Daniel Stenberg (S02E01)</a> - Bug reports every three hours, code constantly changes</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.social/@bagder/115501681801742424">curl statistics</a> - How old code gets rewritten all the time</li> <li><a href="/podcast/s04e05-tembo/">Tembo with Adam Hendel (S04E05)</a> - Software is never done</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://redis.io/blog/security-advisory-cve-2025-49844/">Redis CVE-2025-49844</a> - Remote code execution vulnerability from use-after-free</li> <li><a href="/podcast/s05e05-canonical/">Canonical with John Seager (S05E05)</a> - Ubuntu is optimistic about Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://security.googleblog.com/2025/11/rust-in-android-move-fast-fix-things.html">Rust in Android</a> - Memory safety vulnerabilities below 20%</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.demandsage.com/android-statistics/">Android statistics</a> - 3.9 billion active devices worldwide</li> <li><a href="/podcast/s05e04-roc/">Roc with Richard Feldman (S05E04)</a> - Focus on the end user</li> <li><a href="/podcast/s04e02-svix/">Svix with Tom Hacohen (S04E02)</a> - Love it, but compile times…</li> <li><a href="/podcast/s05e01-prime-video/">Prime Video with Alexandru Ene (S05E01)</a> - Build times need to improve</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/">crates.io</a> - 200 billion crate downloads and 200k published crates</li> <li><a href="/podcast/s05e03-cloudflare/">Cloudflare with Kevin Guthrie and Edward Wang (S05E03)</a> - Ecosystem is fantastic; thanks to all maintainers</li> <li><a href="/blog/rust-conferences-2026/">Rust Conferences 2026</a> - Complete list of upcoming Rust conferences</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=aZ5sfhGmEVU">CodeCrafters Course</a> - Build your own HTTP server in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2025/12/16/Project-Goals-2025-November-Update.md/">Rust Project Goals</a> - November update on 41 active project goals</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/cargo/issues/12207">cargo-script RFC</a> - Run Rust scripts without full Cargo projects</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-project-goals/issues/389">Better pin ergonomics RFC</a> - Improving async Rust ergonomics</li> <li><a href="/podcast/s04e07-ksat/">KSAT with Vegard Sandengen (S04E07)</a> - Make async better</li> <li><a href="/podcast/s04e06-1password/">1Password with Andrew Burkhart (S04E06)</a> - Make it easier to learn Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-book.cs.brown.edu/">Rust Book by Brown University</a> - Interactive learning resource for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html">Clippy lints</a> - All available linter rules for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-project-goals/blob/main/src/2025h2/interop-problem-map.md">C++ and Rust interop</a> - Safer language interoperability initiative</li> <li><a href="/podcast/s04e01-microsoft/">Microsoft with Victor Ciura (S04E01)</a> - C++ doesn’t have to die for Rust to succeed</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://borrowsanitizer.com/">BorrowSanitizer initiative</a> - LLVM instrumentation for detecting aliasing violations</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-project-goals/issues/118">Polonius</a> - Next-generation borrow checker</li> <li><a href="/podcast/s04e04-rust/">Rust with Niko Matsakis (S04E04)</a> - Be excellent to each other (Bill &amp; Ted reference)</li> </ul> Thu, 11 Dec 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e06-rust4linux/ https://corrode.dev/podcast/s05e06-rust4linux/ <div><script id="letscast-player-e15636c5" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust4linux-with-danilo-krummrich/player.js?size=s"></script></div> <p>Bringing Rust into the Linux kernel is one of the most ambitious modernization efforts in open source history. The Linux kernel, with its decades of C code and deeply ingrained development practices, is now opening its doors to a memory-safe language. It’s the first time in over 30 years that a new programming language has been officially adopted for kernel development. But the journey is far from straightforward.</p> <p>In this episode, we speak with Danilo Krummrich, Linux kernel maintainer and Rust for Linux core team member, about the groundbreaking work of integrating Rust into the Linux kernel. Among other things, we talk about the Nova GPU driver, a Rust-based successor to Nouveau for NVIDIA graphics cards, and discuss the technical challenges and cultural shifts required for large-scale Rust adoption in the kernel as well as the future of the Rust4Linux project.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-rust-for-linux">About Rust for Linux</h3> <p>Rust for Linux is a project aimed at bringing the Rust programming language into the Linux kernel. Started to improve memory safety and reduce vulnerabilities in kernel code, the project has been gradually building the infrastructure, abstractions, and tooling necessary for Rust to coexist with the kernel’s existing C codebase.</p> <h3 id="about-danilo-krummrich">About Danilo Krummrich</h3> <p>Danilo Krummrich is a software engineer at Red Hat and a core contributor to the Rust for Linux project. His fundamental contribution to Rust for Linux is the driver-core infrastructure, the foundational framework that makes it possible to write drivers in Rust at all. This includes both C and Rust code that provides the core abstractions for device drivers in the kernel. Danilo is a maintainer for multiple critical kernel subsystems, including Driver Core, DRM (GPUVM, Rust, GPU Scheduler), GPU drivers for NVIDIA GPUs (Nova, Nouveau), Firmware Loader API, as well as Rust bindings for PCI, DMA, and ALLOC. He is the primary developer of the Nova GPU driver, a fully Rust-based driver for modern NVIDIA GPUs.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://source.android.com/">AOSP</a> - The Android Open Source Project</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lore.kernel.org/">Kernel Mailing Lists</a> - Where the Linux development happens</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ojeda.dev/">Miguel Ojeda</a> - Rust4Linux maintainer</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/wedsonaf">Wedson Almeida Filho</a> - Retired Rust4Linux maintainer</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.kernel.org/gpu/nouveau.html">nouveau driver</a> - The old driver for NVIDIA GPUs</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Vulkan">Vulkan</a> - A low level graphics API</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.mesa3d.org/">Mesa</a> - Vulkan and OpenGL implementation for Linux</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Virtual_method_table">vtable</a> - Indirect function call, a source of headaches in nouveau</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.kernel.org/gpu/introduction.html">DRM</a> - Direct Rendering Manager, Linux subsystem for all things graphics</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Monolithic_kernel">Monolithic Kernel</a> - Linux’ kernel architecture</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cliffle.com/blog/rust-typestate/">The Typestate Pattern in Rust</a> - A very nice way to model state machines in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/pinned-init">pinned-init</a> - The userspace crate for pin-init</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustfmt">rustfmt</a> - Free up space in your brain by not thinking about formatting</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.kernel.org/dev-tools/kunit/index.html">kunit</a> - Unit testing framework for the kernel</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/core/index.html">Rust core crate</a> - The only part of the Rust Standard Library used in the Linux kernel</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Gnurou">Alexandre Courbot</a> - NVIDIA employed co-maintainer of nova-core</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://www.kroah.com/linux/">Greg Kroah-Hartman</a> - Linux Foundation fellow and major Linux contributor</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/airlied">Dave Airlie</a> - Maintainer of the DRM tree</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.vim.org/">vim</a> - not even neovim</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://www.mutt.org/">mutt</a> - classic terminal e-mail client</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aerc-mail.org/">aerc</a> - a pretty good terminal e-mail client</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-for-linux.com/contact#zulip-chat">Rust4Linux Zulip</a> - The best entry point for the Rust4Linux community</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Rust-for-Linux">Rust for Linux GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dakr">Danilo Krummrich on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/danilo-krummrich-796885153/">Danilo Krummrich on LinkedIn</a></li> </ul> Thu, 27 Nov 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e05-canonical/ https://corrode.dev/podcast/s05e05-canonical/ <div><script id="letscast-player-84d68eec" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/canonical-with-jon-seager-ea273862-48ff-40d8-b3d6-bc85c680a3a6/player.js?size=s"></script></div> <p>What does it take to rewrite the foundational components of one of the world’s most popular Linux distributions? Ubuntu serves over 12 million daily desktop users alone, and the systems that power it, from sudo to core utilities, have been running for decades with what Jon Seager, VP of Engineering for Ubuntu at Canonical, calls “shaky underpinnings.”</p> <p>In this episode, we talk to Jon about the bold decision to “oxidize” Ubuntu’s foundation. We explore why they’re rewriting critical components like sudo in Rust, how they’re managing the immense risk of changing software that millions depend on daily, and what it means to modernize a 20-year-old operating system without breaking the internet.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-canonical">About Canonical</h3> <p>Canonical is the company behind Ubuntu, one of the most widely-used Linux distributions in the world. From personal desktops to cloud infrastructure, Ubuntu powers millions of systems globally. Canonical’s mission is to make open source software available to people everywhere, and they’re now pioneering the adoption of Rust in foundational system components to improve security and reliability for the next generation of computing.</p> <h3 id="about-jon-seager">About Jon Seager</h3> <p>Jon Seager is VP Engineering for Ubuntu at Canonical, where he oversees the Ubuntu Desktop, Server, and Foundations teams. Appointed to this role in January 2025, Jon is driving Ubuntu’s modernization strategy with a focus on Communication, Automation, Process, and Modernisation. His vision includes adopting memory-safe languages like Rust for critical infrastructure components. Before this role, Jon spent three years as VP Engineering building Juju and Canonical’s catalog of charms. He’s passionate about making Ubuntu ready for the next 20 years of computing.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://juju.is/">Juju</a> - Jon’s previous focus, a cloud orchestration tool</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.gnu.org/software/coreutils/">GNU coretuils</a> - The widest used implementation of commands like ls, rm, cp, and more</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/uutils/coreutils">uutils coreutils</a> - coreutils implementation in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/trifectatechfoundation/sudo-rs">sudo-rs</a> - For your Rust based sandwiches needs</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Long-term_support">LTS</a> - Long Term Support, a release model popularized by Ubuntu</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://git.launchpad.net/~juliank/+git/coreutils-from/tree/debian/coreutils-from-uutils.links?h=main">coreutils-from-uutils</a> - List of symbolic links used for coreutils on Ubuntu, some still point to the GNU implementation</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://manpages.ubuntu.com/manpages/noble/en/man8/sudo.8.html#:~:text=%2DE%2C%20%2D%2Dpreserve%2Denv">man: sudo -E</a> - Example of a feature that sudo-rs does not support</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Single_instruction%2C_multiple_data">SIMD</a> - Single instruction, multiple data</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://packages.ubuntu.com/noble/rust-coreutils">rust-coreutils</a> - The Ubuntu package with all it’s supported CPU platforms listed</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://endler.dev/2018/fastcat/">fastcat</a> - Matthias’ blogpost about his faster version of <code>cat</code></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.freedesktop.org/software/systemd/man/devel/run0.html">systemd-run0</a> - Alternative approach to sudo from the systemd project</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://apparmor.net/">AppArmor</a> - The Linux Security Module used in Ubuntu</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/linux-pam/linux-pam">PAM</a> - The Pluggable Authentication Modules, which handles all system authentication in Linux</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sssd.io/">SSSD</a> - Enables LDAP user profiles on Linux machines</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pendulum-project/ntpd-rs">ntpd-rs</a> - Timesynchronization daemon written in Rust which may land in Ubuntu 26.04</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://trifectatech.org/">Trifecta Tech Foundation</a> - Foundation supporting sudo-rs development</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sequoia-pgp.org/">Sequioa PGP</a> - OpenPGP tools written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mir-server.io/">Mir</a> - Canonicals wayland compositor library, uses some Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/anbox-cloud">Anbox Cloud</a> - Canonical’s Android streaming platform, includes Rust components</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/morphis">Simon Fels</a> - Original creator of Anbox and Anbox Cloud team lead at Canonical</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/lxd">LXD</a> - Container and VM hypervisor</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/dqlite">dqlite</a> - SQLite with a replication layer for distributed use cases, potentially being rewritten in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-for-linux.com/">Rust for Linux</a> - Project to add Rust support to the Linux kernel</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-for-linux.com/nova-gpu-driver">Nova GPU Driver</a> - New Linux OSS driver for NVIDIA GPUs written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ubuntuasahi.org/">Ubuntu Asahi</a> - Community project for Ubuntu on Apple Silicon</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lists.debian.org/debian-devel/2025/10/msg00285.html">debian-devel: Hard Rust requirements from May onward</a> - Parts of apt are being rewritten in Rust (announced a month after the recording of this episode)</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pkg.go.dev/std">Go Standard Library</a> - Providing things like network protocols, cryptographic algorithms, and even tools to handle image formats</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.python.org/3/library/">Python Standard Library</a> - The origin of “batteries included”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/std/index.html#what-is-in-the-standard-library-documentation">The Rust Standard Library</a> - Basic types, collections, filesystem access, threads, processes, synchronisation, and not much more</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/clap-rs/clap">clap</a> - Superstar library for CLI option parsing</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://serde.rs/">serde</a> - Famous high-level serilization and deserialization interface crate</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/">Canonical</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ubuntu.com/">Ubuntu</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://jnsgr.uk/">Jon Seager’s Website</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://jnsgr.uk/2025/02/engineering-ubuntu-for-the-next-20-years/">Jon’s Blog: Engineering Ubuntu For The Next 20 Years</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/blog">Canonical Blog</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ubuntu.com/blog">Ubuntu Blog</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://canonical.com/careers/engineering">Canonical Careers: Engineering</a> - Apply your Rust skills in the Linux ecosystem</li> </ul> Thu, 13 Nov 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e04-roc/ https://corrode.dev/podcast/s05e04-roc/ <div><script id="letscast-player-080f1fca" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/roc-with-richard-feldman/player.js?size=s"></script></div> <p>Building a new programming language from scratch is a monumental undertaking. In this episode, we talk to Richard Feldman, creator of the Roc programming language, about building a functional language that is fast, friendly, and functional. We discuss why the Roc team moved away from using Rust as a host language and instead is in the process of migrating to Zig. What was the decision-making process like? What can Rust learn from this decision? And how does Zig compare to Rust for this kind of systems programming work?</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-roc">About Roc</h3> <p>Roc is a fast, friendly, functional programming language currently in alpha development. It’s a single-paradigm functional language with 100% type inference that compiles to machine code or WebAssembly. Roc takes inspiration from Elm but extends those ideas beyond the frontend, introducing innovations like platforms vs applications, opportunistic mutation, and purity inference. The language features static dispatch, a small set of simple primitives that work well together, and excellent compiler error messages. Roc is already being used in production by companies like Vendr, and is supported by a nonprofit foundation with corporate and individual sponsors.</p> <h3 id="about-richard-feldman">About Richard Feldman</h3> <p>Richard Feldman is the creator of the Roc programming language and author of “Elm in Action.” He works at Zed Industries and has extensive experience with functional programming, particularly Elm. Richard is also the host of Software Unscripted, a weekly podcast featuring casual conversations about code with programming language creators and industry experts. He’s a frequent conference speaker and teacher, with courses available on Frontend Masters. Richard has been a longtime contributor to the functional programming community and previously worked at NoRedInk building large-scale Elm applications.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ziglang.org/">Zig</a> - Better than Rust?</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s03e01-zed/">Rust in Production: Zed</a> - Our interview with Richard’s colleague with more details about Zed</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://gist.github.com/rtfeldman/77fb430ee57b42f5f2ca973a3992532f">Richards blogpost about migrating from Rust to Zig</a> - Sent in by many listeners</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://elm-lang.org/">Elm</a> - Initial inspiration for Roc</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.noredink.com/">NoRedInk</a> - Richard’s first experience with Elm</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.haskell.org/">Haskell</a> - A workable Elm on the backend substitute</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ocaml.org/">OCaml</a> - Functional language, but pure functions only encouraged</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fsharp.org/">F#</a> - Similar shortcomings as OCaml</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/evancz">Evan Czaplicki</a> - Creator of Elm</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ghostty.org/">Ghostty</a> - Terminal emulator from Mitchel Hashimoto with lots of code contributions in Zig</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/bumpref">bumpref</a> - A tiny Rust crate that came out of this discussion, providing <code>Arc::bump()</code>, which is an alias for <code>clone()</code>.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization">RAII</a> - Resource acquisition is initialization, developed for C++, now a core part of Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://frontendmasters.com/courses/rust/">Frontend Masters: The Rust Programming Language</a> - Richard’s course teaching Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/conversion/from_into.html">Rust by Example: From and Into</a> - Traits for ergonomic initialising of objects in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/book/ch10-03-lifetime-syntax.html#lifetime-annotations-in-struct-definitions">The Rust Programming Language: Lifetime Annotations on Struct Definitions</a> - Learn from Roc: try to avoid having lifetime type parameters</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/std/box.html#box-stack-and-heap">Rust By Example: Box, stack and heap</a> - Putting objects on the heap can slow down your application</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Design_Patterns">Design Patterns: Elements of Reusable Object-Oriented Software</a> - Seminal book popularising many common patterns in use today, written by the so-called “Gang of Four”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=wo84LFzx5nI">Casey Muratori: The Big OOPs</a> - Game developer explaining why OOP was an obvious mistake for high performance code</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Alan_Kay">Alan Kay</a> - Coined the term “object-oriented” while developing the Smalltalk language in the 70s</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Niklaus_Wirth">Niklaus Wirth</a> - Working on Modula, a modular programming language, at the same time</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kotlinlang.org/">Kotlin</a> - A new and popular language, basically Java++</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://go.dev/">Go</a> - Popular “greenfield” language, i.e. not coupled to an existing language, not using the object oriented paradigm</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustc_codegen_cranelift">Cranelift backend for Rust</a> - A faster backend than LLVM, but still not released</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://andrewkelley.me/">Andrew Kelly</a> - Creator of Zig</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pod.link/1602572955">Software Unscripted</a> - Richard’s Podcast</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.gpui.rs/">GPUI</a> - Zed’s own UI crate</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/AoS_and_SoA">Structure of Arrays vs Array of structures</a> - A big source of unsafe code in the Rust implementation of Roc</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ziglang.org/documentation/0.15.2/#comptime">The Zig Programming Language: comptime</a> - Zig’s replacement for Rust’s proc-macros, with much broader utility</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/crabtime/latest/crabtime/">crabtime</a> - Comptime crate for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Roc_(mythology)">Roc</a> - Roc’s namesake, the mythical bird</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s01e05-tweede-golf/">Rust in Production: Tweede Golf</a> - Podcast episode with Volkert de Vries, one of the first contributors to Roc</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.roc-lang.org/">Roc Programming Language</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/roc-lang/roc">Roc on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rtfeldman">Richard Feldman on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/rtfeldman/">Richard Feldman on LinkedIn</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rtfeldman">Richard Feldman on X</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pod.link/1602572955">Software Unscripted Podcast</a></li> </ul> Sat, 08 Nov 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/defensive-programming/ https://corrode.dev/blog/defensive-programming/ <p>I have a hobby.</p> <p>Whenever I see the comment <code>// this should never happen</code> in code, I try to find out the exact conditions under which <em>it could</em> happen. And in 90% of cases, I find a way to do just that. More often than not, the developer just hasn’t considered all edge cases or future code changes.</p> <p>In fact, the reason why I like this comment so much is that it often <strong>marks the exact spot</strong> where strong guarantees fall apart. Often, violating implicit invariants that aren’t enforced by the compiler are the root cause.</p> <p>Yes, the compiler prevents memory safety issues, and the standard library is best-in-class. But even the standard library <a href="/blog/pitfalls-of-safe-rust">has its warts</a> and bugs in business logic can still happen.</p> <p>All we can work with are hard-learned patterns to write more defensive Rust code, learned throughout years of shipping Rust code to production. I’m not talking about design patterns here, but rather small idioms, which are rarely documented, but make a big difference in the overall code quality.</p> <h2 id="code-smell-indexing-into-a-vector"><a class="zola-anchor" href="#code-smell-indexing-into-a-vector" aria-label="Anchor link for: code-smell-indexing-into-a-vector">Code Smell: Indexing Into a Vector</a></h2> <p>Here’s some innocent-looking code:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">if !</span><span>matching_users</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> existing_user</span><span style="color: #FF79C6;"> = &amp;</span><span>matching_users[</span><span style="color: #BD93F9;">0</span><span>];</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>What if you refactor it and forget to keep the <code>is_empty()</code> check? The problem is that the vector indexing is decoupled from checking the length. So <code>matching_users[0]</code> can panic at runtime if the vector is empty.</p> <p>Checking the length and indexing are two separate operations, which can be changed independently. That’s our first implicit invariant that’s not enforced by the compiler.</p> <p>If we use slice pattern matching instead, we’ll only get access to the element if the correct <code>match</code> arm is executed.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span> matching_users</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">as_slice</span><span>() {</span></span> <span class="giallo-l"><span> []</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> todo!</span><span>(</span><span style="color: #F1FA8C;">&quot;What to do if no users found!?&quot;</span><span>),</span></span> <span class="giallo-l"><span> [existing_user]</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> // Safe! Compiler guarantees exactly one element</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // No need to index into the vector,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // we can directly use `existing_user` here </span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">RepositoryError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">DuplicateUsers</span><span>)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Note how this automatically uncovered one more edge case: what if the list is empty? We hadn’t explicitly considered this case before. The compiler-enforced pattern matching requires us to think about all possible states! This is a common pattern in all robust Rust code: putting the compiler in charge of enforcing invariants.</p> <h2 id="code-smell-lazy-use-of-default"><a class="zola-anchor" href="#code-smell-lazy-use-of-default" aria-label="Anchor link for: code-smell-lazy-use-of-default">Code Smell: Lazy use of <code>Default</code></a></h2> <p>When initializing an object with many fields, it’s tempting to use <code>..Default::default()</code> to fill in the rest. In practice, this is a common source of bugs. You might forget to explicitly set a new field later when you add it to the struct (thus using the default value instead, which might not be what you want), or you might not be aware of all the fields that are being set to default values.</p> <p>Instead of this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> foo</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span> value1,</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span> value2,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> ..</span><span style="color: #8BE9FD;font-style: italic;">Default</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">default</span><span>()</span><span style="color: #6272A4;"> // Implicitly sets all other fields</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Do this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> foo</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span> value1,</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span> value2,</span></span> <span class="giallo-l"><span> field3</span><span style="color: #FF79C6;">:</span><span> value3,</span><span style="color: #6272A4;"> // Explicitly set all fields</span></span> <span class="giallo-l"><span> field4</span><span style="color: #FF79C6;">:</span><span> value4,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Yes, it’s slightly more verbose, but what you gain is that the compiler will force you to handle all fields explicitly. Now when you add a new field to <code>Foo</code>, the compiler will remind you to set it here as well and reflect on which value makes sense.</p> <p>If you still prefer to use <code>Default</code> but don’t want to lose compiler checks, you can also destructure the default instance:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span> { field1, field2, field3, field4 }</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">default</span><span>();</span></span></code></pre> <p>This way, you get all the default values assigned to local variables and you can still override what you need:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> foo</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span> value1,</span><span style="color: #6272A4;"> // Override what you need</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span> value2,</span><span style="color: #6272A4;"> // Override what you need</span></span> <span class="giallo-l"><span> field3,</span><span style="color: #6272A4;"> // Use default value</span></span> <span class="giallo-l"><span> field4,</span><span style="color: #6272A4;"> // Use default value</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>This pattern gives you the best of both worlds:</p> <ul> <li>You get default values without duplicating default logic</li> <li>The compiler will complain when new fields are added to the struct</li> <li>Your code automatically adapts when default values change</li> <li>It’s clear which fields use defaults and which have custom values</li> </ul> <h2 id="code-smell-fragile-trait-implementations"><a class="zola-anchor" href="#code-smell-fragile-trait-implementations" aria-label="Anchor link for: code-smell-fragile-trait-implementations">Code Smell: Fragile Trait Implementations</a></h2> <p>Completely destructuring a struct into its components can also be a defensive strategy for API adherence. For example, let’s say you’re building a pizza ordering system and have an order type like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> PizzaOrder</span><span> {</span></span> <span class="giallo-l"><span> size</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PizzaSize</span><span>,</span></span> <span class="giallo-l"><span> toppings</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Topping</span><span>&gt;,</span></span> <span class="giallo-l"><span> crust_type</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> CrustType</span><span>,</span></span> <span class="giallo-l"><span> ordered_at</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> SystemTime</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>For your order tracking system, you want to compare orders based on what’s actually on the pizza - the <code>size</code>, <code>toppings</code>, and <code>crust_type</code>. The <code>ordered_at</code> timestamp shouldn’t affect whether two orders are considered the same.</p> <p>Here’s the problem with the obvious approach:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> PartialEq</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> PizzaOrder</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> eq</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, other</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>size </span><span style="color: #FF79C6;">==</span><span> other</span><span style="color: #FF79C6;">.</span><span>size </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> &amp;&amp;</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>toppings </span><span style="color: #FF79C6;">==</span><span> other</span><span style="color: #FF79C6;">.</span><span>toppings </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> &amp;&amp;</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>crust_type </span><span style="color: #FF79C6;">==</span><span> other</span><span style="color: #FF79C6;">.</span><span>crust_type</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Oops! What happens when we add extra_cheese or delivery_address later?</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now imagine your team adds a field for customization options:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> PizzaOrder</span><span> {</span></span> <span class="giallo-l"><span> size</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PizzaSize</span><span>,</span></span> <span class="giallo-l"><span> toppings</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Topping</span><span>&gt;,</span></span> <span class="giallo-l"><span> crust_type</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> CrustType</span><span>,</span></span> <span class="giallo-l"><span> ordered_at</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> SystemTime</span><span>,</span></span> <span class="giallo-l"><span> extra_cheese</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span><span style="color: #6272A4;"> // New field added</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Your <code>PartialEq</code> implementation still compiles, but is it correct? Should <code>extra_cheese</code> be part of the equality check? Probably yes - a pizza with extra cheese is a different order! But you’ll never know because the compiler won’t remind you to think about it.</p> <p>Here’s the defensive approach using destructuring:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> PartialEq</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> PizzaOrder</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> eq</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, other</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span> size,</span></span> <span class="giallo-l"><span> toppings,</span></span> <span class="giallo-l"><span> crust_type,</span></span> <span class="giallo-l"><span> ordered_at</span><span style="color: #FF79C6;">:</span><span> _,</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span> size</span><span style="color: #FF79C6;">:</span><span> other_size,</span></span> <span class="giallo-l"><span> toppings</span><span style="color: #FF79C6;">:</span><span> other_toppings,</span></span> <span class="giallo-l"><span> crust_type</span><span style="color: #FF79C6;">:</span><span> other_crust,</span></span> <span class="giallo-l"><span> ordered_at</span><span style="color: #FF79C6;">:</span><span> _,</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> =</span><span> other;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> size</span><span style="color: #FF79C6;"> ==</span><span> other_size</span><span style="color: #FF79C6;"> &amp;&amp;</span><span> toppings</span><span style="color: #FF79C6;"> ==</span><span> other_toppings</span><span style="color: #FF79C6;"> &amp;&amp;</span><span> crust_type</span><span style="color: #FF79C6;"> ==</span><span> other_crust</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now when someone adds the <code>extra_cheese</code> field, this code won’t compile anymore. The compiler forces you to decide: should <code>extra_cheese</code> be included in the comparison or explicitly ignored with <code>extra_cheese: _</code>?</p> <p>This pattern works for any trait implementation where you need to handle struct fields: <code>Hash</code>, <code>Debug</code>, <code>Clone</code>, etc. It’s especially valuable in codebases where structs evolve frequently as requirements change.</p> <h2 id="code-smell-from-impls-that-are-really-tryfrom"><a class="zola-anchor" href="#code-smell-from-impls-that-are-really-tryfrom" aria-label="Anchor link for: code-smell-from-impls-that-are-really-tryfrom">Code Smell: <code>From</code> Impls That Are Really <code>TryFrom</code></a></h2> <p>Sometimes there’s no conversion that will work 100% of the time. That’s fine. When that’s the case, resist the temptation to offer a <code>From</code> implementation out of habit; use <code>TryFrom</code> instead.</p> <p>Here’s an example of <code>TryFrom</code> in disguise:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> From</span><span>&lt;</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">DetectorStartupErrorReport</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> DetectorStartupErrorSubject</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> from</span><span>(report</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">DetectorStartupErrorReport</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> postfix</span><span style="color: #FF79C6;"> =</span><span> report</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">get_identifier</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">or_else</span><span>(get_binary_name)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span style="color: #BD93F9;"> UNKNOWN_DETECTOR_SUBJECT</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">StreamSubject</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> format!</span><span>(</span><span style="color: #F1FA8C;">&quot;apps.errors.detectors.startup.{postfix}&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">as_str</span><span>(),</span></span> <span class="giallo-l"><span> ))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The <code>unwrap_or_else</code> is a hint that this conversion can fail in some way. We set a default value instead, but is it really the right thing to do for all callers? This should be a <code>TryFrom</code> implementation instead, making the fallible nature explicit. We fail fast instead of continuing with a potentially flawed business logic.</p> <h2 id="code-smell-non-exhaustive-matches"><a class="zola-anchor" href="#code-smell-non-exhaustive-matches" aria-label="Anchor link for: code-smell-non-exhaustive-matches">Code Smell: Non-Exhaustive Matches</a></h2> <p>It’s tempting to use <code>match</code> in combination with a catch-all pattern like <code>_ =&gt; {}</code>, but this can haunt you later. The problem is that you might forget to handle a new case that was added later.</p> <p>Instead of:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant1</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant2</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* catch-all */</span><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Use:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant1</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant2</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant3</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant4</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>By spelling out all variants explicitly, the compiler will warn you when a new variant is added, forcing you to handle it. Another case of putting the compiler to work.</p> <p>If the code for two variants is the same, you can group them:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant1</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant2</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant3</span><span style="color: #FF79C6;"> |</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Variant4</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* shared logic */</span><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="code-smell-placeholders-for-unused-variables"><a class="zola-anchor" href="#code-smell-placeholders-for-unused-variables" aria-label="Anchor link for: code-smell-placeholders-for-unused-variables">Code Smell: <code>_</code> Placeholders for Unused Variables</a></h2> <p>Using <code>_</code> as a placeholder for unused variables can lead to confusion. For example, you might get confused about which variable was skipped. That’s especially true for boolean flags:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Rocket</span><span> { _, _,</span><span style="color: #FF79C6;"> ..</span><span> }</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In the above example, it’s not clear which variables were skipped and why. Better to use descriptive names for the variables that are not used:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Rocket</span><span> { has_fuel</span><span style="color: #FF79C6;">:</span><span> _, has_crew</span><span style="color: #FF79C6;">:</span><span> _,</span><span style="color: #FF79C6;"> ..</span><span> }</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span><span style="color: #6272A4;"> /* ... */</span><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Even if you don’t use the variables, it’s clear what they represent and the code becomes more readable and easier to review without inline type hints.</p> <h2 id="pattern-temporary-mutability"><a class="zola-anchor" href="#pattern-temporary-mutability" aria-label="Anchor link for: pattern-temporary-mutability">Pattern: Temporary Mutability</a></h2> <p>If you only want your data to be mutable temporarily, make that explicit.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_vec</span><span>();</span></span> <span class="giallo-l"><span>data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sort</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> data</span><span style="color: #FF79C6;"> =</span><span> data;</span><span style="color: #6272A4;"> // Shadow to make immutable</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Here `data` is immutable.</span></span></code></pre> <p>This pattern is often called “temporary mutability” and helps prevent accidental modifications after initialization. See the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/patterns/idioms/temporary-mutability.html">Rust unofficial patterns book</a> for more details.</p> <p>You can go one step further and do the initialization part in a scope block:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> data</span><span style="color: #FF79C6;"> =</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_vec</span><span>();</span></span> <span class="giallo-l"><span> data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sort</span><span>();</span></span> <span class="giallo-l"><span> data</span><span style="color: #6272A4;"> // Return the final value</span></span> <span class="giallo-l"><span>};</span></span> <span class="giallo-l"><span style="color: #6272A4;">// Here `data` is immutable</span></span></code></pre> <p>This way, the mutable variable is confined to the inner scope, making it clear that it’s only used for initialization. In case you use any temporary variables during initialization, they won’t leak into the outer scope. In our case above, there were none, but imagine if we had a temporary vector to hold intermediate results:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> data</span><span style="color: #FF79C6;"> =</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_vec</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> temp</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> compute_something</span><span>();</span></span> <span class="giallo-l"><span> data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extend</span><span>(temp);</span></span> <span class="giallo-l"><span> data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sort</span><span>();</span></span> <span class="giallo-l"><span> data</span><span style="color: #6272A4;"> // Return the final value</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Here, <code>temp</code> is only accessible within the inner scope, which prevents it from accidental use later on.</p> <p>This is especially useful when you have multiple temporary variables during initialization that you don’t want accessible in the rest of the function. The scope makes it crystal clear that these variables are only meant for initialization.</p> <h2 id="pattern-defensively-handle-constructors"><a class="zola-anchor" href="#pattern-defensively-handle-constructors" aria-label="Anchor link for: pattern-defensively-handle-constructors">Pattern: Defensively Handle Constructors</a></h2> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Tip for libraries</p> </h4> </div> <p>The following pattern is only truly helpful for libraries and APIs that need to be robust against future changes. In such a case, you want to ensure that all instances of a type are created through a constructor function that enforces validation logic. Because without that, future refactorings can easily lead to invalid states.</p> <p>For application code, it’s probably best to keep things simple. You typically have all the call sites under control and can ensure that validation logic is always called.</p> </div> <p>Let’s say you have a simple type like the following:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now you want to add validation logic to ensure invalid states are never created. One pattern is to return a <code>Result</code> from the constructor:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>, field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field1</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field1 cannot be empty&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field2</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 0</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field2 cannot be zero&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { field1, field2 })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>But nothing stops someone from bypassing your validation by creating an instance directly:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> s</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(),</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span><span>,</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>This should not be possible! It is our implicit invariant that’s not enforced by the compiler: the validation logic is decoupled from struct construction. These are two separate operations, which can be changed independently and the compiler won’t complain.</p> <p>To force <strong>external code</strong> to go through your constructor, add a private field:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span> _private</span><span style="color: #FF79C6;">:</span><span> (),</span><span style="color: #6272A4;"> // This prevents external construction </span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>, field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field1</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field1 cannot be empty&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field2</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 0</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field2 cannot be zero&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { field1, field2, _private</span><span style="color: #FF79C6;">:</span><span> () })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now code outside your module cannot construct <code>S</code> directly because it cannot access the <code>_private</code> field. The compiler enforces that all construction must go through your <code>new()</code> method, which includes your validation logic!</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Why the underscore in <code>_private</code>?</p> </h4> </div> <p>Note that the underscore prefix is just a <strong>naming convention</strong> to indicate the field is intentionally unused; it’s the lack of <code>pub</code> that makes it private and prevents external construction.</p> </div> <p>For libraries that need to evolve over time, you can also use the <code>#[non_exhaustive]</code> attribute instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[non_exhaustive]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This has the same effect of preventing construction outside your crate, but also signals to users that you might add more fields in the future. The compiler will prevent them from using struct literal syntax, forcing them to use your constructor.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p><code>Should you use #[non_exhaustive]</code> or <code>_private</code>?</p> </h4> </div> <p>There’s a big difference between these two approaches:</p> <ul> <li><code>#[non_exhaustive]</code> only works across crate boundaries. <strong>It prevents construction outside your crate.</strong></li> <li><code>_private</code> works at the module boundary. <strong>It prevents construction outside the module</strong>, but within the same crate.</li> </ul> <p>On top of that, some developers find <code>_private: ()</code> more explicit about intent: “this struct has a private field that prevents construction.”</p> <p>With <code>#[non_exhaustive]</code>, the primary intent is signaling that fields might be added in the future, and preventing construction is more of a side effect.</p> </div> <p>But what about code within the <strong>same module</strong>? With the patterns above, code in the same module can still bypass your validation:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Still compiles in the same module!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> s</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(),</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span><span>,</span></span> <span class="giallo-l"><span> _private</span><span style="color: #FF79C6;">:</span><span> (),</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Rust’s privacy works at the module level, not the type level. Anything in the same module can access private items.</p> <p>If you need to enforce constructor usage even within your own module, you need a more defensive approach using nested private modules:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> inner {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub struct</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span> _seal</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This type is private to the inner module</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> struct</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> impl</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>, field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field1</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field1 cannot be empty&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field2</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 0</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field2 cannot be zero&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { field1, field2, _seal</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span> })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Re-export for public use</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub use</span><span> inner</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">S</span><span>;</span></span></code></pre> <p>Now even code in your outer module cannot construct <code>S</code> directly because <code>Seal</code> is trapped in the private <code>inner</code> module. Only the <code>new()</code> method, which lives in the same module as <code>Seal</code>, can construct it. The compiler guarantees that all construction, even internal construction, goes through your validation logic.</p> <p>You could still access the public fields directly, though.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> s</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;valid&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(),</span><span style="color: #BD93F9;"> 42</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"><span>s</span><span style="color: #FF79C6;">.</span><span>field1 </span><span style="color: #FF79C6;">=</span><span style="color: #F1FA8C;"> &quot;&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>();</span><span style="color: #6272A4;"> // Still possible to mutate fields directly</span></span></code></pre> <p>To prevent that, you can make the fields private and provide getter methods instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> inner {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub struct</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span> field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span> _seal</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> struct</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> impl</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(field1</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>, field2</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field1</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field1 cannot be empty&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> field2</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 0</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;field2 cannot be zero&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { field1, field2, _seal</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Seal</span><span> })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> field1</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> &amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span>field1</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> field2</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>field2</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now the only way to create an instance of <code>S</code> is through the <code>new()</code> method, and the only way to access its fields is through the getter methods.</p> <h3 id="when-to-use-each"><a class="zola-anchor" href="#when-to-use-each" aria-label="Anchor link for: when-to-use-each">When to Use Each</a></h3> <p>To enforce validation through constructors:</p> <ul> <li><strong>For external code</strong>: Add a private field like <code>_private: ()</code> or use <code>#[non_exhaustive]</code></li> <li><strong>For internal code</strong>: Use nested private modules with a private “seal” type</li> <li><strong>Choose based on your needs</strong>: Most code only needs to prevent external construction; forcing internal construction is more defensive but also more complex</li> </ul> <p>The key insight is that by making construction impossible without access to a private type, you turn your validation logic from a convention into a guarantee enforced by the compiler. So let’s put that compiler to work!</p> <h2 id="pattern-use-must-use-on-important-types"><a class="zola-anchor" href="#pattern-use-must-use-on-important-types" aria-label="Anchor link for: pattern-use-must-use-on-important-types">Pattern: Use <code>#[must_use]</code> on Important Types</a></h2> <p>The <code>#[must_use]</code> attribute is often neglected. That’s sad, because it’s such a simple yet powerful mechanism to prevent callers from accidentally ignoring important return values.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[must_use </span><span style="color: #FF79C6;">=</span><span style="color: #F1FA8C;"> &quot;Configuration must be applied to take effect&quot;</span><span>]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> with_timeout</span><span>(</span><span style="color: #FF79C6;">mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, timeout</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>timeout </span><span style="color: #FF79C6;">=</span><span> timeout;</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now if someone creates a <code>Config</code> but forgets to use it, the compiler will warn them (even with a custom message!):</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> config</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span> <span class="giallo-l"><span style="color: #6272A4;">// Warning: Configuration must be applied to take effect</span></span> <span class="giallo-l"><span>config</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">with_timeout</span><span>(Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">30</span><span>)); </span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Correct usage:</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> config</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">with_timeout</span><span>(Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">30</span><span>));</span></span> <span class="giallo-l"><span style="color: #50FA7B;">apply_config</span><span>(config);</span></span></code></pre> <p>This is especially useful for guard types that need to be held for their lifetime and results from operations that must be checked. The standard library uses this extensively. For example, <code>Result</code> is marked with <code>#[must_use]</code>, which is why you get warnings if you don’t handle errors.</p> <h2 id="code-smell-boolean-parameters"><a class="zola-anchor" href="#code-smell-boolean-parameters" aria-label="Anchor link for: code-smell-boolean-parameters">Code Smell: Boolean Parameters</a></h2> <p>Boolean parameters make code hard to read at the call site and are error-prone. We all know the scenario where we’re sure this will be the last boolean parameter we’ll ever add to a function.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Too many boolean parameters</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_data</span><span>(data</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>], compress</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>, encrypt</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>, validate</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// At the call site, what do these booleans mean?</span></span> <span class="giallo-l"><span style="color: #50FA7B;">process_data</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>data,</span><span style="color: #BD93F9;"> true</span><span>,</span><span style="color: #BD93F9;"> false</span><span>,</span><span style="color: #BD93F9;"> true</span><span>);</span><span style="color: #6272A4;"> // What does this do?</span></span></code></pre> <p>It’s impossible to understand what this code does without looking at the function signature. Even worse, it’s easy to accidentally swap the boolean values.</p> <p>Instead, use enums to make the intent explicit:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> Compression</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Strong</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Medium</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> Encryption</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> AES</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> ChaCha20</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> Validation</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Enabled</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Disabled</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_data</span><span>(</span></span> <span class="giallo-l"><span> data</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>],</span></span> <span class="giallo-l"><span> compression</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Compression</span><span>,</span></span> <span class="giallo-l"><span> encryption</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Encryption</span><span>,</span></span> <span class="giallo-l"><span> validation</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Validation</span><span>,</span></span> <span class="giallo-l"><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Now the call site is self-documenting</span></span> <span class="giallo-l"><span style="color: #50FA7B;">process_data</span><span>(</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> &amp;</span><span>data,</span></span> <span class="giallo-l"><span> Compression</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Strong</span><span>,</span></span> <span class="giallo-l"><span> Encryption</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">None</span><span>,</span></span> <span class="giallo-l"><span> Validation</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Enabled</span></span> <span class="giallo-l"><span>);</span></span></code></pre> <p>This is much more readable and the compiler will catch mistakes if you pass the wrong enum type. You will notice that the enum variants can be more descriptive than just <code>true</code> or <code>false</code>. And more often than not, there are more than two meaningful options; especially for programs which grow over time.</p> <p>For functions with many options, you can configure them using a parameter struct:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> ProcessDataParams</span><span> {</span></span> <span class="giallo-l"><span> compression</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Compression</span><span>,</span></span> <span class="giallo-l"><span> encryption</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Encryption</span><span>,</span></span> <span class="giallo-l"><span> validation</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Validation</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> ProcessDataParams</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Common configurations as constructor methods</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> production</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span> compression</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Compression</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Strong</span><span>,</span></span> <span class="giallo-l"><span> encryption</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Encryption</span><span style="color: #FF79C6;">::</span><span style="color: #BD93F9;">AES</span><span>,</span></span> <span class="giallo-l"><span> validation</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Validation</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Enabled</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> development</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span> compression</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Compression</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">None</span><span>,</span></span> <span class="giallo-l"><span> encryption</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Encryption</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">None</span><span>,</span></span> <span class="giallo-l"><span> validation</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Validation</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Enabled</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_data</span><span>(data</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>], params</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> ProcessDataParams</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Usage with preset configurations</span></span> <span class="giallo-l"><span style="color: #50FA7B;">process_data</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>data, ProcessDataParams</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">production</span><span>());</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Or customize for specific needs</span></span> <span class="giallo-l"><span style="color: #50FA7B;">process_data</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>data,</span><span style="color: #8BE9FD;font-style: italic;"> ProcessDataParams</span><span> {</span></span> <span class="giallo-l"><span> compression</span><span style="color: #FF79C6;">:</span><span> Compression</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Medium</span><span>,</span></span> <span class="giallo-l"><span> encryption</span><span style="color: #FF79C6;">:</span><span> Encryption</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ChaCha20</span><span>,</span></span> <span class="giallo-l"><span> validation</span><span style="color: #FF79C6;">:</span><span> Validation</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Enabled</span><span>, </span></span> <span class="giallo-l"><span>});</span></span></code></pre> <p>This approach scales much better as your function evolves. Adding new parameters doesn’t break existing call sites, and you can easily add defaults or make certain fields optional. The preset methods also document common use cases and make it easy to use the right configuration for different scenarios.</p> <p>Rust is often criticized for not having named parameters, but using a parameter struct is arguably even better for larger functions with many options.</p> <h2 id="clippy-lints-for-defensive-programming"><a class="zola-anchor" href="#clippy-lints-for-defensive-programming" aria-label="Anchor link for: clippy-lints-for-defensive-programming">Clippy Lints for Defensive Programming</a></h2> <p>Many of these patterns can be enforced automatically using Clippy lints. Here are the most relevant ones:</p> <table><thead><tr><th>Lint</th><th>Description</th></tr></thead><tbody> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing"><code>clippy::indexing_slicing</code></a></td><td>Prevents direct indexing into slices and vectors</td></tr> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from"><code>clippy::fallible_impl_from</code></a></td><td>Warns about <code>From</code> implementations that can panic and should be <code>TryFrom</code> instead.</td></tr> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_enum_match_arm"><code>clippy::wildcard_enum_match_arm</code></a></td><td>Disallows wildcard <code>_</code> patterns.</td></tr> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern"><code>clippy::unneeded_field_pattern</code></a></td><td>Identifies when you’re ignoring too many struct fields with <code>..</code> unnecessarily.</td></tr> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools"><code>clippy::fn_params_excessive_bools</code></a></td><td>Warns when a function has too many boolean parameters (4 or more by default).</td></tr> <tr><td><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#must_use_candidate"><code>clippy::must_use_candidate</code></a></td><td>Suggests adding <code>#[must_use]</code> to types that are good candidates for it.</td></tr> </tbody></table> <p>You can enable these in your project by adding them at the top of your crate, e.g.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>indexing_slicing)]</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>fallible_impl_from)]</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>wildcard_enum_match_arm)]</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>unneeded_field_pattern)]</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>fn_params_excessive_bools)]</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>must_use_candidate)]</span></span></code></pre> <p>Or in your <code>Cargo.toml</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">lints</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">clippy</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">indexing_slicing</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">fallible_impl_from</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">wildcard_enum_match_arm</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">unneeded_field_pattern</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">fn_params_excessive_bools</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">must_use_candidate</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">deny</span><span style="color: #E9F284;">&quot;</span></span></code></pre><h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Defensive programming in Rust is about leveraging the type system and compiler to catch bugs before they happen. By following these patterns, you can:</p> <ul> <li>Make implicit invariants explicit and compiler-checked</li> <li>Future-proof your code against refactoring mistakes</li> <li>Reduce the surface area for bugs</li> </ul> <p>It’s a skill that doesn’t come naturally and it’s not covered in most Rust books, but knowing these patterns can make the difference between code that works but is brittle, and code that is robust and maintainable for years to come.</p> <p>Remember: if you find yourself writing <code>// this should never happen</code>, take a step back and ask how the compiler could enforce that invariant for you instead. The best bug is the one that never compiles in the first place.</p> Thu, 30 Oct 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e03-cloudflare/ https://corrode.dev/podcast/s05e03-cloudflare/ <div><script id="letscast-player-1126fbc7" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/cloudflare-with-edward-wang-kevin-guthrie/player.js?size=s"></script></div> <p>How do you build a system that handles 90 million requests per second? That’s the scale that Cloudflare operates at, processing roughly 25% of all internet traffic through their global network of 330+ edge locations.</p> <p>In this episode, we talk to Kevin Guthrie and Edward Wang from Cloudflare about Pingora, their open-source Rust-based proxy that replaced nginx across their entire infrastructure. We’ll find out why they chose Rust for mission-critical systems handling such massive scale, the technical challenges of replacing battle-tested infrastructure, and the lessons learned from “oxidizing” one of the internet’s largest networks.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-cloudflare">About Cloudflare</h3> <p>Cloudflare is a global network designed to make everything you connect to the Internet secure, private, fast, and reliable. Their network spans 330+ cities worldwide and handles approximately 25% of all internet traffic. Cloudflare provides a range of services including DDoS protection, CDN, DNS, and serverless computing—all built on infrastructure that processes billions of requests every day.</p> <h3 id="about-kevin-guthrie">About Kevin Guthrie</h3> <p>Kevin Guthrie is a Software Architect and Principal Distributed Systems Engineer at Cloudflare working on Pingora and the production services built upon it. He specializes in performance optimization at scale. Kevin has deep expertise in building high-performance systems and has contributed to open-source projects that power critical internet infrastructure.</p> <h3 id="about-edward-wang">About Edward Wang</h3> <p>Edward Wang is a Systems Engineer at Cloudflare who has been instrumental in developing Pingora, Cloudflare’s Rust-based HTTP proxy framework. He co-authored the announcement of Pingora’s open source release. Edward’s work focuses on performance optimization, security, and building developer-friendly APIs for network programming.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/pingora">Pingora</a> - Serving 90+ million requests per second (7e12 per day) at Cloudflare</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/how-we-built-pingora-the-proxy-that-connects-cloudflare-to-the-internet/">How we built Pingora</a> - Cloudflare blog post on Pingora’s architecture</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/pingora-open-source/">Open sourcing Pingora</a> - Announcement of Pingora’s open source release</li> <li><a href="/podcast/s03e03-oxide/">Rust in Production: Oxide</a> - Interview with Steve Klabnik</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.cloudflare.com/learning/cdn/glossary/anycast-network/">Anycast</a> - Routing traffic to the closest point of presence</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.lua.org/">Lua</a> - A small, embeddable scripting language</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nginx.org/">nginx</a> - The HTTP server and reverse proxy that Pingora replaced</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Core_dump">coredump</a> - File capturing the memory of a running process for debugging</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://openresty.org/en/nginx.html">OpenResty</a> - Extending nginx with Lua</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/introducing-oxy/">Oxy</a> - Another proxy developed at Cloudflare in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ashleygwilliams">Ashley Williams</a> - Famous Rust developer who worked at Cloudflare at one point</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/eaufavor">Yuchen Wu</a> - One of the first drivers of Pingora development</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/andrewhavck/">Andrew Hauck</a> - Early driver of Pingora development</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Pingora_Peak">Pingora Peak</a> - The actual mountain in Wyoming where a Cloudflare product manager almost fell off</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/shellflip">shellflip</a> - Graceful process restarter in Rust, used by Pingora</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/tableflip">tableflip</a> - Go library that inspired shellflip</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/bytes">bytes</a> - Reference-counted byte buffers for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#specifying-dependencies-from-git-repositories">The Cargo Book: Specifying dependencies from git repositories</a> - Who needs a registry anyway?</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rustsec/rustsec">cargo audit</a> - Security vulnerability scanner for Rust dependencies</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Epoll">epoll</a> - Async I/O API in Linux</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">Tokio</a> - The async runtime powering Pingora</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/mio">mio</a> - Tokio’s abstraction over epoll and other async I/O OS interfaces</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Noah-Kennedy">Noah Kennedy</a> - An actual Tokio expert on the Pingora team</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/zrv5Cy1R7r4">Rain: Cancelling Async Rust</a> - RustConf 2025 talk with many examples of pitfalls</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/foundations">foundations</a> - Cloudflare’s foundational crate for Rust project that exposes Tokio internal metrics</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Io_uring">io_uring</a> - Shiny new kernel toy for async I/O</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=xV4rLfpidIk&amp;t=111s">ThePrimeTime: Cloudflare - Trie Hard - Big Savings On Cloud</a> - “It’s not a millie, it’s not a billie, it’s a trillie”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/valuable">valuable</a> - Invaluable crate for introspection of objects for logging and tracing</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/bytes">bytes</a> - Very foundational crate for reference counted byte buffers</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/xacrimon/dashmap">DashMap</a> - Concurrent HashMap with as little lock contention as possible</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.memorysafety.org/about/">Prossimo</a> - Initiative for memory safety in critical internet infrastructure</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.memorysafety.org/initiative/reverse-proxy/">River</a> - Prossimo-funded reverse proxy based on Pingora</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rustls/rustls">Rustls</a> - Memory-safe TLS implementation in Rust, also funded by Prossimo</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/http/latest/http/">http crate</a> - HTTP types for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/hyperium/h2">h2</a> - HTTP/2 implementation in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hyper.rs/">hyper</a> - Fast HTTP implementation for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://clickhouse.com/docs/integrations/rust">ClickHouse Rust client</a> - Official Rust client by Paul Loyd</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/pingap">Pingap</a> - Reverse proxy built on Pingora</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/pingora/pull/336">PR: Add Rustls to Pingora</a> - by Harald Gutmann</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/pingora/pull/675">PR: Add s2n-tls to Pingora</a> - by Bryan Gilbert</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.cloudflare.com/">Cloudflare</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/">Cloudflare Blog</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cloudflare/pingora">Pingora on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/author/edward-h-wang/">Edward Wang’s Blog Posts</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/author/kevin-guthrie/">Kevin Guthrie’s Blog Posts</a></li> </ul> Thu, 16 Oct 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e02-scythe/ https://corrode.dev/podcast/s05e02-scythe/ <div><script id="letscast-player-ae39496a" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/scythe-with-andrew-tinka/player.js?size=s"></script></div> <p>Building autonomous robots that operate safely in the real world is one of the most challenging engineering problems today. When those robots carry sharp blades and work around people, the margin for error is razor-thin.</p> <p>In this episode, we talk to Andrew Tinka from Scythe Robotics about how they use Rust to build autonomous electric mowers for commercial landscaping. We discuss the unique challenges of robotics software, why Rust is an ideal choice for cutting-edge safety-critical systems, and what it takes to keep autonomous machines running smoothly in the field.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-scythe-robotics">About Scythe Robotics</h3> <p>Scythe Robotics is building autonomous electric mowers for commercial landscaping. Their machines combine advanced sensors, computer vision, and sophisticated path planning to autonomously trim large outdoor spaces while ensuring safety around people and obstacles. By leveraging Rust throughout their software stack, Scythe achieves the reliability and safety guarantees required for autonomous systems breaking new ground in uncontrolled environments. The company is headquartered in Colorado and is reshaping how commercial properties are maintained.</p> <h3 id="about-andrew-tinka">About Andrew Tinka</h3> <p>Andrew is the Director of Software Engineering at Scythe Robotics, where he drives the development of autonomous systems that power their robotic mowers. He specializes in planning and control for large fleets of mobile robots, with over a decade of experience in multi-agent planning technologies that helped pave the way at Amazon Robotics. Andrew has cultivated deep expertise in building safety-critical software for real-world robotics applications and is passionate about using Rust to create reliable, performant systems. His work covers everything from low-level embedded systems to high-level planning algorithms.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Piste#North_America,_Australia_and_New_Zealand">Ski trails rating</a> - A difficulty rating system common in Colorado</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://developer.nvidia.com/embedded/jetson-modules">NVIDIA Jetson</a> - Combined ARM CPU with a GPU for AI workloads at the heart of every Scythe robot</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/book/ch03-01-variables-and-mutability.html#variables-and-mutability">The Rust Book: Variables and Mutability</a> - Immutability is the default in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=kESBAiTYMoQ">Jon Gjengset: Sguaba</a> - A type safe spatial maths library</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/book/ch18-01-what-is-oo.html#inheritance-as-a-type-system-and-as-code-sharing">The Rust Book: Inheritance as a Type System and as Code Sharing</a> - Unlike Java, Rust doesn’t have inheritance</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/patterns/idioms/default.html">Using <code>{..Default::default}</code> when creating structs</a> - The alternative is to initialize each field explicitly</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/stable/book/ch19-02-refutability.html">The Rust Book: Refutability</a> - Rust tells you when you forgot something</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-clippy">Clippy</a> - Rust’s official linter</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=ao-CLgci-e8">Deterministic fleet management for autonomous mobile robots using Rust - Andy Brinkmeyer from Arculus</a> - 2024 Oxidize warehouse robot talk with deterministic testing</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ros.org/">ROS</a> - The Robot Operating System</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://slawlor.github.io/ractor/">Ractor</a> - A good modern actor framework</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/zrv5Cy1R7r4">Rain: Cancelling Async Rust</a> - RustConf 2025 talk with many examples of pitfalls</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://scytherobotics.com/">Scythe Robotics</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/scythe-robotics/">Scythe on LinkedIn</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/scythe-robotics">Scythe on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/andrewtinka/">Andrew Tinka on LinkedIn</a></li> </ul> Wed, 15 Oct 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/rust-conferences-2026/ https://corrode.dev/blog/rust-conferences-2026/ <p>The Rust community continues to grow, and with it, the number of conferences around the world. While some 2026 conferences haven’t announced their dates yet, we’re tracking what’s confirmed so far. Come say hi if you see us at any of these events! (We’ll bring <a href="/podcast">Rust in Production</a> stickers.)</p> <p>Oh, and in case the call for proposals (CFP) is still open, why not submit a talk or workshop proposal?</p> <!-- Interactive Map --> <div id="conference-map"></div> <div class="map-attribution"> Map powered by <a href="https://leafletjs.com/" target="_blank">Leaflet</a> | © <a href="https://stadiamaps.com/" target="_blank">Stadia Maps</a> © <a href="https://stamen.com/" target="_blank">Stamen Design</a> © <a href="https://openmaptiles.org/" target="_blank">OpenMapTiles</a> © <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors </div> <div class="conference-filters"> <button class="button filter-btn active" data-filter="all">All Conferences</button> <button class="button filter-btn" data-filter="cfp-open">CFP Open</button> <button class="button filter-btn" data-filter="announced">Dates Announced</button> </div> <h2 id="q1-2026"><a class="zola-anchor" href="#q1-2026" aria-label="Anchor link for: q1-2026">Q1 2026</a></h2> <h3 id="rust-nation-london-uk"><a class="zola-anchor" href="#rust-nation-london-uk" aria-label="Anchor link for: rust-nation-london-uk">Rust Nation (London, UK)</a></h3> <a href="https://www.rustnationuk.com/" target="_blank"> <img src="rustnation.jpg" alt="Rust Nation" /> </a> <p>Rust Nation has evolved into a staple event in the Rust community. The organization, speaker lineup, and recordings are always top-notch. As per tradition, they kick off the year of Rust conferences.</p> <ul> <li><strong>When</strong>: February 18-19, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/">1 America Square (Workshops) &amp; The Brewery (Main Conference), London, UK</a></li> <li><strong>Format</strong>: 2 days (workshops + conference)</li> <li><strong>Focus</strong>: Rust ecosystem and community</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/tickets">£220.00 + £44.00 VAT</a></li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/tickets">Tickets</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustnationuk">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hachyderm.io/@Rustnationuk">Mastodon</a></li> </ul> <h3 id="rust-in-paris-france"><a class="zola-anchor" href="#rust-in-paris-france" aria-label="Anchor link for: rust-in-paris-france">Rust in Paris (France)</a></h3> <a href="https://rustinparis.com/" target="_blank"> <img src="rustinparis.jpg" alt="Rust in Paris" /> </a> <p>“When Safety Meets Elegance” is the tagline for Rust in Paris.</p> <ul> <li><strong>When</strong>: March 27, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.google.com/maps/place/Apollo+Th%C3%A9%C3%A2tre/@48.8682435,2.3637481,17z/data=!3m2!4b1!5s0x47e66e084be9ac71:0x5452be83db948318!4m6!3m5!1s0x47e66e0852167e43:0xa259bf31ee319054!8m2!3d48.86824!4d2.366323!16s%2Fg%2F120z_cmr?entry=ttu">L’Apollo Théâtre 18, Rue du Faubourg du Temple, 75011 Paris – France</a></li> <li><strong>Format</strong>: 1 day conference</li> <li><strong>Focus</strong>: Crafting safe &amp; efficient futures</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ti.to/xperhub/rust-in-paris-2026">€120</a></li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustinparis.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustinparis">Past Talks</a></li> </ul> <h3 id="rustikon-warsaw-poland"><a class="zola-anchor" href="#rustikon-warsaw-poland" aria-label="Anchor link for: rustikon-warsaw-poland">Rustikon (Warsaw, Poland)</a></h3> <a href="https://www.rustikon.dev/" target="_blank"> <img src="rustikon.jpg" alt="Rustikon" /> </a> <p>Aims to bring together Rust developers from the region and beyond. Expect a developer-friendly atmosphere with expert talks in a single-track format, perfect for staying connected and engaged.</p> <ul> <li><strong>When</strong>: March 19-20, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/tPT7GzRc7kUh4d3s5">POLIN Conference Centre, Warsaw, Poland</a></li> <li><strong>Format</strong>: 2 day conference</li> <li><strong>Focus</strong>: Rust adoption in Poland and beyond</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustikon.dev/tickets">€300</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sessionize.com/rustikon-2026/">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustikon.dev/">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustikonconf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.social/@Rustikon">Mastodon</a></li> </ul> <h3 id="rustasia-hong-kong-dates-tba"><a class="zola-anchor" href="#rustasia-hong-kong-dates-tba" aria-label="Anchor link for: rustasia-hong-kong-dates-tba">RUSTAsia (Hong Kong) <span class="conference-badge tentative">Dates TBA</span></a></h3> <a target="_blank"> <img src="rustasia.jpg" alt="RUSTAsia" /> </a> <p>A conference for Rust developers in Asia.</p> <ul> <li><strong>When</strong>: TBA (typically March)</li> <li><strong>Where</strong>: Hong Kong</li> <li><strong>Format</strong>: Hybrid (in-person + online)</li> <li><strong>Focus</strong>: Rust in Asia</li> <li><strong>Pricing</strong>: TBA</li> <li><strong>CFP</strong>: TBA</li> <li><strong>Links</strong>: Website offline</li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustasiaconf">Twitter</a></li> </ul> <h2 id="q2-2026"><a class="zola-anchor" href="#q2-2026" aria-label="Anchor link for: q2-2026">Q2 2026</a></h2> <h3 id="rust-india-bengaluru-india"><a class="zola-anchor" href="#rust-india-bengaluru-india" aria-label="Anchor link for: rust-india-bengaluru-india">Rust India (Bengaluru, India)</a></h3> <a href="https://rustindia.org/" target="_blank"> <img src="rustindia.jpg" alt="Rust India" /> </a> <p>A single-day community conference where maintainers, compiler tinkerers, infra teams, and curious builders come together for practical Rust talks, hallway conversations, and real production stories.</p> <ul> <li><strong>When</strong>: April 18, 2026</li> <li><strong>Where</strong>: Bengaluru, India</li> <li><strong>Format</strong>: 1 day (5 full talks + 8 lightning talks)</li> <li><strong>Focus</strong>: Systems programming, reliability, performance tuning, production Rust</li> <li><strong>Pricing</strong>: Tickets opening soon</li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustindia.org/">Open</a> (25 and 45 min formats)</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustindia.org/">Website</a></li> </ul> <h3 id="tokioconf-portland-usa"><a class="zola-anchor" href="#tokioconf-portland-usa" aria-label="Anchor link for: tokioconf-portland-usa">TokioConf (Portland, USA)</a></h3> <a href="https://www.tokioconf.com/" target="_blank"> <img src="tokioconf.jpg" alt="TokioConf" /> </a> <p>The first-ever dedicated conference for developers building high-performance network applications with Tokio and async Rust. A single-track event bringing together ~300 developers from across the Rust ecosystem.</p> <ul> <li><strong>When</strong>: April 20-22, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.hyatt.com/hyatt-regency/en-US/pdxrp-hyatt-regency-portland-at-the-oregon-convention-center">Hyatt Regency Portland, 375 NE Holladay St, Portland, OR 97232</a></li> <li><strong>Format</strong>: 3 days (1 day optional workshops + 2 days single-track conference)</li> <li><strong>Focus</strong>: Async Rust, Tokio, high-performance network applications</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.eventbrite.com/e/tokioconf-2026-tickets-1595919270499">Early Bird $650, General Admission $750</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sessionize.com/tokioconf-2026">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.tokioconf.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.eventbrite.com/e/tokioconf-2026-tickets-1595919270499">Tickets</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/blog">Tokio Blog</a></li> </ul> <h3 id="rustweek-utrecht-netherlands"><a class="zola-anchor" href="#rustweek-utrecht-netherlands" aria-label="Anchor link for: rustweek-utrecht-netherlands">RustWeek (Utrecht, Netherlands)</a></h3> <a href="https://2026.rustweek.org/" target="_blank"> <img src="rustweek.jpg" alt="RustWeek" /> </a> <p>RustWeek is a week-long event that combines talks, workshops, and social events. It’s located in cozy Utrecht, the fourth-largest city in the Netherlands. The world’s biggest Rust conference returns, welcoming over 900+ community members. All Rustaceans are welcome to attend and submit talks.</p> <ul> <li><strong>When</strong>: May 18-23, 2026</li> <li><strong>Where</strong>: Utrecht, Netherlands</li> <li><strong>Format</strong>: Full week (2 days talks + 1 day workshops + social events)</li> <li><strong>Focus</strong>: Broad, open to everyone</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://event.onliveevent.nl/rustweek-2026">Tickets available</a></li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://2026.rustweek.org/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustnederlandrustnl">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustnl.bsky.social">BlueSky</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fosstodon.org/@rustnl">Mastodon</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/rustnl/">LinkedIn</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/Rust_NL">Twitter</a></li> </ul> <h3 id="rustmeet-krakow-poland"><a class="zola-anchor" href="#rustmeet-krakow-poland" aria-label="Anchor link for: rustmeet-krakow-poland">RUSTMEET (Kraków, Poland)</a></h3> <a href="https://rustmeet.eu/" target="_blank"> <img src="rustmeet.jpg" alt="RUSTMEET" /> </a> <p>An event in Poland, actively co-created by Rust enthusiasts.</p> <ul> <li><strong>When</strong>: June 12-14, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.eu/">Hotel Kolna, Kraków, Poland</a> (also online)</li> <li><strong>Format</strong>: 3 days (talks + workshops + lightning talks + social event)</li> <li><strong>Focus</strong>: Rust programming language</li> <li><strong>Pricing</strong>: Available via <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.eu/">Confreg</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.eu/">Open until March 22, 2026</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.eu/">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/rustmeet/">LinkedIn</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://c.im/@rustmeet">Mastodon</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustmeet.bsky.social">BlueSky</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://discord.com/invite/CsVnFrYVzm">Discord</a></li> </ul> <h2 id="q3-2026"><a class="zola-anchor" href="#q3-2026" aria-label="Anchor link for: q3-2026">Q3 2026</a></h2> <h3 id="rustconf-montreal-canada"><a class="zola-anchor" href="#rustconf-montreal-canada" aria-label="Anchor link for: rustconf-montreal-canada">RustConf (Montreal, Canada)</a></h3> <a href="https://rustconf.com/" target="_blank"> <img src="rustconf.jpg" alt="RustConf" /> </a> <p>RustConf is the official Rust conference organized by the Rust Foundation. It’s a great place to meet the Rust core team and other community members. After Seattle in 2025, RustConf returns to beautiful Montreal, Canada.</p> <ul> <li><strong>When</strong>: September 8-11, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://congresmtl.com/">Palais des Congrès de Montréal</a>, Montréal, Canada, Québec</li> <li><strong>Format</strong>: 4 days (1 day workshops + 3 days talks)</li> <li><strong>Focus</strong>: Official Rust conference</li> <li><strong>Pricing</strong>: TBA</li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustconf.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mailchi.mp/e0f01ceec688/rustconf-newsletter-registration">Newsletter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustfoundation">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hachyderm.io/@rustconf">Mastodon</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustconf.com">BlueSky</a></li> </ul> <h3 id="oxidize-berlin-germany"><a class="zola-anchor" href="#oxidize-berlin-germany" aria-label="Anchor link for: oxidize-berlin-germany">Oxidize (Berlin, Germany)</a></h3> <a href="https://oxidizeconf.com/" target="_blank"> <img src="oxidize.jpg" alt="Oxidize" /> </a> <p>Two days of applied Rust insights from industry innovators. Topics range from cross-platform GUI development to Rust in safety-critical systems.</p> <ul> <li><strong>When</strong>: September 14-16, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/Q3SzoU7EDJv4kxnHA">Tagungswerk, Berlin, Germany</a></li> <li><strong>Format</strong>: 3 days (1 day workshops + 2 days talks)</li> <li><strong>Focus</strong>: Applied Rust insights</li> <li><strong>Pricing</strong>: TBA</li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://oxidizeconf.com/">Open until March 23, 2026</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://oxidizeconf.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@OxidizeConf">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/OxidizeConf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://social.ferrous-systems.com/@oxidize">Mastodon</a></li> </ul> <h2 id="q4-2026"><a class="zola-anchor" href="#q4-2026" aria-label="Anchor link for: q4-2026">Q4 2026</a></h2> <h3 id="eurorust-barcelona-spain"><a class="zola-anchor" href="#eurorust-barcelona-spain" aria-label="Anchor link for: eurorust-barcelona-spain">EuroRust (Barcelona, Spain)</a></h3> <a href="https://eurorust.eu/" target="_blank"> <img src="eurorust.jpg" alt="EuroRust" /> </a> <p>One of the largest Rust conferences in Europe and a well-established event in the Rust community. A 2-day conference that covers all things Rust: from Rust patterns and idioms to system programming and CLI tooling, servers WASM and embedded systems.</p> <p>The conference travels to a different European city each year. This time, it’s in Barcelona, Spain. 🇪🇸</p> <ul> <li><strong>When</strong>: October 14-17, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/nUzwZ1x7fahyD7aW9">Auditori L’illa, Barcelona, Spain</a></li> <li><strong>Format</strong>: 2 day event</li> <li><strong>Focus</strong>: Rust patterns, idioms, system programming, CLI tooling, servers, WASM, embedded systems</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ti.to/events-matter/eurorust-2026">Private Ticket €275, Freelancer Ticket €332, Company Ticket: €600</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sessionize.com/eurorust-2026">Open until April 27, 2026</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://eurorust.eu/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@eurorust">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/euro_rust">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fosstodon.org/@eurorust">Mastodon</a></li> </ul> <h3 id="rustlab-bologna-italy"><a class="zola-anchor" href="#rustlab-bologna-italy" aria-label="Anchor link for: rustlab-bologna-italy">RustLab (Bologna, Italy)</a></h3> <a href="https://rustlab.it/" target="_blank"> <img src="rustlab.jpg" alt="RustLab" /> </a> <p>The Italian Rust conference traditionally takes place in Florence. It’s lovingly organized featuring delicious Italian food and a great community.</p> <ul> <li><strong>When</strong>: November 1-3, 2026</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/PFdKnc3hivvwjj6X7">Savoia Regency Hotel, Bologna</a></li> <li><strong>Format</strong>: 3 days (1 day workshops + 2 days talks)</li> <li><strong>Focus</strong>: Rust in Italy and beyond</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustlab.it/">€240 Early Bird Lite / €370 Early Bird Premium</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sessionize.com/rustlab-2026">Open until April 13, 2026</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustlab.it/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustlabconference3671">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustlab_conf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.uno/@rustlab">Mastodon</a></li> </ul> <hr /> <p>That’s all we know about Rust conferences for 2026 so far! As conferences announce their dates and details, we’ll keep this page updated.</p> <p>Missing an event? Spot an error? Feel free to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/corrode.github.io/edit/master/content/blog/rust-conferences-2026/index.md">edit this list directly</a> or let us know.</p> <p>See you at the next conference! 🦀</p> <p><em>Note: This list will be updated regularly as more conferences announce their 2026 dates. Most conferences are yet to announce their exact dates, venues, ticket prices, and CFP timelines. Check back often for updates!</em></p> <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js" integrity="sha256-20nQCchB9co0qIjJZRGuk2/Z9VM+kNiyxNV1lvTlZBo=" crossorigin="" ></script> <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY=" crossorigin="" /> <style> iframe, object, embed { max-width: 100%; } /* Filter buttons - overrides for .button class */ .conference-filters { display: flex; gap: 0.75rem; margin: 2rem 0; flex-wrap: wrap; } .filter-btn { padding: 8px 16px; font-size: 0.9rem; border: 2px solid rgba(17, 17, 17, 0.2); background: transparent !important; color: #111 !important; } .filter-btn:hover { border-color: #111; background: rgba(17, 17, 17, 0.05) !important; } .filter-btn.active { background: #111 !important; color: white !important; border-color: #111; } /* Conference badge styling */ .conference-badge { font-size: 0.85rem; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase; padding: 0.4rem 0.9rem; border: 2px solid; border-radius: 4px; display: inline-block; margin-left: 0.75rem; vertical-align: middle; } .conference-badge.tentative { color: #111; background: transparent; border-color: rgba(17, 17, 17, 0.3); } .conference-badge.days { color: #111; background: #fab71c; border-color: #fab71c; } .conference-badge.cfp-open { color: #111; background: #22c55e; border-color: #22c55e; } /* Map styles */ #conference-map { position: relative; height: 500px; width: 110%; margin-left: -5%; overflow: hidden; border-radius: 8px; } .map-attribution { font-size: 0.75rem; color: #888; margin: 0.5rem 0 2rem 0; text-align: center; width: 110%; margin-left: -5%; } .map-attribution a { color: #888; text-decoration: none; } .map-attribution a:hover { color: #555; text-decoration: underline; } .marker-container { width: 20px; height: 20px; } .pulse-marker { width: 20px; height: 20px; border-radius: 50%; background: #ff1493; box-shadow: 0 0 0 0 rgba(255, 20, 147, 0.7); animation: pulse 2s infinite; position: relative; cursor: pointer; } .pulse-marker::before { content: ''; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); width: 12px; height: 12px; border-radius: 50%; background: #fff; } @keyframes pulse { 0% { box-shadow: 0 0 0 0 rgba(255, 20, 147, 0.7); } 70% { box-shadow: 0 0 0 15px rgba(255, 20, 147, 0); } 100% { box-shadow: 0 0 0 0 rgba(255, 20, 147, 0); } } .leaflet-tooltip { background: white; border: 2px solid #ff1493; border-radius: 8px; padding: 12px 16px; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); font-size: 14px; line-height: 1.5; min-width: 200px; } .leaflet-tooltip::before { border-top-color: #ff1493; } .tooltip-title { font-weight: bold; font-size: 16px; color: #ff1493; margin-bottom: 6px; } .tooltip-dates { font-size: 13px; color: #666; margin-bottom: 4px; } .tooltip-location { font-size: 12px; color: #888; } /* Dark mode support */ @media (prefers-color-scheme: dark) { .filter-btn { color: white !important; border-color: rgba(255, 255, 255, 0.3); } .filter-btn:hover { background: rgba(255, 255, 255, 0.1) !important; border-color: rgba(255, 255, 255, 0.5); } .filter-btn.active { background: white !important; color: #111 !important; border-color: white; } .conference-badge.tentative { color: white; border-color: rgba(255, 255, 255, 0.3); } .conference-badge.cfp-open { background: #4ade80; } /* Map dark mode */ .leaflet-tooltip { background: #1f2937; border-color: #ff1493; color: #e5e7eb; } .tooltip-title { color: #ff69b4; } .tooltip-dates { color: #9ca3af; } .tooltip-location { color: #6b7280; } /* Map attribution dark mode */ .map-attribution { color: #aaa; } .map-attribution a { color: #aaa; } .map-attribution a:hover { color: #ddd; } } </style> <script> // Only show confirmed conferences on the map function initConferenceMap() { const conferences = [ { name: 'Rust Nation', city: 'London', country: 'UK', lat: 51.5074, lng: -0.1278, dates: 'February 18-19, 2026' }, { name: 'Rust in Paris', city: 'Paris', country: 'France', lat: 48.8682, lng: 2.3663, dates: 'March 27, 2026' }, { name: 'Rustikon', city: 'Warsaw', country: 'Poland', lat: 52.2297, lng: 21.0122, dates: 'March 19-20, 2026' }, { name: 'TokioConf', city: 'Portland', country: 'USA', lat: 45.5272, lng: -122.6645, dates: 'April 20-22, 2026' }, { name: 'RustWeek', city: 'Utrecht', country: 'Netherlands', lat: 52.0907, lng: 5.1214, dates: 'May 18-23, 2026' }, { name: 'Rust India', city: 'Bengaluru', country: 'India', lat: 12.9716, lng: 77.5946, dates: 'April 18, 2026' }, { name: 'RUSTMEET', city: 'Kraków', country: 'Poland', lat: 50.0647, lng: 19.9450, dates: 'June 12-14, 2026' }, { name: 'RustConf', city: 'Montreal', country: 'Canada', lat: 45.5017, lng: -73.5673, dates: 'September 8-11, 2026' }, { name: 'Oxidize', city: 'Berlin', country: 'Germany', lat: 52.5200, lng: 13.4050, dates: 'September 14-16, 2026' }, { name: 'EuroRust', city: 'Barcelona', country: 'Spain', lat: 41.3851, lng: 2.1734, dates: 'October 14-17, 2026' }, { name: 'RustLab', city: 'Bologna', country: 'Italy', lat: 44.4949, lng: 11.3426, dates: 'November 1-3, 2026' } ]; // Create the map const map = L.map('conference-map', { attributionControl: false, center: [30, 10], zoom: 2, minZoom: 2, maxZoom: 10 }); // Light and dark tile layers - using Stamen Toner from Stadia Maps const stadiaApiKey = '07e2d930-9008-40cb-aa03-2cdf13cf5e2f'; const lightLayer = L.tileLayer( `https://tiles.stadiamaps.com/tiles/stamen_toner_lite/{z}/{x}/{y}{r}.png?api_key=${stadiaApiKey}`, { minZoom: 0, maxZoom: 20, attribution: '&copy; <a href="https://www.stadiamaps.com/" target="_blank">Stadia Maps</a> &copy; <a href="https://www.stamen.com/" target="_blank">Stamen Design</a> &copy; <a href="https://openmaptiles.org/" target="_blank">OpenMapTiles</a> &copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors' } ); const darkLayer = L.tileLayer( `https://tiles.stadiamaps.com/tiles/stamen_toner/{z}/{x}/{y}{r}.png?api_key=${stadiaApiKey}`, { minZoom: 0, maxZoom: 20, attribution: '&copy; <a href="https://www.stadiamaps.com/" target="_blank">Stadia Maps</a> &copy; <a href="https://www.stamen.com/" target="_blank">Stamen Design</a> &copy; <a href="https://openmaptiles.org/" target="_blank">OpenMapTiles</a> &copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors' } ); function applyMapTheme(scheme) { if (scheme === 'dark') { if (map.hasLayer(lightLayer)) { map.removeLayer(lightLayer); } if (!map.hasLayer(darkLayer)) { darkLayer.addTo(map); } } else { if (map.hasLayer(darkLayer)) { map.removeLayer(darkLayer); } if (!map.hasLayer(lightLayer)) { lightLayer.addTo(map); } } } // Hook into site's theme system const originalToggleColorScheme = window.toggleColorScheme; window.toggleColorScheme = function() { if (originalToggleColorScheme) { originalToggleColorScheme(); } // Wait a bit for the theme to apply, then update map setTimeout(() => { const scheme = typeof getPreferredColorScheme === 'function' ? getPreferredColorScheme() : (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'); applyMapTheme(scheme); }, 50); }; // Get initial theme from site's theme system const currentScheme = typeof getPreferredColorScheme === 'function' ? getPreferredColorScheme() : (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'); applyMapTheme(currentScheme); // Add conference markers conferences.forEach(conf => { // Create custom divIcon with pulsating marker // Use wrapper class and inner HTML to avoid conflicts with Leaflet's transform positioning const icon = L.divIcon({ className: 'marker-container', html: '<div class="pulse-marker"></div>', iconSize: [20, 20], iconAnchor: [10, 10], tooltipAnchor: [0, -10] }); // Create tooltip content const tooltipContent = ` <div class="tooltip-title">${conf.name}</div> <div class="tooltip-dates">${conf.dates}</div> <div class="tooltip-location">${conf.city}, ${conf.country}</div> `; // Create marker const marker = L.marker([conf.lat, conf.lng], { icon: icon }) .addTo(map) .bindTooltip(tooltipContent, { permanent: false, direction: 'top', offset: [0, -10] }); // Show tooltip on hover marker.on('mouseover', function() { this.openTooltip(); }); marker.on('mouseout', function() { this.closeTooltip(); }); }); } // Add days until conference start function addDaysUntilConference() { // Find all h3 headings (conference titles) const headings = document.querySelectorAll('article h3'); headings.forEach(h3 => { // Find the next list that contains conference details let currentElement = h3.nextElementSibling; while (currentElement) { if (currentElement.tagName === 'UL') { // Found the list, now look for the "When:" item const listItems = currentElement.querySelectorAll('li'); listItems.forEach(li => { const text = li.textContent; // Check if this list item contains "When:" and doesn't have "TBA" if (!text.includes('When:') || text.includes('TBA')) return; // Match date pattern: "Month Day(-Day)?, Year" const datePattern = /(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2})(?:-\d{1,2})?,\s+(\d{4})/; const match = text.match(datePattern); if (match) { const monthName = match[1]; const day = parseInt(match[2], 10); const year = parseInt(match[3], 10); // Map month names to numbers (0-indexed) const monthMap = { 'January': 0, 'February': 1, 'March': 2, 'April': 3, 'May': 4, 'June': 5, 'July': 6, 'August': 7, 'September': 8, 'October': 9, 'November': 10, 'December': 11 }; // Create date object using Date constructor with explicit parameters const confDate = new Date(year, monthMap[monthName], day); const today = new Date(); today.setHours(0, 0, 0, 0); // Reset time to midnight for accurate day calculation // Calculate days difference const diffTime = confDate - today; const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)); // Add a days badge if conference is in the future if (diffDays > 0) { // Check if badge already exists const existingDaysBadge = h3.querySelector('.conference-badge.days'); if (!existingDaysBadge) { const daysBadge = document.createElement('span'); daysBadge.className = 'conference-badge days'; daysBadge.textContent = `In ${diffDays} days`; h3.appendChild(daysBadge); } } } }); break; } currentElement = currentElement.nextElementSibling; } }); } // Add CFP open badges function addCFPBadges() { // Find all h3 headings (conference titles) const headings = document.querySelectorAll('article h3'); headings.forEach(h3 => { // Find the next list that contains conference details let currentElement = h3.nextElementSibling; while (currentElement) { if (currentElement.tagName === 'UL') { // Found the list, now look for the "CFP:" item const listItems = currentElement.querySelectorAll('li'); listItems.forEach(li => { const text = li.textContent; // Check if this list item contains "CFP:" if (!text.includes('CFP:')) return; // Check if CFP is open (contains "Open" or "Extended" but not "Closed" or "TBA") const isOpen = (text.includes('Open') || text.includes('Extended')) && !text.includes('Closed') && !text.includes('TBA'); if (isOpen) { // Check if badge already exists const existingCFPBadge = h3.querySelector('.conference-badge.cfp-open'); if (!existingCFPBadge) { const cfpBadge = document.createElement('span'); cfpBadge.className = 'conference-badge cfp-open'; cfpBadge.textContent = 'CFP Open'; cfpBadge.title = 'Call for Proposals is currently open'; h3.appendChild(cfpBadge); } } }); break; } currentElement = currentElement.nextElementSibling; } }); } // Filter conferences function setupFilters() { const filterButtons = document.querySelectorAll('.filter-btn'); const headings = document.querySelectorAll('article h3'); // Store conference data for filtering const conferences = []; headings.forEach(h3 => { let currentElement = h3.nextElementSibling; const conferenceElements = [h3]; let cfpText = ''; let whenText = ''; // Collect all elements for this conference while (currentElement && currentElement.tagName !== 'H3' && currentElement.tagName !== 'H2') { conferenceElements.push(currentElement); // Extract CFP and When info if (currentElement.tagName === 'UL') { const listItems = currentElement.querySelectorAll('li'); listItems.forEach(li => { const text = li.textContent; if (text.includes('CFP:')) cfpText = text; if (text.includes('When:')) whenText = text; }); } currentElement = currentElement.nextElementSibling; } conferences.push({ elements: conferenceElements, cfpText: cfpText, whenText: whenText }); }); // Handle filter button clicks filterButtons.forEach(btn => { btn.addEventListener('click', () => { // Update active state filterButtons.forEach(b => b.classList.remove('active')); btn.classList.add('active'); const filter = btn.dataset.filter; // Filter conferences conferences.forEach(conf => { let shouldShow = true; if (filter === 'cfp-open') { const hasCFP = conf.cfpText && (conf.cfpText.includes('Open') || conf.cfpText.includes('Extended')) && !conf.cfpText.includes('Closed') && !conf.cfpText.includes('TBA'); shouldShow = hasCFP; } else if (filter === 'announced') { shouldShow = conf.whenText && !conf.whenText.includes('TBA'); } // 'all' shows everything conf.elements.forEach(el => { el.style.display = shouldShow ? '' : 'none'; }); }); }); }); } // Run after DOM is loaded if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', () => { initConferenceMap(); addDaysUntilConference(); addCFPBadges(); setupFilters(); }); } else { initConferenceMap(); addDaysUntilConference(); addCFPBadges(); setupFilters(); } </script> Thu, 02 Oct 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s05e01-prime-video/ https://corrode.dev/podcast/s05e01-prime-video/ <div><script id="letscast-player-111a5334" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/prime-video-with-alexandru-ene/player.js?size=s"></script></div> <p>Are you one of over 240 million subscribers of Amazon’s Prime Video service? If so, you might be surprised to learn that much of the infrastructure behind Prime Video is built using Rust. They use a single codebase for media players, game consoles, and tablets. In this episode, we sit down with Alexandru Ene, a Principal Engineer at Amazon, to discuss how Rust is used at Prime Video, the challenges they face in building a global streaming service, and the benefits of using Rust for their systems.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-prime-video">About Prime Video</h3> <p>Prime Video is a streaming service offered by Amazon that provides a wide range of movies, TV shows, and original content to its subscribers. With over 240 million subscribers worldwide, Prime Video is one of the largest streaming platforms in the world. In addition to its vast content library, Prime Video also offers features such as offline viewing, 4K streaming, and support for multiple devices. On the backend, Prime Video relies on a variety of technologies to deliver its content, including Rust, which is used for building high-performance and reliable systems that can handle the demands of a global audience.</p> <h3 id="about-alexandru-ene">About Alexandru Ene</h3> <p>Alexandru worked on the transition of Prime Video’s user interface from JavaScript to Rust. He has been with Amazon for over 8 years and previously worked at companies like Ubisoft and EA. He has a background in computer science and is an active open source maintainer. Alexandru lives in London.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=Fsi9HPcyrU8">Ferris Makes Emulators Ep.001 - The Journey Begins</a> - First episode of a famous series where Jake Taylor wrote a Nintendo 64 emulator in Rust from scratch</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/CMake">CMake</a> - Very common build system used in C++ applications</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://conan.io/">Conan</a> - C++ Package Manager community project</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ericlippert.com/2003/09/16/smart-pointers-are-too-smart/">C++ Smart Pointers</a> - Still a footgun</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://gotw.ca/publications/concurrency-ddj.htm">Herb Sutter: The Free Lunch Is Over</a> - The seminal 2005 paper that highlights the importance of concurrency, well past C++’s mainstream adoption</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s02e01-curl/">Rust in Production: cURL</a> - Baseline library used everywhere, written in C, but performant <em>and</em> safe</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.amazon.com/b?node=16775794011">Prime Video Platforms</a> - One app runs on all of these</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://webassembly.org/">WebAssembly (WASM)</a> - Enabling Rust code with good performance that you can still download and run like JavaScript, avoiding the need for firmware updates on some devices</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Entity_component_system">Entity Component System</a> - Used in the UI Rust code for pages in the app</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bevy.org/">Bevy</a> - Game engine written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.leptos.dev/">Leptos</a> - UI framework that makes reactive programming in Rust easier</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">tokio</a> - The de facto standard async runtime for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Single_instruction,_multiple_data">SIMD</a> - A nice feature set some CPUs support</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bytecodealliance/wasm-micro-runtime">WebAssembly Micro Runtime</a> - A tiny WASM runtime well suited for IoT platforms</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.w3.org/groups/wg/wasm/">WebAssembly Working Group</a></li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.primevideo.com">Amazon Prime Video</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=_wcOovoDFMI">Rust &amp; WASM for UI: Faster Prime Video on ANY Device - Alexandru Ene, QCon San Francisco 2024</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/alexene0x0a/">Alexandru Ene on LinkedIn</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://alexene.dev">Alexandru’s Blog</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/AlexEne">Alexandru Ene on GitHub</a></li> </ul> Thu, 11 Sep 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/simple/ https://corrode.dev/blog/simple/ <p><strong>The phone buzzes at 3 AM.</strong></p> <p>You roll out of bed, open your laptop, and see this in the logs:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>thread &#39;</span><span style="color: #8BE9FD;font-style: italic;">tokio</span><span style="color: #FF79C6;">-</span><span>runtime</span><span style="color: #FF79C6;">-</span><span>worker</span><span style="color: #F1FA8C;">&#39; panicked at &#39;</span><span>called `</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">unwrap</span><span>()` on an `</span><span style="color: #8BE9FD;font-style: italic;">Err</span><span>` value</span><span style="color: #FF79C6;">:</span><span> </span></span> <span class="giallo-l"><span style="color: #50FA7B;">Error</span><span>(</span><span style="color: #F1FA8C;">&quot;data did not match any variant of untagged enum Customer at line 1 column 15&quot;</span><span>)</span><span style="color: #F1FA8C;">&#39;, </span></span> <span class="giallo-l"><span style="color: #F1FA8C;">src/parsers/universal.rs:47:23</span></span></code></pre> <p>You open the codebase and find this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> UniversalParser</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DeserializeOwned</span><span>&gt; {</span></span> <span class="giallo-l"><span> format</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span style="color: #8BE9FD;font-style: italic;"> DataFormat</span><span>&gt;,</span></span> <span class="giallo-l"><span> _marker</span><span style="color: #FF79C6;">:</span><span> std</span><span style="color: #FF79C6;">::</span><span>marker</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">PhantomData</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DeserializeOwned</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> UniversalParser</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> parse</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, content</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;,</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>format</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">parse</span><span>(content)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>A few thoughts rush through your head:</p> <p>“What the hell is a PhantomData?”<br /> “Why is there a trait object?”<br /> “This is going to be a long night.”</p> <p>The error must be buried <em>somewhere</em> in the interaction between that <code>DataFormat</code> trait, the generic parser, and serde deserialization. You scroll through 200 lines of trait implementations and generic constraints. Each layer adds another level of indirection. The stack trace is 15 levels deep. It’s like peeling an onion… it makes you cry.</p> <p>You run <code>git blame</code> and curse the colleague who wrote this code. Whoops, it was you a few months ago.</p> <p><strong>Quick rewind. The phone buzzes at 3 AM.</strong></p> <p>You roll out of bed, open your laptop, and see this in the logs:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>Error: CSV parse error at line 847: invalid UTF-8 sequence at byte index 23</span></span></code></pre> <p>You find this code:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Deserialize</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Customer</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> name</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> email</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>, </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> phone</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> parse_customers</span><span>(csv_content</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Customer</span><span>&gt;, csv</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> reader</span><span style="color: #FF79C6;"> =</span><span> csv</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Reader</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_reader</span><span>(csv_content</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">as_bytes</span><span>());</span></span> <span class="giallo-l"><span> reader</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">deserialize</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">collect</span><span>()</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>All right, we seem to be parsing some customer data from a CSV file.</p> <p>You look at line 847 of the input file and see corrupted character encoding. You remove the bad line, deploy a fix, and go back to sleep.</p> <h2 id="don-t-be-clever"><a class="zola-anchor" href="#don-t-be-clever" aria-label="Anchor link for: don-t-be-clever">Don’t Be Clever</a></h2> <p>Rust programmers tend to be very clever. Too clever for their own good at times. Let me be the first to admit that I’m guilty of this myself.</p> <p>We love to stretch Rust to its limits. After all, this is Rust! An empowering playground of infinite possibility. Shouldn’t we use the language to its full extent?</p> <p>Nothing in Rust forces us to be fancy. You can write straightforward code in Rust just like in any other language. But in code reviews, I often see people trying to outsmart themselves and stumbling over their own shoelaces. They use all the advanced features at their disposal without thinking much about maintainability.</p> <p>Here’s the problem: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://idiallo.com/blog/writing-code-is-easy-reading-is-hard">Writing code is easy. Reading it isn’t.</a> These advanced features are like salt: a little bit can enhance the flavor, but too much can ruin the dish. And advanced features have a tendency to overcomplicate things and make readability harder.</p> <p>Software engineering is all about managing complexity, and complexity creeps in when we’re not looking. We should focus on keeping complexity down.</p> <p>Of course, some complexity is truly unavoidable. That’s the inherent complexity of the task. What we should avoid, however, is the accidental complexity, which we introduce ourselves. As projects grow, accidental complexity tends to grow with them. That is the cruft we all should challenge.</p> <p>And simplicity also has other benefits:</p> <blockquote> <p>Simplicity is prerequisite for reliability.</p> </blockquote> <p>I don’t always agree with Edsger W. Dijkstra, but in this case, he was spot-on. Without simplicity, reliability is impossible (or at least hard to achieve). That’s because simple systems have fewer moving parts to reason about.</p> <p>Good code is mostly boring, especially for production use. Simple is obvious. Simple is predictable. Predictable is good.</p> <h2 id="why-simple-is-hard"><a class="zola-anchor" href="#why-simple-is-hard" aria-label="Anchor link for: why-simple-is-hard">Why Simple is Hard</a></h2> <p>But if simplicity is so obviously “better,” why isn’t it the norm? Because achieving simplicity is hard! It doesn’t come naturally. Simplicity is typically not the <em>first attempt</em> but the <em>last revision</em>. <sup class="footnote-reference" id="fr-pascal-1"><a href="#fn-pascal">1</a></sup></p> <blockquote> <p>Simplicity and elegance are unpopular because they require hard work and discipline to achieve.</p> </blockquote> <p>Well put, Edsger.</p> <p>It takes <em>effort</em> to build simple systems. It takes even more effort to <em>keep</em> them simple. That’s because you constantly have to fight <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Entropy">entropy</a>. Going from simple to more complex is much easier than the reverse.</p> <p>Let’s come back to our 3 AM phone call.</p> <p>The first version of the code was built by an engineer who wanted to make the system “flexible and extensible.” The second was written by a developer who just wanted to parse a CSV file. Turns out there never once was a need to parse anything other than CSV files.</p> <p>Of course, the original author likely had good reasons for their design. Maybe prior experience might have suggested that more formats would be needed in the future? Or the team wanted to simplify testing by mocking the data format and ended up with a set of abstractions that turned out to be limiting? And shouldn’t the problem have been discovered during code review?</p> <p>These are all valid points! But code reviews also take effort, and it’s easy to miss the forest for the trees. A less experienced Rust developer might not have the experience to evaluate the situation properly and saying “I don’t get it” also takes courage. And even if the code review had caught the complexity, it might have consumed a lot of energy to convince the original author to simplify the code or to change the design because of deadlines or sunk cost fallacies. It’s easy to judge past decisions with hindsight; that’s not my intention. Quite the opposite, actually: <strong>a series of individually perfectly reasonable decisions can lead to an overly complex, unmaintainable system.</strong> And taken in isolation, each small bit of complexity looks harmless. But complexity quickly compounds.</p> <p>One lesson here is that the path to complexity is paved with good intentions. Another is that senior engineers should pair with junior ones more often to avoid knowledge silos.</p> <p>More experienced developers tend to use more abstractions because they get excited about the possibilities. And I can’t blame them, really. Writing simple code is oftentimes pretty boring. It’s much more fun to test out that new feature we just learned. But after a while we forget how Rust beginners feel about our code: it’s the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Curse_of_knowledge">curse of knowledge</a>.</p> <p>Remember: <strong>abstractions are never zero cost.</strong> <sup class="footnote-reference" id="fr-nasa-1"><a href="#fn-nasa">2</a></sup></p> <blockquote> <p>Not all abstractions are created equal.</p> <p>In fact, many are not abstractions at all — they’re just thin veneers, layers of indirection that add complexity without adding real value.</p> <p>– <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fhur.me/posts/2024/thats-not-an-abstraction">Fernando Hurtado Cardenas</a></p> </blockquote> <p>Abstractions cause complexity, and complexity has very real consequences. At some point, complexity will slow you down because it causes cognitive load. And cognitive load matters a lot because our mental capacity is finite.</p> <p>The people who are starting with Rust are often overwhelmed by the complexity of the language. Try to keep that in mind as you get more proficient. If you fail to do that, you might alienate team members who are not as experienced as you, and they might give up on the project or Rust altogether.</p> <p>Furthermore, if you switch companies and leave behind a complex codebase, the team will have a hard time maintaining it and onboarding new team members. The biggest holdup is <a href="/blog/flattening-rusts-learning-curve">how quickly people will be able to get up to speed with Rust</a>. Don’t make it even harder on them. From time to time, look at Rust through a beginner’s eyes.</p> <h2 id="generics-are-a-liability"><a class="zola-anchor" href="#generics-are-a-liability" aria-label="Anchor link for: generics-are-a-liability">Generics Are A Liability</a></h2> <p>For some reason I feel compelled to talk about generics for a moment…</p> <p>Not only do they make the code harder to understand, they can also have a real cost on compile times. Each generic gets monomorphized, i.e. a separate copy of the code is generated for each type that is used with that generic at compile time.</p> <p>My advice is to only make something generic if you need to switch out the implementation <em>right now</em>. Resist premature generalization! (Which is related—but not identical to—premature optimization.)</p> <p>“We might need it in the future” is a dangerous statement. The classic example is “we might need to switch databases in the future” leading to over-abstracted data access layers that nobody asked for. Be careful with that assumption because it’s hard to predict the future. <sup class="footnote-reference" id="fr-future-1"><a href="#fn-future">3</a></sup></p> <p>Your beautiful abstraction might become your biggest nemesis. If you can defer the decision for <em>just</em> a little longer, it’s often better to do so.</p> <p>Generics also have an impact on the “feel” of the entire codebase. If you use a lot of generics, you will have to deal with the consequences everywhere. You will have to understand the signatures of functions and structs as well as the error messages that come with them. The hidden compilation cost of generics is hard to measure and optimize for.</p> <p>Use generics sparingly. The thinking should be “this is generic functionality” instead of “I could make this generic.”</p> <p>Let’s say you are working on a public API. A function that will be used a lot will need to take some string-based data from the user. You wonder whether you should take a <code>&amp;str</code> or a <code>String</code> or something else as an input to your functions and why.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user_input</span><span>(input</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with input</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>That’s quite simple and doesn’t allocate. But what if the caller wants to pass a String?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user_input</span><span>(input</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with input</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We take ownership of the input. But hold on, what if we don’t need ownership and we want to support both?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user_input</span><span>(input</span><span style="color: #FF79C6;">: impl</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with input</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>That works. But do you see how the complexity goes up?</p> <p>Behind the scenes, it monomorphizes the function for each type that implements <code>AsRef&lt;str&gt;</code>.</p> <p>That means that if we pass a <code>String</code> and a <code>&amp;str</code>, we get two copies of that function. That means longer compile times and larger binaries.</p> <p>Wait, what if we need to return something that references the input and we need the result to live as long as the input?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user_input</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span>&gt;(input</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a S</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> S</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;</span><span style="color: #FF79C6;"> + ?</span><span style="color: #8BE9FD;font-style: italic;">Sized</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with input</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Oh wait, we might need to send this across threads:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user_input</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span>&gt;(input</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a S</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> S</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Send</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Sync</span><span style="color: #FF79C6;"> + ?</span><span style="color: #8BE9FD;font-style: italic;">Sized</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with input</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>See how we went from a simple <code>&amp;str</code> parameter to this monstrosity? Each step seemed “reasonable,” but we’ve created a nightmare that nobody wants to read or debug.</p> <p>The problem is so simple, so how did that complexity creep in? We were trying to be clever! We were trying to improve the function by making it more generic. But is it really “better”?</p> <p>All we wanted was a simple function that takes a string and does something with it.</p> <p>Stay simple. Don’t overthink it!</p> <p>Say we’re writing a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/lycheeverse/lychee">link checker</a> and we want to build a bunch of requests to check the links. We could use a function that returns a <code>Vec&lt;Result&lt;Request&gt;&gt;</code>.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> create_requests</span><span>(urls</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Request</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span> urls</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>url</span><span style="color: #FF79C6;">|</span><span style="color: #50FA7B;"> create_request</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>url))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>()</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Or, we could return an iterator instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> create_requests</span><span>(urls</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt; impl</span><span style="color: #8BE9FD;font-style: italic;"> Iterator</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Request</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span> urls</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>url</span><span style="color: #FF79C6;">|</span><span style="color: #50FA7B;"> create_request</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>url))</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The iterator doesn’t look too bad, but the vec is simpler. What to do? The caller likely needs to collect the results anyway. Since we’re processing a finite set of URLs, the link checker needs all results to report successes/failures, and the results will probably be iterated multiple times. Memory usage isn’t a big concern here since the number of URLs in a document is typically small. All else being equal, the vec is probably the simpler choice.</p> <h2 id="simple-code-is-often-fast-code"><a class="zola-anchor" href="#simple-code-is-often-fast-code" aria-label="Anchor link for: simple-code-is-often-fast-code">Simple Code Is Often Fast Code</a></h2> <p>There’s a prejudice that simple code is slow. Quite the contrary! It turns out many effective algorithms are surprisingly simple. In fact, some of the simplest algorithms we’ve discovered are also the most efficient.</p> <p>Take quicksort or path tracing, for example. Both can be written down in a handful of lines and described in a few sentences.</p> <p>The idea is pretty simple and can fit on a napkin:</p> <ol> <li>Try to get the first element from the list. If there is no element, the list is empty and we’re done.</li> <li>Split the list into two sublists: elements smaller than the pivot and elements larger than or equal to the pivot.</li> <li>Sort each sublist recursively.</li> <li>By combining the sorted smaller list, the pivot, and the sorted larger list, you get the fully sorted list!</li> </ol> <p>Here’s an ad-hoc version of this algorithm in Rust:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> quicksort</span><span>(</span><span style="color: #FF79C6;">mut</span><span> v</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">usize</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">usize</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(pivot)</span><span style="color: #FF79C6;"> =</span><span> v</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">pop</span><span>()</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span> v;</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> (smaller, larger)</span><span style="color: #FF79C6;"> =</span><span> v</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">partition</span><span>(</span><span style="color: #FF79C6;">|</span><span>x</span><span style="color: #FF79C6;">|</span><span> x &lt;</span><span style="color: #FF79C6;"> &amp;</span><span>pivot);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #50FA7B;"> quicksort</span><span>(smaller)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">into_iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">chain</span><span>(std</span><span style="color: #FF79C6;">::</span><span>iter</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">once</span><span>(pivot))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">chain</span><span>(</span><span style="color: #50FA7B;">quicksort</span><span>(larger))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>()</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>It’s not too far off from the description.</p> <p>Yes, my simple implementation only supports <code>usize</code> right now and for any real-world use case, you should use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/primitive.slice.html#method.sort">built-in sort algorithm</a>, which is 20x faster than the above version in my benchmarks, but my point is that simple code packs a punch. On my machine, this implementation sorts 100k numbers in 1 millisecond.</p> <p>This is an O(n log n) algorithm. It’s as fast as it gets for a comparison-based sort and it’s just a few lines of code. <sup class="footnote-reference" id="fr-optimization-1"><a href="#fn-optimization">4</a></sup></p> <p>Often, simple code can be optimized by the compiler more easily and runs faster on CPUs. That’s because CPUs are optimized for basic data structures and predictable access patterns. And parallelizing work is also easier when that is the case. All of that works in our favor when our code is simple.</p> <p>Somewhat counterintuitively, especially when you’re doing something complicated, you should be extra careful to keep it simple. Simplicity is a sign of deep insight, of great understanding, of clarity—and clarity has a positive effect on the way a system functions. And since complicated systems are, well, complicated, that extra clarity helps keep things under control.</p> <p>What I appreciate about Rust is how it balances high-level and low-level programming. We should leverage that more often. Most of the time, I write Rust code in a straightforward manner, and when that extra bit of performance becomes critical, Rust always lets me go back and optimize.</p> <p>For example, in hot code paths, avoiding allocations might make sense, at which point you might have to deal with <a href="/blog/lifetimes/">lifetimes</a>. But that’s a late-stage optimization. Don’t reach for it while the design is still in flux.</p> <h2 id="keep-your-users-in-mind"><a class="zola-anchor" href="#keep-your-users-in-mind" aria-label="Anchor link for: keep-your-users-in-mind">Keep Your Users in Mind</a></h2> <p>Most of the code you’ll write for companies will be application code, not library code. That’s because most companies don’t make money writing libraries, but business logic. There’s no need to get fancy here. Application code should be straightforward.</p> <p>Library code can be a slightly different story. It can get complicated if it ends up being an important building block for other code. For example, in hot code paths, avoiding allocations might make sense, at which point you might have to deal with <a href="/blog/lifetimes">lifetimes</a>. This uncertainty about how code might get used by others can lead to overabstraction. Try to make the common case straightforward. The correct path should be the obvious path users take.</p> <p>Say you’re building a base64 encoder. It’s safe to assume that most people will want to encode a string (probably a unicode string like a <code>&amp;str</code>) and that they want to use a “canonical” or “standard” base64 encoding. Don’t expect your users to jump through hoops to do the <em>most common thing</em>. Unless you have a <em>really</em> good reason, your API should have a function like this somewhere:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">/// Encode input as Base64 string</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> base64_encode</span><span>(input</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>;</span></span></code></pre> <p>Yes, you could make it generic over <code>AsRef&lt;[u8]&gt;</code> or support multiple alphabets:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">/// Generic base64 encoder supporting multiple alphabets</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> base64_encode</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>]&gt;&gt;(input</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>, alphabet</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Base64Alphabet</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>;</span></span></code></pre> <p>…and you might even offer a builder pattern for maximum flexibility:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> encoded</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Base64Encoder</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">with_alphabet</span><span>(Base64Alphabet</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">UrlSafe</span><span>)</span><span style="color: #6272A4;"> // What is UrlSafe?</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">with_decode_allow_trailing_bits</span><span>(</span><span style="color: #BD93F9;">true</span><span>)</span><span style="color: #6272A4;"> // Huh?</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">with_decode_padding_mode</span><span>(engine</span><span style="color: #FF79C6;">::</span><span>DecodePaddingMode</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">RequireNone</span><span>)</span><span style="color: #6272A4;"> // I don&#39;t even...</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">encode</span><span>(</span><span style="color: #F1FA8C;">&quot;Hello, world!&quot;</span><span>);</span></span></code></pre> <p>But what most users care about is how to get an encoded string:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> encoded</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> base64_encode</span><span>(</span><span style="color: #F1FA8C;">&quot;Hello, world!&quot;</span><span>);</span></span></code></pre> <p>You could call the function above <code>base64_encode_simple</code> or <code>base64::encode_standard</code> to make it clear that it’s a simplified version of a more generic algorithm.</p> <p>Simplicity is especially important when working with other developers because code is a way to communicate ideas, and you should strive to express your ideas clearly. It’s fine to offer additional functionality, but don’t make the easy thing hard in the process.</p> <h2 id="tips-for-fighting-complexity"><a class="zola-anchor" href="#tips-for-fighting-complexity" aria-label="Anchor link for: tips-for-fighting-complexity">Tips For Fighting Complexity</a></h2> <blockquote> <p>Controlling complexity is the essence of computer programming. – <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/The_Elements_of_Programming_Style">Brian Kernighan and P.J. Plauger, The Elements of Programming Style</a></p> </blockquote> <h3 id="start-small"><a class="zola-anchor" href="#start-small" aria-label="Anchor link for: start-small">Start Small</a></h3> <p>Jerry Seinfeld had two writing modes: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://perell.com/note/the-jerry-seinfeld-guide-to-writing/">creating mode and editing mode</a>.</p> <ul> <li>When in creating mode, he’s exploring possibilities and letting ideas flow freely.</li> <li>When in editing mode, he’s refining, cutting, and polishing.</li> </ul> <p>These modes require different mindsets, and trying to do both simultaneously leads to paralysis. As a consequence, Seinfeld would never edit while creating because it would kill the creative flow.</p> <p>The same principle applies to coding. Don’t try to architect the perfect solution on your first attempt. Write the naïve implementation first, then let your inner editor refine it. Switch off that inner critic. Who knows? You might just come up with a simpler design!</p> <h3 id="resist-the-temptation-to-optimize-early"><a class="zola-anchor" href="#resist-the-temptation-to-optimize-early" aria-label="Anchor link for: resist-the-temptation-to-optimize-early">Resist the Temptation To Optimize Early</a></h3> <p>It can be tempting to use all of these fine, sharp tools you have at your disposal. But sharp tools they are! To master Rust is to say “no” to these tools more often than you say “yes.”</p> <p>You might see an optimization opportunity and feel the urge to jump at it. But time and again, I see people make that optimization without prior validation. The result is that the code performs the same or becomes slower or is otherwise less ideal than the previous version. Measure twice, cut once.</p> <h3 id="defer-refactoring"><a class="zola-anchor" href="#defer-refactoring" aria-label="Anchor link for: defer-refactoring">Defer Refactoring</a></h3> <p>That might sound counterintuitive. After all, shouldn’t constant refactoring make our code better as we go?</p> <p>The problem is that we have limited information at the time of writing our first prototype. If we refactor too early, we might end up in a worse place than where we started.</p> <p>Take the CSV exporter from the beginning as an example: a smart engineer saw an opportunity to refactor the code in order to support multiple input formats. That locked us into a place where we had a generic exporter, which became a huge debugging burden while preventing us from seeing a better abstraction had we deferred the refactoring. Maybe we would have noticed that we’re always dealing with CSV data, but we could decouple data validation from data exportation. If we had seen that, it would have led to better error messages like:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>Error: Customer 123 has invalid address field:</span></span> <span class="giallo-l"><span>Invalid UTF-8 sequence at byte index 23: Address: &quot;123 M\xE9n St.&quot;</span></span></code></pre> <p>This opportunity was lost because we jumped the gun and refactored too early.</p> <p>I propose solving the problem at hand first and refactoring afterward. That’s because refactoring a simple program is way easier than doing the same for a complex one. Everyone can do the former, while I can count on one hand those who can do the latter. Preserve the opportunity to refactor your code. Refactoring might look like the smart thing to do at the time, but if you allow the simple code to just stick around for a little longer, the right opportunity for the refactor might present itself.</p> <p>A good time to reflect is when your code starts to feel repetitive. That’s a sign that there’s a hidden pattern in your data. The right abstraction is trying to talk to you! It’s fine to make multiple attempts at an abstraction. See what feels right. If none of it does, just go back to the simple version and document your findings.</p> <h3 id="performance-crimes-are-ok"><a class="zola-anchor" href="#performance-crimes-are-ok" aria-label="Anchor link for: performance-crimes-are-ok">Performance Crimes Are “OK”</a></h3> <p>Rust is super fast, so you can literally commit all the performance crimes you like. Clone liberally, iterate over the same data structure multiple times, use a vector where a hashmap would be better.</p> <p>It simply doesn’t matter. Hardware is fast and cheap, so put it to work.</p> <p>Despite this reality, there’s a noticeable tendency among Rust developers to add significant complexity or extra code to avoid any and all allocations in code that isn’t even performance-critical. I think that’s because Rust is very anal about memory management, which makes developers hyper-aware of these costs. This awareness can get in the way of simplicity. Sometimes using <code>Arc</code> or <code>Box</code> is not worth optimizing away if it keeps the code simple.</p> <p>If you’d like to learn more, I gave a talk on that topic titled <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/four-horsemen-talk">The Four Horsemen of Bad Rust Code</a>.</p> <h3 id="be-curious-but-conservative"><a class="zola-anchor" href="#be-curious-but-conservative" aria-label="Anchor link for: be-curious-but-conservative">Be Curious But Conservative</a></h3> <p>All of the above doesn’t mean you should not learn about the good abstractions. It’s fun to learn and to be knowledgeable.</p> <p>But you can focus on learning new concepts without hurting yourself. Understanding macros, lifetimes, interior mutability, etc. is very helpful, but in everyday “normal” Rust code you almost never make use of these concepts, so don’t worry about them too much and keep moving.</p> <p>Use all the features you need and none you don’t.</p> <h3 id="don-t-confuse-simple-with-sloppy"><a class="zola-anchor" href="#don-t-confuse-simple-with-sloppy" aria-label="Anchor link for: don-t-confuse-simple-with-sloppy">Don’t Confuse Simple with Sloppy</a></h3> <p>Crucially, writing simple software does not mean implementing “good-enough-for-now” software. That approach surely will lead to technical debt and maintenance nightmares further down the line as workarounds get stacked on top of each other. No, simple software can still be well-designed software, but it keeps the current requirements in mind. For example, <a href="/blog/compile-time-invariants/">compile-time invariants</a> and <a href="/blog/illegal-state/">making illegal states unrepresentable</a> are techniques that add real safety without adding accidental complexity. The type system does the work so your code doesn’t have to. The goal is not to take shortcuts. Quite the contrary: the goal is to avoid unnecessary complexity, which often is the root cause for having to take shortcuts later on when bad systems design prevents a cleaner solution. In <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://endler.dev/2025/how-to-review-code/">code reviews</a>, I pay extra attention to ensuring we don’t cut corners to avoid doing the necessary design work.</p> <h2 id="how-to-recognize-the-right-level-of-abstraction"><a class="zola-anchor" href="#how-to-recognize-the-right-level-of-abstraction" aria-label="Anchor link for: how-to-recognize-the-right-level-of-abstraction">How to Recognize The Right Level of Abstraction</a></h2> <p>One litmus test I like to use is “Does it feel good to add new functionality?”</p> <p>Good abstractions tend to “click” together. It just feels like there’s no overlap between the abstractions and no grunt work or extra conversions needed. The next step always feels obvious. Testing works without much mocking, your documentation for your structs almost writes itself. There’s no “this struct does X <strong>and</strong> Y” in your documentation. It’s either X <strong>or</strong> Y. Explaining the design to a fellow developer is straightforward. This is when you know you have a winner.</p> <p>Getting there is not easy. It can take many iterations. The result of that process is what you’ll often see in popular libraries.</p> <p>The right abstractions guide you to do the right thing: to find the obvious place to add new functionality, the right place to look for a bug, the right spot to make that database query.</p> <p>All of that is easier if the code is simple. That’s why experienced developers always have simplicity in mind when they build out abstractions.</p> <p>It’s possible that the original sin of a smart engineer is to optimize a thing that should not exist in the first place. Cross that bridge when you get there.</p> <h2 id="write-code-for-humans"><a class="zola-anchor" href="#write-code-for-humans" aria-label="Anchor link for: write-code-for-humans">Write Code for Humans</a></h2> <p>Be clear, not clever. Write code for humans, not computers.</p> <p>Simplicity is clarity. Simplicity is to succinctly express the essence of a thing. Simplicity is about removing the unnecessary, the irrelevant, the noise. Simple is good. Be simple.</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-pascal"> <p>I think there’s a similarity to writing here, where elegance (which is correlated with simplicity, in my opinion) requires an iterative process of constant improvement. The editing process is what makes most writing great. In 1657, Blaise Pascal famously wrote: “I have only made this letter longer because I have not had the time to make it shorter.” I think about that a lot when I write. <a href="#fr-pascal-1">↩</a></p> </li> <li id="fn-nasa"> <p>For reference, see <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.eecs.umich.edu/~imarkov/10rules.pdf">“The Power of 10 Rules”</a> by Gerard J. Holzmann of the NASA/JPL Laboratory for Reliable Software. <a href="#fr-nasa-1">↩</a></p> </li> <li id="fn-future"> <p>I should know because I passed on a few very risky but lucrative investment opportunities because I lacked the ability to accurately predict the future. <a href="#fr-future-1">↩</a></p> </li> <li id="fn-optimization"> <p>Of course, this is not the most efficient implementation of quicksort. It allocates a lot of intermediate vectors and has O(n^2) worst-case performance. There are optimizations for partially sorted data, better pivot selection strategies, and in-place partitioning. But they are just that: optimizations. The core idea remains the same. <a href="#fr-optimization-1">↩</a></p> </li> </ol> </section> Thu, 24 Jul 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e08-season-finale/ https://corrode.dev/podcast/s04e08-season-finale/ <div><script id="letscast-player-77a830f9" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/season-4-finale/player.js?size=s"></script></div> <p>It’s time for another recap including our highlights of Season 4.</p> <p>We’ve been at this for a while now (four seasons, and 32 episodes to be exact). We had guests from a wide range of industries: from Microsoft to Astral, and from password managers to satellite systems.</p> <p>This time, it’s all about using Rust for foundational software, which is software that is critical to a team or even an entire organization. Rust is a great fit for this type of software!</p> Thu, 10 Jul 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e07-ksat/ https://corrode.dev/podcast/s04e07-ksat/ <div><script id="letscast-player-204ce5f9" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/ksat-with-vegard-sandengen/player.js?size=s"></script></div> <p>As a kid, I was always fascinated by space tech. That fascination has only grown as I’ve learned more about the engineering challenges involved in space exploration.</p> <p>In this episode, we talk to Vegard Sandengen, a Rust engineer at KSAT, a company that provides ground station services for satellites. They use Rust to manage the data flow from hundreds of satellites, ensuring that data is received, processed, and stored efficiently. This data is then made available to customers around the world, enabling them to make informed decisions based on real-time satellite data.</p> <p>We dive deep into the technical challenges of building reliable, high-performance systems that operate 24/7 to capture and process satellite data. Vegard shares insights into why Rust was chosen for these mission-critical systems, how they handle the massive scale of data processing, and the unique reliability requirements when dealing with space-based infrastructure.</p> <p>From ground station automation to data pipeline optimization, this conversation explores how modern systems programming languages are enabling the next generation of space technology infrastructure.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-ksat">About KSAT</h3> <p>KSAT, or Kongsberg Satellite Services, is a global leader in providing ground station services for satellites. The company slogan is “We Connect Space And Earth,” and their mission-critical services are used by customers around the world to access satellite data for a wide range of applications, including weather monitoring, environmental research, and disaster response.</p> <h3 id="about-vegard-sandengen">About Vegard Sandengen</h3> <p>Vegard Sandengen is a Rust engineer at KSAT, where he works on the company’s data management systems. He has a Master’s degree in computer science and has been working in the space industry for several years.</p> <p>At KSAT, Vegard focuses on building high-performance data processing pipelines that handle satellite telemetry and payload data from ground stations around the world. His work involves optimizing real-time data flows and ensuring system reliability for mission-critical space operations.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.spacex.com/">SpaceX</a> - Private space exploration company revolutionizing satellite launches</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ccsds.org/">CCSDS</a> - Space data systems standardization body</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Ground_station">Ground Station</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Polar_orbit">Polar Orbit</a> - Orbit with usually limited ground station visibility</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Troll_Satellite_Station">TrollSat</a> - Remote Ground Station in Antarctica</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.openstack.org/">OpenStack</a> - Build-your-own-cloud software stack</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/rME_t6Jn_Kw?list=PL2b0df3jKKiTWZeF7cip6ZUsaVXxWioRi&amp;t=736">RustConf 2024: K2 Space Lightning Talk</a> - K2 Space’s sponsored lightning talk, talking about 100% Rust based satellites</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.k2space.com/">K2 Space</a> - Space company building satellites entirely in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.blueorigin.com/">Blue Origin</a> - Space exploration company focused on reusable rockets</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rocketlabusa.com/">Rocket Lab</a> - Small satellite launch provider</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/ground-station/">AWS Ground Station</a> - Cloud-based satellite ground station service</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Strangler_fig_pattern">Strangler Pattern</a> - A software design pattern to replace legacy applications step-by-step</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/generics/new_types.html">Rust by Example: New Type Idiom</a> - Creating new wrapper types to leverage Rust’s type system guarantees for correct code</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://serde.rs/">serde</a> - Serialization and deserialization framework for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/juhaku/utoipa">utoipa</a> - OpenAPI specification generation from Rust code</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/serde-rs/json">serde-json</a> - The go-to solution for parsing JSON in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/axum">axum</a> - Ergonomic web framework built on tokio and tower</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx">sqlx</a> - Async SQL toolkit with compile-time checked queries</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rayon-rs/rayon">rayon</a> - Data parallelism library for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">tokio</a> - Asynchronous runtime for Rust applications</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/console">tokio-console</a> - Debugger for async Rust applications</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tracing.rs/">tracing</a> - Application-level tracing framework for async-aware diagnostics</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.w3.org/TR/trace-context/">W3C Trace Context</a> - Standard for distributed tracing context propagation</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opentelemetry.io/">OpenTelemetry</a> - Observability framework for distributed systems</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.honeycomb.io/">Honeycomb</a> - Observability platform for complex distributed systems</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview">Azure Application Insights</a> - Application performance monitoring service</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ksat.no/">KSAT</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/veeg">Vegard on GitHub</a></li> </ul> Thu, 26 Jun 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e06-1password/ https://corrode.dev/podcast/s04e06-1password/ <div><script id="letscast-player-0e3cbed3" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/1password-with-andrew-burkhart/player.js?size=s"></script></div> <p>Handling secrets is extremely hard. You have to keep them safe (obviously), while at the same time you need to integrate with a ton of different systems and always provide a great user-experience, because otherwise people will just find a way around your system. When talking to peers, a lot of people mention 1Password as a company that nailed this balance.</p> <p>In today’s episode, I talk to Andrew about how 1Password uses Rust to build critical systems that must never fail, how Rust helps them handle secrets for millions of users, and the lessons they learned when adopting Rust in their stack.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-1password">About 1Password</h3> <p>1Password is a password manager that helps users securely store and manage their passwords, credit card information, and other sensitive data. It provides a user-friendly interface and strong security features to protect users’ secrets across multiple devices.</p> <h3 id="about-andrew-burkhart">About Andrew Burkhart</h3> <p>Andrew is a Senior Rust Developer at 1Password in the Product Foundations org, on the Frameworks team and specifically on the Core Platform squad handling the asynchronous frameworks other developers use to build features (i.e. requests into the Rust core from the Native clients, data sync, etc.). He specifically specialized in that synchronization process, getting data federated from cloud to clients to native apps and back.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://samnewman.io/patterns/architectural/bff/">Backend for Frontend Pattern</a> - Architectural pattern for creating dedicated backends for specific frontends</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/1Password/typeshare">typeshare</a> - Generate types for multiple languages from Rust code</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/1Password/zeroizing-alloc">zeroizing-alloc</a> - 1Password’s minimal secure heap zero-on-free implementation for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/1Password/arboard">arboard</a> - Cross-platform clipboard manager written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/1password/passkey-rs">passkey-rs</a> - Pure Rust implementation of the WebAuthn Passkey specification</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://webassembly.org/">WebAssembly (WASM)</a> - Binary instruction format for portable execution across platforms</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">tokio</a> - The de facto standard async runtime for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-clippy">Clippy</a> - A collection of lints to catch common mistakes in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/EmbarkStudios/cargo-deny">cargo-deny</a> - Cargo plugin for linting dependencies, licenses, and security advisories</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nixos.org/">Nix</a> - Purely functional package manager for reproducible builds</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nixos.wiki/wiki/Flakes">Nix Flakes</a> - Experimental feature for hermetic, reproducible Nix builds</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://direnv.net/">direnv</a> - Load and unload environment variables based on current directory</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cacm.acm.org/research/spotify-guilds/">ACM: Spotify Guilds</a> - A study into Spotify’s Agile Model’s Guilds</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/axum">axum</a> - Ergonomic and modular web framework built on tokio and tower</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tower-rs/tower">tower</a> - Library for building robust networking clients and servers</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/tracing">tracing</a> - Application-level tracing framework for async-aware diagnostics</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rusqlite/rusqlite">rusqlite</a> - Ergonomic wrapper for SQLite in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/mockall/latest/mockall/">mockall</a> - Powerful mock object library for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/pretty_assertions/latest/pretty_assertions/">pretty_assertions</a> - Better assertion macros with colored diff output</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://neon-rs.dev/">neon</a> - Library for writing native Node.js modules in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/nom-supreme/latest/nom_supreme/">nom-supreme</a> - Parser combinator additions and utilities for nom</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ipetkov/crane">crane</a> - Nix library for building Cargo projects</li> <li><a href="/podcast/s03e01-zed/">Rust in Production: Zed</a> - High-performance code editor built in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/console">tokio-console</a> - Debugger for async Rust programs using tokio</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://marabos.nl/atomics/">Rust Atomics and Locks by Mara Bos</a> - Free online book about low-level concurrency in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-book.cs.brown.edu/">The Rust Programming Language (Brown University Edition)</a> - Interactive version of the Rust Book with quizzes</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustlings">Rustlings</a> - Small exercises to get you used to reading and writing Rust code</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://1password.com/">1Password</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/DrewBurkhart">Andrew on GitHub</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/andrewburkhartdev/">Andrew on LinkedIn</a></li> </ul> Thu, 12 Jun 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e05-tembo/ https://corrode.dev/podcast/s04e05-tembo/ <div><script id="letscast-player-a72393de" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/tembo-with-adam-hendel/player.js?size=s"></script></div> <p>Recently I was in need of a simple job queue for a Rust project. I already had Postgres in place and wondered if I could reuse it for this purpose. I found PGMQ by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.tembo.io/">Tembo</a>. PGMQ a simple job queue written in Rust that uses Postgres as a backend. It fit the bill perfectly.</p> <p>In today’s episode, I talk to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/adam-hendel/">Adam Hendel</a>, the founding engineer of Tembo, about one of their projects, PGMQ, and how it came to be. We discuss the design decisions behind job queues, interfacing from Rust to Postgres, and the engineering decisions that went into building the extension.</p> <p>It was delightful to hear that you could build all of this yourself, but that you would probably just waste your time doing so and would come up with the same design decisions as Adam and the team.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-tembo">About Tembo</h3> <p>Tembo builds developer tools that help teams build and ship software faster. Their first product, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pgmq/pgmq/">PGMQ</a>, was created to solve the problem of job queues in a simple and efficient way, leveraging the power of Postgres. They since made a pivot to focus on AI-driven code assistance, but PGMQ can be used independently and is available as an open-source project.</p> <h3 id="about-adam-hendel">About Adam Hendel</h3> <p>Adam Hendel is the founding engineer at Tembo, where he has been instrumental in developing PGMQ and other tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ChuckHend/pg_vectorize">pg_vectorize</a>. He has since moved on to work on his own startup, but remains involved with the PGMQ project.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/about/">PostgreSQL</a> - Super flexible ~40 year old relational database that just works</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.r-project.org/">R</a> - Statistical Programming Language</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pgcentralfoundation/pgrx/">pgrx</a> - Extend Postgres with Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/docs/current/plpgsql.html">Postgres Docs: PL/pgSQL</a> - Scripting with Procedural Language in PostgreSQL</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/docs/current/spi.html">Postgres Docs: SPI</a> - The Postgres Server Programming Interface</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pgmq/pgmq">pgmq</a> - A lightweight message queue extension, initially written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.tembo.io/blog/introducing-pgmq">Tembo Blog: Introducing PGMQ</a> - a blog post about the project</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx">sqlx</a> - All of the great things of an ORM, without all of the bad things of an ORM</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">tokio</a> - The de facto standard async runtime for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/sqs/">AWS SQS</a> - Amazon Web Services Simple Queue Service</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/docs/current/sql-listen.html">Postgres Docs: LISTEN</a> - The native Postgres <code>sub</code> part of of pubsub</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/docs/current/sql-notify.html">Postgres Docs: NOTIFY</a> - The native Postgres <code>pub</code> part of of pubsub</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio-stream/latest/tokio_stream/">tokio-stream</a> - Tokio utility for asynchronous series of values</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.postgresql.org/docs/current/textsearch.html">Postgres Docs: Full Text Search</a> - Postgres included FTS capabilities</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pgvector/pgvector">pgvector</a> - The standard extension for vector/AI workloads in Postgres</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ChuckHend/pg_vectorize">pg_vectorize</a> - Automatically create embeddings for use with pgvector</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.python.org/3/library/constants.html#None">Python Standard Library: None</a> - A type, but not an enum</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s04e03-astral/">Rust in Production: Astral with Charlie Marsh</a> - Massively improving Python day 1 experience</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/huggingface/candle">Hugging Face candle</a> - Use ML models in Rust</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.tembo.io/">Tembo</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/adam-hendel/">Adam on LinkedIn</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ChuckHend">Adam on GitHub</a></li> </ul> Fri, 06 Jun 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/foundational-software/ https://corrode.dev/blog/foundational-software/ <p>Ten years of stable Rust; writing this feels surreal.</p> <p>It’s only been <em>yesterday</em> that we all celebrated the 1.0 release of this incredible language.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/happy-birthday-rust-from-cologne-germany/5824"><img src="https://corrode.dev/blog/foundational-software/rust-10.png" alt="The Rust Cologne/Bonn User Group wishes Rust 1.0 a Happy Birthday!" /></a></p> <p>I was at Rust Week where Niko Matsakis gave his talk “Our Vision for Rust” in which he made a profound and insightful statement:</p> <blockquote> <p>Rust is a language for building <strong>foundational software</strong>.</p> </blockquote> <p>That deeply struck me.</p> <p>I highly recommend you read his blog post titled <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://smallcultfollowing.com/babysteps/blog/2025/03/10/rust-2025-intro/">“Rust in 2025: Targeting foundational software”</a>, which is a great summary on the topic. I wanted to expand on the idea and share what this means to corrode (and perhaps to a wider extent to Rust in the industry).</p> <h2 id="the-issue-with-systems-programming"><a class="zola-anchor" href="#the-issue-with-systems-programming" aria-label="Anchor link for: the-issue-with-systems-programming">The Issue With “Systems Programming”</a></h2> <p>First off, do we really need another term? After all, many people still think of Rust as a systems programming language first and foremost, so why can’t we just stick to “systems programming”?</p> <p>I believe the framing is all wrong. From the outside, “systems programming” might establish that it is about “building systems,” but the term is loaded with historical baggage that feels limiting and prohibitive. It creates an artificial distinction between systems programming and “other types of programming.”</p> <p>The mindset “We are not a systems programming company so we don’t need Rust” is common, but limiting.</p> <p>If I may be candid for a moment, I believe well-known systems-programming domains have a tendency to be toxic. Even the best developers in the world have had that experience.</p> <blockquote> <p>The first contribution that I had to the Linux kernel was some fix for the ext3 file system. It was a very emotional moment for me. I sent a patch to the Linux Kernel and then I saw an email response from Al Viro - one of those developers I’d only heard about and dreamed of meeting someday. He responded, <strong>‘I’ve never seen code this bad in my life. You managed to introduce three new bugs in two new lines of code. People like you should never be allowed to get close to a keyboard again.’</strong> That was my introduction to Linux.</p> <p>– Glauber Costa, co-founder of Turso, on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=biBLEKm2dtY&amp;t=307s">Top Shelf Podcast</a></p> </blockquote> <p>Glauber went on to work at Red Hat, Parallels, ScyllaDB, and Datadog on schedulers, databases, and performance optimizations, but just imagine how many capable developers got discouraged by similar early feedback or never even tried to contribute to the Linux kernel in the first place.</p> <p>I find that ironic because <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Tanenbaum%E2%80%93Torvalds_debate">people once dismissed Linux itself as just a toy project</a>. The Linux kernel wasn’t built in a day. <strong>People need time to learn.</strong></p> <p>The whole idea of Rust is to enable <strong>everyone</strong> to build reliable and efficient software. To me, it’s about breaking down the barriers to entry and making larger parts of the software stack accessible to more people. You can sit with us.</p> <blockquote> <p>We are committed to providing a friendly, safe and welcoming environment for all</p> <p>– <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rust-lang.org/policies/code-of-conduct">The Rust Code of Conduct</a></p> </blockquote> <p>That is also where the idea for corrode comes from: To cut through red tape in the industry. The goal is to gradually chip away at the crust of our legacy software with all its flaws and limitations and establish a better foundation for the future of infrastructure. To <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://smallcultfollowing.com/babysteps/blog/2025/05/15/10-years-of-rust/">try and defy the ‘common wisdom’ about what the tradeoffs have to be</a>. The term corrode is Latin for <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.etymonline.com/search?q=corrode">“to gnaw to bits, wear away.”</a> <sup class="footnote-reference" id="fr-corrode-1"><a href="#fn-corrode">1</a></sup></p> <h2 id="where-rust-shines"><a class="zola-anchor" href="#where-rust-shines" aria-label="Anchor link for: where-rust-shines">Where Rust Shines</a></h2> <blockquote> <p>“I think ‘infrastructure’ is a more useful way of thinking about Rust’s niche than arguing over the exact boundary that defines ‘systems programming’.”</p> <p>“This is the essence of the systems Rust is best for writing: not flashy, not attention-grabbing, often entirely unnoticed. Just the robust and reliable necessities that enable us to get our work done, to attend to other things, confident that the system will keep humming along unattended.”</p> <p>– Graydon Hoare, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustfoundation.org/media/10-years-of-stable-rust-an-infrastructure-story/">10 Years of Stable Rust: An Infrastructure Story</a></p> </blockquote> <p>In conversations with potential customers, one key aspect that comes up with Rust a lot is this perception that Rust is merely a systems programming language. They see the benefit of reliable software, but they don’t see how Rust could help them.</p> <p>I used to reply along the lines of Rust’s mantra: “empowering everyone to build reliable and efficient software” – and while I love this mission, it didn’t always “click” with people.</p> <p>In practice, my clients use Rust for a <strong>much broader range of software</strong>, not just kernel drivers and embedded code! They use Rust for writing software that <strong>underpins other software</strong>.</p> <p>Then I used to tell my own story: I did some C++ in the past, but I wouldn’t call myself a hardcore systems person. And yet, I help a lot of clients with really interesting and complex pieces of software. I ship code that is used by many people and companies like Google, Microsoft, AWS, and NVIDIA. Rust is a great enabler, a superpower, a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.archive.org/web/20230603070738/https://thefeedbackloop.xyz/safety-is-rusts-fireflower/">fireflower</a>.</p> <h2 id="rust-the-great-enabler"><a class="zola-anchor" href="#rust-the-great-enabler" aria-label="Anchor link for: rust-the-great-enabler">Rust, The Great Enabler</a></h2> <p>I found that my clients often don’t use Rust as a C++ replacement. Many of them don’t even have any C++ in production to begin with. They also don’t need to work on the hardware-software interface or spend their time in low-level code.</p> <p>What all clients have in common, however, is that the services they build with Rust are <strong>foundational to their core business</strong>. Rust is used for building platforms: systems which enable building other systems on top.</p> <p>These services need to be robust and reliable and serve as platforms for other code that might or might not be written in Rust. This is, in my opinion, the core value proposition of Rust: to build things that form the bedrock of critical infrastructure and must operate reliably for years.</p> <p>Rust is a day-2 language, i.e. it only starts to shine after taking a leap of faith and using it for an extensive period of time. In Rust, all of the problems that you have during the lifecycle of your application surface early in development. Once a service hits production, maintaining it is a breeze. There is very little on-call work.</p> <p>The focus should be on what Rust enables: a way to express very complicated ideas on a type-system level, which will help build complex abstractions through simple core mechanics: ownership, borrowing, lifetimes, and its trait system.</p> <p>This mindset takes away the focus from Rust as a C++ replacement and also explains why so many teams which use languages like Python, TypeScript, and Kotlin are attracted to Rust.</p> <p>What is less often talked about is that Rust is a language that enables people to move across domain boundaries: from embedded to cloud, from data science to developer tooling. Few other languages are so versatile and none offer the same level of correctness guarantees.</p> <p>If you know Rust, you can program simple things in all of these domains.</p> <h2 id="why-focus-on-foundational-software"><a class="zola-anchor" href="#why-focus-on-foundational-software" aria-label="Anchor link for: why-focus-on-foundational-software">Why Focus On Foundational Software?</a></h2> <p>But don’t we just replace “Systems Programming” with “Foundational Software”? Does using the term “Foundational Software” simply create a new limiting category?</p> <p>Crucially, foundational software is different from low-level software and systems software. For my clients, it’s all foundational. For example, building a data plane is foundational. Writing a media-processing pipeline is foundational.</p> <p>Rust serves as a catalyst: companies start using it for critical software but then, as they get more comfortable with the language, expand into using it in other areas of their business:</p> <blockquote> <p>I’ve seen it play out as we built Aurora DSQL - we chose Rust for the new dataplane components, and started off developing other components with other tools. The control plane in Kotlin, operations tools in TypeScript, etc. Standard “right tool for the job” stuff. But, as the team has become more and more familiar and comfortable with Rust, it’s become the way everything is built. A lot of this is because we’ve seen the benefits of Rust, but at least some is because the team just enjoys writing Rust.</p> <p>– <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://smallcultfollowing.com/babysteps/blog/2025/05/15/10-years-of-rust/">Marc Brooker, engineer at Amazon Web Services in Seattle on lobste.rs</a></p> </blockquote> <p>That fully aligns with my experience: I find that teams become ambitious after a while. They reach for loftier goals because they <em>can</em>. The fact they don’t have to deal with security issues anymore enables better affordances. From my conversations with other Rustaceans, we all made the same observation: suddenly we can build more ambitious projects that we never dared tackle before.</p> <p>It feels to me as if this direction is more promising: starting with the foundational tech and growing into application-level/business-level code if needed/helpful. That’s better than the other way around, which often feels unnecessarily clunky. Once the foundations are in Rust, other systems can be built on top of it.</p> <p>Just because we focus on foundational software doesn’t mean we can’t do other things. But the focus is to make sure that Rust stays true to its roots.</p> <h2 id="systems-you-plan-to-maintain-for-years"><a class="zola-anchor" href="#systems-you-plan-to-maintain-for-years" aria-label="Anchor link for: systems-you-plan-to-maintain-for-years">Systems You Plan To Maintain For Years</a></h2> <p>So, what <em>is</em> foundational software?</p> <p>It’s software that organizations deem critical for their success. It might be:</p> <ul> <li>a robust web backend</li> <li>a package manager</li> <li>a platform for robotics</li> <li>a storage layer</li> <li>a satellite control system</li> <li>an SDK for multiple languages</li> <li>a real-time notification service</li> </ul> <p>and many, many more.</p> <p>All of these things power organizations and <em>must not fail</em> or at least do so <em>gracefully</em>. My clients and the companies I interviewed on our <a href="/podcast">podcast</a> all have one thing in common: They work on Rust projects that are not on the sideline, but front and center, and they shape the future of their infrastructure. Rust is useful in situations where the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dreamsongs.com/Files/worse-is-worse.pdf">“worse is better” philosophy falls apart</a>; it’s a language for building the “right thing”:</p> <blockquote> <p>With the right thing, designers are equally concerned with simplicity, correctness, consistency, and completeness.</p> </blockquote> <p>I think many companies will choose Rust to build their future platforms on. As such, it competes with C++ as much as it does with Kotlin or Python <sup class="footnote-reference" id="fr-sustainability-1"><a href="#fn-sustainability">2</a></sup>.</p> <p>I believe that we should shift the focus away from memory safety (which many other languages also offer) and instead focus on the explicitness, expressiveness, and ecosystem of Rust that is highly competitive with these languages. It is a language for teams which want to build things <em>right</em> and are at odds with the “move fast and break things” philosophy of the past. Rust is future-looking. Backwards-compatibility is enforced by the compiler and many people work on the robustness aspect of the language.</p> <p>Dropbox was one of the first production users of Rust. They built their storage layer on top of it. At no point did they think about using Rust as a C++ replacement. Instead, they saw the potential of Rust as a language for building scalable and reliable systems. Many more companies followed suit: Amazon, Google, Microsoft, Meta, Discord, Cloudflare, and many more. These organizations build platforms and Rust, a tool for professional programmers, developed by world experts over more than a decade of hard work, is best equipped to fit the bill.</p> <h2 id="rust-is-a-tool-for-professionals"><a class="zola-anchor" href="#rust-is-a-tool-for-professionals" aria-label="Anchor link for: rust-is-a-tool-for-professionals">Rust Is A Tool For Professionals</a></h2> <p>Is Rust used for real?</p> <blockquote> <p>“At this point, we now know the answer: yes, Rust is used a lot. It’s used for real, critical projects to do actual work by some of the largest companies in our industry. We did good.”</p> <p>“[Rust is] not a great hobby language but it is a fantastic professional language, precisely because of the ease of refactors and speed of development that comes with the type system and borrow checker.”</p> <p>– Graydon Hoare, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustfoundation.org/media/10-years-of-stable-rust-an-infrastructure-story/">10 Years of Stable Rust: An Infrastructure Story</a></p> </blockquote> <p>To build a truly industrial-strength ecosystem, we need to remember the professional software lifecycle, which is often measured in decades. Stability plays a big role in that. The fact that Rust has stable editions and a language specification is crucial for industry adoption.</p> <p>But Rust is more than just a compiler and its standard library: the tooling and wider ecosystem are equally important. To build foundational software, you need guarantees that vulnerabilities get fixed and that the ecosystem evolves and adapts to the customer’s needs. The ecosystem is still mostly driven by volunteers who maintain key libraries and tools in their free time. There is more to be said about supply-chain security and sustainability in a future post.</p> <h2 id="rust-is-a-language-for-decades"><a class="zola-anchor" href="#rust-is-a-language-for-decades" aria-label="Anchor link for: rust-is-a-language-for-decades">Rust Is A Language For Decades</a></h2> <p>Building foundational systems is rooted in the profound belief that the efforts will pay off in the long run because organizations and society will benefit from them for decades. (<a href="/blog/long-term-rust-maintenance/">Long-term Rust Project Maintenance</a> covers the day-to-day work of keeping a Rust codebase healthy over years: dependency management, API design, release automation, and more.)</p> <p>We are building systems that will be used by people who may not even know they are using them, but who will depend on them every day; that’s critical infrastructure.</p> <p>And Rust allows us to do so with great ergonomics. Rust inherited the pragmatism from C++ and the purism from Haskell.</p> <p>Rust enables us to build sustainable software that stays within its means and is concerned about low resource usage. Systems where precision and correctness matter. Solutions that work across language boundaries and up and down the stack.</p> <p>Rust is a language for decades and my mission is to be a part of this shift.</p> <p>On to the next 10 years!</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-corrode"> <p>Conveniently, it also has a ‘C’ and an ‘R’ in the name, which bridges both languages. <a href="#fr-corrode-1">↩</a></p> </li> <li id="fn-sustainability"> <p>This also raises the question: <a href="/blog/rust-in-ten-years/">“Will Rust be alive in 10 years?”</a> And to me the answer is clear: many large organizations have already bet on it and are building their future on top of it. Rust is here to stay. <a href="#fr-sustainability-1">↩</a></p> </li> </ol> </section> Thu, 29 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e04-rust/ https://corrode.dev/podcast/s04e04-rust/ <div><script id="letscast-player-439d0634" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-with-niko-matsakis/player.js?size=s"></script></div> <p>Few developers have been as influential to my career as Niko Matsakis. Of course he is a world-class engineer with a PhD from ETH Zürich, a Rust core maintainer who has been working on the language for way more than a decade, and a Senior Principal Engineer at AWS. But more importantly, he is an empathetic human and an exceptional communicator.</p> <p>I’ve personally been waiting for one year to get him on the show and steal one hour of his precious time. Now, finally, I got my chance at live recording at Rust Week 2025. The result is everything I hoped for: a trip down memory lane which takes us back to the early days of Rust, an honest and personal look at Rust’s strengths and weaknesses, and a glimpse into the future of the language. All of that packed with insightful anecdotes based on Niko’s decades of experience. If you like Rust, you will enjoy this episode.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-rust">About Rust</h3> <p>Rust is the language which brought us all together. What started as a side-project of Graydon Hoare, a single developer at Mozilla, has grown into a worldwide community of hobbyists, professionals, and companies which all share the same goal: to build better, safer software paired with great ergonomics and performance.</p> <h3 id="about-niko-matsakis">About Niko Matsakis</h3> <p>Niko is a long-time Rust core team member, having joined the project in 2012. He was and still is part of the team which designed and implemented Rust’s borrow checker, which is the language’s most important feature. He has been a voice of reason and a guiding light for many of us, including myself. His insightful talks and blog posts have helped countless developers to see the language and its goals in a new light.</p> <h3 id="special-thanks">Special Thanks</h3> <p>Thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustnl.org/">RustNL</a>, the organizers of Rust Week 2025 for inviting Simon and me to record this episode live. They did a fantastic job organizing the event, and it was an honor to be part of it.</p> <h3 id="links-from-the-episode">Links From The Episode</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustweek.org/">RustWeek 2025</a> - Rust conference in Utrecht where we recorded this live episode</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/DataPower">DataPower</a> - Niko’s employer before working on Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/XSLT">XSLT</a> - Language to transform arbitrarily shaped XML into different arbitrary shapes</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ethz.ch/">ETH Zürich</a> - Niko’s Alma Mater</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.mozilla.org/en-GB/">Mozilla</a> - Niko’s first employer while working on Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/tree/ef75860a0a72f79f97216f8aaa5b388d98da6480/src/boot">rustboot</a> - Rust’s first compiler written in OCaml</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Don_Quixote">Don Quixote</a> - Personification of impractical idealism, just like Rust was in the beginning</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://archive.fosdem.org/2015/schedule/event/the_story_of_rust/">Steve Klabnik’s FOSDEM talk</a> - Coining “The Graydon years”, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://steveklabnik.github.io/history-of-rust/">Slides</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/79PSagCD_AY">Recording of the same talk for ACM</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/blob/0.2/doc/rust.md#keywords">Rust 0.2 Keywords</a> - <code>ret</code> for <code>return</code>, <code>cont</code> for <code>continue</code></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/blob/0.8/doc/tutorial.md#boxes">Boxes in Rust 0.8</a> - <code>~T</code> and <code>@T</code> as syntax features instead of <code>Box&lt;T&gt;</code> and <code>Rc&lt;T&gt;</code></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Green_thread">Green Threads</a> - Like OS threads, but greener!</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/thread/index.html"><code>std::threads</code></a> - Not green, just part of the standard library</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/rc/struct.Rc.html"><code>std::rc::Rc</code></a> - The <code>@T</code> of <code>std</code></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/boxed/struct.Box.html"><code>std::boxed::Box</code></a> - The <code>~T</code> of <code>std</code> with some special compiler sauce</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/sync/struct.Arc.html"><code>std::sync::Arc</code></a> - Thread safe <code>Rc</code></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/pyo3/latest/pyo3/struct.Py.html"><code>pyo3::Py</code></a> - A pointer type in a different library!</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html">The Rust Book: Understanding Ownership</a> - Ownership and borrowing are the first third of “the simple core of Rust”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch18-02-trait-objects.html">The Rust Book: Using Trait Objects</a> - Trait-based dispatch being the second part of “the simple core of Rust”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/marker/trait.Send.html"><code>std::marker::Send</code></a> - A trait without even a method to dispatch, aptly placed in the <code>marker</code> module</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/marker/trait.Sync.html"><code>std::marker::Sync</code></a> - Another example of a marker trait</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Substructural_type_system#Linear_type_systems">Linear Type Systems</a> - Foundational research topic for borrowing in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/regex">regex</a> - “Real stuff” built in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rayon-rs/rayon">rayon</a> - Turning iterators into parallel processing</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">Tokio Async Runtime</a> - An entire async ecosystem as a performant library</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rfcs/pull/2394#discussion_r179909812">Comment on RFC 2394</a> - The beginning of the <code>await x</code> / <code>x.await</code> discussion?</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/alexcrichton">Alex Crichton</a> - Rust compiler, wasm, and lang-advisors team member</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/cramertj">cramertj</a> - Rust lang-advisors and libs-contributors team member</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://without.boats/">withoutboats</a> - Rust team alumni</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://carllerche.com/">Carl Lerche</a> - tokio maintainer</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aturon.github.io/">aturon</a> - Rust team alumni</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/ALGOL_60#Code_sample_comparisons">ALGOL 60</a> - Doesn’t look like C</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/nightly/unstable-book/language-features/try-blocks.html">try blocks</a> - Do we need a postfix <code>match</code> operator for this?</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018/">Rust Blog: Announcing Rust 1.31 and Rust 2018</a> - A watershed moment for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018/#non-lexical-lifetimes">Non-lexical lifetimes</a> - Included in 1.31 and Rust 2018</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://santiagopastorino.com/">Santiago Pastorino</a> - Rust compiler contributor, worked on non-lexical lifetimes</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Makefile">Makefile Example</a> - “We don’t need cargo, Make is fine”</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future/">Rust Blog: Laying the foundation for Rust’s future</a> - Mozilla’s parting gift to Rust?</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tmandry">Tyler Mandry</a> - Rust lang team co-lead with Niko</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://joshtriplett.org/">Josh Triplett</a> - Rust lang, cargo, and libs team member</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/s3/storage-classes/express-one-zone/">Amazon S3 Express One Zone storage class</a> - Super low latency S3, written in Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/rds/aurora/dsql/">Amazon Aurora DSQL</a> - Serverless SQL, an AWS project that started 100% in JVM and finished 100% Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.allthingsdistributed.com/2025/05/just-make-it-scale-an-aurora-dsql-story.html">Just make it scale: An Aurora DSQL story</a> - Blog post detailing the Aurora DSQL Rust rewrite</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://smallcultfollowing.com/babysteps/blog/2025/03/10/rust-2025-intro/">Rust in 2025: Targeting foundational software</a> - Niko’s vision for Rust</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/rph_1DODXDU">Be excellent to each other</a> - Party on dudes!</li> </ul> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rust-lang.org/">Rust Language</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustfoundation.org/">Rust Foundation</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://smallcultfollowing.com/babysteps/">Niko Matsakis’ Homepage</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/nikomatsakis">Niko Matsakis on GitHub</a></li> </ul> Wed, 21 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/sharp-edges-in-rust-std/ https://corrode.dev/blog/sharp-edges-in-rust-std/ <p>The <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/">Rust standard library</a>, affectionately called <code>std</code>, is exceptionally well-designed, but that doesn’t mean it’s perfect. More experienced Rust developers tend to navigate around some of its sharper parts.</p> <p>In this article, I want to highlight the areas in <code>std</code> that I personally avoid. Keep in mind that this list is subjective, so take it with a grain of salt. My intention is to point out some pitfalls and suggest alternatives where appropriate.</p> <h2 id="threading"><a class="zola-anchor" href="#threading" aria-label="Anchor link for: threading">Threading</a></h2> <p>Rust’s threading library is quite solid. That said, managing threads can be a bit of a footgun. In particular, forgetting to <em>join</em> a thread can have some unexpected side effects.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>thread;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>time</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Resource</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Drop</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Resource</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> drop</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This never gets called</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;CRITICAL CLEANUP: Resource dropped&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> handle</span><span style="color: #FF79C6;"> =</span><span> thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> resource</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Resource</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do some work... </span></span> <span class="giallo-l"><span> thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">sleep</span><span>(Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">60</span><span>));</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Resource should be dropped here when thread ends</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Main thread exits immediately.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // But! We forgot to join the spawned thread!</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // handle.join().unwrap();</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In the above scenario, cleanup tasks (such as flushing caches or closing files) might not get executed. So, even if you do nothing with the handle, it is still a best practice to <code>join()</code> it. For more details on the topic, check out matklad’s article: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://matklad.github.io/2019/08/23/join-your-threads.html">“Join Your Threads”</a>.</p> <p>In fact, there was a proposal to make <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/thread/struct.JoinHandle.html"><code>std::thread::JoinHandle</code></a> be <code>#[must_use]</code>, but it was ultimately <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/pull/48830">declined</a> because it would produce too many warnings.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/pull/48830#issuecomment-371649213">This comment summarized the situation pretty well</a>:</p> <blockquote> <p>I’d say the key issue here is that <code>thread::spawn</code> is the easiest way of spawning threads, but not the best one for casual use. Manually calling <code>.join().unwrap()</code> is a chore and easy to forget, which makes <code>thread::spawn</code> a potential footgun.</p> </blockquote> <p>For new code, <strong>I recommend using <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/thread/fn.scope.html"><code>thread::scope</code></a></strong> instead, which is a much better API in every conceivable way. The documentation addresses the above issue directly:</p> <blockquote> <p>Unlike non-scoped threads, scoped threads can borrow non-<code>'static</code> data, as the scope guarantees <strong>all threads will be joined at the end of the scope</strong>. All threads spawned within the scope that <strong>haven’t been manually joined will be automatically joined</strong> before this function returns.</p> </blockquote> <p>Alternatively, you could use a thread pool library or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rayon-rs/rayon">rayon</a>, in case you have an iterator you want to parallelize without manually managing threads.</p> <h2 id="std-collections-linkedlist"><a class="zola-anchor" href="#std-collections-linkedlist" aria-label="Anchor link for: std-collections-linkedlist"><code>std::collections::LinkedList</code></a></h2> <p>Implementing a linked list in Rust is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/too-many-lists/">not easy</a>. That’s because Rust’s ownership model is detrimental to self-referential data structures.</p> <p>Some people might not know that the standard library ships an implementation of a linked list at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/collections/struct.LinkedList.html"><code>std::collections::LinkedList</code></a>. In all those years, I never felt the urge to use it. It might even be the least-used collection type in the standard library overall.</p> <p>For all ordinary use cases, a <code>Vec</code> is superior and straightforward to use. Vectors also have better cache locality and performance characteristics: all items are stored in contiguous memory, which is much better for fast memory access. On the other side, elements in a linked list can be scattered all over the heap. If you want to learn more, you can read <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://arxiv.org/pdf/2306.06942">this paper</a>, which contains some benchmarks.</p> <p>You might be wondering why linked lists get used at all. They have their place as a very specialized data structure that is only really helpful in some resource-constrained or low-level environments like a kernel. The Linux kernel, for example, uses a lot of linked lists. The reason is that the kernel’s intrusive linked list implementation embeds list nodes directly within data structures which is very memory efficient and allows objects to be in multiple lists simultaneously without additional allocations. <sup class="footnote-reference" id="fr-linux-1"><a href="#fn-linux">1</a></sup></p> <p>As for normal, everyday code, just use a <code>Vec</code>. Even <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/nightly/std/collections/struct.LinkedList.html">the documentation of <code>LinkedList</code></a> itself agrees:</p> <blockquote> <p>NOTE: It is almost always better to use <code>Vec</code> or <code>VecDeque</code> because array-based containers are generally faster, more memory efficient, and make better use of CPU cache.</p> </blockquote> <p>I believe the LinkedList should not have been included in the standard library in the first place. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/too-many-lists/sixth.html">Even its original author agrees</a>.</p> <p>There are some surprising gaps in the API; for instance, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/collections/struct.LinkedList.html#method.remove"><code>LinkedList::remove</code></a> is still a nightly-only feature<sup class="footnote-reference" id="fr-ll-remove-1"><a href="#fn-ll-remove">2</a></sup>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>collections</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">LinkedList</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> list</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> LinkedList</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>([</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;">2</span><span>,</span><span style="color: #BD93F9;">3</span><span>]);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> dbg!</span><span>(list);</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This is still unstable!</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // https://github.com/rust-lang/rust/issues/69210</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The operation should compute in O(n) time.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Panics if out of range...</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // list.remove(0);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Even if you wanted a linked list, it probably would not be <code>std::collections::LinkedList</code>:</p> <ul> <li>It doesn’t support O(1) splice, O(1) node erasure, or O(1) node insertion - only O(1) operations at the list ends</li> <li>It has all the disadvantages of a doubly-linked list but none of its advantages</li> <li>Custom implementations are often needed anyway. For example, many real-world use cases require an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.data-structures-in-practice.com/intrusive-linked-lists/">intrusive linked list</a> implementation, not provided by <code>std</code>. An intrusive list is what the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://elixir.bootlin.com/linux/v6.14.5/source/include/linux/list.h">Linux kernel provides</a> and even Rust for Linux has <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-for-linux.github.io/docs/rust/src/kernel/linked_list.rs.html">its own implementation</a> of an intrusive list.</li> <li>Arena-based linked lists are often needed for better performance.</li> </ul> <p>There is a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://internals.rust-lang.org/t/whats-the-status-of-std-linkedlist-maybe-deprecate-in-rust-2018/8068">longer discussion in the Rust forum</a>.</p> <p>Better implementations exist that provide more of the missing operations expected from a proper linked list implementation:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/contain-rs/linked-list">contain-rs/linked-list</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Amanieu/intrusive-rs">intrusive-collections</a></li> </ul> <p>There’s a thing to be said about <code>BTreeMap</code> as well, but I leave it at that. <sup class="footnote-reference" id="fr-btreemap-1"><a href="#fn-btreemap">3</a></sup></p> <h2 id="path-handling"><a class="zola-anchor" href="#path-handling" aria-label="Anchor link for: path-handling">Path Handling</a></h2> <p><code>Path</code> does a decent job of abstracting away the underlying file system. One thing I always disliked was that <code>Path::join</code> returns a <code>PathBuf</code> instead of a <code>Result&lt;PathBuf, Error&gt;</code>. I mentioned in my <a href="/blog/pitfalls-of-safe-rust/#surprising-behavior-of-path-join-with-absolute-paths">‘Pitfalls of Safe Rust’</a> article that <code>Path::join</code> joining a relative path with an absolute path results in the absolute path being returned.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> relative_path</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;relative/path&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> absolute_path</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;/absolute/path&quot;</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // This will return &quot;/absolute/path&quot;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> result</span><span style="color: #FF79C6;"> =</span><span> relative_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(absolute_path);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(result, absolute_path); </span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>I think that’s pretty counterintuitive and a potential source of bugs. On top of that, many programs assume paths are UTF-8 encoded and frequently convert them to <code>str</code>. That’s always a fun dance:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> path</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;/path/to/file.txt&quot;</span><span>);</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The awkward dance with multiple conversions</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">as_os_str</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_str</span><span>() {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(s)</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Yay! We can use string operations</span></span> <span class="giallo-l"><span> },</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Oh well, it&#39;s not UTF-8.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Many developers just use lossy conversion to avoid dealing with this</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Which might _silently_ corrupt path data but keeps the code moving...</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> lossy</span><span style="color: #FF79C6;"> =</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string_lossy</span><span>();</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>These <code>path.as_os_str().to_str()</code> operations must be repeated everywhere. It makes path manipulation ever so slightly annoying.</p> <p>There are a few more issues with paths in Rust:</p> <ul> <li><code>Path</code>/<code>OsStr</code> lacks common string manipulation methods (like <code>find()</code>, <code>replace()</code>, etc.), which makes many common operations on paths quite tedious</li> <li>The design creates a poor experience for Windows users, with inefficient <code>Path</code>/<code>OsStr</code> handling that doesn’t fit the platform well. It’s a cross-platform compromise, but it creates some real problems.</li> </ul> <p>Of course, for everyday use, <code>Path</code> is perfectly okay, but if path handling is a core part of your application, you might want to consider using an external crate instead. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/camino-rs/camino"><code>camino</code></a> is a good alternative crate, which just assumes that paths are UTF-8 (which, in 2025, is a fair assumption). This way, operations have much better ergonomics.</p> <h2 id="platform-specific-date-and-time-handling"><a class="zola-anchor" href="#platform-specific-date-and-time-handling" aria-label="Anchor link for: platform-specific-date-and-time-handling">Platform-Specific Date and Time Handling</a></h2> <p>In my opinion, it’s actually great to have some basic time functionality right in the standard library. However, just be aware that <code>std::time::SystemTime</code> is platform dependent, which <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/issues/44394">causes some headaches</a>. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/issues/48980">Same for <code>Instant</code></a>, which is a wrapper around the most precise time source on each OS.</p> <p>Since time is such a thin wrapper around whatever the operating system provides, you can run into some nasty behavior. For example, <strong>this does not always result in “1 nanosecond” on Windows</strong>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>time</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> SystemTime</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> now</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> SystemTime</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">now</span><span>();</span></span> <span class="giallo-l"><span style="color: #50FA7B;">dbg!</span><span>((now</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_nanos</span><span>(</span><span style="color: #BD93F9;">1</span><span>))</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">duration_since</span><span>(now));</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The documentation does not specify the clock’s accuracy or how it handles leap seconds, except to note that <code>SystemTime</code> does not account for them.</p> <p>If you depend on proper control over time, such as managing leap seconds or cross-platform support, you’re better off using an external crate. For a great overview, see this survey in the Rust forum, titled: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/the-state-of-time-in-rust-leaps-and-bounds/107620">‘The state of time in Rust: leaps and bounds’</a>.</p> <p>In general, I believe <code>std::time</code> works well in combination with the rest of the standard library, such as for <code>sleep</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>thread;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>time</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">sleep</span><span>(Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">1</span><span>));</span></span></code></pre> <p>…but apart from that, I don’t use it for much else. If I had to touch any sort of date calculations, I would defer to an external crate.</p> <p>There are a few options:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/jiff/latest/jiff/_documentation/comparison/index.html"><code>jiff</code></a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/chronotope/chrono"><code>chrono</code></a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/time-rs/time"><code>time</code></a></li> </ul> <p><code>jiff</code> is a new library, which aims to improve upon the existing libraries.</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <p>As you can see, my list of warts in the Rust standard library is quite short. Given that Rust 1.0 was released more than a decade ago, the standard library has held up <em>really</em> well. That said, I reserve the right to update this article in case I become aware of additional sharp edges in the future.</p> <p>If you’re looking to go further, <a href="/blog/pitfalls-of-safe-rust/">Pitfalls of Safe Rust</a> covers a broader set of bugs that the compiler won’t catch: integer overflows, unsafe type casts, TOCTOU races, and more.</p> <p>In general, I like that Rust has a relatively small standard library because once a feature is in there it stays there forever. <sup class="footnote-reference" id="fr-forever-1"><a href="#fn-forever">4</a></sup></p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-linux"> <p>For a more in-depth discussion on why the Linux kernel uses linked lists, see <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.data-structures-in-practice.com/intrusive-linked-lists/">this article</a>. <a href="#fr-linux-1">↩</a></p> </li> <li id="fn-ll-remove"> <p>Perhaps this is a little surprising if you mostly use vectors, but removing an element from a list is an <code>O(n)</code> operation. <a href="#fr-ll-remove-1">↩</a></p> </li> <li id="fn-btreemap"> <p>“Hold on, what’s wrong with BTreeMap?” you might ask.</p> <details><summary> This is just a mild observation rather than a strong criticism. If you're truly interested, expand the details by clicking here.</summary> <p>Okay, as you know, Rust has two map implementations in the standard library: <code>BTreeMap</code>, which guarantees insertion ordering, while <code>HashMap</code> is unordered, but more commonly used. For a long time, a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/hashmap-vs-btreemap/13804/2">“performance trick”</a> was to use <code>BTreeMap</code> if you needed a faster hash map implementation.</p> <p>Since then, the performance of <code>HashMap</code> has improved significantly. One reason is that the implementation of <code>HashMap</code> has <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch08-03-hash-maps.html#hashing-functions">changed to use a “siphash” algorithm</a> and is now <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/collections/struct.HashMap.html">based on Google’s SwissTable</a>. The combination of these changes has made <code>HashMap</code> much more performant than before, so there is no good reason to use <code>BTreeMap</code> anymore, other than the ordering guarantee.</p> <p>One important distinction to note: iteration order over a <code>HashMap</code> is random, while <code>BTreeMap</code>’s iteration order is always sorted by the key’s <code>Ord</code> implementation (not by insertion order). This makes <code>BTreeMap</code> useful when you need to iterate over keys in a sorted manner. If you’re aggregating data in a <code>HashMap</code> but need a sorted list, you’ll need to collect into a vector and sort it manually. In contrast, <code>BTreeMap</code> gives you sorted iteration for free. So while <code>HashMap</code> is better for random access operations, <code>BTreeMap</code> is still helpful when sorted iteration is required. I would argue that it’s a bit of a niche use case, however.</p> <p>In <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.scattered-thoughts.net/writing/smolderingly-fast-btrees/">“Smolderingly fast b-trees”</a>, Jamie Brandon compares the performance of Rust’s <code>BTreeMap</code> and <code>HashMap</code>. Here are the key takeaways:</p> <ul> <li>When comparing performance, btrees were found to be significantly slower than hashmaps in most scenarios, especially for lookups. In the worst case with random-ish strings that share common prefixes, btrees performed dramatically worse.</li> <li>Hashmaps benefit more from speculative execution between multiple lookups, while btrees don’t.</li> <li>btrees have performance “cliffs” when comparisons get more expensive and touch more memory</li> <li>For space usage, the author estimates that btrees would use &gt;60% more memory than hashmaps for random keys.</li> </ul> <p>I’d argue that a normal HashMap is almost always the better choice and having two map implementations in the standard library can be confusing.</p> <p>On top of that, if the hash map is your bottleneck, you’re doing pretty well already. If you need anything faster, there are plenty of great external crates like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/indexmap-rs/indexmap">indexmap</a> for insertion-order preservation and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/xacrimon/dashmap">dashmap</a> for concurrent access.</p> <p>As I said, nothing earth-shaking, but I think it’s worth mentioning that there are better alternatives to <code>BTreeMap</code> out there in the ecosystem.</p> </details> <a href="#fr-btreemap-1">↩</a></li> <li id="fn-forever"> <p>Yes, you <em>can</em> deprecate functionality, but this is a very timid and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rfcs/1270-deprecation.html">laborious process</a> and that still doesn’t mean functionality gets removed. For example, <code>std::env::home_dir()</code> has been deprecated for years and is now not getting removed, but instead will be <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://releases.rs/docs/1.85.0/#compatibility-notes">fixed with a bugfix release and un-deprecated</a>. <a href="#fr-forever-1">↩</a></p> </li> </ol> </section> Sat, 17 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/migration-guides/cpp-to-rust/ https://corrode.dev/learn/migration-guides/cpp-to-rust/ <p>Some people learn new programming languages best by looking at examples for how to do the same thing they know in one language is done in the other. Below is a syntax comparison table which can serve as a quick reference for common C++ constructs and their equivalents in Rust. It is not a comprehensive guide, but I hope it helps out a C++ developer looking for a quick reference to Rust syntax.</p> <h2 id="comparing-idioms-in-rust-and-c"><a class="zola-anchor" href="#comparing-idioms-in-rust-and-c" aria-label="Anchor link for: comparing-idioms-in-rust-and-c">Comparing Idioms in Rust and C++</a></h2> <table> <thead> <tr> <th>Feature</th> <th>Rust</th> <th>C++</th> </tr> </thead> <tbody> <tr> <td><strong>Immutable Variable Declaration</strong></td> <td><code>let x: i32 = 5;</code> (immutable by default)</td> <td><code>const int x = 5;</code></td> </tr> <tr> <td><strong>Mutable Variables</strong></td> <td><code>let mut x = 5;</code></td> <td><code>int x = 5;</code> (mutable by default)</td> </tr> <tr> <td><strong>Type Inference</strong></td> <td><code>let x = 5;</code></td> <td><code>auto x = 5;</code></td> </tr> <tr> <td><strong>Constant Declaration</strong></td> <td><code>const MAX: i32 = 100;</code></td> <td><code>constexpr int MAX = 100;</code> or<br><code>consteval int MAX_FN() { return 100; }</code></td> </tr> <tr> <td><strong>Function Declaration</strong></td> <td><pre><code class="language-rust">fn add(first: i32, second: i32) -> i32 { first + second }</code></pre></td> <td><pre><code class="language-cpp">int add(int first, int second) { return first + second; }</code></pre></td> </tr> <tr> <td><strong>Implicit Return</strong></td> <td><pre><code class="language-rust">fn add(a: i32, b: i32) -> i32 { a + b }</code></pre></td> <td><pre><code class="language-cpp">auto add(int a, int b) -> int { return a + b; }</code></pre></td> </tr> <tr> <td><strong>Immutable Reference</strong></td> <td><code>&T</code></td> <td><code>const T&</code></td> </tr> <tr> <td><strong>Mutable Reference</strong></td> <td><code>&mut T</code></td> <td><code>T&</code></td> </tr> <tr> <td><strong>Raw Pointer</strong></td> <td><code>*const T</code><br><code>*mut T</code></td> <td><code>const T*</code><br><code>T*</code></td> </tr> <tr> <td><strong>Struct Declaration</strong></td> <td> <pre><code class="language-rust">struct Person { id: u32, health: i32 }</code></pre> </td> <td> <pre><code class="language-cpp">struct Person { unsigned int id; int health; };</code></pre> </td> </tr> <tr> <td><strong>Struct Initialization</strong></td> <td><code>Person { id: uid, health: 100 }</code></td> <td><code>Person{uid, 100}</code> or <code>Person{.id = uid, .health = 100}</code><br> (multiple initialization styles available in C++)</td> </tr> <tr> <td><strong>Struct Field Access</strong></td> <td><code>person.id</code></td> <td><code>person.id</code></td> </tr> <tr> <td><strong>Class/Method Implementation</strong></td> <td> <pre><code class="language-rust">impl MyClass { fn new(name: &String, data: &Vec<String>) -> Self { // ... } }</code></pre> </td> <td> <pre><code class="language-cpp">// Usually split between header (.h) and implementation (.cpp) // Header: class MyClass { public: MyClass(const string& name, const vector<string>& data); }; // Implementation: MyClass::MyClass(const string& name, const vector<string>& data) { // ... }</code></pre> </td> </tr> <tr> <td><strong>Method with Self</strong></td> <td> <pre><code class="language-rust">fn get_name(&self) -> String { self.name.clone() }</code></pre> </td> <td> <pre><code class="language-cpp">string get_name() const { return name; // 'this' is implicit in C++ }</code></pre> </td> </tr> <tr> <td><strong>Static Method</strong></td> <td><code>fn static_method() { /* ... */ }</code></td> <td><code>static void static_method() { /* ... */ }</code><br> <em>Note: 'static' in C++ has multiple meanings including file-scope lifetime, class-level function, and non-exported symbols</em></td> </tr> <tr> <td><strong>Interface/Trait</strong></td> <td> <pre><code class="language-rust">trait Shape { fn get_area(&self) -> f64; }</code></pre> </td> <td> <pre><code class="language-cpp">class Shape { public: virtual double get_area() const = 0; };</code></pre> </td> </tr> <tr> <td><strong>Implementing Interface</strong></td> <td> <pre><code class="language-rust">impl Shape for Circle { fn get_area(&self) -> f64 { // ... } }</code></pre> </td> <td> <pre><code class="language-cpp">class Circle : public Shape { public: double get_area() const override { // ... } };</code></pre> </td> </tr> <tr> <td><strong>Generic Function</strong></td> <td> <pre><code class="language-rust">fn generic_call<T: Shape>(gen_shape: &T) { // ... }</code></pre> </td> <td> <pre><code class="language-cpp">template<typename T> void generic_call(const T& gen_shape) { // ... }</code></pre> </td> </tr> <tr> <td><strong>Associated Types</strong></td> <td> <pre><code class="language-rust">trait Shape { type InnerType; fn make_inner(&self) -> Self::InnerType; }</code></pre> </td> <td> <pre><code class="language-cpp">// C++20 concepts approach template<typename T> concept Shape = requires(T t) { typename T::InnerType; { t.make_inner() } -> std::convertible_to<typename T::InnerType>; };</code></pre> </td> </tr> <tr> <td><strong>Enums (Tagged Union)</strong></td> <td> <pre><code class="language-rust">enum MyShape { Circle(f64), Rectangle(f64, f64) }</code></pre> </td> <td> <pre><code class="language-cpp">// Must specify contained types std::variant<Circle, Rectangle> my_shape; // Uses integer tags rather than named variants</code></pre> </td> </tr> <tr> <td><strong>Pattern Matching</strong></td> <td> <pre><code class="language-rust">match shape { MyShape::Circle(r) => // ..., MyShape::Rectangle(w, h) => // ... }</code></pre> </td> <td> <pre><code class="language-cpp">std::visit(overloaded { [](const Circle& c) { /* ... */ }, [](const Rectangle& r) { /* ... */ } }, my_shape);</code></pre> </td> </tr> <tr> <td><strong>Optional Types</strong></td> <td><code>Option&lt;T&gt;</code> (Some(T) or None)</td> <td><code>std::optional&lt;T&gt;</code></td> </tr> <tr> <td><strong>Error Handling</strong></td> <td><code>Result&lt;T, E&gt;</code> (Ok(T) or Err(E))</td> <td><code>std::expected&lt;T, E&gt;</code> (C++23)</td> </tr> <tr> <td><strong>Error Propagation</strong></td> <td><code>let file = File::open("file.txt")?;</code></td> <td>No direct equivalent; uses exceptions or return codes</td> </tr> <tr> <td><strong>Automatic Trait Implementation</strong></td> <td><code>#[derive(Debug, Clone, PartialEq)]</code></td> <td>No direct equivalent (may change with C++26 reflection)</td> </tr> <tr> <td><strong>Memory Management</strong></td> <td> <pre><code class="language-rust">// Manual allocation let boxed = Box::new(value); // Explicit non-trivial copies let s = String::from("text"); let owned = borrowed.to_owned(); let cloned = original.clone();</code></pre> </td> <td> <pre><code class="language-cpp">// Manual allocation auto* ptr = new T(); // Smart pointers auto unique = std::make_unique<T>(); auto shared = std::make_shared<T>(); // Implicit non-trivial copies when passing by value auto copy = original; // May implicitly copy</code></pre> </td> </tr> <tr> <td><strong>Destructors</strong></td> <td> <pre><code class="language-rust">impl Drop for MyType { fn drop(&mut self) { // cleanup } }</code></pre> </td> <td> <pre><code class="language-cpp">~MyType() { // cleanup }</code></pre> </td> </tr> <tr> <td><strong>Serialization</strong></td> <td><code>#[derive(Serialize, Deserialize)]</code></td> <td>Requires manual implementation or code generation<br>(may change with C++26 reflection)</td> </tr> <tr> <td><strong>Print to Console</strong></td> <td><code>println!("Hello, {name}");</code></td> <td><code>std::cout << "Hello, " << name << std::endl;</code><br> <code>std::println("Hello, {}", name);</code> (C++23)</td> </tr> <tr> <td><strong>Debug Output</strong></td> <td><code>println!("{:?}", object);</code></td> <td>No direct equivalent; requires custom implementation</td> </tr> <tr> <td><strong>Pretty Debug Output</strong></td> <td><code>println!("{:#?}", object);</code></td> <td>No direct equivalent</td> </tr> </tbody> </table> <h2 id="rust-vs-c-type-equivalents"><a class="zola-anchor" href="#rust-vs-c-type-equivalents" aria-label="Anchor link for: rust-vs-c-type-equivalents">Rust vs C++ Type Equivalents</a></h2> <table style="width:100%"> <thead> <tr> <th>Type</th> <th>Rust</th> <th>C++</th> </tr> </thead> <tbody> <tr> <td><strong>Boolean</strong></td> <td><code>bool</code></td> <td><code>bool</code></td> </tr> <tr> <td><strong>Character</strong></td> <td><code>char</code> (Unicode scalar value, 4 bytes)</td> <td><code>char32_t</code> (or <code>wchar_t</code> on some platforms)</td> </tr> <tr> <td><strong>Byte (Raw Data)</strong></td> <td><code>u8</code> (always unsigned)</td> <td><code>uint8_t</code> or <code>unsigned char</code> (for guaranteed unsigned)</td> </tr> <tr> <td><strong>Unsigned Integers</strong></td> <td> <pre><code class="language-rust">u8, u16, u32, u64, u128, usize</code></pre> </td> <td> <pre><code class="language-cpp">uint8_t, uint16_t, uint32_t, uint64_t, __uint128, uintptr_t/size_t</code></pre> </td> </tr> <tr> <td><strong>Signed Integers</strong></td> <td> <pre><code class="language-rust">i8, i16, i32, i64, i128, isize</code></pre> </td> <td> <pre><code class="language-cpp">int8_t, int16_t, int32_t, int64_t, __int128, intptr_t/ptrdiff_t</code></pre> </td> </tr> <tr> <td><strong>Floating Point</strong></td> <td><code>f32, f64</code></td> <td><code>float, double</code></td> </tr> <tr> <td><strong>Unit Type</strong></td> <td><code>()</code> (unit)</td> <td><code>void</code></td> </tr> <tr> <td><strong>Never Type</strong></td> <td><code>!</code> (never)</td> <td><code>[[noreturn]] void</code></td> </tr> <tr> <td><strong>Immutable Reference</strong></td> <td><code>&T</code></td> <td><code>const T&</code></td> </tr> <tr> <td><strong>Mutable Reference</strong></td> <td><code>&mut T</code></td> <td><code>T&</code></td> </tr> <tr> <td><strong>Raw Pointers</strong></td> <td><code>*const T</code>, <code>*mut T</code></td> <td><code>const T*</code>, <code>T*</code></td> </tr> <tr> <td><strong>Arrays</strong></td> <td><code>[T; N]</code></td> <td><code>std::array&lt;T, N&gt;</code> or <code>T[N]</code></td> </tr> <tr> <td><strong>Slices</strong></td> <td><code>&[T]</code></td> <td><code>std::span&lt;T&gt;</code> (C++20)</td> </tr> <tr> <td><strong>Dynamic Array</strong></td> <td><code>Vec&lt;T&gt;</code></td> <td><code>std::vector&lt;T&gt;</code></td> </tr> <tr> <td><strong>String</strong></td> <td><code>String</code> (UTF-8 encoded)</td> <td><code>std::string</code></td> </tr> <tr> <td><strong>String Slice</strong></td> <td><code>&str</code> (UTF-8 encoded)</td> <td><code>std::string_view</code> (C++17)</td> </tr> <tr> <td><strong>C Compatible String</strong></td> <td><code>CString</code>, <code>&CStr</code></td> <td><code>std::string</code>, <code>const char*</code></td> </tr> <tr> <td><strong>Nullable/Optional</strong></td> <td><code>Option&lt;T&gt;</code></td> <td><code>std::optional&lt;T&gt;</code> (C++17)</td> </tr> <tr> <td><strong>Error Handling</strong></td> <td><code>Result&lt;T, E&gt;</code></td> <td><code>std::expected&lt;T, E&gt;</code> (C++23)</td> </tr> <tr> <td><strong>Smart Pointer (Unique)</strong></td> <td><code>Box&lt;T&gt;</code></td> <td><code>std::unique_ptr&lt;T&gt;</code></td> </tr> <tr> <td><strong>Smart Pointer (Shared)</strong></td> <td><code>Rc&lt;T&gt;</code> (single-threaded)<br><code>Arc&lt;T&gt;</code> (thread-safe)</td> <td><code>std::shared_ptr&lt;T&gt;</code></td> </tr> <tr> <td><strong>Weak Pointer</strong></td> <td><code>Weak&lt;T&gt;</code> (from Rc/Arc)</td> <td><code>std::weak_ptr&lt;T&gt;</code></td> </tr> <tr> <td><strong>Hash Map</strong></td> <td><code>HashMap&lt;K, V&gt;</code></td> <td><code>std::unordered_map&lt;K, V&gt;</code></td> </tr> <tr> <td><strong>Ordered Map</strong></td> <td><code>BTreeMap&lt;K, V&gt;</code></td> <td><code>std::map&lt;K, V&gt;</code></td> </tr> <tr> <td><strong>Hash Set</strong></td> <td><code>HashSet&lt;T&gt;</code></td> <td><code>std::unordered_set&lt;T&gt;</code></td> </tr> <tr> <td><strong>Ordered Set</strong></td> <td><code>BTreeSet&lt;T&gt;</code></td> <td><code>std::set&lt;T&gt;</code></td> </tr> <tr> <td><strong>Double-Ended Queue</strong></td> <td><code>VecDeque&lt;T&gt;</code></td> <td><code>std::deque&lt;T&gt;</code></td> </tr> <tr> <td><strong>Linked List</strong></td> <td><code>LinkedList&lt;T&gt;</code></td> <td><code>std::list&lt;T&gt;</code></td> </tr> <tr> <td><strong>Priority Queue</strong></td> <td><code>BinaryHeap&lt;T&gt;</code></td> <td><code>std::priority_queue&lt;T&gt;</code></td> </tr> <tr> <td><strong>Tuple</strong></td> <td><code>(T1, T2, ...)</code></td> <td><code>std::tuple&lt;T1, T2, ...&gt;</code></td> </tr> <tr> <td><strong>Tagged Union</strong></td> <td><code>enum Variant { A(T1), B(T2), ... }</code></td> <td><code>std::variant&lt;T1, T2, ...&gt;</code> (C++17)</td> </tr> <tr> <td><strong>Interior Mutability</strong></td> <td><code>Cell&lt;T&gt;</code>, <code>RefCell&lt;T&gt;</code></td> <td><code>mutable</code> keyword</td> </tr> <tr> <td><strong>Thread-Safe Mutability</strong></td> <td><code>Mutex&lt;T&gt;</code>, <code>RwLock&lt;T&gt;</code></td> <td><code>std::mutex</code> + <code>T</code></td> </tr> <tr> <td><strong>Atomic Types</strong></td> <td><code>AtomicBool</code>, <code>AtomicUsize</code>, etc.</td> <td><code>std::atomic&lt;bool&gt;</code>, <code>std::atomic&lt;size_t&gt;</code>, etc.</td> </tr> </tbody> </table> Thu, 15 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e03-astral/ https://corrode.dev/podcast/s04e03-astral/ <div><script id="letscast-player-7b80a2f5" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/uv-with-charlie-marsh/player.js?size=s"></script></div> <p>Up until a few years ago, Python tooling was a nightmare: basic tasks like installing packages or managing Python versions was a pain. The tools were brittle and did not work well together, mired in a swamp of underspecified implementation defined behaviour.</p> <p>Then, apparently suddenly, but in reality backed by years of ongoing work on formal interoperability specifications, we saw a renaissance of new ideas in the Python ecosystem. It started with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://python-poetry.org/">Poetry</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pipx.pypa.io/stable/">pipx</a> and continued with tooling written in Rust like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rye.astral.sh/">rye</a>, which later got incorporated into <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://astral.sh/">Astral</a>.</p> <p>Astral in particular contributed a very important piece to the puzzle: <code>uv</code> – an extremely fast Python package and project manager that supersedes all previous attempts; For example, it is 10x-100x faster than pip.</p> Mon, 05 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/flattening-rusts-learning-curve/ https://corrode.dev/blog/flattening-rusts-learning-curve/ <p>I see people make the same mistakes over and over again when learning Rust. Here are my thoughts (ordered by importance) on how you can ease the learning process. My goal is to help you save time and frustration.</p> <h2 id="let-your-guard-down"><a class="zola-anchor" href="#let-your-guard-down" aria-label="Anchor link for: let-your-guard-down">Let Your Guard Down</a></h2> <p>Stop resisting. That’s the most important lesson.</p> <p>Accept that learning Rust requires adopting a completely different mental model than what you’re used to. There are a ton of new concepts to learn like lifetimes, ownership, and the trait system. And depending on your background, you’ll need to add generics, pattern matching, or macros to the list.</p> <p>Your learning pace doesn’t have much to do with whether you’re smart or not or if you have a lot of programming experience. Instead, what matters more is <strong>your attitude toward the language</strong>.</p> <p>I have seen junior devs excel at Rust with no prior training and senior engineers struggle for weeks/months or even give up entirely. Leave your hubris at home.</p> <p>Treat the borrow checker as a co-author, not an adversary. This reframes the relationship. Let the compiler do the teaching: for example, this works great with lifetimes, because the compiler will tell you when a lifetime is ambiguous. Then just add it but take the time to reason about <em>why</em> the compiler couldn’t figure it out itself.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> longest</span><span>(x</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>, y</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> x</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt; y</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() {</span></span> <span class="giallo-l"><span> x</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> y</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If you try to compile this, the compiler will ask you to add a lifetime parameter. It provides this helpful suggestion:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #BD93F9;">1</span><span style="color: #FF79C6;"> | fn</span><span style="color: #50FA7B;"> longest</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt;(x</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>, y</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ++++ ++ ++ ++</span></span></code></pre> <p>So you don’t have to guess what the compiler wants and can follow its instructions. But also sit down and wonder <em>why</em> the compiler couldn’t figure it out itself.</p> <p>Most of the time when fighting the compiler it is actually exposing a design flaw. Similarly, if your code gets overly verbose or looks ugly, there’s probably a better way. Declare defeat and learn to do it the Rust way.</p> <p>If you come from a dynamic language like Python, you’ll find that Rust is more verbose in general. Most of it just comes from type annotations, though. Some people might dismiss Rust as being “unelegant” or “ugly”, but the verbosity actually serves a good purpose and is immensely helpful for building large-scale applications:</p> <ul> <li>First off, you will read the code more often than you write it, which means type annotations will give you more local context to reason with.</li> <li>Second, it helps immensely with refactoring because the compiler can check if you broke any code while you move things around. If your code turns out to look very ugly, take a step back and ask if there’s a simpler solution. Don’t dismiss the language right away.</li> </ul> <p>Turn on all <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/clippy/">clippy lints</a> on day one – even the pedantic ones. Run the linter and follow the suggestions religiously. Don’t skip that step once your program compiles.</p> <p>Resistance is futile. The longer you refuse to learn, the longer you will suffer; but the moment you let your guard down is the moment you’ll start to learn. Forget what you think you knew about programming and really start to listen to what the compiler, the standard library, and clippy are trying to tell you.</p> <h2 id="baby-steps"><a class="zola-anchor" href="#baby-steps" aria-label="Anchor link for: baby-steps">Baby Steps</a></h2> <p>I certainly tried to run before I could walk. That alone cost me a lot of precious time.</p> <p>Don’t make it too hard on yourself in the beginning. Here are some tips:</p> <ul> <li>Use <code>String</code> and <code>clone()</code> and <code>unwrap</code> generously; you can always refactor later – and refactoring is the best part about Rust! I wrote an article on saving yourself time during that phase <a href="/blog/prototyping/">here</a>.</li> <li>Use simple if or match statements before starting to learn some of the more idiomatic <code>.and_then</code> etc. combinators</li> <li>Avoid async Rust in week 1. The additional rules are a tax on people still learning the core ownership model.</li> </ul> <p>Don’t introduce too many new concepts at the same time! Instead, while you learn about a new concept, have an editor open and write out a few examples. What helped was to just write some code in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/">Rust playground</a> and try to get it to compile. Write super small snippets (e.g., one <code>main.rs</code> for one concept) instead of using one big “tutorial” repo. Get into the habit of throwing most of your code away.</p> <p>I still do that and test out ideas in the playground or when I brainstorm with clients.</p> <p>For instance, here’s one of my favorite code snippets to explain the concept of ownership:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> my_func</span><span>(v</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with v</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> s</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;hello&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> my_func</span><span>(s);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> my_func</span><span>(s);</span><span style="color: #6272A4;"> // error, but why?</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Can you fix it? Can you explain it? Ask yourself what would change if <code>v</code> was an <code>i32</code>.</p> <p>If Rust code looks scary to you, <strong>break it down</strong>. Write your own, simpler version, then slowly increase the complexity. Rust is easier to write than to read. By writing lots of Rust, you will also learn how to read it better as well.</p> <h2 id="be-accurate"><a class="zola-anchor" href="#be-accurate" aria-label="Anchor link for: be-accurate">Be Accurate</a></h2> <blockquote> <p>How you do anything is how you do everything. – An ancient Rust proverb</p> </blockquote> <p>You can be sloppy in other languages, but not in Rust. That means you have to be accurate while you code or the code just won’t compile. The expectation is that this approach will save you debugging time in the future.</p> <p>I found that the people who learn Rust the fastest all have great attention to detail. If you try to just get things done and move on, you will have a harder time than if you aim to do things right on your first try. You will have a much better time if you re-read your code to fix stupid typos before pressing “compile.” Also build a habit of automatically adding <code>&amp;</code> and <code>mut</code> where necessary as you go.</p> <p>A good example of someone who thinks about these details while coding is Tsoding. For example, watch <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=b0KIDIOL_i4">this stream where he builds a search engine in Rust from scratch</a> to see what I mean. I think you can learn this skill as long as you’re putting in your best effort and give it some time.</p> <h2 id="don-t-cheat"><a class="zola-anchor" href="#don-t-cheat" aria-label="Anchor link for: don-t-cheat">Don’t Cheat</a></h2> <p>With today’s tooling it is very easy to offload the bulk of the work to the computer. Initially, it will feel like you’re making quick progress, but in reality, you just strengthen bad habits in your workflow. If you can’t explain what you wrote to someone else or if you don’t know about the tradeoffs/assumptions a part of your code makes, you took it too far.</p> <p>Often, this approach stems from a fear that you’re not making progress fast enough. But you don’t have to prove to someone else that you’re clever enough to pick up Rust very quickly.</p> <h4 id="walk-the-walk"><a class="zola-anchor" href="#walk-the-walk" aria-label="Anchor link for: walk-the-walk">Walk the Walk</a></h4> <p>To properly learn Rust you actually have to write a lot of code by hand. Don’t be a lurker on Reddit, reading through other people’s success stories. Have some skin in the game! Put in the hours because there is no silver bullet. Once it works, consider open sourcing your code even if you know it’s not perfect.</p> <h4 id="don-t-go-on-auto-pilot"><a class="zola-anchor" href="#don-t-go-on-auto-pilot" aria-label="Anchor link for: don-t-go-on-auto-pilot">Don’t Go on Auto-Pilot</a></h4> <p>LLMs are like driving a car on auto-pilot. It’s comfortable at first, but you won’t feel in control and slowly, that uneasy feeling will creep in. Turn off the autopilot while learning.</p> <p>A quick way to set you up for success is to learn by writing code in the Rust Playground first. Don’t use LLMs or code completion. Just type it out! If you can’t, that means you haven’t fully internalized a concept yet. That’s fine! Go to the standard library and read the docs. Take however long it takes and then come back and try again.</p> <p>Slow is steady and steady is fast.</p> <h4 id="build-muscle-memory"><a class="zola-anchor" href="#build-muscle-memory" aria-label="Anchor link for: build-muscle-memory">Build Muscle Memory</a></h4> <p>Muscle memory in programming is highly underrated. People will tell you that this is what code completion is for, but I believe it’s a requirement to reach a state of flow: if you constantly blunder over syntax errors or, worse, just wait for the next auto-completion to make progress, that is a terrible developer experience.</p> <p>When writing manually, you will make more mistakes. Embrace them! These mistakes will help you learn to understand the compiler output. You will get a “feeling” for how the output looks in different error scenarios. Don’t gloss over these errors. Over time you will develop an intuition about what feels “rustic.”</p> <h4 id="predict-the-output"><a class="zola-anchor" href="#predict-the-output" aria-label="Anchor link for: predict-the-output">Predict The Output</a></h4> <p>Another thing I like to do is to run “prediction exercises” where I guess if code will compile before running it. This builds intuition. Try to make every program free of syntax errors before you run it. Don’t be sloppy. Of course, you won’t always succeed, but you will get much better at it over time.</p> <h4 id="try-to-solve-problems-yourself-only-then-look-up-the-solution"><a class="zola-anchor" href="#try-to-solve-problems-yourself-only-then-look-up-the-solution" aria-label="Anchor link for: try-to-solve-problems-yourself-only-then-look-up-the-solution">Try To Solve Problems Yourself, Only <em>Then</em> Look Up The Solution.</a></h4> <p>Read lots of other people’s code. I recommend <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/BurntSushi/ripgrep"><code>ripgrep</code></a>, for example, which is some of the best Rust code out there.</p> <h4 id="develop-a-healthy-share-of-reading-writing-code"><a class="zola-anchor" href="#develop-a-healthy-share-of-reading-writing-code" aria-label="Anchor link for: develop-a-healthy-share-of-reading-writing-code">Develop A Healthy Share Of Reading/Writing Code.</a></h4> <p>Don’t be afraid to get your hands dirty. Which areas of Rust do you avoid? What do you run away from? Focus on that. Tackle your blind spots. Track your common “escape hatches” (unsafe, clone, etc.) to identify your current weaknesses. For example, if you are scared of proc macros, write a bunch of them.</p> <h4 id="break-your-code"><a class="zola-anchor" href="#break-your-code" aria-label="Anchor link for: break-your-code">Break Your Code</a></h4> <p>After you’re done with an exercise, break it! See what the compiler says. See if you can explain what happens.</p> <h4 id="don-t-use-other-people-s-crates-while-learning"><a class="zola-anchor" href="#don-t-use-other-people-s-crates-while-learning" aria-label="Anchor link for: don-t-use-other-people-s-crates-while-learning">Don’t Use Other People’s Crates While Learning</a></h4> <p>A poor personal version is better than a perfect external crate (at least while learning). Write some small library code yourself as an exercise. Notable exceptions are probably <code>serde</code> and <code>anyhow</code>, which can save you time dealing with JSON inputs and setting up error handling that you can spend on other tasks as long as you know how they work.</p> <h2 id="build-good-intuitions"><a class="zola-anchor" href="#build-good-intuitions" aria-label="Anchor link for: build-good-intuitions">Build Good Intuitions</a></h2> <p>Concepts like lifetimes are hard to grasp. Sometimes it helps to draw how data moves through your system. Develop a habit to explain concepts to yourself and others through drawing. I’m not sure, but I think this works best for “visual”/creative people (in comparison to highly analytical people).</p> <p>I personally use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://excalidraw.com/">excalidraw</a> for drawing. It has a “comicy” feel, which takes the edge off a bit. The implication is that it doesn’t feel highly accurate, but rather serves as a rough sketch. Many good engineers (as well as great Mathematicians and Physicists) are able to visualize concepts with sketches.</p> <p>In Rust, sketches can help to visualize lifetimes and ownership of data or for architecture diagrams.</p> <h2 id="build-on-top-of-what-you-already-know"><a class="zola-anchor" href="#build-on-top-of-what-you-already-know" aria-label="Anchor link for: build-on-top-of-what-you-already-know">Build On Top Of What You Already Know</a></h2> <p>Earlier I said you should forget everything you know about programming. How can I claim now that you should build on top of what you already know?</p> <p>What I meant is that Rust is the most different in familiar areas like control flow handling and value passing. E.g., mutability is very explicit in Rust and calling a function typically “moves” its arguments. That’s where you have to accept that Rust is just <em>different</em> and learn from <em>first principles</em>.</p> <p>However, it is okay to map Rust concepts to other languages you already know. For instance, “a trait is a bit like an interface” is wrong, but it is a good starting point to understand the concept.</p> <p>Here are a few more examples:</p> <ul> <li>“A struct is like a class (minus the inheritance)”</li> <li>“A closure is like a lambda function (but it can capture variables)”</li> <li>“A module is like a namespace (but more powerful)”</li> <li>“A borrow is like a pointer (but with single owner).”</li> </ul> <p>And if you have a functional background, it might be:</p> <ul> <li>“<code>Option</code> is like the <code>Maybe</code> monad”</li> <li>“Traits are like type-classes”</li> <li>“Enums are algebraic data types”</li> </ul> <p>The idea is that mapping concepts helps fill in the gaps more quickly.</p> <p>Map what you already know from another language (e.g., Python, TypeScript) to Rust concepts. As long as you know that there are subtle differences, I think it’s helpful.</p> <p>I don’t see people mention this a lot, but I believe that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rosettacode.org/wiki/Rosetta_Code">Rosetta Code</a> is a great resource for that. You basically browse their list of tasks, pick one you like and start comparing the Rust solution with the language you’re strongest in.</p> <p>Also, port code from a language you know to Rust. This way, you don’t have to learn a new domain at the same time as you learn Rust. You can build on your existing knowledge and experience.</p> <ul> <li>Translate common language idioms from your strongest language to Rust. E.g., how would you convert a list comprehension from Python to Rust? Try it first, then look for resources, which explain the concept in Rust. For instance, <a href="/blog/iterators">I wrote one</a> on this topic specifically.</li> <li>I know people who have a few standard exercises that they port to every new language they learn. For example, that could be a ray-tracer, a sorting algorithm, or a small web app.</li> </ul> <p>Finally, find other people who come from the same background as you. Read their blogs where they talk about their experiences learning Rust. Write down your experiences as well.</p> <h2 id="don-t-guess"><a class="zola-anchor" href="#don-t-guess" aria-label="Anchor link for: don-t-guess">Don’t Guess</a></h2> <p>I find that people who tend to <em>guess</em> their way through challenges often have the hardest time learning Rust.</p> <p>In Rust, the details are everything. Don’t gloss over details, because they always reveal some wisdom about the task at hand. Even if you don’t care about the details, they will come back to bite you later.</p> <p>For instance, why do you have to call <code>to_string()</code> on a thing that’s already a string?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #50FA7B;">my_func</span><span>(</span><span style="color: #F1FA8C;">&quot;hello&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span></span></code></pre> <p>Those stumbling blocks are learning opportunities. It might look like a waste of time to ask these questions and means that it will take longer to finish a task, but it will pay off in the long run.</p> <p>Reeeeeally read the error messages the compiler prints. Everyone thinks they do this, but time and again I see people look confused while the solution is right there in their terminal. There are <code>hints</code> as well; don’t ignore those. This alone will save you sooo much time. Thank me later.</p> <p>You might say that is true for every language, and you’d be right. But in Rust, the error messages are actually worth your time. Some of them are like small meditations: opportunities to think about the problem at a deeper level.</p> <p>If you get any borrow-checker errors, refuse the urge to guess what’s going on. Instead of guessing, <em>walk through the data flow by hand</em> (who owns what and when). Try to think it through for yourself and only try to compile again once you understand the problem.</p> <h2 id="lean-on-type-driven-development"><a class="zola-anchor" href="#lean-on-type-driven-development" aria-label="Anchor link for: lean-on-type-driven-development">Lean on Type-Driven Development</a></h2> <p>The key to good Rust code is through its type system.</p> <p>It’s <strong>all</strong> in the type system. Everything you need is hidden in plain sight. But often, people skip too much of the documentation and just look at the examples.</p> <p>What few people do is <em>read the actual function documentation</em>. You can even click through the standard library all the way to the source code to read the thing they are using. There is no magic (and that’s what’s so magical about it).</p> <p>You can do that in Rust much better than in most other languages. That’s because Python for example is written in C, which requires you to cross that language boundary to learn what’s going on. Similarly, the C++ standard library isn’t a single, standardized implementation, but rather has several different implementations maintained by different organizations. That makes it super hard to know <em>what exactly is going on</em>. In Rust, the source code is available right inside the documentation. Make good use of that!</p> <p>Function signatures tell a lot! The sooner you will embrace this additional information, the quicker you will be off to the races with Rust. If you have the time, read interesting parts of the standard library docs. Even after years, I always learn something when I do.</p> <p>Try to model your own projects with types first. This is when you start to have way more fun with the language. It feels like you have a conversation with the compiler about the problem you’re trying to solve.</p> <p>For example, once you learn how concepts like expressions, iterators and traits fit together, you can write more concise, readable code.</p> <p>Once you learn how to encode invariants in types, you can write more correct code that you don’t have to run to test. Instead, you can’t compile incorrect code in the first place.</p> <p>Learn Rust through “type-driven development” and let the compiler errors guide your design.</p> <h2 id="invest-time-in-finding-good-learning-resources"><a class="zola-anchor" href="#invest-time-in-finding-good-learning-resources" aria-label="Anchor link for: invest-time-in-finding-good-learning-resources">Invest Time In Finding Good Learning Resources</a></h2> <p>Before you start, shop around for resources that fit your personal learning style. To be honest, there is not that much good stuff out there yet. On the plus side, it doesn’t take too long to go through the list of resources <em>before</em> settling on one specific platform/book/course. The right resource depends on what learner you are. In the long run, finding the right resource saves you time because you will learn quicker.</p> <p>I personally don’t like doing toy exercises that others have built out for me. That’s why I don’t like Rustlings too much; the exercises are not “fun” and too theoretical. I want more practical exercises. I found that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://projecteuler.net/">Project Euler</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://adventofcode.com/">Advent of Code</a> work way better for me. The question comes up quite often, so I wrote a blog post about <a href="/blog/rust-learning-resources-2026/">my favorite Rust learning resources</a>.</p> <h4 id="don-t-just-watch-youtube"><a class="zola-anchor" href="#don-t-just-watch-youtube" aria-label="Anchor link for: don-t-just-watch-youtube">Don’t Just Watch YouTube</a></h4> <p>I like to watch YouTube, but exclusively for recreational purposes. In my opinion, watching <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/c/theprimeagen">ThePrimeagen</a> is for entertainment only. He’s an amazing programmer, but trying to learn how to program by watching someone else do it is like trying to learn how to become a great athlete by watching the Olympics. Similarly, I think we all can agree that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/c/JonGjengset">Jon Gjengset</a> is an exceptional programmer and teacher, but watching him might be overwhelming if you’re just starting out. (Love the content though!)</p> <p>Same goes for conference talks or podcasts: they are great for context, and for soft-skills, but not for learning Rust.</p> <p>Instead, invest in a good book if you can. Books are not yet outdated and you can read them offline, add personal notes, type out the code yourself and get a “spatial overview” of the depth of the content by flipping through the pages.</p> <p>Similarly, if you’re serious about using Rust professionally, buy a course or get your boss to invest in a trainer. Of course, I’m super biased here as I run a Rust consultancy, but I truly believe that it will save you and your company countless hours and will set you up for long-term success. Think about it: you will work with this codebase for years to come. Better make that experience a pleasant one. A good trainer, just like a good teacher, will not go through the Rust book with you, but watch you program Rust in the wild and give you personalized feedback about your weak spots.</p> <h2 id="find-a-coding-buddy"><a class="zola-anchor" href="#find-a-coding-buddy" aria-label="Anchor link for: find-a-coding-buddy">Find A Coding Buddy</a></h2> <p>“Shadow” more experienced team members or friends.</p> <p>Don’t be afraid to ask for a code review on Mastodon or the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/">Rust forum</a> and return the favor and do code reviews there yourself. Take on opportunities for pair programming.</p> <h4 id="explain-rust-code-to-non-rust-developers"><a class="zola-anchor" href="#explain-rust-code-to-non-rust-developers" aria-label="Anchor link for: explain-rust-code-to-non-rust-developers">Explain Rust Code To Non-Rust Developers</a></h4> <p>This is such a great way to see if you truly understood a concept. Don’t be afraid to say “I don’t know.” Then go and explore the answer together by going straight to the docs. It’s way more rewarding and honest.</p> <p>Help out with OSS code that is abandoned. If you put in a solid effort to fix an unmaintained codebase, you will help others while learning how to work with other people’s Rust code.</p> <p>Read code out loud and explain it. There’s no shame in that! It helps you “serialize” your thoughts and avoid skipping important details.</p> <p>Take notes. Write your own little “Rust glossary” that maps Rust terminology to concepts in your business domain. It doesn’t have to be complete and just has to serve your needs.</p> <p>Write down things you found hard and things you learned. If you find a great learning resource, share it!</p> <h2 id="believe-in-the-long-term-benefit"><a class="zola-anchor" href="#believe-in-the-long-term-benefit" aria-label="Anchor link for: believe-in-the-long-term-benefit">Believe In The Long-Term Benefit</a></h2> <p>If you learn Rust because you want to put it on your CV, stop. Learn something else instead.</p> <p>I think you have to actually <em>like</em> programming (and not just the idea of it) to enjoy Rust.</p> <p>If you want to be successful with Rust, you have to be in it for the long run. Set realistic expectations: You won’t be a “Rust grandmaster” in a week but you can achieve a lot in a month of focused effort. There is no silver bullet, but if you avoid the most common ways to shoot yourself in the foot, you pick up the language much faster. Rust is a day 2 language. You won’t “feel” as productive as in your first week of Go or Python, but stick it out and it will pay off. Good luck and have fun!</p> Thu, 01 May 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e02-svix/ https://corrode.dev/podcast/s04e02-svix/ <div><script id="letscast-player-db5e5052" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/svix-with-tom-hacohen/player.js?size=s"></script></div> <p>We don’t usually think much about Webhooks – at least I don’t. It’s just web requests after all, right? In reality, there is a lot of complexity behind routing webhook requests through the internet.</p> <p>What if a webhook request gets lost? How do you know it was received in the first place? Can it be a security issue if a webhook gets handled twice? (Spoiler alert: yes)</p> Thu, 17 Apr 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s04e01-microsoft/ https://corrode.dev/podcast/s04e01-microsoft/ <div><script id="letscast-player-ec2b56fd" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/microsoft-with-victor-ciura/player.js?size=s"></script></div> <p>Victor Ciura is a veteran C++ developer who worked on Visual C++ and the Clang Power Tools. In this first episode of season 4, we talk to him about large-scale Rust adoption at Microsoft.</p> Tue, 01 Apr 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/pitfalls-of-safe-rust/ https://corrode.dev/blog/pitfalls-of-safe-rust/ <p>When people say Rust is a “safe language”, they often mean memory safety. And while memory safety is a great start, it’s far from all it takes to build robust applications.</p> <p><strong>Memory safety is necessary but not sufficient for overall reliability.</strong></p> <p>In this article, I want to show you a few common gotchas in safe Rust that the compiler doesn’t detect and how to avoid them.</p> <h2 id="why-rust-can-t-always-help"><a class="zola-anchor" href="#why-rust-can-t-always-help" aria-label="Anchor link for: why-rust-can-t-always-help">Why Rust Can’t Always Help</a></h2> <p>Even in safe Rust code, you still need to handle various risks and edge cases. You need to address aspects like input validation and making sure that your business logic is correct.</p> <p>Here are just a few categories of bugs that Rust <strong>doesn’t</strong> protect you from:</p> <ul> <li>Type casting mistakes (e.g. overflows)</li> <li>Logic bugs</li> <li>Panics because of using <code>unwrap</code> or <code>expect</code></li> <li>Malicious or incorrect <code>build.rs</code> scripts in third-party crates</li> <li>Incorrect unsafe code in third-party libraries</li> <li>Race conditions</li> </ul> <p>Let’s look at ways to avoid some of the more common problems. The tips are roughly ordered by how likely you are to encounter them.</p> <h2 id="table-of-contents"><a class="zola-anchor" href="#table-of-contents" aria-label="Anchor link for: table-of-contents">Table of Contents</a></h2> <details class="toc"> <summary> Click here to expand the table of contents. </summary> <ul> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#protect-against-integer-overflow">Protect Against Integer Overflow</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#avoid-as-for-numeric-conversions">Avoid <code>as</code> For Numeric Conversions</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#use-bounded-types-for-numeric-values">Use Bounded Types for Numeric Values</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#don-t-index-into-arrays-without-bounds-checking">Don’t Index Into Arrays Without Bounds Checking</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#use-split-at-checked-instead-of-split-at">Use <code>split_at_checked</code> Instead Of <code>split_at</code></a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#make-invalid-states-unrepresentable">Make Invalid States Unrepresentable</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#avoid-primitive-types-for-business-logic">Avoid Primitive Types For Business Logic</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#handle-default-values-carefully">Handle Default Values Carefully</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#implement-debug-safely">Implement <code>Debug</code> Safely</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#careful-with-serialization">Careful With Serialization</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#protect-against-time-of-check-to-time-of-use-toctou">Protect Against Time-of-Check to Time-of-Use (TOCTOU)</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#use-constant-time-comparison-for-sensitive-data">Use Constant-Time Comparison for Sensitive Data</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#don-t-accept-unbounded-input">Don’t Accept Unbounded Input</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#surprising-behavior-of-path-join-with-absolute-paths">Surprising Behavior of <code>Path::join</code> With Absolute Paths</a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#check-for-unsafe-code-in-your-dependencies-with-cargo-geiger">Check For Unsafe Code In Your Dependencies With <code>cargo-geiger</code></a></li> <li><a href="https://corrode.dev/blog/pitfalls-of-safe-rust/#conclusion">Conclusion</a></li> </ul> </details> <h2 id="protect-against-integer-overflow"><a class="zola-anchor" href="#protect-against-integer-overflow" aria-label="Anchor link for: protect-against-integer-overflow">Protect Against Integer Overflow</a></h2> <p>Overflow errors can happen pretty easily:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Use unchecked arithmetic</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> calculate_total</span><span>(price</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>, quantity</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span> {</span></span> <span class="giallo-l"><span> price</span><span style="color: #FF79C6;"> *</span><span> quantity</span><span style="color: #6272A4;"> // Could overflow!</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If <code>price</code> and <code>quantity</code> are large enough, the result will overflow. Rust will panic in debug mode, but in release mode, it will silently wrap around.</p> <p>To avoid this, use checked arithmetic operations:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DO: Use checked arithmetic operations</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> calculate_total</span><span>(price</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>, quantity</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">u32</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> ArithmeticError</span><span>&gt; {</span></span> <span class="giallo-l"><span> price</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">checked_mul</span><span>(quantity)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">ok_or</span><span>(ArithmeticError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Overflow</span><span>)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Static checks are not removed since they don’t affect the performance of generated code. So if the compiler is able to detect the problem at compile time, it will do so:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 2</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> y</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 128</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> z</span><span style="color: #FF79C6;"> =</span><span> x</span><span style="color: #FF79C6;"> *</span><span> y;</span><span style="color: #6272A4;"> // Compile-time error!</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The error message will be:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>error</span><span style="color: #FF79C6;">:</span><span> this arithmetic operation will overflow</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> --&gt;</span><span> src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">4</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">13</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #BD93F9;">4</span><span style="color: #FF79C6;"> | let</span><span> z</span><span style="color: #FF79C6;"> =</span><span> x</span><span style="color: #FF79C6;"> *</span><span> y;</span><span style="color: #6272A4;"> // Compile-time error!</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ^^^^^</span><span> attempt to compute `</span><span style="color: #BD93F9;">2_</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 128_</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>`, which would overflow</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> =</span><span> note</span><span style="color: #FF79C6;">:</span><span> `#[deny(arithmetic_overflow)]` on by default</span></span></code></pre> <p>For all other cases, use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/num/latest/num/trait.CheckedAdd.html"><code>checked_add</code></a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/num/latest/num/trait.CheckedSub.html"><code>checked_sub</code></a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/num/latest/num/trait.CheckedMul.html"><code>checked_mul</code></a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/num/latest/num/trait.CheckedDiv.html"><code>checked_div</code></a>, which return <code>None</code> instead of wrapping around on underflow or overflow. <sup class="footnote-reference" id="fr-intrinsics_docs-1"><a href="#fn-intrinsics_docs">1</a></sup></p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Quick Tip: Enable Overflow Checks In Release Mode</p> </h4> </div> <p>Rust carefully balances performance and safety. In scenarios where a performance hit is acceptable, memory safety takes precedence. <sup class="footnote-reference" id="fr-memory_safety-1"><a href="#fn-memory_safety">1</a></sup></p> <p>Integer overflows can lead to unexpected results, but they are not inherently unsafe. On top of that, overflow checks can be expensive, which is why Rust disables them in release mode. <sup class="footnote-reference" id="fr-overflow-1"><a href="#fn-overflow">2</a></sup></p> <p>However, you can re-enable them in case your application can trade the last 1% of performance for better overflow detection.</p> <p>Put this into your <code>Cargo.toml</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">profile</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">release</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">overflow-checks</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> true</span><span style="color: #6272A4;"> # Enable integer overflow checks in release mode</span></span></code></pre> <p>This will enable overflow checks in release mode. As a consequence, the code will panic if an overflow occurs.</p> <p>See <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/profiles.html#release">the docs</a> for more details.</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-memory_safety"> <p>One example where Rust accepts a performance cost for safety would be checked array indexing, which prevents buffer overflows at runtime. Another is when the Rust maintainers <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://internals.rust-lang.org/t/help-us-benchmark-saturating-float-casts/6231">fixed float casting</a> because the previous implementation could cause undefined behavior when casting certain floating point values to integers. <a href="#fr-memory_safety-1">↩</a></p> </li> <li id="fn-overflow"> <p>According to some benchmarks, overflow checks cost a few percent of performance on typical integer-heavy workloads. See Dan Luu’s analysis <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://danluu.com/integer-overflow/">here</a> <a href="#fr-overflow-1">↩</a></p> </li> </ol> </section> </div> <h2 id="avoid-as-for-numeric-conversions"><a class="zola-anchor" href="#avoid-as-for-numeric-conversions" aria-label="Anchor link for: avoid-as-for-numeric-conversions">Avoid <code>as</code> For Numeric Conversions</a></h2> <p>While we’re on the topic of integer arithmetic, let’s talk about type conversions. Casting values with <code>as</code> is convenient but risky unless you know exactly what you are doing.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> y</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i8</span><span style="color: #FF79C6;"> =</span><span> x</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> i8</span><span>;</span><span style="color: #6272A4;"> // Can overflow!</span></span></code></pre> <p>There are three main ways to convert between numeric types in Rust:</p> <ol> <li> <p>⚠️ Using the <code>as</code> keyword: This approach works for both lossless and lossy conversions. In cases where data loss might occur (like converting from <code>i64</code> to <code>i32</code>), <strong>it will simply truncate the value</strong>.</p> </li> <li> <p>Using <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/convert/trait.From.html"><code>From::from()</code></a>: This method only allows <strong>lossless conversions</strong>. For example, you can convert from <code>i32</code> to <code>i64</code> since all 32-bit integers can fit within 64 bits. However, you cannot convert from <code>i64</code> to <code>i32</code> using this method since it could potentially lose data.</p> </li> <li> <p>Using <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/convert/trait.TryFrom.html"><code>TryFrom</code></a>: This method is similar to <code>From::from()</code> but returns a <code>Result</code> instead of panicking. This is useful when you want to handle potential data loss gracefully.</p> </li> </ol> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Quick Tip: Safe Numeric Conversions</p> </h4> </div> <p><strong>If in doubt, prefer <code>From::from()</code> and <code>TryFrom</code> over <code>as</code>.</strong></p> <ol> <li>use <code>From::from()</code> when you can guarantee no data loss.</li> <li>use <code>TryFrom</code> when you need to handle potential data loss gracefully.</li> <li>only use <code>as</code> when you’re comfortable with potential truncation or know the values will fit within the target type’s range and when performance is absolutely critical.</li> </ol> <p>(<em>Adapted from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.com/a/28280042/270334">StackOverflow answer by delnan</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.com/a/48795524/270334">additional context</a>.</em>)</p> </div> <p>The <code>as</code> operator is <strong>not safe for narrowing conversions</strong>. It will silently truncate the value, leading to unexpected results.</p> <p>What is a “narrowing conversion”? It’s when you convert a larger type to a smaller type, e.g. <code>i32</code> to <code>i8</code>.</p> <p>For example, see how <code>as</code> chops off the high bits from our value:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> a</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 0x1234</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> b</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span> a</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;0x{:04x}, 0x{:02x}&quot;</span><span>, a, b);</span><span style="color: #6272A4;"> // 0x1234, 0x34</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>So, coming back to our first example above, instead of writing</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> y</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i8</span><span style="color: #FF79C6;"> =</span><span> x</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> i8</span><span>;</span><span style="color: #6272A4;"> // Can overflow!</span></span></code></pre> <p>use <code>TryFrom</code> instead and handle the error gracefully:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> y</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> i8</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">try_from</span><span>(x)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or</span><span>(</span><span style="color: #F1FA8C;">&quot;Number is too big to be used here&quot;</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span></code></pre><h2 id="use-bounded-types-for-numeric-values"><a class="zola-anchor" href="#use-bounded-types-for-numeric-values" aria-label="Anchor link for: use-bounded-types-for-numeric-values">Use Bounded Types for Numeric Values</a></h2> <p>Bounded types make it easier to express invariants and avoid invalid states. E.g. if you have a numeric type and 0 is <em>never</em> a correct value, use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/num/type.NonZeroUsize.html"><code>std::num::NonZeroUsize</code></a> instead.</p> <p>You can also create your own bounded types:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Use raw numeric types for domain values</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Measurement</span><span> {</span></span> <span class="giallo-l"><span> distance</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> f64</span><span>,</span><span style="color: #6272A4;"> // Could be negative!</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// DO: Create bounded types</span></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Clone</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Copy</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Distance</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">f64</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Distance</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(value</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> f64</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> DistanceError</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> value</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #BD93F9;"> 0.0</span><span style="color: #FF79C6;"> || !</span><span>value</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_finite</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">DistanceError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Invalid</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #50FA7B;">Distance</span><span>(value))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Measurement</span><span> {</span></span> <span class="giallo-l"><span> distance</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Distance</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=a9157c58ada88e85b82d835a5eceac66">Rust Playground</a>)</p> <h2 id="don-t-index-into-arrays-without-bounds-checking"><a class="zola-anchor" href="#don-t-index-into-arrays-without-bounds-checking" aria-label="Anchor link for: don-t-index-into-arrays-without-bounds-checking">Don’t Index Into Arrays Without Bounds Checking</a></h2> <p>Whenever I see the following, I get goosebumps 😨:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> arr</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> elem</span><span style="color: #FF79C6;"> =</span><span> arr[</span><span style="color: #BD93F9;">3</span><span>];</span><span style="color: #6272A4;"> // uh-oh!</span></span></code></pre> <p>That’s a common source of bugs. Unlike C, Rust <em>does</em> check array bounds and prevents a security vulnerability, but <strong>it still panics at runtime</strong>.</p> <p>Instead, use the <code>get</code> method:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> elem</span><span style="color: #FF79C6;"> =</span><span> arr</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">get</span><span>(</span><span style="color: #BD93F9;">3</span><span>);</span></span></code></pre> <p>It returns an <code>Option</code> which you can now handle gracefully. See <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://shnatsel.medium.com/how-to-avoid-bounds-checks-in-rust-without-unsafe-f65e618b4c1e">this blog post</a> for more info on the topic.</p> <h2 id="use-split-at-checked-instead-of-split-at"><a class="zola-anchor" href="#use-split-at-checked-instead-of-split-at" aria-label="Anchor link for: use-split-at-checked-instead-of-split-at">Use <code>split_at_checked</code> Instead Of <code>split_at</code></a></h2> <p>This issue is related to the previous one. Say you have a slice and you want to split it at a certain index.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> mid</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 4</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> arr</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> (left, right)</span><span style="color: #FF79C6;"> =</span><span> arr</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">split_at</span><span>(mid);</span></span></code></pre> <p>You might expect that this returns a tuple of slices where the first slice contains all elements and the second slice is empty.</p> <p>⚠️ <strong>Instead, the above code will panic because the mid index is out of bounds!</strong></p> <p>To handle that more gracefully, use <code>split_at_checked</code> instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> arr</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span> <span class="giallo-l"><span style="color: #6272A4;">// This returns an Option</span></span> <span class="giallo-l"><span style="color: #FF79C6;">match</span><span> arr</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">split_at_checked</span><span>(mid) {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>((left, right))</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with left and right</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Handle the error</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This returns an <code>Option</code> which allows you to handle the error case. (<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=8208b1a16e73e63d37799fed27cd1e49">Rust Playground</a>)</p> <p>More info about <code>split_at_checked</code> <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/primitive.slice.html#method.split_at_checked">here</a>.</p> <h2 id="avoid-primitive-types-for-business-logic"><a class="zola-anchor" href="#avoid-primitive-types-for-business-logic" aria-label="Anchor link for: avoid-primitive-types-for-business-logic">Avoid Primitive Types For Business Logic</a></h2> <p>It’s very tempting to use primitive types for everything. Especially Rust beginners fall into this trap.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Use primitive types for usernames</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> authenticate_user</span><span>(username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Raw String could be anything - empty, too long, or contain invalid characters</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>However, do you really accept <em>any</em> string as a valid username? What if it’s empty? What if it contains emojis or special characters? That would likely be unexpected.</p> <p>Instead, you can create a custom type for your domain:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Clone</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> PartialEq</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Eq</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Hash</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(name</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> UsernameError</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Check for empty username</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UsernameError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Empty</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Check length (for example, max 30 characters)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt;</span><span style="color: #BD93F9;"> 30</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UsernameError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">TooLong</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Only allow alphanumeric characters and underscores</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if !</span><span>name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chars</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">all</span><span>(</span><span style="color: #FF79C6;">|</span><span>c</span><span style="color: #FF79C6;">|</span><span> c</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_alphanumeric</span><span>()</span><span style="color: #FF79C6;"> ||</span><span> c</span><span style="color: #FF79C6;"> ==</span><span style="color: #F1FA8C;"> &#39;_&#39;</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UsernameError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidCharacters</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #50FA7B;">Username</span><span>(name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>()))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Allow to get a reference to the inner string</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> as_str</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> &amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> authenticate_user</span><span>(username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // We know this is always a valid username!</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // No empty strings, no emojis, no spaces, etc.</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=fe47108e246366718d7759eb7abf02f3">Rust playground</a>)</p> <h2 id="make-invalid-states-unrepresentable"><a class="zola-anchor" href="#make-invalid-states-unrepresentable" aria-label="Anchor link for: make-invalid-states-unrepresentable">Make Invalid States Unrepresentable</a></h2> <p>Can you spot the bug in the following code?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Allow invalid combinations</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Configuration</span><span> {</span></span> <span class="giallo-l"><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span>,</span></span> <span class="giallo-l"><span> host</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> ssl</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span> ssl_cert</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;, </span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The problem is that you can have <code>ssl</code> set to <code>true</code> but <code>ssl_cert</code> set to <code>None</code>. That’s an invalid state! If you try to use the SSL connection, you can’t because there’s no certificate.</p> <p>This issue can be detected at compile-time by using types to enforce valid states. First, let’s define the possible states for the connection:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> ConnectionSecurity</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Insecure</span><span>,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // We can&#39;t have an SSL connection</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // without a certificate!</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ssl</span><span> { cert_path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span> },</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now we can’t have an invalid state! Either we have an SSL connection with a certificate or we don’t have SSL at all.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Configuration</span><span> {</span></span> <span class="giallo-l"><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span>,</span></span> <span class="giallo-l"><span> host</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> security</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> ConnectionSecurity</span><span>,</span><span style="color: #6272A4;"> // All possible states are valid! </span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In comparison to the previous section, the bug was caused by an <em>invalid combination of closely related fields</em>. To prevent that, clearly map out all possible states and transitions between them. A simple way is to define an enum with optional metadata for each state.</p> <p>The learning here is that Rust can’t protect you from logic bugs. If you’re curious to learn more, here is a more in-depth <a href="/blog/illegal-state/">blog post on the topic</a>.</p> <h2 id="handle-default-values-carefully"><a class="zola-anchor" href="#handle-default-values-carefully" aria-label="Anchor link for: handle-default-values-carefully">Handle Default Values Carefully</a></h2> <p>It’s quite common to add a blanket <code>Default</code> implementation to your types without thinking twice about it. But that can lead to unforeseen issues.</p> <p>For example, here’s a case where the port is set to 0 by default, which is not a valid port number.<sup class="footnote-reference" id="fr-port-1"><a href="#fn-port">2</a></sup></p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Implement `Default` without consideration</span></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Default</span><span>)]</span><span style="color: #6272A4;"> // Might create invalid states!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> ServerConfig</span><span> {</span></span> <span class="giallo-l"><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span>,</span><span style="color: #6272A4;"> // Will be 0, which might be unexpected </span></span> <span class="giallo-l"><span> max_connections</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>,</span></span> <span class="giallo-l"><span> timeout_seconds</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u64</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Instead, consider if a default value makes sense for your type. If there is no sane default, don’t implement <code>Default</code> at all and let the user be explicit.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DO: Make Default meaningful or don&#39;t implement it</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> ServerConfig</span><span> {</span></span> <span class="giallo-l"><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Port</span><span>,</span></span> <span class="giallo-l"><span> max_connections</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> NonZeroUsize</span><span>,</span></span> <span class="giallo-l"><span> timeout_seconds</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> ServerConfig</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Port</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span> port,</span></span> <span class="giallo-l"><span> max_connections</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> NonZeroUsize</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #BD93F9;">100</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>(),</span></span> <span class="giallo-l"><span> timeout_seconds</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">30</span><span>),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="implement-debug-safely"><a class="zola-anchor" href="#implement-debug-safely" aria-label="Anchor link for: implement-debug-safely">Implement <code>Debug</code> Safely</a></h2> <p>A related issue is the <code>Debug</code> trait. One might assume that <code>Debug</code> is only used for “debugging purposes” and is therefore harmless, but if you blindly derive <code>Debug</code> for all types, you might expose sensitive data. That’s because <code>Debug</code> is often used in logging and error messages, even in production code. Instead, implement <code>Debug</code> manually for types that contain sensitive information.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// This would expose sensitive data in logs!</span></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> password</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span><span style="color: #6272A4;"> // Will be printed as plain text!</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Instead, you could write:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> password</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Here we implement Debug manually to redact the password</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> fmt</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, f</span><span style="color: #FF79C6;">: &amp;mut</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Formatter</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">_</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span> {</span></span> <span class="giallo-l"><span> f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">write_str</span><span>(</span><span style="color: #F1FA8C;">&quot;[REDACTED]&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Let’s say we were to print a <code>User</code> instance:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;ferris&quot;</span><span>),</span></span> <span class="giallo-l"><span> password</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> Password</span><span>(String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;supersecret&quot;</span><span>)),</span></span> <span class="giallo-l"><span>};</span></span> <span class="giallo-l"><span style="color: #50FA7B;">println!</span><span>(</span><span style="color: #F1FA8C;">&quot;{user:#?}&quot;</span><span>);</span></span></code></pre> <p>The output would be:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;">User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;ferris&quot;</span><span>,</span></span> <span class="giallo-l"><span> password</span><span style="color: #FF79C6;">:</span><span> [</span><span style="color: #BD93F9;">REDACTED</span><span>],</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=8fd18d9e13f60193bc14e97ea258707e">Rust playground</a>)</p> <p>For production code, use a crate like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/secrecy"><code>secrecy</code></a>.</p> <p>However, it’s not black and white either: If you implement <code>Debug</code> manually, you might forget to update the implementation when your struct changes. A common pattern is to destructure the struct in the <code>Debug</code> implementation to catch such errors.</p> <p>Instead of this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// don&#39;t</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> DatabaseURI</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> fmt</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, f</span><span style="color: #FF79C6;">: &amp;mut</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Formatter</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">_</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> write!</span><span>(f,</span><span style="color: #F1FA8C;"> &quot;{}://{}:[REDACTED]@{}/{}&quot;</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>scheme,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>user,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>host,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>database)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>How about destructuring the struct to catch changes?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// do</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> DatabaseURI</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> fmt</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, f</span><span style="color: #FF79C6;">: &amp;mut</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Formatter</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">_</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span> std</span><span style="color: #FF79C6;">::</span><span>fmt</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Destructure the struct to catch changes</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This way, the compiler will warn you if you add a new field</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // and forget to update the Debug implementation</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span style="color: #8BE9FD;font-style: italic;"> DatabaseURI</span><span> { scheme, user, password</span><span style="color: #FF79C6;">:</span><span> _, host, database, }</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> write!</span><span>(f,</span><span style="color: #F1FA8C;"> &quot;{scheme}://{user}:[REDACTED]@{host}/{database}&quot;</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // -- or --</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // f.debug_struct(&quot;DatabaseURI&quot;)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .field(&quot;scheme&quot;, scheme)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .field(&quot;user&quot;, user)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .field(&quot;password&quot;, &amp;&quot;***&quot;)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .field(&quot;host&quot;, host)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .field(&quot;database&quot;, database)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // .finish()</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=a2facbaa5290f9518072ac214df370aa">Rust playground</a>)</p> <p>Thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.wezm.net">Wesley Moore (wezm)</a> for the hint and to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/M3t0r">Simon Brüggen (m3t0r)</a> for the example.</p> <h2 id="careful-with-serialization"><a class="zola-anchor" href="#careful-with-serialization" aria-label="Anchor link for: careful-with-serialization">Careful With Serialization</a></h2> <p>Don’t blindly derive <code>Serialize</code> and <code>Deserialize</code> either, especially for sensitive data. The values you read/write might not be what you expect!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Serialize</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Deserialize</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> UserCredentials</span><span> {</span></span> <span class="giallo-l"><span> #[serde(default)]</span><span style="color: #6272A4;"> // ⚠️ Accepts empty strings when deserializing!</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> #[serde(default)]</span></span> <span class="giallo-l"><span> password</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span><span style="color: #6272A4;"> // ⚠️ Leaks the password when serialized!</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>When deserializing, the fields might be empty. Empty credentials could potentially pass validation checks if not properly handled.</p> <p>On top of that, the serialization behavior could also leak sensitive data. By default, <code>Serialize</code> will include the password field in the serialized output, which could expose sensitive credentials in logs, API responses, or debug output.</p> <p>A common fix is to implement your own custom serialization and deserialization methods by using <code>impl&lt;'de&gt; Deserialize&lt;'de&gt; for UserCredentials</code>.</p> <p>The advantage is that you have full control over input validation. However, the disadvantage is that you need to implement all the logic yourself.</p> <p>An alternative strategy is to use the <code>#[serde(try_from = "FromType")]</code> attribute.</p> <p>Let’s take the <code>Password</code> field as an example. Start by using the newtype pattern to wrap the standard types and add custom validation:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Deserialize</span><span>)]</span></span> <span class="giallo-l"><span style="color: #6272A4;">// Tell serde to call `Password::try_from` with a `String`</span></span> <span class="giallo-l"><span>#[serde(try_from </span><span style="color: #FF79C6;">=</span><span style="color: #F1FA8C;"> &quot;String&quot;</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span></code></pre> <p>Now implement <code>TryFrom</code> for <code>Password</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> TryFrom</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> PasswordError</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Create a new password</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Throws an error if the password is too short.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// You can add more checks here.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> try_from</span><span>(value</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Validate the password</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> value</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &lt;</span><span style="color: #BD93F9;"> 8</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">PasswordError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">TooShort</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #50FA7B;">Password</span><span>(value))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>With this trick, you can no longer deserialize invalid passwords:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Panic: password too short!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> password</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Password</span><span style="color: #FF79C6;"> =</span><span> serde_json</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_str</span><span>(</span><span style="color: #F1FA8C;">r#&quot;&quot;pass&quot;&quot;#</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span></code></pre> <p>(Try it on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=ba0f1a45d5ac982b00a5b5f68a1a0d9e">Rust Playground</a>)</p> <p>Credits go to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dev.to/equalma/validate-fields-and-types-in-serde-with-tryfrom-c2n">EqualMa’s article on dev.to</a> and to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/durka">Alex Burka (durka)</a> for the hint.</p> <h2 id="protect-against-time-of-check-to-time-of-use-toctou"><a class="zola-anchor" href="#protect-against-time-of-check-to-time-of-use-toctou" aria-label="Anchor link for: protect-against-time-of-check-to-time-of-use-toctou">Protect Against Time-of-Check to Time-of-Use (TOCTOU)</a></h2> <p>This is a more advanced topic, but it’s important to be aware of it. TOCTOU (time-of-check to time-of-use) is a class of software bugs caused by changes that happen between when you check a condition and when you use a resource.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Vulnerable approach with separate check and use</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> remove_dir</span><span>(path</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;()&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // First check if it&#39;s a directory</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if !</span><span>path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_dir</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NotADirectory</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;not a directory&quot;</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // TOCTOU vulnerability: Between the check above and the use below,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // the path could be replaced with a symlink to a directory we shouldn&#39;t access!</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> remove_dir_impl</span><span>(path)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=fb208eb58e49ce70bde77a48b9b102d1">Rust playground</a>)</p> <p>The safer approach opens the directory first, ensuring we operate on what we checked:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DO: Safer approach that opens first, then checks</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> remove_dir</span><span>(path</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;()&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Open the directory WITHOUT following symlinks</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> handle</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> OpenOptions</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">read</span><span>(</span><span style="color: #BD93F9;">true</span><span>)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Fails if not a directory or is a symlink</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">custom_flags</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">O_NOFOLLOW</span><span style="color: #FF79C6;"> |</span><span style="color: #8BE9FD;font-style: italic;"> O_DIRECTORY</span><span>) </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">open</span><span>(path)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // We can now safely remove the directory contents using the open handle</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> remove_dir_impl</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>handle)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=08a3a0a030a1878171e7eb76adb6ffb8">Rust playground</a>)</p> <p>Here’s why it’s safer: while we hold the handle, the directory can’t be replaced with a symlink. This way, the directory we’re working with is the same as the one we checked. Any attempt to replace it won’t affect us because the handle is already open.</p> <p>You’d be forgiven if you overlooked this issue before. In fact, even the Rust core team missed it in the standard library. What you saw is a simplified version of an actual bug in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/fs/fn.remove_dir_all.html"><code>std::fs::remove_dir_all</code></a> function. Read more about it in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2022/01/20/cve-2022-21658.html">this blog post about CVE-2022-21658</a>.</p> <h2 id="use-constant-time-comparison-for-sensitive-data"><a class="zola-anchor" href="#use-constant-time-comparison-for-sensitive-data" aria-label="Anchor link for: use-constant-time-comparison-for-sensitive-data">Use Constant-Time Comparison for Sensitive Data</a></h2> <p>Timing attacks are a nifty way to extract information from your application. The idea is that the time it takes to compare two values can leak information about them. For example, the time it takes to compare two strings can reveal how many characters are correct. Therefore, for production code, be careful with regular equality checks when handling sensitive data like passwords.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Use regular equality for sensitive comparisons</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> verify_password</span><span>(stored</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>], provided</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>])</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span> stored</span><span style="color: #FF79C6;"> ==</span><span> provided</span><span style="color: #6272A4;"> // Vulnerable to timing attacks!</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// DO: Use constant-time comparison</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> subtle</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">ConstantTimeEq</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Choice</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> verify_password</span><span>(stored</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>], provided</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>])</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span> stored</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ct_eq</span><span>(provided)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap_u8</span><span>()</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 1</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="don-t-accept-unbounded-input"><a class="zola-anchor" href="#don-t-accept-unbounded-input" aria-label="Anchor link for: don-t-accept-unbounded-input">Don’t Accept Unbounded Input</a></h2> <p>Protect Against Denial-of-Service Attacks with Resource Limits. These happen when you accept unbounded input, e.g. a huge request body which might not fit into memory.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// DON&#39;T: Accept unbounded input</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_request</span><span>(data</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>])</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;(),</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> decoded</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> decode_data</span><span>(data)</span><span style="color: #FF79C6;">?</span><span>;</span><span style="color: #6272A4;"> // Could be enormous!</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Process decoded data</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Instead, set explicit limits for your accepted payloads:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> MAX_REQUEST_SIZE</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1024</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 1024</span><span>;</span><span style="color: #6272A4;"> // 1MiB</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_request</span><span>(data</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>])</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;(),</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt;</span><span style="color: #BD93F9;"> MAX_REQUEST_SIZE</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">RequestTooLarge</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> decoded</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> decode_data</span><span>(data)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Process decoded data</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="surprising-behavior-of-path-join-with-absolute-paths"><a class="zola-anchor" href="#surprising-behavior-of-path-join-with-absolute-paths" aria-label="Anchor link for: surprising-behavior-of-path-join-with-absolute-paths">Surprising Behavior of <code>Path::join</code> With Absolute Paths</a></h2> <p>If you use <code>Path::join</code> to join a relative path with an absolute path, it will silently replace the relative path with the absolute path.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> path</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;/usr&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(</span><span style="color: #F1FA8C;">&quot;/local/bin&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;{path:?}&quot;</span><span>);</span><span style="color: #6272A4;"> // Prints &quot;/local/bin&quot; </span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This is because <code>Path::join</code> will return the second path if it is absolute.</p> <p>I was not the only one who was confused by this behavior. Here’s a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/rationale-behind-replacing-paths-while-joining/104288">thread on the topic</a>, which also includes an answer by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/u/jdahlstrom/summary">Johannes Dahlström</a>:</p> <blockquote> <p>The behavior is useful because a caller […] can choose whether it wants to use a relative or absolute path, and the callee can then simply absolutize it by adding its own prefix and the absolute path is unaffected which is probably what the caller wanted. The callee doesn’t have to separately check whether the path is absolute or not.</p> </blockquote> <p>And yet, I still think it’s a footgun. It’s easy to overlook this behavior when you use user-provided paths. Perhaps <code>join</code> should return a <code>Result</code> instead? In any case, be aware of this behavior.</p> <h2 id="check-for-unsafe-code-in-your-dependencies-with-cargo-geiger"><a class="zola-anchor" href="#check-for-unsafe-code-in-your-dependencies-with-cargo-geiger" aria-label="Anchor link for: check-for-unsafe-code-in-your-dependencies-with-cargo-geiger">Check For Unsafe Code In Your Dependencies With <code>cargo-geiger</code></a></h2> <p>So far, we’ve only covered issues with your own code. For production code, you also need to check your dependencies. Especially unsafe code would be a concern. This can be quite challenging, especially if you have a lot of dependencies.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/geiger-rs/cargo-geiger">cargo-geiger</a> is a neat tool that checks your dependencies for unsafe code. It can help you identify potential security risks in your project.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-geiger</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> geiger</span></span></code></pre> <p>This will give you a report of how many unsafe functions are in your dependencies. Based on this, you can decide if you want to keep a dependency or not.</p> <h2 id="clippy-can-prevent-many-of-these-issues"><a class="zola-anchor" href="#clippy-can-prevent-many-of-these-issues" aria-label="Anchor link for: clippy-can-prevent-many-of-these-issues">Clippy Can Prevent Many Of These Issues</a></h2> <p>Here is a set of clippy lints that can help you catch these issues at compile time. See for yourself in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2024&amp;gist=26fffd0b9c89822295c4225182238c8c">Rust playground</a>.</p> <p>Here’s the gist:</p> <ul> <li><code>cargo check</code> will <strong>not</strong> report any issues.</li> <li><code>cargo run</code> will <strong>panic</strong> or silently fail at runtime.</li> <li><code>cargo clippy</code> will <strong>catch</strong> all issues at <em>compile time</em> (!) 😎</li> </ul> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Arithmetic</span></span> <span class="giallo-l"><span>#![deny(arithmetic_overflow)]</span><span style="color: #6272A4;"> // Prevent operations that would cause integer overflow</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>checked_conversions)]</span><span style="color: #6272A4;"> // Suggest using checked conversions between numeric types</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>cast_possible_truncation)]</span><span style="color: #6272A4;"> // Detect when casting might truncate a value</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>cast_sign_loss)]</span><span style="color: #6272A4;"> // Detect when casting might lose sign information</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>cast_possible_wrap)]</span><span style="color: #6272A4;"> // Detect when casting might cause value to wrap around</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>cast_precision_loss)]</span><span style="color: #6272A4;"> // Detect when casting might lose precision</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>integer_division)]</span><span style="color: #6272A4;"> // Highlight potential bugs from integer division truncation</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>arithmetic_side_effects)]</span><span style="color: #6272A4;"> // Detect arithmetic operations with potential side effects</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>unchecked_duration_subtraction)]</span><span style="color: #6272A4;"> // Ensure duration subtraction won&#39;t cause underflow</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Unwraps</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>unwrap_used)]</span><span style="color: #6272A4;"> // Discourage using .unwrap() which can cause panics</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>expect_used)]</span><span style="color: #6272A4;"> // Discourage using .expect() which can cause panics</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>panicking_unwrap)]</span><span style="color: #6272A4;"> // Prevent unwrap on values known to cause panics</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>option_env_unwrap)]</span><span style="color: #6272A4;"> // Prevent unwrapping environment variables which might be absent</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Array indexing</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>indexing_slicing)]</span><span style="color: #6272A4;"> // Avoid direct array indexing and use safer methods like .get()</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Path handling</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>join_absolute_paths)]</span><span style="color: #6272A4;"> // Prevent issues when joining paths with absolute paths</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Serialization issues</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>serde_api_misuse)]</span><span style="color: #6272A4;"> // Prevent incorrect usage of Serde&#39;s serialization/deserialization API</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Unbounded input</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>uninit_vec)]</span><span style="color: #6272A4;"> // Prevent creating uninitialized vectors which is unsafe</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Unsafe code detection</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>transmute_int_to_char)]</span><span style="color: #6272A4;"> // Prevent unsafe transmutation from integers to characters</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>transmute_int_to_float)]</span><span style="color: #6272A4;"> // Prevent unsafe transmutation from integers to floats</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>transmute_ptr_to_ref)]</span><span style="color: #6272A4;"> // Prevent unsafe transmutation from pointers to references</span></span> <span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>transmute_undefined_repr)]</span><span style="color: #6272A4;"> // Detect transmutes with potentially undefined representations</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>time</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ARITHMETIC ISSUES</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Integer overflow: This would panic in debug mode and silently wrap in release</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> a</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 255</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _b</span><span style="color: #FF79C6;"> =</span><span> a</span><span style="color: #FF79C6;"> +</span><span style="color: #BD93F9;"> 1</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Unsafe casting: Could truncate the value</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> large_number</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i64</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1_000_000_000_000</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _small_number</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span style="color: #FF79C6;"> =</span><span> large_number</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Sign loss when casting</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> negative</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span style="color: #FF79C6;"> = -</span><span style="color: #BD93F9;">5</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _unsigned</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span style="color: #FF79C6;"> =</span><span> negative</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Integer division can truncate results</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _result</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 5</span><span style="color: #FF79C6;"> /</span><span style="color: #BD93F9;"> 2</span><span>;</span><span style="color: #6272A4;"> // Results in 2, not 2.5</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Duration subtraction can underflow</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> short</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">1</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> long</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_secs</span><span>(</span><span style="color: #BD93F9;">2</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _negative</span><span style="color: #FF79C6;"> =</span><span> short</span><span style="color: #FF79C6;"> -</span><span> long;</span><span style="color: #6272A4;"> // This would underflow</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // UNWRAP ISSUES</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Using unwrap on Option that could be None</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> data</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> None</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _value</span><span style="color: #FF79C6;"> =</span><span> data</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Using expect on Result that could be Err</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> result</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;error occurred&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _value</span><span style="color: #FF79C6;"> =</span><span> result</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">expect</span><span>(</span><span style="color: #F1FA8C;">&quot;This will panic&quot;</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Trying to get environment variable that might not exist</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _api_key</span><span style="color: #FF79C6;"> =</span><span> std</span><span style="color: #FF79C6;">::</span><span>env</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">var</span><span>(</span><span style="color: #F1FA8C;">&quot;API_KEY&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // ARRAY INDEXING ISSUES</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Direct indexing without bounds checking</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> numbers</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _fourth</span><span style="color: #FF79C6;"> =</span><span> numbers[</span><span style="color: #BD93F9;">3</span><span>];</span><span style="color: #6272A4;"> // This would panic</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Safe alternative with .get()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(fourth)</span><span style="color: #FF79C6;"> =</span><span> numbers</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">get</span><span>(</span><span style="color: #BD93F9;">3</span><span>) {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;{fourth}&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // PATH HANDLING ISSUES</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Joining with absolute path discards the base path</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> base</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;/home/user&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _full_path</span><span style="color: #FF79C6;"> =</span><span> base</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(</span><span style="color: #F1FA8C;">&quot;/etc/config&quot;</span><span>);</span><span style="color: #6272A4;"> // Results in &quot;/etc/config&quot;, base is ignored</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Safe alternative</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> base</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;/home/user&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> relative</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Path</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;config&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> full_path</span><span style="color: #FF79C6;"> =</span><span> base</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(relative);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Safe path joining: {:?}&quot;</span><span>, full_path);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // UNSAFE CODE ISSUES</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Creating uninitialized vectors (could cause undefined behavior)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> vec</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">with_capacity</span><span>(</span><span style="color: #BD93F9;">10</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> unsafe</span><span> {</span></span> <span class="giallo-l"><span> vec</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">set_len</span><span>(</span><span style="color: #BD93F9;">10</span><span>);</span><span style="color: #6272A4;"> // This is UB as Strings aren&#39;t initialized</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Phew, that was a lot of pitfalls! How many of them did you know about?</p> <p>Even if Rust is a great language for writing safe, reliable code, developers still need to be disciplined to avoid bugs.</p> <p>A lot of the common mistakes we saw have to do with Rust being a systems programming language: In computing systems, a lot of operations are performance critical and inherently unsafe. We are dealing with external systems outside of our control, such as the operating system, hardware, or the network. The goal is to build safe abstractions on top of an unsafe world.</p> <p>Rust shares an FFI interface with C, which means that it can do anything C can do. So, while some operations that Rust allows are theoretically possible, they might lead to unexpected results.</p> <p>But not all is lost! If you are aware of these pitfalls, you can avoid them, and with the above clippy lints, you can catch most of them at compile time.</p> <p>That’s why testing, linting, and fuzzing are still important in Rust.</p> <p>For maximum robustness, combine Rust’s safety guarantees with strict checks and strong verification methods.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Let an Expert Review Your Rust Code</p> </h4> </div> <p>I hope you found this article helpful! If you want to take your Rust code to the next level, consider a code review by an expert. I offer code reviews for Rust projects of all sizes. <a href="/services/">Get in touch</a> to learn more.</p> </div> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-intrinsics_docs"> <p>There’s also methods for wrapping and saturating arithmetic, which might be useful in some cases. It’s worth it to check out the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/intrinsics/index.html"><code>std::intrinsics</code></a> documentation to learn more. <a href="#fr-intrinsics_docs-1">↩</a></p> </li> <li id="fn-port"> <p>Port 0 usually means that the OS will assign a random port for you. So, <code>TcpListener::bind("127.0.0.1:0").unwrap()</code> is valid, but it might not be supported on all operating systems or it might not be what you expect. See the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/net/struct.TcpListener.html#method.bind"><code>TcpListener::bind</code></a> docs for more info. <a href="#fr-port-1">↩</a></p> </li> </ol> </section> Thu, 06 Mar 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/rust-learning-resources-2026/ https://corrode.dev/blog/rust-learning-resources-2026/ <p>Want to finally learn Rust?</p> <p>When I ask developers what they look for in a Rust learning resource, I tend to get the same answers:</p> <ul> <li>They want <strong>hands-on</strong> learning experiences</li> <li>They need content that’s <strong>applicable to their work</strong></li> <li>They look for <strong>up-to-date material</strong> from <strong>experienced developers</strong></li> <li>They prefer to use <strong>their own development environment</strong></li> </ul> <p>All of the above are valid points, especially for learning Rust, a language known for its notoriously <a href="/blog/flattening-rusts-learning-curve">steep learning curve</a>.</p> <p>If you’ve been thinking about learning Rust for a while now and perhaps you’ve already started dabbling with it, now’s the time to fully commit. I’ve put together my favorite Rust learning resources for 2026 to help you jumpstart your Rust journey. I made sure to include a healthy mix of self-paced resources, interactive exercises, and hands-on workshops.</p> <h2 id="rustlings"><a class="zola-anchor" href="#rustlings" aria-label="Anchor link for: rustlings">Rustlings</a></h2> <p><img src="https://corrode.dev/blog/rust-learning-resources-2026/./rustlings.png" alt="Rustlings on the terminal" /></p> <p>Key Points:</p> <ul> <li><strong>Level</strong>: Beginner to Intermediate</li> <li><strong>Focus</strong>: Small exercises / Rust basics</li> <li><strong>Time</strong>: A few minutes to a few hours</li> </ul> <p>The classic Rust learning resource. If it was a cocktail, it would be an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Old_fashioned_(cocktail)">Old Fashioned</a>. Rustlings works great for beginners and for anyone wanting a quick refresher on specific Rust concepts.</p> <p>You can run Rustlings from your command line, and it guides you through a series of exercises. All it takes is running a few commands in your terminal:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install rustlings</span></span> <span class="giallo-l"><span style="color: #50FA7B;">rustlings</span><span style="color: #F1FA8C;"> init</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">cd</span><span style="color: #F1FA8C;"> rustlings/</span></span> <span class="giallo-l"><span style="color: #50FA7B;">rustlings</span></span></code></pre> <p>Go to the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustlings">official Rustlings repository</a> to learn more.</p> <h2 id="rustfinity"><a class="zola-anchor" href="#rustfinity" aria-label="Anchor link for: rustfinity">Rustfinity</a></h2> <p><img src="https://corrode.dev/blog/rust-learning-resources-2026/./rustfinity.jpg" alt="Rustfinity Homepage" /></p> <p>Key Points:</p> <ul> <li><strong>Level</strong>: Beginner to Intermediate</li> <li><strong>Focus</strong>: Small exercises / Rust basics</li> <li><strong>Time</strong>: A few minutes to a few hours</li> </ul> <p>Rustfinity is a bit like Rustlings, but more modern and structured. It gives you a browser interface that guides you through each exercise and runs tests to check your solutions. No need to set up anything locally, which makes it great for workshops or learning on the go.</p> <p>You start with “Hello, World!” and work your way up to more complex exercises. It’s a relatively new resource, but I’ve tried several exercises myself and enjoyed the experience.</p> <p>They also host “Advent of Rust” events with some more challenging problems available <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustfinity.com/advent-of-rust">here</a>.</p> <p>Learn more at the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustfinity.com/">Rustfinity website</a>.</p> <h2 id="100-exercises-to-learn-rust"><a class="zola-anchor" href="#100-exercises-to-learn-rust" aria-label="Anchor link for: 100-exercises-to-learn-rust">100 Exercises To Learn Rust</a></h2> <p><img src="https://corrode.dev/blog/rust-learning-resources-2026/./100-exercises.jpg" alt="100 Exercises To Learn Rust" /></p> <p>Key Points:</p> <ul> <li><strong>Level</strong>: Beginner to Intermediate</li> <li><strong>Focus</strong>: Small exercises / Rust basics</li> <li><strong>Time</strong>: A few minutes to a few hours</li> </ul> <p>This is another relatively new resource by Luca Palmieri, who is the author of the popular <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.zero2prod.com">“Zero To Production”</a> book. It’s a collection of 100 exercises that help you learn Rust. The course is based on the “learning by doing” principle and designed to be interactive and hands-on.</p> <p>You can work through the material in your browser, or download a PDF or buy a printed copy for offline reading. The course comes with a local CLI tool called <code>wr</code> that verifies your solutions.</p> <p>You can learn more about the course <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-exercises.com/100-exercises/">here</a>.</p> <h2 id="codecrafters"><a class="zola-anchor" href="#codecrafters" aria-label="Anchor link for: codecrafters">CodeCrafters</a></h2> <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;"> <iframe style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" src="https://www.youtube-nocookie.com/embed/aZ5sfhGmEVU" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> </div> <p>Key Points:</p> <ul> <li><strong>Level</strong>: Intermediate to Advanced</li> <li><strong>Focus</strong>: Real-world projects / Systems programming</li> <li><strong>Time</strong>: A few days to a few weeks per project (depending on your experience)</li> </ul> <p>If you already know how to code some Rust and want to take it one step further, CodeCrafters is currently the best resource for learning advanced Rust concepts in your own time. I like that they focus on real-world systems programming projects, which is where Rust is really strong.</p> <p>You’ll learn how to build your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS server from scratch.</p> <p>Most people work on the projects on evenings and weekends, and it takes a few days or weeks to complete a challenge, but the sense of accomplishment when you finish is incredible: you’ll complete a project that teaches you both Rust and the inner workings of systems you use daily.</p> <p>If you got curious, the video above is my full walkthrough of the “Build your own HTTP server” challenge.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Try CodeCrafters For Free</p> </h4> </div> <p>CodeCrafters is the platform I genuinely recommend to friends after they’ve learned the basics of Rust. It’s the next best thing after a personal mentor or workshop.</p> <p>You can <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://app.codecrafters.io/join?via=mre">try CodeCrafters for free here</a> and get 40% off if you upgrade to a paid plan later. Full disclosure: I receive a commission for new subscriptions, but I would recommend CodeCrafters even if I didn’t.</p> <p>On top of that, most companies will reimburse educational resources through their L&amp;D budget, so check with your manager about getting reimbursed.</p> </div> <h2 id="workshops"><a class="zola-anchor" href="#workshops" aria-label="Anchor link for: workshops">Workshops</a></h2> <p><img src="https://corrode.dev/blog/rust-learning-resources-2026/./write-yourself-a-shell.jpg" alt="Write Yourself a Shell Workshop" /></p> <p>Key Points:</p> <ul> <li><strong>Level</strong>: Beginner to Intermediate</li> <li><strong>Focus</strong>: Focused exercises and small projects</li> <li><strong>Time</strong>: A few days of focused effort</li> </ul> <p>I’m biased here, but nothing beats a hands-on workshop with a Rust expert. Learning from experienced Rust developers is probably the quickest way to get up to speed with Rust – especially if you plan to use Rust at work. That’s because trainers can provide you with personalized feedback and guidance, and help you avoid common pitfalls. It’s like having a personal trainer for your Rust learning journey.</p> <p>My workshops are designed to be hands-on and tailored to the needs of the participants. I want people to walk away with a finished project they can extend.</p> <p>All course material is open source and freely available on GitHub:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/write-yourself-a-cli">Write Yourself a CLI</a> - Create a tool to find files on your system</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/write-yourself-a-web-app">Write Yourself a Web App</a> - Build a small web app that shows weather data</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/write-yourself-a-shell">Write Yourself a Shell</a> - Build a small but fully functional shell from scratch</li> </ul> <p>You can go through the material on your own to see if it fits your needs. Once you’re ready, feel free to reach out about tailoring the content for you and your team.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Speed Up Your Learning Process</p> </h4> </div> <p>Is your company considering a switch to Rust?</p> <p>Rust is known for its steep learning curve, but with the right resources and guidance, you can become proficient in a matter of weeks. I offer hands-on workshops and training for teams and individuals who want to accelerate their learning process.</p> <p>Check out my <a href="/services">services page</a> or <a href="mailto:hi@corrode.dev?subject=Rust%20Workshops">send me an email</a> to learn more.</p> </div> Thu, 06 Feb 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e09-season-finale/ https://corrode.dev/podcast/s03e09-season-finale/ <div><script id="letscast-player-4cc795a6" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/season-3-finale/player.js?size=s"></script></div> <p>You know the drill by now. It’s time for another recap!</p> <p>Sit back, get a warm beverage and look back at the highlights of Season 3 with us.</p> <p>We’ve been at this for a while now (three seasons, one year, and 24 episodes to be exact). We had guests from a wide range of industries: from automotive to CAD software, and from developer tooling to systems programming.</p> <p>Our focus this time around was on the technical details of Rust in production, especially integration of Rust into existing codebases and ecosystem deep dives. Thanks to everyone who participated in the survey last season, which helped us dial in our content. Let us know if we hit the mark or missed it!</p> Tue, 28 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/tips-for-faster-ci-builds/ https://corrode.dev/blog/tips-for-faster-ci-builds/ <p>I’ve been working with many clients lately who host their Rust projects on GitHub. CI is typically a bottleneck in the development process since it can significantly slow down feedback loops. However, there are several effective ways to speed up your GitHub Actions workflows!</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Want a Real-World Example?</p> </h4> </div> <p>Check out this production-ready GitHub Actions workflow that implements all the tips from this article: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/lycheeverse/lychee/blob/master/.github/workflows/ci.yml">click here</a>.</p> <p>Also see Arpad Borsos’ <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Swatinem/rust-gha-workflows">workflow templates</a> for Rust projects.</p> </div> <h2 id="use-swatinem-s-cache-action"><a class="zola-anchor" href="#use-swatinem-s-cache-action" aria-label="Anchor link for: use-swatinem-s-cache-action">Use Swatinem’s cache action</a></h2> <p>This is easily my most important recommendation on this list.</p> <p>My friend <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/swatinem">Arpad Borsos</a>, also known as Swatinem, has created a cache action specifically tailored for Rust projects. It’s an excellent way to speed up any Rust CI build and requires no code changes to your project.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> CI</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #BD93F9;">on</span><span style="color: #FF79C6;">:</span><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> push</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> branches</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #F1FA8C;"> main</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> pull_request</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> build</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> ubuntu-latest-arm64</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;"> env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_TERM_COLOR</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> always</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;"> steps</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> actions/checkout@v4</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> dtolnay/rust-toolchain@stable</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> # The secret sauce!</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Swatinem/rust-cache@v2</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">: |</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> cargo check</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> cargo test</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> cargo build --release</span></span></code></pre> <p>The action requires no additional configuration and works out of the box. There’s no need for a separate step to store the cache — this happens automatically through a post-action. This approach ensures that broken builds aren’t cached, and for subsequent builds, you can save several minutes of build time.</p> <p>Here’s the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Swatinem/rust-cache">documentation</a> where you can learn more.</p> <h2 id="use-the-locked-flag"><a class="zola-anchor" href="#use-the-locked-flag" aria-label="Anchor link for: use-the-locked-flag">Use the <code>--locked</code> flag</a></h2> <p>When running <code>cargo build</code>, <code>cargo test</code>, or <code>cargo check</code>, you can pass the <code>--locked</code> flag to prevent Cargo from updating the <code>Cargo.lock</code> file.</p> <p>This is particularly useful for CI operations since you save the time to update dependencies. Typically you want to test the exact dependency versions specified in your lock file anyway.</p> <p>On top of that, it ensures reproducible builds, which is crucial for CI. From the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/commands/cargo-install.html">Cargo documentation</a>:</p> <blockquote> <p>The <code>--locked</code> flag can be used to force Cargo to use the packaged <code>Cargo.lock</code> file if it is available. This may be useful for ensuring reproducible builds, to use the exact same set of dependencies that were available when the package was published.</p> </blockquote> <p>Here’s how you can use it in your GitHub Actions workflow:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #FF79C6;">-</span><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo check --locked</span></span> <span class="giallo-l"><span style="color: #FF79C6;">-</span><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo test --locked</span></span></code></pre><h2 id="use-cargo-chef-for-docker-builds"><a class="zola-anchor" href="#use-cargo-chef-for-docker-builds" aria-label="Anchor link for: use-cargo-chef-for-docker-builds">Use <code>cargo-chef</code> For Docker Builds</a></h2> <p>For Rust Docker images, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/LukeMathWalker/cargo-chef"><code>cargo-chef</code></a> can significantly speed up the build process by leveraging Docker’s layer caching:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="docker"><span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> lukemathwalker/cargo-chef:latest-rust-1 </span><span style="color: #FF79C6;">AS</span><span> chef</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> /app</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> chef </span><span style="color: #FF79C6;">AS</span><span> planner</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> . .</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo chef prepare --recipe-path recipe.json</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> chef </span><span style="color: #FF79C6;">AS</span><span> builder </span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=planner /app/recipe.json recipe.json</span></span> <span class="giallo-l"><span style="color: #6272A4;"># Build dependencies - this is the caching Docker layer!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo chef cook --release --recipe-path recipe.json</span></span> <span class="giallo-l"><span style="color: #6272A4;"># Build application</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> . .</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo build --release --bin app</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># We do not need the Rust toolchain to run the binary!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> debian:bookworm-slim </span><span style="color: #FF79C6;">AS</span><span> runtime</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> /app</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=builder /app/target/release/app /usr/local/bin</span></span> <span class="giallo-l"><span style="color: #FF79C6;">ENTRYPOINT</span><span> [</span><span style="color: #F1FA8C;">&quot;/usr/local/bin/app&quot;</span><span>]</span></span></code></pre> <p>Alternatively, if you don’t mind a little extra typing, you can write your own Dockerfile without <code>cargo-chef</code>:</p> <details> <summary>Click to expand</summary> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="docker"><span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> rust:1.81-slim-bookworm </span><span style="color: #FF79C6;">AS</span><span> builder</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> /usr/src/app</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Copy the Cargo files to cache dependencies</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> Cargo.toml Cargo.lock ./</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Create a dummy main.rs to build dependencies</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> mkdir src &amp;&amp; \</span></span> <span class="giallo-l"><span> echo </span><span style="color: #F1FA8C;">&#39;fn main() { println!(&quot;Dummy&quot;) }&#39;</span><span> &gt; src/main.rs &amp;&amp; \</span></span> <span class="giallo-l"><span> cargo build --release &amp;&amp; \</span></span> <span class="giallo-l"><span> rm src/main.rs</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Now copy the actual source code</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> src ./src</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Build for release</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> touch src/main.rs &amp;&amp; cargo build --release</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Runtime stage</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> debian:bookworm-slim</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Install minimal runtime dependencies</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> apt-get update &amp;&amp; apt-get install -y --no-install-recommends ca-certificates &amp;&amp; rm -rf /var/lib/apt/lists/*</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Copy the build artifact from the build stage</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=builder /usr/src/app/target/release/your-app /usr/local/bin/</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Set the startup command to run our binary</span></span> <span class="giallo-l"><span style="color: #FF79C6;">CMD</span><span> [</span><span style="color: #F1FA8C;">&quot;your-app&quot;</span><span>]</span></span></code></pre></details> <h2 id="environment-flags-to-disable-incremental-compilation"><a class="zola-anchor" href="#environment-flags-to-disable-incremental-compilation" aria-label="Anchor link for: environment-flags-to-disable-incremental-compilation">Environment Flags To Disable Incremental Compilation</a></h2> <p>Rust provides environment flags to disable incremental compilation. While incremental compilation speeds up local development builds, in CI it can actually slow down the process due to dependency tracking overhead and negatively impact caching. So it’s better to switch it off:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Build</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #BD93F9;">on</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> pull_request</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> push</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> branches</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #F1FA8C;"> main</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;">env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #6272A4;"> # Disable incremental compilation for faster from-scratch builds</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_INCREMENTAL</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> build</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> ...</span><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> steps</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> ...</span></span></code></pre><h2 id="disable-debug-info"><a class="zola-anchor" href="#disable-debug-info" aria-label="Anchor link for: disable-debug-info">Disable Debug Info</a></h2> <p>While debug info is valuable for debugging, it significantly increases the size of the <code>./target</code> directory, which can harm caching efficiency. It’s easy to switch off:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_PROFILE_TEST_DEBUG</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span></span></code></pre><h2 id="use-cargo-nextest"><a class="zola-anchor" href="#use-cargo-nextest" aria-label="Anchor link for: use-cargo-nextest">Use <code>cargo nextest</code></a></h2> <p><code>cargo nextest</code> enables parallel test execution, which can substantially speed up your CI process. While they claim a 3x speedup over <code>cargo test</code>, in CI environments I typically observe around 40% because the runners don’t have as many cores as a developer machine. It’s still a nice speedup.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> test</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> ubuntu-latest</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> steps</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> actions/checkout@v4</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> dtolnay/rust-toolchain@stable</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> taiki-e/install-action@nextest</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Swatinem/rust-cache@v2</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Compile</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo check --locked</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Test</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo nextest</span><span> </span></span></code></pre><h2 id="cargo-toml-settings"><a class="zola-anchor" href="#cargo-toml-settings" aria-label="Anchor link for: cargo-toml-settings"><code>Cargo.toml</code> Settings</a></h2> <p>These release profile settings can significantly improve build times and binary size:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">profile</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">release</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">lto</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> true</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">codegen-units</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1</span></span></code></pre> <ul> <li>LTO (Link Time Optimization) performs optimizations across module boundaries, which can reduce binary size and improve runtime performance.</li> <li>Setting <code>codegen-units = 1</code> trades parallel compilation for better optimization opportunities. While this might make local builds slower, it often speeds up CI builds by reducing memory pressure on resource-constrained runners.</li> </ul> <p>If you only want to apply these settings in CI, you can use the <code>CARGO_PROFILE_RELEASE_LTO</code> and <code>CARGO_PROFILE_RELEASE_CODEGEN_UNITS</code> environment variables:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> build</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> ubuntu-latest</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_PROFILE_RELEASE_LTO</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> true</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_PROFILE_RELEASE_CODEGEN_UNITS</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 1</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> steps</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> actions/checkout@v4</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Build</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo build --release --locked</span></span></code></pre><h2 id="use-beefier-runners"><a class="zola-anchor" href="#use-beefier-runners" aria-label="Anchor link for: use-beefier-runners">Use Beefier Runners</a></h2> <p>GitHub Actions has recently announced that Linux ARM64 hosted runners are now available for free in public repositories. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.blog/changelog/2025-01-16-linux-arm64-hosted-runners-now-available-for-free-in-public-repositories-public-preview/">Here’s</a> the announcement.</p> <p>Switching to ARM64 provides up to 40% performance improvement and is straightforward. Simply replace <code>ubuntu-latest</code> with <code>ubuntu-latest-arm64</code> in your workflow file:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> test</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> ubuntu-latest-arm64</span></span></code></pre> <p>However, in my <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/lycheeverse/lychee/pull/1614">tests</a>, the downside was that it took a long time until a runner was allocated to the job. The waiting time dwarfed the actual build time. I assume GitHub will add more runners in the future to mitigate this issue.</p> <p>If you are using Rust for production workloads, it’s worth looking into dedicated VMs. These are not free, but in comparison to the small GitHub runners, you can get a significant uplift on build times.</p> <p>Any provider will do, as long as you get a VM with a decent amount of CPU cores (16+ is recommended) and a good amount of RAM (32GB+). Hetzner Cloud is a popular choice for this purpose because of its competitive pricing. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cloud.google.com/solutions/spot-vms">Spot instances</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.hetzner.com/sb/">server auctions</a> can be a good way to save money. Here are some setup resources to get you started:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/jonico/awesome-runners">Awesome Runners</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://altinity.com/blog/slash-ci-cd-bills-part-2-using-hetzner-cloud-github-runners-for-your-repository">Using Hetzner Cloud GitHub Runners for Your Repository</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://runs-on.com/">Runs-on, a Github Actions hoster</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.blacksmith.sh/">Blacksmith</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/hetznercloud/awesome-hcloud">Awesome HCloud Repo</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Cyclenerd/hcloud-github-runner">HCloud Runner</a></li> </ul> <p>There are services like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://depot.dev/">Depot</a>, which host runners for you. They promise large speedups for Rust builds, but I haven’t tested them myself.</p> <h2 id="automate-dependency-updates"><a class="zola-anchor" href="#automate-dependency-updates" aria-label="Anchor link for: automate-dependency-updates">Automate Dependency Updates</a></h2> <p>Implement <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.github.com/en/code-security/getting-started/dependabot-quickstart-guide">dependabot</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.renovatebot.com/">Renovate</a> to automate dependency updates. Instead of manually creating PRs for updates and waiting for CI, these bots handle this automatically, creating PRs that you can merge when ready.</p> <p>Renovate has a bit of an edge over dependabot in terms of configurability and features.</p> <h2 id="streamline-release-creation"><a class="zola-anchor" href="#streamline-release-creation" aria-label="Anchor link for: streamline-release-creation">Streamline Release Creation</a></h2> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://release-plz.ieni.dev/"><code>release-plz</code></a> automates release creation when PRs are merged. This GitHub action eliminates the manual work of creating releases and is highly recommended for maintaining a smooth workflow.</p> <p><img src="https://corrode.dev/blog/tips-for-faster-ci-builds/release-plz.jpg" alt="release-plz website screenshot" /></p> <h2 id="optimize-your-rust-code"><a class="zola-anchor" href="#optimize-your-rust-code" aria-label="Anchor link for: optimize-your-rust-code">Optimize Your Rust Code</a></h2> <p>If you’ve implemented all these optimizations and your builds are still slow, it’s time to optimize the Rust code itself. I’ve compiled many tips in my other blog post <a href="/blog/tips-for-faster-rust-compile-times/">here</a>.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Remember that each project is unique. Start with the easier wins like Swatinem’s cache action and <code>--locked</code> flag, then progressively implement more advanced optimizations as needed. Monitor your CI metrics to ensure the changes are having the desired effect.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Need Professional Support?</p> </h4> </div> <p>Is your Rust CI still too slow despite implementing these optimizations? I can help you identify and fix performance bottlenecks in your build pipeline. <a href="/services">Book a free consultation</a> to discuss your specific needs.</p> </div> Mon, 27 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/case-studies/hubstaff/ https://corrode.dev/learn/case-studies/hubstaff/ <p>It’s 2019, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hubstaff.com/">Hubstaff</a>’s engineering team is sketching out plans for their new webhook system. The new system needs to handle millions of events and work reliably at scale. The safe choice would be to stick with their trusty Ruby on Rails stack – after all, it had served them well so far. But that’s not the path they chose.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>About Hubstaff</p> </h4> </div> <p>Hubstaff helps distributed teams track time and manage their workforce. With 500,000+ active users across 112,000+ businesses, they needed their systems to scale reliably. As a remote-first company with 120 team members, they understand the importance of robust, efficient software.</p> </div> <h2 id="why-hubstaff-chose-rust-when-rails-was-working-fine"><a class="zola-anchor" href="#why-hubstaff-chose-rust-when-rails-was-working-fine" aria-label="Anchor link for: why-hubstaff-chose-rust-when-rails-was-working-fine">Why Hubstaff Chose Rust When Rails Was Working Fine</a></h2> <p>When I sat down with Alex, Hubstaff’s CTO, he painted a vivid picture of that moment. “Our entire application stack was powered by Ruby and JavaScript,” he told me. “It worked, but we knew we needed something different for this new challenge.”</p> <p>The team stood at a crossroads. Go, with its simplicity and familiar patterns, felt like as a safe harbor. But there was another path – one less traveled at the time:</p> <blockquote> <p>“We chose to proceed with Rust,” Alex recalled. “Not just because it was efficient, but because it would push us to <strong>think in fundamentally different ways</strong>.”</p> </blockquote> <figure> <img src="alex.jpg" alt="Alex Yarotsky, CTO at Hubstaff"> <figcaption>Alex Yarotsky, CTO at Hubstaff</figcaption> </figure> <h2 id="a-webhook-system-that-scaled-10x"><a class="zola-anchor" href="#a-webhook-system-that-scaled-10x" aria-label="Anchor link for: a-webhook-system-that-scaled-10x">A Webhook System That Scaled 10x</a></h2> <p>Fast-forward to today.</p> <p>The webhook system is processing ten times the initial load without breaking a sweat. Of course, the team had to make adjustments along the way, not to their Rust code, but to their SQL queries.</p> <blockquote> <p>“Since its launch, we’ve had to optimize SQL queries multiple times to keep up with demand,” Alex shared, “but we’ve never faced any issues with the app’s memory or CPU consumption. Not once.”</p> </blockquote> <p>Over time, more and more microservices got ported to Rust.</p> <figure> <img src="screenshot.png" alt="Hubstaff's Webhook System"> <figcaption>A screenshot of Hubstaff's Webhook System</figcaption> </figure> <h2 id="when-to-use-rust-and-when-to-stick-with-rails"><a class="zola-anchor" href="#when-to-use-rust-and-when-to-stick-with-rails" aria-label="Anchor link for: when-to-use-rust-and-when-to-stick-with-rails">When to Use Rust And When to Stick With Rails</a></h2> <p>Instead of going all-in on Rust, Hubstaff found wisdom in balance.</p> <p>Here’s their reasoning:</p> <ol> <li>High-Load Operations → Rust</li> <li>Lightweight APIs and Dashboard Backend → Rails</li> <li>Communication through standardized APIs and message queues</li> </ol> <p>But what about Rust’s infamous learning curve?</p> <p>“Once developers are up to speed,” Alex noted, “there’s no noticeable slowdown in development. The Rust ecosystem has matured to the point where we’re not constantly reinventing the wheel.”</p> <h2 id="from-server-to-desktop"><a class="zola-anchor" href="#from-server-to-desktop" aria-label="Anchor link for: from-server-to-desktop">From Server to Desktop</a></h2> <p>Once the team gained enough confidence in Rust, they started rewriting their desktop application. This was an area of the business, that was traditionally governed by C++, but the team was already sold on the idea:</p> <blockquote> <p>The transition to Rust was surprisingly smooth. I think a big reason for that was the collective frustration with our existing C++ codebase. Rust felt like a breath of fresh air, and the idea naturally resonated with the team.</p> </blockquote> <p>This quote is from Artur Jakubiec, Technical Lead at Hubstaff, who was leading the desktop app migration.</p> <figure> <img src="artur.jpeg" alt="Artur Jakubiec, Technical Lead at Hubstaff"> <figcaption>Artur Jakubiec, Technical Lead at Hubstaff</figcaption> </figure> <p>But Rust wasn’t an obvious choice for their desktop app. The easy path would have been Electron – the tried-and-true choice for companies looking to provide a desktop client from their web app. However, Hubstaff had learned to trust that Rust would get the job done.</p> <blockquote> <p>“<strong>Electron simply wasn’t an option,</strong>” Artur stated firmly. “We needed something lightweight, something that could bridge our future with our past. That’s why we chose <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tauri.app/">Tauri</a>.”</p> </blockquote> <blockquote> <p>“It’s still early days for this approach, as we’re currently in the process of migrating our desktop app. However, we’re already envisioning some compelling synergies emerging from this setup. For example, many of the APIs used by our desktop and mobile apps are high-load systems, and following our strategy, they’re slated to be migrated to Rust soon. <strong>With the desktop team already familiarizing themselves with Rust during this transition, they’ll be better equipped to make contributions or changes to these APIs, which will reduce reliance on the server team.</strong>” added Alex.</p> </blockquote> <h2 id="the-current-architecture"><a class="zola-anchor" href="#the-current-architecture" aria-label="Anchor link for: the-current-architecture">The Current Architecture</a></h2> <p>Today, Hubstaff’s architecture is a mix of Ruby on Rails, Rust, and JavaScript. Their webhooks system, backend services, and desktop app are all powered by Rust and they keep expanding their Rust footprint across the stack for heavy-load operations.</p> <figure> <figure> <img class="centered" src="architecture.svg" alt="Hubstaff's Architecture"> <figcaption>Simplified Overview of Hubstaff's Current Architecture</figcaption> </figure> </figure> <h2 id="was-it-all-flowers-and-sunshine"><a class="zola-anchor" href="#was-it-all-flowers-and-sunshine" aria-label="Anchor link for: was-it-all-flowers-and-sunshine">Was It All Flowers And Sunshine?</a></h2> <p>Of course, there were moments of doubt. Adding a new language to an already complex tech stack isn’t a decision teams make lightly.</p> <p>“There was skepticism,” Artur Jakubiec, their Desktop Tech Lead, admitted. “Not about Rust itself, but about balancing our ecosystem.”</p> <p>But instead of letting doubt win, Artur took action. He spent weeks building <a href="/blog/prototyping">prototypes</a>, gathering data, and crafting a vision of what could be. It wasn’t just about convincing management – it was about showing his team a glimpse of the future they could build together.</p> <p>Especially the build system caused some headaches:</p> <blockquote> <p>One thing I really wish existed when we started was better C++-Rust integration, not just at the language level but especially in the <strong>build systems</strong>. Oddly enough, integrating Rust into CMake/C++ workflows (using tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrosion-rs/corrosion">Corrosion</a>) was relatively straightforward, but going the other way — <strong>embedding C++ into Rust—proved much more challenging</strong>. A more seamless and standardized approach for bidirectional integration would have saved us a lot of time and effort.</p> </blockquote> <p>Artur adds:</p> <blockquote> <p>Of course, challenges remain, particularly in ensuring <strong>seamless knowledge transfer and establishing best practices across teams</strong>. But the potential for closer collaboration and a unified stack makes this an exciting step forward.</p> </blockquote> <h2 id="was-it-all-worth-it"><a class="zola-anchor" href="#was-it-all-worth-it" aria-label="Anchor link for: was-it-all-worth-it">Was It All Worth It?</a></h2> <p>For developers coming from interpreted languages like Ruby, two main insights stood out from our conversation:</p> <blockquote> <p>Initially, switching to a compiled language felt like a hustle, but the “aha” moments made it worthwhile. The first came when we realized just <strong>how many edge cases the Rust compiler catches for you</strong> — it’s like having an additional safety net during development. The second came after deploying Rust applications to production. <strong>Seeing how much more resource-efficient the Rust app was compared to its Ruby counterpart was a real eye-opener</strong>. It demonstrated the tangible benefits of Rust’s focus on performance, reinforcing why it was worth tackling the learning curve.</p> </blockquote> <p>But what about the C++ developers, which worked on the desktop app? What helped was that the team had prior experience with lower-level concepts from C++.</p> <blockquote> <p>I believe the team’s strong C++ background made the transition to Rust almost seamless. Many of Rust’s more challenging low-level concepts have parallels in C++, such as the memory model, RAII, move semantics, pointers, references, and even aspects of ADTs (achievable in C++ with tools like <code>std::optional</code> and <code>std::variant</code>). Similarly, Rust’s ownership system and concepts like lifetimes echo patterns familiar to anyone experienced in managing resources in C++.</p> </blockquote> <p>Let’s look at the facts:</p> <ul> <li>Desktop developers now contribute to backend services, breaking down old silos.</li> <li>Five years without a single memory-related issue in production.</li> <li>Their C++ developers are on-board with Rust’s safety guarantees as well.</li> <li>Infrastructure costs stayed flat despite 10x growth.</li> </ul> <p>But perhaps the biggest change is <strong>confidence in the codebase</strong>:</p> <blockquote> <p>“With C++, there’s a constant sense of paranoia about every line you write,” Artur revealed. “<strong>Rust transformed that fear into confidence</strong>. It changed not just how we code, but how we feel about coding.” […] “it’s like stepping into a world where you can trust your tools”</p> </blockquote> <p>On top of that, Alex added that using Rust across the stack has also opened up new collaboration opportunities across the teams.</p> <p>Artur adds that the onboarding experience has also been smoother than expected:</p> <blockquote> <p>So far, onboarding hasn’t been an issue at all. Honestly, there’s no secret sauce — it’s all about getting new team members working on the code as soon as possible.</p> </blockquote> <figure> <img src="team.jpg" alt="Hubstaff Team"> <figcaption>Parts of the Hubstaff Team at their 2022 team offsite in Punta Cana</figcaption> </figure> <h2 id="where-they-are-today"><a class="zola-anchor" href="#where-they-are-today" aria-label="Anchor link for: where-they-are-today">Where They Are Today</a></h2> <p>Today, Hubstaff’s journey continues. Their Rust footprint grows steadily: 4,200 lines of mission-critical server code, 2,000 lines in their desktop app, and a team of passionate Rustaceans that’s still growing.</p> <p>But when I asked Alex and Artur what they’re most proud of, it wasn’t the technical achievements that topped their list. It was how they got there: thoughtfully, methodically, and together as a team.</p> <ul> <li><strong>2019</strong>: First steps into Rust - Webhook system prototype. 🌱</li> <li><strong>2020</strong>: Webhook system processes first million events. 🌿</li> <li><strong>2024</strong>: Started desktop app migration to Rust/Tauri. 🪴</li> <li><strong>2025</strong>: Expanding Rust across their entire stack. Public release of new Rust-powered desktop app. 🌳</li> </ul> <h2 id="key-lessons-for-teams-considering-rust"><a class="zola-anchor" href="#key-lessons-for-teams-considering-rust" aria-label="Anchor link for: key-lessons-for-teams-considering-rust">Key Lessons for Teams Considering Rust</a></h2> <p>What would Alex and Artur recommend to teams standing at their own crossroads?<br /> Here’s what they shared:</p> <ol> <li>Start with a clear mission, not just a technical preference</li> <li>Invest in your team’s journey through learning and support</li> <li>Make data-driven decisions</li> <li>Build bridges between the old and the new</li> <li>Look for opportunities for collaboration and knowledge sharing</li> </ol> <h2 id="thanks"><a class="zola-anchor" href="#thanks" aria-label="Anchor link for: thanks">Thanks</a></h2> <p>Special thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/ayarotsky/">Alex Yarotsky</a>, CTO and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/artur-jakubiec/">Artur Jakubiec</a>, Technical Lead at Hubstaff for sharing their journey with Rust.</p> <p>Want to learn more about Hubstaff? <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hubstaff.com/">Check out their website</a>.</p> Thu, 23 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e08-volvo/ https://corrode.dev/podcast/s03e08-volvo/ <div><script id="letscast-player-5d620579" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/volvo-with-julius-gustavsson/player.js?size=s"></script></div> <p>The car industry is not known for its rapid adoption of new technologies. Therefore, it’s even more exciting to see a company like Volvo Cars embracing Rust for core components of their software stack.</p> Tue, 21 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/expressions/ https://corrode.dev/blog/expressions/ <p>Rust’s focus on expressions is an underrated aspect of the language. Code feels more natural to compose once you embrace expressions as a core mechanic in Rust. I would go as far as to say that expressions shaped the way I think about control flow in general.</p> <p>“Everything is an expression” is a bit of an exaggeration, but it’s a useful mental model while you internalize the concept.<sup class="footnote-reference" id="fr-reference-1"><a href="#fn-reference">1</a></sup></p> <p>But what’s so special about them?</p> <h2 id="expressions-produce-values-statements-do-not"><a class="zola-anchor" href="#expressions-produce-values-statements-do-not" aria-label="Anchor link for: expressions-produce-values-statements-do-not">Expressions produce values, statements do not.</a></h2> <p>The difference between expressions and statements can easily be dismissed as a minor detail. Underneath the surface, though, the fact that expressions return values has a profound impact on the ergonomics of a language.</p> <p>In Rust, most things produce a value: literals, variables, function calls, blocks, and control flow statements like <code>if</code>, <code>match</code>, and <code>loop</code>. Even <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/expressions/operator-expr.html#borrow-operators"><code>&amp;</code></a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-dereference-operator"><code>*</code></a> are expressions in Rust.</p> <h2 id="expressions-in-rust-vs-other-languages"><a class="zola-anchor" href="#expressions-in-rust-vs-other-languages" aria-label="Anchor link for: expressions-in-rust-vs-other-languages">Expressions In Rust vs other languages</a></h2> <p>Rust inherits expressions from its functional roots in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/ML_(programming_language)">ML family of languages</a>; they are not so common in other languages. Go, C++, Java, and TypeScript have them, but they pale in comparison to Rust.</p> <p>In Go, for example, an <code>if</code> statement is… well, a <em>statement</em> and not an expression. This has some surprising side-effects. For example, you can’t use <code>if</code> statements in a ternary expression like you would in Rust:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="go"><span class="giallo-l"><span style="color: #6272A4;">// This is not valid Go code!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">var</span><span> x</span><span style="color: #FF79C6;"> = if</span><span> condition {</span><span style="color: #BD93F9;"> 1</span><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span><span style="color: #BD93F9;"> 2</span><span> };</span></span></code></pre> <p>Instead, you’d have to write a full-blown <code>if</code> statement along with a slightly unfortunate upfront variable declaration:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="go"><span class="giallo-l"><span style="color: #FF79C6;">var</span><span> x</span><span style="color: #8BE9FD;font-style: italic;"> int</span></span> <span class="giallo-l"><span style="color: #FF79C6;">if</span><span> condition {</span></span> <span class="giallo-l"><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1</span></span> <span class="giallo-l"><span>}</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 2</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Since <code>if</code> is an expression in Rust, using it in a ternary expression is perfectly normal.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;"> = if</span><span> condition {</span><span style="color: #BD93F9;"> 1</span><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span><span style="color: #BD93F9;"> 2</span><span> };</span></span></code></pre> <p>That explains the absence of the ternary operator in Rust (i.e. there is no syntax like <code>x = condition ? 1 : 2;</code>). No special syntax is needed because <code>if</code> is comparably concise.</p> <p>Also note that in comparison to Go, our variable <code>x</code> does not need to be mutable. As we will see, Rust’s expressions often lead to less mutable code.</p> <p>In combination with pattern matching, expressions in Rust become even more powerful:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> (a, b)</span><span style="color: #FF79C6;"> = if</span><span> condition { (</span><span style="color: #F1FA8C;">&quot;first&quot;</span><span>,</span><span style="color: #BD93F9;"> true</span><span>) }</span><span style="color: #FF79C6;"> else</span><span> { (</span><span style="color: #F1FA8C;">&quot;second&quot;</span><span>,</span><span style="color: #BD93F9;"> false</span><span>) };</span></span></code></pre> <p>Here, the left side of the assignment (a, b) is a pattern that destructures the tuple returned by the <code>if-else</code> expression.</p> <p>What if you deal with more complex control flow? That’s not a problem. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/expressions/match-expr.html"><code>match</code> is an expression</a>, too. It is common to assign the result of a <code>match</code> expression to a variable.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> color</span><span style="color: #FF79C6;"> = match</span><span> duck {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Huey</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Red&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Dewey</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Blue&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Louie</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Green&quot;</span><span>,</span></span> <span class="giallo-l"><span>};</span></span></code></pre><h2 id="combining-match-and-if-expressions"><a class="zola-anchor" href="#combining-match-and-if-expressions" aria-label="Anchor link for: combining-match-and-if-expressions">Combining <code>match</code> and <code>if</code> Expressions</a></h2> <p>Let’s say you want to return a duck’s color, but you want to return the correct color based on the year. (In the early Disney comics, the nephews were wearing different colors.)</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> color</span><span style="color: #FF79C6;"> = match</span><span> duck {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // In early comic books, the</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ducks were colored randomly</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> if</span><span> year</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #BD93F9;"> 1980</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> random_color</span><span>(),</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // In the early 80s, Huey&#39;s cap was pink</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Huey</span><span style="color: #FF79C6;"> if</span><span> year</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #BD93F9;"> 1982</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Pink&quot;</span><span>,</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Since 1982, the ducks have dedicated colors</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Huey</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Red&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Dewey</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Blue&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Duck</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Louie</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #F1FA8C;"> &quot;Green&quot;</span><span>,</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Neat, right? You can combine <code>match</code> and <code>if</code> expressions to create complex logic in a few lines of code.</p> <p>Note: those <code>if</code>s are called <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/expressions/match-expr.html">match arm guards</a>, and they really <em>are</em> full-fledged <code>if</code> expressions. You can put anything in there just like in a regular <code>if</code>.</p> <h2 id="lesser-known-facts-about-expressions"><a class="zola-anchor" href="#lesser-known-facts-about-expressions" aria-label="Anchor link for: lesser-known-facts-about-expressions">Lesser known facts about expressions</a></h2> <h3 id="break-is-an-expression"><a class="zola-anchor" href="#break-is-an-expression" aria-label="Anchor link for: break-is-an-expression"><code>break</code> is an expression</a></h3> <p>You can return a value from a loop with <code>break</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> foo</span><span style="color: #FF79C6;"> = loop</span><span> {</span><span style="color: #FF79C6;"> break</span><span style="color: #BD93F9;"> 1</span><span> };</span></span> <span class="giallo-l"><span style="color: #6272A4;">// foo is 1</span></span></code></pre> <p>More commonly, you’d use it like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> result</span><span style="color: #FF79C6;"> = loop</span><span> {</span></span> <span class="giallo-l"><span> counter</span><span style="color: #FF79C6;"> +=</span><span style="color: #BD93F9;"> 1</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> counter</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> 10</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> break</span><span> counter</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 2</span><span>;</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>};</span></span> <span class="giallo-l"><span style="color: #6272A4;">// result is 20</span></span></code></pre><h3 id="dbg-returns-the-value-of-the-inner-expression"><a class="zola-anchor" href="#dbg-returns-the-value-of-the-inner-expression" aria-label="Anchor link for: dbg-returns-the-value-of-the-inner-expression"><code>dbg!()</code> returns the value of the inner expression</a></h3> <p>You can wrap any expression with <code>dbg!()</code> without changing the behavior of your code (aside from the debug output).</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> dbg!</span><span>(</span><span style="color: #50FA7B;">compute_complex_value</span><span>());</span></span></code></pre><h2 id="real-world-refactoring-with-expressions"><a class="zola-anchor" href="#real-world-refactoring-with-expressions" aria-label="Anchor link for: real-world-refactoring-with-expressions">Real-World Refactoring With Expressions</a></h2> <p>So far, I showed you some fancy expression tricks, but how do you apply this in practice?</p> <p>To illustrate this, imagine you have a <code>Config</code> struct that reads a configuration file from a given path:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">/// Configuration for the application</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span> config_path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PathBuf</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// Creates a new Config with the given path</span></span> <span class="giallo-l"><span style="color: #6272A4;">///</span></span> <span class="giallo-l"><span style="color: #6272A4;">/// The path is resolved against the home directory if relative.</span></span> <span class="giallo-l"><span style="color: #6272A4;">/// Validates that the path exists and has the correct extension.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> with_config_path</span><span>(path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PathBuf</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>, std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> todo!</span><span>()</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Here’s how you might implement the <code>with_config_path</code> method in an imperative style:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> with_config_path</span><span>(path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PathBuf</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>, std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // First determine the base path</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> config_path;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_absolute</span><span>() {</span></span> <span class="giallo-l"><span> config_path</span><span style="color: #FF79C6;"> =</span><span> path;</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> home</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_home_dir</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_none</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NotFound</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Home directory not found&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> config_path</span><span style="color: #FF79C6;"> =</span><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(path);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do validation</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if !</span><span>config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">exists</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NotFound</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config path does not exist&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_file</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> ext</span><span style="color: #FF79C6;"> =</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> ext</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_none</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config file must have .conf extension&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> ext</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_str</span><span>()</span><span style="color: #FF79C6;"> !=</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(</span><span style="color: #F1FA8C;">&quot;conf&quot;</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config file must have .conf extension&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { config_path });</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>There are a few things we can improve here:</p> <ul> <li>The code is quite imperative</li> <li>Lots of temporary variables</li> <li>Explicit mutation with <code>mut</code></li> <li>Nested if statements</li> <li>Manual unwrapping with <code>is_none()</code>/<code>unwrap()</code></li> </ul> <h2 id="tip-1-remove-the-unwraps"><a class="zola-anchor" href="#tip-1-remove-the-unwraps" aria-label="Anchor link for: tip-1-remove-the-unwraps">Tip 1: Remove the unwraps</a></h2> <p>It’s always a good idea to examine <code>unwrap()</code> calls and find safer alternatives. While we “only” have two <code>unwrap()</code> calls here, both point at flaws in our design. Here’s the first one:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> config_path;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_absolute</span><span>() {</span></span> <span class="giallo-l"><span> config_path</span><span style="color: #FF79C6;"> =</span><span> path;</span></span> <span class="giallo-l"><span>}</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> home</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_home_dir</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_none</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NotFound</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Home directory not found&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> config_path</span><span style="color: #FF79C6;"> =</span><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(path);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We know that <code>home</code> is not <code>None</code> when we <code>unwrap</code> it, because we checked it right above. But what if we refactor the code? We might forget the check and introduce a bug.</p> <p>This can be rewritten as:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> config_path</span><span style="color: #FF79C6;"> = if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_absolute</span><span>() {</span></span> <span class="giallo-l"><span> path</span></span> <span class="giallo-l"><span>}</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> home</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_home_dir</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span> io</span><span style="color: #FF79C6;">::</span><span>Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NotFound</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Home directory not found&quot;</span><span>,</span></span> <span class="giallo-l"><span> ))</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(path)</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Or, if we introduce a custom error type:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> config_path</span><span style="color: #FF79C6;"> = if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_absolute</span><span>() {</span></span> <span class="giallo-l"><span> path</span></span> <span class="giallo-l"><span>}</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> home</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_home_dir</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span> ConfigError</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">HomeDirNotFound</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(path)</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>The other <code>unwrap</code> is also unnecessary and makes the happy path harder to read. Here is the original code:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">if</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_file</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> ext</span><span style="color: #FF79C6;"> =</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> ext</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_none</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config file must have .conf extension&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> ext</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_str</span><span>()</span><span style="color: #FF79C6;"> !=</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(</span><span style="color: #F1FA8C;">&quot;conf&quot;</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config file must have .conf extension&quot;</span><span>,</span></span> <span class="giallo-l"><span> ));</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We can rewrite this as:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">if</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_file</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(ext)</span><span style="color: #FF79C6;"> =</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #FF79C6;">...</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> ext</span><span style="color: #FF79C6;"> !=</span><span style="color: #F1FA8C;"> &quot;conf&quot;</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #FF79C6;">...</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Or we return early to avoid the nested <code>if</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">if !</span><span>config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_file</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #FF79C6;">...</span><span>);</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(ext)</span><span style="color: #FF79C6;"> =</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #FF79C6;">...</span><span>);</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">if</span><span> ext</span><span style="color: #FF79C6;"> !=</span><span style="color: #F1FA8C;"> &quot;conf&quot;</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #FF79C6;">...</span><span>));</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=f852d031661536d4cac9f8ac3c9d7317">Playground</a>)</p> <h2 id="tip-2-remove-the-muts"><a class="zola-anchor" href="#tip-2-remove-the-muts" aria-label="Anchor link for: tip-2-remove-the-muts">Tip 2: Remove the <code>mut</code>s</a></h2> <p>Usually, my next step is to get rid of as many <code>mut</code> variables as possible.</p> <p>Note how there are no more <code>mut</code> keywords after our first refactoring. This is a typical pattern in Rust: often when we get rid of an <code>unwrap()</code>, we can remove a <code>mut</code> as well.</p> <p>Nevertheless, it is always a good idea to look for all <code>mut</code> variables and see if they are really necessary.</p> <h2 id="tip-3-remove-the-explicit-return-statements"><a class="zola-anchor" href="#tip-3-remove-the-explicit-return-statements" aria-label="Anchor link for: tip-3-remove-the-explicit-return-statements">Tip 3: Remove the explicit return statements</a></h2> <p>The last expression in a block is implicitly returned and that <code>return</code> is an expression itself, so you can often get rid of explicit <code>return</code> statements. In our case that means:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">return</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { config_path });</span></span></code></pre> <p>becomes</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;">Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span> { config_path })</span></span></code></pre> <p>Another simple heuristic is to hunt for <code>returns</code> and semicolons in the middle of your code. These are like “seams” in our program; stop signs, which break the natural data flow. Almost effortlessly, removing these blockers often improves the flow; it’s like magic.</p> <p>For example, the above validation code can also be written without returns:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span> config_path {</span></span> <span class="giallo-l"><span> path</span><span style="color: #FF79C6;"> if !</span><span>path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_file</span><span>()</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config path is not a file&quot;</span><span>,</span></span> <span class="giallo-l"><span> )),</span></span> <span class="giallo-l"><span> path</span><span style="color: #FF79C6;"> if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> !=</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">OsStr</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;conf&quot;</span><span>))</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span>ErrorKind</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">InvalidInput</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Config file must have .conf extension&quot;</span><span>,</span></span> <span class="giallo-l"><span> )),</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>I like that, because we avoid one error message duplication and all conditions start on the left. Whether you prefer that over <code>let-else</code> is a matter of taste. <sup class="footnote-reference" id="fr-let-else-statement-1"><a href="#fn-let-else-statement">2</a></sup></p> <h2 id="don-t-take-it-too-far"><a class="zola-anchor" href="#don-t-take-it-too-far" aria-label="Anchor link for: don-t-take-it-too-far">Don’t take it too far</a></h2> <p>Remember when I said “everything is an expression”? Don’t take this too far or people will stop inviting you to dinner parties.</p> <p>It’s fun to know that you could use <code>then_some</code>, <code>unwrap_or_else</code>, and <code>map_or</code> to chain expressions together, but don’t use them just to show off.</p> <div class="info"> <div class="info-header"> <span class="icon icon-warning"></span> <h4><p>Warning</p> </h4> </div> <p>The below code is correct, but the combinators get in the way of readability. It feels more like a Lisp program than Rust code.</p> </div> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> with_config_path</span><span>(path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> PathBuf</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>, io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span> (</span><span style="color: #FF79C6;">if</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_absolute</span><span>() {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(path)</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> get_home_dir</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">ok_or_else</span><span>(</span><span style="color: #6272A4;">/* error */</span><span>)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>home</span><span style="color: #FF79C6;">|</span><span> home</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(path))</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">and_then</span><span>(</span><span style="color: #FF79C6;">|</span><span>config_path</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span> (</span><span style="color: #FF79C6;">!</span><span>config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">exists</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">then_some</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Err</span><span>(</span><span style="color: #6272A4;">/* error */</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span> config_path</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">is_file</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">then</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span> (</span><span style="color: #FF79C6;">!</span><span>config_path</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">extension</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map_or</span><span>(</span><span style="color: #BD93F9;">false</span><span>,</span><span style="color: #FF79C6;"> |</span><span>ext</span><span style="color: #FF79C6;">|</span><span> ext</span><span style="color: #FF79C6;"> ==</span><span style="color: #F1FA8C;"> &quot;conf&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">then_some</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Err</span><span>(</span><span style="color: #6272A4;">/* error */</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Ok</span><span>(()))</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Ok</span><span>(()))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>_</span><span style="color: #FF79C6;">|</span><span> config_path)</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>config_path</span><span style="color: #FF79C6;">|</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> { config_path })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Keep your friends and colleagues in mind when writing code. Find a balance between expressiveness and readability.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>If you find that your code doesn’t feel idiomatic, see if expressions can help. They tend to guide you towards more ergonomic Rust code.</p> <p>Once you find the right balance, expressions are a joy to use – especially in smaller context where data flow is key. The “trifecta” of iterators, expressions, and pattern matching is the foundation of data transformations in Rust. I wrote a complementary article about iterators <a href="/blog/iterators/">here</a>.</p> <p>Of course, it’s not forbidden to mix expressions and statements! For example, I personally like to use <code>let-else</code> statements when it makes my code easier to understand. If you’re unsure about whether using an expression is worth it, seek feedback from someone less familiar with Rust. If they look confused, you probably tried to be too clever.</p> <p>Now, try to refactor some code to train that muscle.</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-reference"> <p>The <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/statements-and-expressions.html">Rust Reference</a> puts it like this: “Rust is primarily an expression language. This means that most forms of value-producing or effect-causing evaluation are directed by the uniform syntax category of expressions. Each kind of expression can typically nest within each other kind of expression, and rules for evaluation of expressions involve specifying both the value produced by the expression and the order in which its sub-expressions are themselves evaluated.” <a href="#fr-reference-1">↩</a></p> </li> <li id="fn-let-else-statement"> <p>By the way, <code>let-else</code> is not an expression, but a statement. That’s because the <code>else</code> branch doesn’t produce a value. Instead, it moves the “failure” case into the body block, while allowing the “success” case to continue in the surrounding context without additional nesting. I recommend reading the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rfcs/3137-let-else.html">RFC</a> for more details. <a href="#fr-let-else-statement-1">↩</a></p> </li> </ol> </section> Wed, 15 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/prototyping/ https://corrode.dev/blog/prototyping/ <p>Programming is an iterative process. As much as we would like to come up with the perfect solution from the start, it rarely works that way.</p> <p>Good programs often begin as quick prototypes. While many experiments remain prototypes, the best programs can evolve into production code.</p> <p>Whether you’re writing games, CLI tools, or designing library APIs, prototyping helps tremendously in finding the best approach before committing to a design. It often helps reveal the patterns behind more idiomatic code.</p> <p>For all its explicitness, Rust is surprisingly ergonomic when iterating on ideas. Contrary to popular belief, it is a joy for building prototypes.</p> <p>You don’t need to be a Rust expert to be productive - in fact, many of the techniques we’ll discuss specifically help you <em>sidestep</em> Rust’s more advanced features. If you focus on simple patterns and make use of Rust’s excellent tooling, even less experienced Rust developers can quickly bring their ideas to life.</p> <div class="info"> <div class="info-header"> <span class="icon icon-radio"></span> <h4><p>Feel like listening instead?</p> </h4> </div> <p>I talked about prototyping in Rust on SE Radio. The article was the basis for the episode, so you can listen to it while reading along.</p> <iframe src="https://play.libsyn.com/embed/episode/id/36781410/height/128/theme/modern/size/standard/thumbnail/yes/custom-color/ffffff/time-start/00:00:00/playlist-height/200/direction/backward/download/yes/hide-subscribe/no/hide-share/no" width="100%" height="128" scrolling="yes" class="iframe-class" frameborder="0"></iframe> </div> <h2 id="why-people-think-rust-is-not-good-for-prototyping"><a class="zola-anchor" href="#why-people-think-rust-is-not-good-for-prototyping" aria-label="Anchor link for: why-people-think-rust-is-not-good-for-prototyping">Why People Think Rust Is Not Good For Prototyping</a></h2> <p>The common narrative goes like this:</p> <blockquote> <p>When you start writing a program, you don’t know what you want and you change your mind pretty often. Rust pushes back when you change your mind because the type system is very strict. On top of that, getting your idea to compile takes longer than in other languages, so the feedback loop is slower.</p> </blockquote> <p>I’ve found that developers not yet too familiar with Rust often share this preconception. These developers stumble over the strict type system and the borrow checker while trying to sketch out a solution. They believe that with Rust you’re either at 0% or 100% done (everything works and has no undefined behavior) and there’s nothing in between.</p> <p>Here are some typical misbeliefs:</p> <ol> <li>“Memory safety and prototyping just don’t go together.”</li> <li>“Ownership and borrowing take the fun out of prototyping.”</li> <li>“You have to get all the details right from the beginning.”</li> <li>“Rust always requires you to handle errors.”</li> </ol> <p>These are all <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://medium.com/@victor.ronin/love-hate-relationship-with-rust-language-part-2-c36f57d5485d">common misconceptions</a> and they are not true.</p> <p><strong>It turns out you can avoid all of these pitfalls and still get a lot of value from prototyping in Rust.</strong></p> <h2 id="problems-with-prototyping-in-other-languages"><a class="zola-anchor" href="#problems-with-prototyping-in-other-languages" aria-label="Anchor link for: problems-with-prototyping-in-other-languages">Problems with Prototyping in Other Languages</a></h2> <p>If you’re happy with a scripting language like Python, why bother with Rust?</p> <p>That’s a fair question! After all, Python is known for its quick feedback loop and dynamic type system, and you can always rewrite the code in Rust later.</p> <p>Yes, Python is a great choice for prototyping. But I’ve been a Python developer for long enough to know that I’ll very quickly grow out of the “prototype” phase -– which is when the language falls apart for me.</p> <p>One thing I found particularly challenging in Python was hardening my prototype into a robust, production-ready codebase. I’ve found that the really hard bugs in Python are often type-related: deep down in your call chain, the program crashes because you just passed the wrong type to a function. Because of that, I find myself wanting to switch to something more robust as soon as my prototype starts to take shape.</p> <p>The problem is that switching languages is a <em>huge</em> undertaking – especially mid-project. Maybe you’ll have to maintain two codebases simultaneously for a while. On top of that, Rust follows different idioms than Python, so you might have to rethink the software architecture. And to add insult to injury, you have to change build systems, testing frameworks, and deployment pipelines as well.</p> <p>Wouldn’t it be nice if you could use a single language for prototyping and production?</p> <h2 id="what-makes-rust-great-for-prototyping"><a class="zola-anchor" href="#what-makes-rust-great-for-prototyping" aria-label="Anchor link for: what-makes-rust-great-for-prototyping">What Makes Rust Great for Prototyping?</a></h2> <p>Using a single language across your entire project lifecycle is great for productivity. Rust scales from proof-of-concept to production deployment and that eliminates costly context switches and rewrites. Rust’s strong type system catches design flaws early, but we will see how it also provides pragmatic escape hatches if needed. This means prototypes can naturally evolve into production code; even the first version is often production-ready.</p> <p>But don’t take my word for it. Here’s what Discord had to say about migrating from Go to Rust:</p> <blockquote> <p>Remarkably, we had only put very basic thought into optimization as the Rust version was written. Even with just basic optimization, Rust was able to outperform the hyper hand-tuned Go version. This is a huge testament to how easy it is to write efficient programs with Rust compared to the deep dive we had to do with Go. – From <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://discord.com/blog/why-discord-is-switching-from-go-to-rust">Why Discord is switching from Go to Rust</a></p> </blockquote> <h2 id="what-a-solid-rust-prototyping-workflow-looks-like"><a class="zola-anchor" href="#what-a-solid-rust-prototyping-workflow-looks-like" aria-label="Anchor link for: what-a-solid-rust-prototyping-workflow-looks-like">What A Solid Rust Prototyping Workflow Looks Like</a></h2> <p>If you start with Rust, you get a lot of benefits out of the box: a robust codebase, a strong type system, and built-in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/clippy/">linting</a>.</p> <p>All without having to change languages mid-project! It saves you the context switch between languages once you’re done with the prototype.</p> <img src="flow.svg" alt="flow" class="natural"> <p>Python has a few good traits that we can learn from:</p> <ul> <li>fast feedback loop</li> <li>changing your mind is easy</li> <li>it’s simple to use (if you ignore the edge cases)</li> <li>very little boilerplate</li> <li>it’s easy to experiment and refactor</li> <li>you can do something useful in just a few lines</li> <li>no compilation step</li> </ul> <p>The goal is to get as close to that experience in Rust as possible while staying true to Rust’s core principles. Let’s make changes quick and painless and rapidly iterate on our design without painting ourselves into a corner. (And yes, there will still be a compilation step, but hopefully, a quick one.)</p> <h2 id="tips-and-tricks-for-prototyping-in-rust"><a class="zola-anchor" href="#tips-and-tricks-for-prototyping-in-rust" aria-label="Anchor link for: tips-and-tricks-for-prototyping-in-rust">Tips And Tricks For Prototyping In Rust</a></h2> <h3 id="use-simple-types"><a class="zola-anchor" href="#use-simple-types" aria-label="Anchor link for: use-simple-types">Use simple types</a></h3> <p>Even while prototyping, the type system is not going away. There are ways to make this a blessing rather than a curse.</p> <p>Use simple types like <code>i32</code>, <code>String</code>, <code>Vec</code> in the beginning. We can always make things more complex later if we have to – the reverse is much harder.</p> <p>Here’s a quick reference for common prototype-to-production type transitions:</p> <table><thead><tr><th>Prototype</th><th>Production</th><th>When to switch</th></tr></thead><tbody> <tr><td><code>String</code></td><td><code>&amp;str</code></td><td>When you need to avoid allocations or store string data with a clear lifetime</td></tr> <tr><td><code>Vec&lt;T&gt;</code></td><td><code>&amp;[T]</code></td><td>When the owned vector becomes too expensive to clone or you can’t afford the heap</td></tr> <tr><td><code>Box&lt;T&gt;</code></td><td><code>&amp;T</code> or <code>&amp;mut T</code></td><td>When <code>Box</code> becomes a bottleneck or you don’t want to deal with heap allocations</td></tr> <tr><td><code>Rc&lt;T&gt;</code></td><td><code>&amp;T</code></td><td>When the reference counting overhead becomes too expensive or you need mutability</td></tr> <tr><td><code>Arc&lt;Mutex&lt;T&gt;&gt;</code></td><td><code>&amp;mut T</code></td><td>When you can guarantee exclusive access and don’t need thread safety</td></tr> </tbody></table> <p>These owned types sidestep most ownership and lifetime issues, but they do it by allocating memory on the heap - just like Python or JavaScript would.</p> <p>You can always refactor when you actually need the performance or tighter resource usage, but chances are you won’t.<sup class="footnote-reference" id="fr-1-1"><a href="#fn-1">1</a></sup></p> <h3 id="make-use-of-type-inference"><a class="zola-anchor" href="#make-use-of-type-inference" aria-label="Anchor link for: make-use-of-type-inference">Make use of type inference</a></h3> <p>Rust is a statically, strongly typed language. It would be a deal-breaker to write out all the types all the time if it weren’t for Rust’s type inference.</p> <p>You can often omit (“elide”) the types and let the compiler figure it out from the context.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> y</span><span style="color: #FF79C6;"> =</span><span style="color: #F1FA8C;"> &quot;hello&quot;</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> z</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span></code></pre> <p>This is a great way to get started quickly and defer the decision about types to later. The system scales well with more complex types, so you can use this technique even in larger projects.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;"> 2</span><span>,</span><span style="color: #BD93F9;"> 3</span><span>];</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> y</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #BD93F9;">4</span><span>,</span><span style="color: #BD93F9;"> 5</span><span>,</span><span style="color: #BD93F9;"> 6</span><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// From the context, Rust knows that `z` needs to be a `Vec&lt;i32&gt;`</span></span> <span class="giallo-l"><span style="color: #6272A4;">// The `_` is a placeholder for the type that Rust will infer</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> z</span><span style="color: #FF79C6;"> =</span><span> x</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chain</span><span>(y</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>())</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">collect</span><span style="color: #FF79C6;">::</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;_&gt;&gt;();</span></span></code></pre> <p>Here’s a more complex example which shows just how powerful Rust’s type inference can be:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>collections</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">HashMap</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Start with some nested data</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span></span> <span class="giallo-l"><span> (</span><span style="color: #F1FA8C;">&quot;fruits&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #F1FA8C;">&quot;apple&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;banana&quot;</span><span>]),</span></span> <span class="giallo-l"><span> (</span><span style="color: #F1FA8C;">&quot;vegetables&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #F1FA8C;">&quot;carrot&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;potato&quot;</span><span>]),</span></span> <span class="giallo-l"><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Let Rust figure out this complex transformation</span></span> <span class="giallo-l"><span style="color: #6272A4;">// Can you tell what the type of `categorized` is?</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> categorized</span><span style="color: #FF79C6;"> =</span><span> data</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">into_iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">flat_map</span><span>(</span><span style="color: #FF79C6;">|</span><span>(category, items)</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span> items</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into_iter</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">move |</span><span>item</span><span style="color: #FF79C6;">|</span><span> (item, category))</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span style="color: #FF79C6;">::</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">HashMap</span><span>&lt;_, _&gt;&gt;();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// categorized is now a HashMap&lt;&amp;str, &amp;str&gt; mapping items to their categories</span></span> <span class="giallo-l"><span style="color: #50FA7B;">println!</span><span>(</span><span style="color: #F1FA8C;">&quot;What type is banana? {}&quot;</span><span>, categorized</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">get</span><span>(</span><span style="color: #F1FA8C;">&quot;banana&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>());</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=fac339eecef40b69b919a1670a0a53df">Playground</a>)</p> <p>It’s not easy to visualize the structure of <code>categorized</code> in your head, but Rust can figure it out.</p> <h3 id="use-the-rust-playground"><a class="zola-anchor" href="#use-the-rust-playground" aria-label="Anchor link for: use-the-rust-playground">Use the Rust playground</a></h3> <p>You probably already know about the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org">Rust Playground</a>. The playground doesn’t support auto-complete, but it’s still great when you’re on the go or you’d like to share your code with others.</p> <p>I find it quite useful for quickly jotting down a bunch of functions or types to test out a design idea.</p> <h3 id="use-unwrap-liberally"><a class="zola-anchor" href="#use-unwrap-liberally" aria-label="Anchor link for: use-unwrap-liberally">Use <code>unwrap</code> Liberally</a></h3> <p>It’s okay to use <code>unwrap</code> in the early stages of your project. An explicit <code>unwrap</code> is like a stop sign that tells you “here’s something you need to fix later.” You can easily grep for <code>unwrap</code> and replace it with proper error handling later when you polish your code. This way, you get the best of both worlds: quick iteration cycles and a clear path to robust error handling. There’s also a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used">clippy lint</a> that points out all the <code>unwrap</code>s in your code.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>fs;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Quick and dirty path handling during prototyping</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> home</span><span style="color: #FF79C6;"> =</span><span> std</span><span style="color: #FF79C6;">::</span><span>env</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">var</span><span>(</span><span style="color: #F1FA8C;">&quot;HOME&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> config_path</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> PathBuf</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(home)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(</span><span style="color: #F1FA8C;">&quot;.config&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(</span><span style="color: #F1FA8C;">&quot;myapp&quot;</span><span>);</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Create config directory if it doesn&#39;t exist</span></span> <span class="giallo-l"><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">create_dir_all</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>config_path)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Read the config file, defaulting to empty string if it doesn&#39;t exist</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> config_file</span><span style="color: #FF79C6;"> =</span><span> config_path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">join</span><span>(</span><span style="color: #F1FA8C;">&quot;config.json&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> config_content</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>config_file)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or_default</span><span>();</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Parse the JSON config</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> config</span><span style="color: #FF79C6;">:</span><span> serde_json</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Value</span><span style="color: #FF79C6;"> = if !</span><span>config_content</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span> serde_json</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_str</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>config_content)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>()</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> serde_json</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">json!</span><span>({})</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Loaded config: {:?}&quot;</span><span>, config);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>See all those unwraps? To more experienced Rustaceans, they stand out like a sore thumb – and that’s a good thing!</p> <p>Compare that to languages like JavaScript which can throw exceptions your way at any time. It’s much harder to ensure that you handle all the edge-cases correctly. At the very least, it costs time. Time you could spend on more important things.</p> <p>While prototyping with Rust, you can safely ignore error handling and focus on the happy path without losing track of improvement areas.</p> <h3 id="add-anyhow-to-your-prototypes"><a class="zola-anchor" href="#add-anyhow-to-your-prototypes" aria-label="Anchor link for: add-anyhow-to-your-prototypes">Add <code>anyhow</code> to your prototypes</a></h3> <p>I like to add <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/anyhow"><code>anyhow</code></a> pretty early during the prototyping phase, to get more fine-grained control over my error handling. This way, I can use <code>bail!</code> and <code>with_context</code> to quickly add more context to my errors without losing momentum. Later on, I can revisit each error case and see if I can handle it more gracefully.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> anyhow</span><span style="color: #FF79C6;">::</span><span>{bail,</span><span style="color: #8BE9FD;font-style: italic;"> Context</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Here&#39;s how to use `with_context` to add more context to an error</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> home</span><span style="color: #FF79C6;"> =</span><span> std</span><span style="color: #FF79C6;">::</span><span>env</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">var</span><span>(</span><span style="color: #F1FA8C;">&quot;HOME&quot;</span><span>)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">with_context</span><span>(</span><span style="color: #FF79C6;">||</span><span style="color: #F1FA8C;"> &quot;Could not read HOME environment variable&quot;</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// ...alternatively, use `bail` to return an error immediately </span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(home)</span><span style="color: #FF79C6;"> =</span><span> std</span><span style="color: #FF79C6;">::</span><span>env</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">var</span><span>(</span><span style="color: #F1FA8C;">&quot;HOME&quot;</span><span>)</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> bail!</span><span>(</span><span style="color: #F1FA8C;">&quot;Could not read HOME environment variable&quot;</span><span>);</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>The great thing about <code>anyhow</code> is that it’s a solid choice for error handling in production code as well, so you don’t have to rewrite your error handling logic later on.</p> <h3 id="use-a-good-ide"><a class="zola-anchor" href="#use-a-good-ide" aria-label="Anchor link for: use-a-good-ide">Use a good IDE</a></h3> <p>There is great IDE support for Rust.</p> <p>IDEs can help you with code completion and refactoring, which keep you in the flow and help you write code faster. Autocompletion is so much better with Rust than with dynamic languages because the type system gives the IDE a lot more information to work with.</p> <p>As a corollary to the previous section, be sure to use enable inlay hints (or inline type hints) in your editor. This way, you can quickly see the inferred types right inside your IDE and make sure the types match your expectations. There’s support for this in most Rust IDEs, including <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.jetbrains.com/help/rust/viewing-reference-information.html#inlay-hints">RustRover</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://code.visualstudio.com/docs/typescript/typescript-editing#_inlay-hints">Visual Studio Code</a>.</p> <p><img src="https://corrode.dev/blog/prototyping/inlay-hints.png" alt="Inlay hints in Rust Rover" /></p> <h3 id="use-bacon-for-quick-feedback-cycles"><a class="zola-anchor" href="#use-bacon-for-quick-feedback-cycles" aria-label="Anchor link for: use-bacon-for-quick-feedback-cycles">Use <code>bacon</code> for quick feedback cycles</a></h3> <p>Rust is not a scripting language; there is a compile step!</p> <p>However, for small projects, the compile times are negligible. Unfortunately, you have to manually run <code>cargo check</code> every time you make a change or use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-analyzer.github.io/">rust-analyzer</a> in your editor to get instant feedback.</p> <p>To fill the gap, you can use external tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Canop/bacon"><code>bacon</code></a> which automatically recompiles and runs your code whenever you make a change. This way, you can get <em>almost</em> the same experience as with a REPL in, say, Python or Ruby.</p> <p>The setup is simple:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #6272A4;"># Install bacon</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install</span><span style="color: #BD93F9;"> --locked</span><span style="color: #F1FA8C;"> bacon</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Run bacon in your project directory</span></span> <span class="giallo-l"><span style="color: #50FA7B;">bacon</span></span></code></pre> <p>And just like that, you can get some pretty compilation output alongside your code editor.</p> <p><img src="https://corrode.dev/blog/prototyping/bacon.png" alt="bacon" /></p> <p>Oh, and in case you were wondering, <code>cargo-watch</code> was another popular tool for this purpose, but it’s since been <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/watchexec/cargo-watch#maintenance">deprecated</a>.</p> <h3 id="cargo-script-is-awesome"><a class="zola-anchor" href="#cargo-script-is-awesome" aria-label="Anchor link for: cargo-script-is-awesome"><code>cargo-script</code> is awesome</a></h3> <p>Did you know that cargo can also run scripts?</p> <p>For example, put this into a file called <code>script.rs</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#</span><span style="color: #FF79C6;">!/</span><span>usr</span><span style="color: #FF79C6;">/</span><span>bin</span><span style="color: #FF79C6;">/</span><span>env cargo</span><span style="color: #FF79C6;"> +</span><span>nightly</span><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;font-style: italic;">Zscript</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Hello prototyping world&quot;</span><span>);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now you can make the file executable with <code>chmod +x script.rs</code> and run it with <code>./script.rs</code> which it will compile and execute your code! This allows you to quickly test out ideas without having to create a new project. There is support for dependencies as well.</p> <p>At the moment, <code>cargo-script</code> is a nightly feature, but it will be released soon on stable Rust. You can read more about it in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rfcs/3424-cargo-script.html">RFC</a>.</p> <h3 id="don-t-worry-about-performance"><a class="zola-anchor" href="#don-t-worry-about-performance" aria-label="Anchor link for: don-t-worry-about-performance">Don’t worry about performance</a></h3> <p>You have to try really really hard to write slow code in Rust. Use that to your advantage: during the prototype phase, try to keep the code as simple as possible.</p> <p>I gave a talk titled <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/four-horsemen-talk">“The Four Horsemen of Bad Rust Code”</a> where I argue that premature optimization is one of the biggest sins in Rust.</p> <p>Especially experienced developers coming from C or C++ are tempted to optimize too early.</p> <p>Rust makes code perform well by default - you get memory safety at virtually zero runtime cost. When developers try to optimize too early, they often run up against the borrow checker by using complex lifetime annotations and intricate reference patterns in pursuit of better performance. This leads to harder-to-maintain code that may not actually run faster.</p> <p>Resist the urge to optimize too early! You will thank yourself later. <sup class="footnote-reference" id="fr-2-1"><a href="#fn-2">2</a></sup></p> <h3 id="use-println-and-dbg-for-debugging"><a class="zola-anchor" href="#use-println-and-dbg-for-debugging" aria-label="Anchor link for: use-println-and-dbg-for-debugging">Use <code>println!</code> and <code>dbg!</code> for debugging</a></h3> <p>I find that printing values is pretty handy while prototyping. It’s one less context switch to make compared to starting a debugger.</p> <p>Most people use <code>println!</code> for that, but <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.dbg.html"><code>dbg!</code></a> has a few advantages:</p> <ul> <li>It prints the file name and line number where the macro is called. This helps you quickly find the source of the output.</li> <li>It outputs the expression as well as its value.</li> <li>It’s less syntax-heavy than <code>println!</code>; e.g. <code>dbg!(x)</code> vs. <code>println!("{x:?}")</code>.</li> </ul> <p>Where <code>dbg!</code> really shines is in recursive functions or when you want to see the intermediate values during an iteration:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> factorial</span><span>(n</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // `dbg!` returns the argument, </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // so you can use it in the middle of an expression</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span style="color: #50FA7B;"> dbg!</span><span>(n</span><span style="color: #FF79C6;"> &lt;=</span><span style="color: #BD93F9;"> 1</span><span>) {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> dbg!</span><span>(</span><span style="color: #BD93F9;">1</span><span>)</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> dbg!</span><span>(n</span><span style="color: #FF79C6;"> *</span><span style="color: #50FA7B;"> factorial</span><span>(n</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #50FA7B;">dbg!</span><span>(</span><span style="color: #50FA7B;">factorial</span><span>(</span><span style="color: #BD93F9;">4</span><span>));</span></span></code></pre> <p>The output is nice and tidy:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">8</span><span>] n</span><span style="color: #FF79C6;"> &lt;=</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> false</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">8</span><span>] n</span><span style="color: #FF79C6;"> &lt;=</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> false</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">8</span><span>] n</span><span style="color: #FF79C6;"> &lt;=</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> false</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">2</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">8</span><span>] n</span><span style="color: #FF79C6;"> &lt;=</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> true</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">3</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span><span>]</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">7</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span><span>] n</span><span style="color: #FF79C6;"> *</span><span style="color: #50FA7B;"> factorial</span><span>(n</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>)</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 2</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">7</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span><span>] n</span><span style="color: #FF79C6;"> *</span><span style="color: #50FA7B;"> factorial</span><span>(n</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>)</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 6</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">7</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span><span>] n</span><span style="color: #FF79C6;"> *</span><span style="color: #50FA7B;"> factorial</span><span>(n</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>)</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 24</span></span> <span class="giallo-l"><span>[src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">1</span><span>]</span><span style="color: #50FA7B;"> factorial</span><span>(</span><span style="color: #BD93F9;">4</span><span>)</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 24</span></span></code></pre> <p>Note that you should not keep the <code>dbg!</code> calls in your final code as they will also be executed in release mode. If you’re interested, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://edgarluque.com/blog/rust-dbg-macro/">here are more details on how to use the <code>dbg!</code> macro</a>.</p> <h3 id="design-through-types"><a class="zola-anchor" href="#design-through-types" aria-label="Anchor link for: design-through-types">Design through types</a></h3> <p>Quite frankly, the type system is one of the main reasons I love Rust. It feels great to express my ideas in types and see them come to life. I would encourage you to heavily lean into the type system during the prototyping phase.</p> <p>In the beginning, you won’t have a good idea of the types in your system. That’s fine! Start with <em>something</em> and quickly sketch out solutions and gradually add constraints to model the business requirements. Don’t stop until you find a version that feels just right. You know you’ve found a good abstraction when your types “click” with the rest of the code. <sup class="footnote-reference" id="fr-3-1"><a href="#fn-3">3</a></sup> Try to build up a vocabulary of concepts and own types which describe your system.</p> <p>Wrestling with Rust’s type system might feel slower at first compared to more dynamic languages, but it often leads to fewer iterations overall. Think of it this way: in a language like Python, each iteration might be quicker since you can skip type definitions, but you’ll likely need more iterations as you discover edge cases and invariants that weren’t immediately obvious. In Rust, the type system forces you to think through these relationships up front. Although each iteration takes longer, you typically need fewer of them to arrive at a robust solution.</p> <p>This is exactly what we’ll see in the following example.</p> <p>Say you’re modeling course enrollments in a student system. You might start with something simple:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Enrollment</span><span> {</span></span> <span class="giallo-l"><span> student</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> StudentId</span><span>,</span></span> <span class="giallo-l"><span> course</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> CourseId</span><span>,</span></span> <span class="giallo-l"><span> is_enrolled</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>But then requirements come in: some courses are very popular. More students want to enroll than there are spots available, so the school decides to add a waitlist.</p> <p>Easy, let’s just add another boolean flag!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Enrollment</span><span> {</span></span> <span class="giallo-l"><span> student</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> StudentId</span><span>,</span></span> <span class="giallo-l"><span> course</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> CourseId</span><span>,</span></span> <span class="giallo-l"><span> is_enrolled</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span> is_waitlisted</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span><span style="color: #6272A4;"> // 🚩 uh oh</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The problem is that both boolean flags could be set to <code>true</code>! This design allows invalid states where a student could be both enrolled and waitlisted.</p> <p>Think for a second how we could leverage Rust’s type system to make this impossible…</p> <p>Here’s one attempt:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> EnrollmentStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> {</span></span> <span class="giallo-l"><span> date</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt;,</span></span> <span class="giallo-l"><span> },</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Waitlisted</span><span> {</span></span> <span class="giallo-l"><span> position</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span>,</span></span> <span class="giallo-l"><span> },</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Enrollment</span><span> {</span></span> <span class="giallo-l"><span> student</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> StudentId</span><span>,</span></span> <span class="giallo-l"><span> course</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> CourseId</span><span>,</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> EnrollmentStatus</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now we have a clear distinction between an active enrollment and a waitlisted enrollment. What’s better is that we encapsulate the details of each state in the enum variants. We can never have someone on the waitlist without a position in said list.</p> <p>Just think about how much more complicated this would be in a dynamic language or a language that doesn’t support tagged unions like Rust does.</p> <p>In summary, iterating on your data model is the crucial part of any prototyping phase. The result of this phase is not the code, but a <em>deeper understanding of the problem domain itself</em>. You can harvest this knowledge to build a more robust and maintainable solution.</p> <p>It turns out you can model a surprisingly large system in just a few lines of code.</p> <p>So, never be afraid to play around with types and refactor your code as you go.</p> <h3 id="the-todo-macro"><a class="zola-anchor" href="#the-todo-macro" aria-label="Anchor link for: the-todo-macro">The <code>todo!</code> Macro</a></h3> <p>One of the cornerstones of prototyping is that you don’t have to have all the answers right away. In Rust, I find myself reaching for the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.todo.html"><code>todo!</code></a> macro to express that idea.</p> <p>I routinely just scaffold out the functions or a module and then fill in the blanks later.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// We don&#39;t know yet how to process the data</span></span> <span class="giallo-l"><span style="color: #6272A4;">// but we&#39;re pretty certain that we need a function</span></span> <span class="giallo-l"><span style="color: #6272A4;">// that takes a Vec&lt;i32&gt; and returns an i32</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_data</span><span>(data</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> todo!</span><span>()</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// There exists a function that loads the data and returns a Vec&lt;i32&gt;</span></span> <span class="giallo-l"><span style="color: #6272A4;">// How exactly it does that is not important right now</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> load_data</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> todo!</span><span>()</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Given that we have a function to load the data</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> load_data</span><span>();</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ... and a function to process it</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> result</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> process_data</span><span>(data);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ... we can print the result</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Result: {}&quot;</span><span>, result);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We did not do much here, but we have a clear idea of what the program should do. Now we can go and iterate on the design. For example, should <code>process_data</code> take a reference to the data? Should we create a struct to hold the data and the processing logic? How about using an iterator instead of a vector? Should we introduce a trait to support algorithms for processing the data?</p> <p>These are all helpful questions that we can answer without having to worry about the details of the implementation. And yet our code is typesafe and compiles, and it is ready for refactoring.</p> <h3 id="unreachable-for-unreachable-branches"><a class="zola-anchor" href="#unreachable-for-unreachable-branches" aria-label="Anchor link for: unreachable-for-unreachable-branches"><code>unreachable!</code> for unreachable branches</a></h3> <p>On a related note, you can use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.unreachable.html"><code>unreachable!</code></a> macro to mark branches of your code that should never be reached.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> age</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 170</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span> age {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 0</span><span style="color: #FF79C6;">..</span><span style="color: #BD93F9;">150</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Normal human age&quot;</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 150</span><span style="color: #FF79C6;">.. =&gt;</span><span style="color: #50FA7B;"> unreachable!</span><span>(</span><span style="color: #F1FA8C;">&quot;Witchcraft!&quot;</span><span>),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This is a great way to document your assumptions about the code. The result is the same as if you had used <code>todo!</code>, but it’s more explicit about the fact that this branch should never be reached:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>thread</span><span style="color: #F1FA8C;"> &#39;main&#39;</span><span> panicked at src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">6</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">18</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span>internal error</span><span style="color: #FF79C6;">:</span><span> entered unreachable code</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Witchcraft!</span></span></code></pre> <p>Note that we added a message to the <code>unreachable!</code> macro to make it clear what the assumption is.</p> <h3 id="use-assert-for-invariants"><a class="zola-anchor" href="#use-assert-for-invariants" aria-label="Anchor link for: use-assert-for-invariants">Use <code>assert!</code> for invariants</a></h3> <p>Another way to document your assumptions is to use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.assert.html"><code>assert!</code></a> macro. This is especially useful for invariants that should hold true at runtime.</p> <p>For example, the above code could be rewritten like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> age</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 170</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(age</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #BD93F9;"> 150</span><span>,</span><span style="color: #F1FA8C;"> &quot;This is very unlikely to be a human age&quot;</span><span>);</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Normal human age&quot;</span><span>);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>During prototyping, this can be helpful to catch logic bugs early on without having to write a lot of tests and you can safely carry them over to your production code.</p> <p>Consider using <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.debug_assert.html"><code>debug_assert!</code></a> for expensive invariant checks that should only run in test/debug builds.</p> <h3 id="avoid-generics"><a class="zola-anchor" href="#avoid-generics" aria-label="Anchor link for: avoid-generics">Avoid generics</a></h3> <p>Chances are, you won’t know which parts of your application should be generic in the beginning. Therefore it’s better to be conservative and use concrete types instead of generics until necessary.</p> <p>So instead of writing this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;(x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Write this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>(x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If you need the same function for a different type, feel free to just copy and paste the function and change the type. This way, you avoid the trap of settling on the wrong kind of abstraction too early. Maybe the two functions only differ by type signature for now, but they might serve a completely different purpose. If the function is not generic from the start, it’s easier to remove the duplication later.</p> <p>Only introduce generics when you see a clear pattern emerge in multiple places. I personally avoid generics up until the very last moment. I want to feel the “pain” of duplication logic before I abstract it away. In 50% of the cases, I find that the problem is not missing generics, but that there’s a better algorithm or data structure that solves the problem more elegantly.</p> <p>Also avoid “fancy” generic type signatures:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;&gt;(x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Yes, this allows you to pass in a <code>&amp;str</code> or a <code>String</code>, but at the cost of readability.</p> <p>Just use an owned type for your first implementation:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>(x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Chances are, you won’t need the flexibility after all.</p> <p>In summary, generics are powerful, but they can make the code harder to read and write. Avoid them until you have a clear idea of what you’re doing.</p> <h3 id="avoid-lifetimes"><a class="zola-anchor" href="#avoid-lifetimes" aria-label="Anchor link for: avoid-lifetimes">Avoid Lifetimes</a></h3> <p>One major blocker for rapid prototyping is Rust’s ownership system. If the compiler constantly reminds you of borrows and lifetimes it can ruin your flow. For example, it’s cumbersome to deal with references when you’re just trying to get something to work.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// First attempt with references - compiler error!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Note</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt; {</span></span> <span class="giallo-l"><span> title</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>,</span></span> <span class="giallo-l"><span> content</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> create_note</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Note</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">_</span><span>&gt; {</span><span style="color: #6272A4;"> // ❌ lifetime error</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> title</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;Draft&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> content</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;My first note&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Note</span><span> {</span></span> <span class="giallo-l"><span> title</span><span style="color: #FF79C6;">: &amp;</span><span>title,</span></span> <span class="giallo-l"><span> content</span><span style="color: #FF79C6;">: &amp;</span><span>content</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This code doesn’t compile because the references are not valid outside of the function.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Compiling</span><span> playground v0</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0.1</span><span> (</span><span style="color: #FF79C6;">/</span><span>playground)</span></span> <span class="giallo-l"><span>error[</span><span style="color: #8BE9FD;font-style: italic;">E0106</span><span>]</span><span style="color: #FF79C6;">:</span><span> missing lifetime specifier</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> --&gt;</span><span> src</span><span style="color: #FF79C6;">/</span><span>lib</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">7</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">26</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #BD93F9;">7</span><span style="color: #FF79C6;"> | fn</span><span style="color: #50FA7B;"> create_note</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Note</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">_</span><span>&gt; {</span><span style="color: #6272A4;"> // ❌ lifetime error</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ^^</span><span> expected named lifetime parameter</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> =</span><span> help</span><span style="color: #FF79C6;">:</span><span> this function&#39;</span><span style="color: #8BE9FD;font-style: italic;">s</span><span style="color: #FF79C6;"> return type</span><span> contains a borrowed value, but there is no value</span><span style="color: #FF79C6;"> for</span><span> it to be borrowed from</span></span> <span class="giallo-l"><span>help</span><span style="color: #FF79C6;">:</span><span> consider using the `&#39;</span><span style="color: #8BE9FD;font-style: italic;">static</span><span>` lifetime, but this is uncommon unless you&#39;</span><span style="color: #8BE9FD;font-style: italic;">re</span><span> returning a borrowed value from a `</span><span style="color: #FF79C6;">const</span><span>` or a `</span><span style="color: #FF79C6;">static</span><span>`, or</span><span style="color: #FF79C6;"> if</span><span> you will only have owned values</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=7274f20a06226316c93d9984f1d66b5f">Playground</a>)</p> <p>A simple way around that is to use owned types like <code>String</code> and <code>Vec</code> and avoid lifetime annotations altogether. <a href="/blog/lifetimes/">They’re needed less often than you’d think</a>. Just <code>.clone()</code> wherever you need to pass data around.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Much simpler with owned types</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Note</span><span> {</span></span> <span class="giallo-l"><span> title</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> content</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> create_note</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Note</span><span> {</span><span style="color: #6272A4;"> // ✓ just works</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Note</span><span> {</span></span> <span class="giallo-l"><span> title</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;Draft&quot;</span><span>),</span></span> <span class="giallo-l"><span> content</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;My first note&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If you have a type that you need to move between threads (i.e. it needs to be <code>Send</code>), you can use an <code>Arc&lt;Mutex&lt;T&gt;&gt;</code> to get around the borrow checker. If you’re worried about performance, remember that other languages like Python or Java do this implicitly behind your back.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>sync</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">Arc</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Mutex</span><span>};</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>thread;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> note</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Arc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(Mutex</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Note</span><span> {</span></span> <span class="giallo-l"><span> title</span><span style="color: #FF79C6;">:</span><span> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;Draft&quot;</span><span>),</span></span> <span class="giallo-l"><span> content</span><span style="color: #FF79C6;">:</span><span> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from</span><span>(</span><span style="color: #F1FA8C;">&quot;My first note&quot;</span><span>)</span></span> <span class="giallo-l"><span>}));</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> note_clone</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Arc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">clone</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>note);</span></span> <span class="giallo-l"><span>thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">move ||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> note</span><span style="color: #FF79C6;"> =</span><span> note_clone</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">lock</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"><span> note</span><span style="color: #FF79C6;">.</span><span>content</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push_str</span><span>(</span><span style="color: #F1FA8C;">&quot; with additions&quot;</span><span>);</span></span> <span class="giallo-l"><span>});</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=4b93a53ebc1d7ee6bc2b39c91543fba7">Playground</a>)</p> <p>If you feel like you have to use <code>Arc&lt;Mutex&lt;T&gt;&gt;</code> too often, there might be a design issue. For example, you might be able to avoid sharing state between threads.</p> <h3 id="keep-a-flat-hierarchy"><a class="zola-anchor" href="#keep-a-flat-hierarchy" aria-label="Anchor link for: keep-a-flat-hierarchy">Keep a flat hierarchy</a></h3> <p><code>main.rs</code> is your best friend while prototyping.</p> <p>Stuff your code in there – no need for modules or complex organization yet. This makes it easy to experiment and move things around.</p> <h4 id="first-draft-everything-in-main-rs"><a class="zola-anchor" href="#first-draft-everything-in-main-rs" aria-label="Anchor link for: first-draft-everything-in-main-rs">First draft: everything in main.rs</a></h4> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> load_config</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> { port</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 8080</span><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> {</span></span> <span class="giallo-l"><span> config</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> new</span><span>(config</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> { config }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> start</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>) {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Starting server on port {}&quot;</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>config</span><span style="color: #FF79C6;">.</span><span>port);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> config</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> load_config</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> server</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Server</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(config);</span></span> <span class="giallo-l"><span> server</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">start</span><span>();</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Once you have a better feel for your code’s structure, Rust’s <code>mod</code> keyword becomes a handy tool for sketching out potential organization. You can nest modules right in your main file.</p> <h4 id="later-experiment-with-module-structure-in-the-same-file"><a class="zola-anchor" href="#later-experiment-with-module-structure-in-the-same-file" aria-label="Anchor link for: later-experiment-with-module-structure-in-the-same-file">Later: experiment with module structure in the same file</a></h4> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> config {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub</span><span> port</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u16</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> load</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Config</span><span> { port</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 8080</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> server {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use crate::</span><span>config;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> {</span></span> <span class="giallo-l"><span> config</span><span style="color: #FF79C6;">:</span><span> config</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Config</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> impl</span><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(config</span><span style="color: #FF79C6;">:</span><span> config</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Config</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Server</span><span> { config }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> start</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>) {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Starting server on port {}&quot;</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>config</span><span style="color: #FF79C6;">.</span><span>port);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This inline module structure lets you quickly test different organizational patterns. You can easily move code between scopes with cut and paste, and experiment with different APIs and naming conventions. Once a particular structure feels right, you can move modules into their own files.</p> <p>The key is to keep things simple until it calls for more complexity. Start flat, then add structure incrementally as your understanding of the problem grows.</p> <p>See also <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://matklad.github.io/2021/08/22/large-rust-workspaces.html">Matklad’s article on large Rust workspaces</a>.</p> <h3 id="start-small"><a class="zola-anchor" href="#start-small" aria-label="Anchor link for: start-small">Start small</a></h3> <p>Allow yourself to ignore some of the best practices for production code for a while.</p> <p>It’s possible, but you need to switch off your inner critic who always wants to write perfect code from the beginning. Rust enables you to comfortably defer perfection. You can make the rough edges obvious so that you can sort them out later. Don’t let perfect be the enemy of good.</p> <p>One of the biggest mistakes I observe is an engineer’s perfectionist instinct to jump on minor details which don’t have a broad enough impact to warrant the effort. It’s better to have a working prototype with a few rough edges than a perfect implementation of a small part of the system.</p> <p>Remember: you are exploring! Use a coarse brush to paint the landscape first. Try to get into a flow state where you can quickly iterate. Don’t get distracted by the details too early. During this phase, it’s also fine to throw away a lot failed attempts.</p> <p>There’s some overlap between prototyping and “<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=33FG6O3qejM">easy Rust</a>.”</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <p>The beauty of prototyping in Rust is that your “rough drafts” have the same memory safety and performance as polished code. Even when I liberally use <code>unwrap()</code>, stick everything in <code>main.rs</code>, and reach for owned types everywhere, the resulting code is on-par with a Python prototype in reliability, but outperforms it easily. This makes it perfect for experimenting with real-world workloads, even before investing time in proper error handling.</p> <p>Let’s see how Rust stacks up against Python for prototyping:</p> <table><thead><tr><th>Aspect</th><th>Python</th><th>Rust</th></tr></thead><tbody> <tr><td>Initial Development Speed</td><td>✓ Very quick to write initial code<br>✓ No compilation step<br>✓ Dynamic typing speeds up prototyping<br>✓ File watchers available</td><td>⚠️ Slightly slower initial development<br>✓ Type inference helps<br>✓ Tools like <code>bacon</code> provide quick feedback</td></tr> <tr><td>Standard Library</td><td>✓ Batteries included<br>✓ Rich ecosystem</td><td>❌ Smaller standard library<br>✓ Growing ecosystem of high-quality crates</td></tr> <tr><td>Transition to Production</td><td>❌ Need extensive testing to catch type errors<br>❌ Bad performance might require extra work or rewrite in another language</td><td>✓ Minimal changes needed beyond error handling<br>✓ Already has good performance<br>✓ Memory safety guaranteed</td></tr> <tr><td>Maintenance</td><td>❌ Type errors surface during runtime<br>❌ Refactoring is risky</td><td>✓ Compiler catches most issues<br>✓ Safe refactoring with type system</td></tr> <tr><td>Code Evolution</td><td>❌ Hard to maintain large codebases<br>❌ Type issues compound</td><td>✓ Compiler guides improvements<br>✓ Types help manage complexity</td></tr> </tbody></table> <p>Quite frankly, Rust makes for an excellent prototyping language if you embrace its strengths. Yes, the type system will make you think harder about your design up front - but that’s actually a good thing! Each iteration might take a bit longer than in Python or JavaScript, but you’ll typically need fewer iterations from prototype to production.</p> <p>I’ve found that my prototypes in other languages often hit a wall where I need to switch to something more robust. With Rust, I can start simple and gradually turn that proof-of-concept into production code, all while staying in the same language and ecosystem.</p> <p>If you have any more tips or tricks for prototyping in Rust, <a href="/services">get in touch</a> and I’ll add them to the list!</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-1"> <p>More experienced Rust developers might find themselves reaching for an <code>impl IntoIterator&lt;Item=T&gt;</code> where <code>&amp;[T]</code>/<code>Vec&lt;T&gt;</code> would do. Keep it simple! <a href="#fr-1-1">↩</a></p> </li> <li id="fn-2"> <p>In the talk, I show an example where early over-optimization led to the wrong abstraction and made the code slower. The actual bottleneck was elsewhere and hard to uncover without profiling. <a href="#fr-2-1">↩</a></p> </li> <li id="fn-3"> <p>I usually know when I found a good abstraction once I can use all of Rust’s features like expression-oriented programming and pattern matching together with my own types. <a href="#fr-3-1">↩</a></p> </li> </ol> </section> Thu, 09 Jan 2025 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e07-brave/ https://corrode.dev/podcast/s03e07-brave/ <div><script id="letscast-player-9d22a062" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/brave-with-anton-lazarev/player.js?size=s"></script></div> <p>Web browsers today face increasing demands for both performance and privacy. At Brave, they’re tackling both challenges head-on with their Rust-based ad-blocking engine. This isn’t just about blocking ads – it’s about doing so with minimal performance impact while maintaining compatibility with existing filter lists and adapting to evolving web technologies.</p> Thu, 26 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e06-holiday/ https://corrode.dev/podcast/s03e06-holiday/ <div><script id="letscast-player-ec214dbb" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/holiday-special/player.js?size=s"></script></div> <p>While we try not to get too sentimental, celebrating one year of ‘Rust in Production’ alongside the holiday season feels like a perfect occasion to reflect. For this special episode of the podcast, we’ve gathered heartfelt messages from our guests to the Rust community.</p> <p>There are two common themes that run through these messages:</p> <ul> <li>The importance of writing simple, approachable Rust code to help flatten the learning curve for newcomers</li> <li>Their gratitude for the vibrant ecosystem and the wealth of available crates</li> </ul> <p>As we look ahead to the Rust 2024 edition, we’re excited about what’s to come. Thank you for being part of this journey with us, and here’s to a great start to 2025! May the new year bring us all faster compile times, gentler learning curves, and, if we get lucky, let-chains on stable Rust.</p> Fri, 13 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/migration-guides/python-to-rust/ https://corrode.dev/learn/migration-guides/python-to-rust/ <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>A Practical Guide for Decision Makers</p> </h4> </div> <p>This guide is written for technical leaders and developers considering moving their teams from Python to Rust. I used to be a Python developer myself, and I know how daunting it can be to switch to a new language. Base on years of experience helping teams make this transition, I’ll share practical insights on what works, what doesn’t, and how to ensure a successful migration.</p> </div> <p>Python is an incredibly versatile language that powers everything from web applications to data science pipelines. However, as organizations scale, they often encounter limitations around performance, type safety, and robustness. While Rust isn’t a direct replacement for Python, it has some answers to these challenges.</p> <p>But is Rust the right choice for your team?</p> <p>In this article, you’ll learn:</p> <ul> <li>How to evaluate whether Rust is the right choice for your Python codebase</li> <li>Practical strategies for Python-to-Rust migration</li> <li>Common pitfalls and how to avoid them</li> <li>Ways to maintain productivity during the transition</li> <li>How to leverage Python’s strengths alongside Rust</li> </ul> <h2 id="get-your-customized-migration-plan"><a class="zola-anchor" href="#get-your-customized-migration-plan" aria-label="Anchor link for: get-your-customized-migration-plan">Get Your Customized Migration Plan</a></h2> <p>I help teams migrate from Python to Rust, providing tailored guidance and training. If you’re considering a migration, answer a few questions about your project, and I’ll reach out with a customized plan.</p> <div class="quiz-container"> <div class="quiz-progress-container"> <div class="progress-bar" id="progress-bar" style="width: 0%"></div> </div> <div id="quiz-question-container"></div> <div id="quiz-navigation-container"> <button class="quiz-navbutton" id="quiz-prev-question" style="display: none" > ← Previous </button> <button class="quiz-navbutton" id="quiz-next-question">Next →</button> </div> <div id="quiz-results" style="display: none"> <h2>Thank you for your interest!</h2> <p> I'll send you a customized migration strategy based on your responses. </p> <p> In the meantime, feel free to check out my <a href="/blog">other articles about Rust</a>. </p> </div> </div> <script> const languageOptions = [ "Python", "Java", "C++", "Go", "TypeScript", "JavaScript", "C#", "Ruby", "PHP", "Swift", "Kotlin", "Other", ]; const questions = [ { type: "multipleChoice", question: "Which languages are currently used in your codebase?", id: "currentLanguages", options: languageOptions, }, { type: "multipleChoice", question: "Which types of applications are you looking to migrate?", id: "applicationType", direction: "column", options: [ "Web services / APIs", "CLI tools", "Embedded systems", "Desktop applications", "WebAssembly modules", "Data processing pipelines", "Machine learning systems", "Other", ], }, { type: "radio", question: "What's the size of your codebase?", id: "codebaseSize", options: ["< 10k lines", "< 100k lines", "> 100k lines"], }, { type: "radio", question: "What's your team's experience with Rust?", id: "rustExperience", direction: "column", options: [ "No experience yet", "Some team members have experimented with it", "We have one or more small projects in production", "We have significant production experience", ], }, { type: "multipleChoice", question: "What are your main motivations for migrating to Rust?", direction: "column", id: "motivations", options: [ "Performance improvements", "Better type safety", "Memory efficiency", "Production reliability", "Cross-platform deployment", "WebAssembly support", "Embedded systems development", "Microservices migration", "Other", ], }, { type: "multipleChoice", question: "What are your main concerns about migrating to Rust?", id: "concerns", direction: "column", options: [ "Learning curve for the team", "Migration complexity", "Maintaining productivity during transition", "Finding Rust developers", "Integration with existing Python code", "Third-party library availability", "Build times", "Testing and deployment changes", "None/Other", ], }, { type: "radio", question: "What's your timeline for the migration?", id: "timeline", options: [ "Immediate (next 3 months)", "Medium-term (3-12 months)", "Long-term (12+ months)", ], }, { type: "multipleChoice", question: "What kind of support is most important for your team?", id: "supportNeeded", direction: "column", options: [ "Planning and strategy", "Project audit", "Training and workshops", "Code reviews and mentoring", "PyO3 integration support", "Performance optimization", "Architecture design", "Best practices guidance", "Team hiring support", ], }, { type: "radio", question: "How many developers would be involved in the migration?", options: ["1", "2-3", "4-9", "10+"], id: "teamSize", }, { type: "input", question: "Anything else you'd like to share about your migration plans?", id: "additionalComments", placeholder: "Share your thoughts...", optional: true, }, { type: "email", question: "What's your email? I'll send you a customized migration strategy based on your responses.", id: "email", placeholder: "Your email address", }, ]; const formURL = "https://submit-form.com/YkAFE1mIq"; // Quiz state let answers = {}; let currentQuestionIndex = 0; let totalQuestions; // DOM elements const progressBar = document.getElementById("progress-bar"); const questionContainer = document.getElementById("quiz-question-container"); const prevButton = document.getElementById("quiz-prev-question"); const nextButton = document.getElementById("quiz-next-question"); function initQuiz() { totalQuestions = questions.length; nextButton.addEventListener("click", nextQuestion); prevButton.addEventListener("click", previousQuestion); // Handle browser back/forward buttons window.addEventListener("popstate", (event) => { if (event.state) { currentQuestionIndex = event.state.index; answers = event.state.answers || {}; displayQuestion(currentQuestionIndex); } else { resetQuiz(); } }); displayQuestion(0); } function resetQuiz() { answers = {}; currentQuestionIndex = 0; displayQuestion(0); } function updateProgressBar() { const progressPercentage = ((currentQuestionIndex + 1) / totalQuestions) * 100; progressBar.style.width = `${progressPercentage}%`; } function createQuestionElement(question) { const element = document.createElement("div"); element.className = "question"; element.innerHTML = `<h3>${question.question}${ question.optional ? " (Optional)" : "" }</h3>`; let inputContainer; switch (question.type) { case "multipleChoice": inputContainer = document.createElement("div"); if (question.direction) { inputContainer.style.display = "flex"; inputContainer.style.flexDirection = question.direction; } else { inputContainer.className = "checkbox-grid"; } question.options.forEach((option) => { const label = document.createElement("label"); label.className = "checkbox-label"; const input = document.createElement("input"); input.type = "checkbox"; input.name = question.id; input.value = option; label.appendChild(input); label.append(` ${option}`); inputContainer.appendChild(label); }); break; case "radio": inputContainer = document.createElement("div"); inputContainer.className = "quiz-flex-container"; if (question.direction) { inputContainer.style.flexDirection = question.direction; } question.options.forEach((option) => { const label = document.createElement("label"); label.className = "quiz-button"; label.textContent = option; const input = document.createElement("input"); input.type = "radio"; input.name = question.id; input.value = option; input.addEventListener("change", () => { saveCurrentAnswers(); nextButton.disabled = false; // Auto-advance if (currentQuestionIndex < totalQuestions - 1) { nextQuestion(); } }); label.appendChild(input); inputContainer.appendChild(label); }); break; case "input": case "email": inputContainer = document.createElement("input"); inputContainer.type = question.type; inputContainer.id = question.id; inputContainer.name = question.id; inputContainer.placeholder = question.placeholder || ""; if (question.type === "email") { inputContainer.required = true; } if (!question.optional) { inputContainer.required = true; } break; } element.appendChild(inputContainer); return { element, inputContainer }; } function saveCurrentAnswers() { const inputs = questionContainer.querySelectorAll("input"); const questionId = questions[currentQuestionIndex].id; delete answers[questionId]; inputs.forEach((input) => { if (input.type === "checkbox") { if (input.checked) { answers[questionId] = answers[questionId] || []; answers[questionId].push(input.value); } } else if ( (input.type === "radio" && input.checked) || input.type === "text" || input.type === "email" ) { if (input.value.trim()) { answers[questionId] = input.value; } } }); } function restorePreviousAnswers(question, container) { const previousAnswer = answers[question.id]; if (!previousAnswer) return; const inputs = container.querySelectorAll("input"); inputs.forEach((input) => { if (input.type === "checkbox") { input.checked = previousAnswer.includes(input.value); } else if (input.type === "radio") { input.checked = input.value === previousAnswer; } else { input.value = previousAnswer; } }); } function updateNavigationState() { prevButton.style.display = currentQuestionIndex > 0 ? "" : "none"; const question = questions[currentQuestionIndex]; nextButton.disabled = !isQuestionAnswered(question); } function isQuestionAnswered(question) { if (question.optional) return true; const answer = answers[question.id]; if (!answer) return false; if (Array.isArray(answer)) return answer.length > 0; if (question.type === "email") { const input = document.getElementById(question.id); return input && input.checkValidity() && answer.trim().length > 0; } return answer.trim().length > 0; } function nextQuestion() { if (currentQuestionIndex < totalQuestions - 1) { saveCurrentAnswers(); currentQuestionIndex++; displayQuestion(currentQuestionIndex); } else { submitQuiz(); } } function previousQuestion() { if (currentQuestionIndex > 0) { saveCurrentAnswers(); currentQuestionIndex--; displayQuestion(currentQuestionIndex); } } function displayQuestion(index) { const question = questions[index]; if (!question) return; history.pushState( { index, answers: { ...answers } }, `Question ${index + 1}`, `?question=${index + 1}` ); questionContainer.innerHTML = ""; const { element, inputContainer } = createQuestionElement(question); questionContainer.appendChild(element); restorePreviousAnswers(question, inputContainer); updateProgressBar(); updateNavigationState(); if (question.type === "input" || question.type === "email") { const input = inputContainer; input.addEventListener("input", () => { if (question.type === "email") { nextButton.disabled = !input.checkValidity() && !question.optional; } else { nextButton.disabled = !input.value.trim() && !question.optional; } }); } else if (question.type === "multipleChoice") { const inputs = inputContainer.querySelectorAll("input"); inputs.forEach((input) => { input.addEventListener("change", () => { const anyChecked = Array.from(inputs).some((i) => i.checked); nextButton.disabled = !anyChecked && !question.optional; }); }); } if (question.type === "radio") { nextButton.disabled = !answers[question.id] && !question.optional; } } async function submitQuiz() { saveCurrentAnswers(); // Hide the quiz questionContainer.innerHTML = ""; document.getElementById("quiz-navigation-container").style.display = "none"; // Show the thank you message const resultsContainer = document.getElementById("quiz-results"); resultsContainer.style.display = "block"; try { // Using Formspark as an example const response = await fetch(formUrl, { method: "POST", headers: { "Content-Type": "application/json", Accept: "application/json", }, body: JSON.stringify(answers), }); if (!response.ok) { throw new Error("Failed to submit"); } } catch (error) { console.error("Failed to submit form:", error); // Optionally show an error message to the user } } document.addEventListener("DOMContentLoaded", initQuiz); </script> <style> .quiz-container { margin: 0 auto; overflow: hidden; } .quiz-progress-container { width: 100%; background-color: #ddd; height: 5px; margin-bottom: 20px; } .progress-bar { height: 100%; background-color: #ee3856; transition: width 0.5s ease-in-out; } #quiz-navigation-container { width: 100%; margin-top: 10px; display: flex; justify-content: flex-end; gap: 10px; } .quiz-navbutton { padding: 10px 20px; background-color: #111; color: white; cursor: pointer; border: none; } .quiz-flex-container { display: flex; gap: 10px; flex-wrap: wrap; } .quiz-button { padding: 14px; border-radius: 4px; background-color: #111; color: white; white-space: nowrap; cursor: pointer; flex: 1; text-align: center; font-size: large; } .quiz-button:hover { background-color: #ee3856; } input, .checkbox-label, .quiz-button:hover { cursor: pointer; } #quiz-next-question:disabled { cursor: not-allowed; opacity: 0.5; } .quiz-button input[type="radio"] { display: none; } .quiz-container input[type="input"], .quiz-container input[type="text"], .quiz-container input[type="email"] { font-size: larger; width: 100%; padding: 15px; border: 1px solid #000; box-sizing: border-box; margin-bottom: 20px; } .quiz-container input::placeholder { color: #ccc; } .question h2 { margin: 0; } .question .checkbox-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 10px; } .checkbox-label { display: flex; align-items: center; gap: 8px; } .question input[type="checkbox"] { -webkit-appearance: none; -moz-appearance: none; appearance: none; flex-shrink: 0; /* Prevent checkbox from shrinking */ width: 20px; height: 20px; border: 2px solid #111; border-radius: 4px; margin: 0; /* Remove margin, we're using gap instead */ } .question input[type="checkbox"]:checked { border: 2px solid #111; background-color: #ee3856; } @media (max-width: 600px) { .quiz-container input[type="text"], .quiz-container input[type="email"] { width: calc(100% - 30px); } } @media (prefers-color-scheme: dark) { .quiz-button { background-color: #fab71c; color: #111; } .question input[type="checkbox"] { border-color: #fff; } .question input[type="checkbox"]:checked { border: 2px solid #fff; background-color: #ee3856; } } </style> <h2 id="key-differences-between-python-and-rust"><a class="zola-anchor" href="#key-differences-between-python-and-rust" aria-label="Anchor link for: key-differences-between-python-and-rust">Key Differences Between Python and Rust</a></h2> <table><thead><tr><th>Aspect</th><th>Python 🐍</th><th>Rust 🦀</th></tr></thead><tbody> <tr><td>Type System</td><td>Dynamic, optional type hints</td><td>Static, strong type system</td></tr> <tr><td>Memory Management</td><td>Garbage collected</td><td>No GC, ownership and borrowing</td></tr> <tr><td>Performance</td><td>Moderate</td><td>High performance, low-level control</td></tr> <tr><td>Deployment</td><td>Runtime required</td><td>Single binary, minimal runtime</td></tr> <tr><td>Package Manager</td><td>Multiple (pip, conda, uv)</td><td>cargo (built-in, consistent)</td></tr> <tr><td>Error Handling</td><td>Exceptions</td><td>Result type</td></tr> <tr><td>Concurrency</td><td>Limited by GIL</td><td>zero-cost abstractions, no GIL</td></tr> <tr><td>Learning Curve</td><td>Gentle</td><td>Steep</td></tr> <tr><td>Ecosystem Size</td><td>Large (500,000+ packages)</td><td>Medium (160,000+ crates)</td></tr> </tbody></table> <h2 id="why-python-teams-consider-rust"><a class="zola-anchor" href="#why-python-teams-consider-rust" aria-label="Anchor link for: why-python-teams-consider-rust">Why Python Teams Consider Rust</a></h2> <p>Python developers often want to transition to Rust for several reasons:</p> <ol> <li> <p>Developers interested in Rust are likely willing to understand systems programming concepts. They grew out of Python’s limitations and are looking for more control over performance and memory management.</p> </li> <li> <p>Python developers often long for stronger type guarantees. They appreciate Rust’s static type system and the safety it provides.</p> </li> <li> <p>Developers with a Python background often work on data processing or web applications. These are areas where Rust’s performance benefits are most pronounced.</p> </li> </ol> <p>While Python excels at readability and rapid development, teams often hit scaling challenges as their applications grow. Below, I’ve listed a few common pain points that get mentioned in consultations with teams considering a migration.</p> <h3 id="performance-bottlenecks"><a class="zola-anchor" href="#performance-bottlenecks" aria-label="Anchor link for: performance-bottlenecks">Performance Bottlenecks</a></h3> <p>Python’s Global Interpreter Lock (GIL) limits true parallelism, making it challenging to fully utilize modern multi-core processors. There is a version of Python without the GIL, but it <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=41677131">doesn’t solve the performance issues</a>.</p> <p>While tools like asyncio help with I/O-bound tasks, CPU-intensive operations remain constrained. Teams often resort to complex workarounds involving multiple processes or C extensions.</p> <h3 id="type-safety-concerns"><a class="zola-anchor" href="#type-safety-concerns" aria-label="Anchor link for: type-safety-concerns">Type Safety Concerns</a></h3> <p>Despite Python’s type hints, runtime type errors still occur. Types are optional in Python. Developers need the discipline to add and maintain type hints consistently, which can be challenging in large codebases. Furthermore, adoption is inconsistent across the Python ecosyste (e.g., third-party libraries). Large Python applications can become difficult to maintain and refactor confidently.</p> <p>From experience, there is a breaking point around the 10-100k lines of code mark where the lack of type safety becomes a significant liability.<sup class="footnote-reference" id="fr-1-1"><a href="#fn-1">1</a></sup></p> <h3 id="deployment-complexity"><a class="zola-anchor" href="#deployment-complexity" aria-label="Anchor link for: deployment-complexity">Deployment Complexity</a></h3> <p>Python applications require managing runtime environments, dependencies, and potential version conflicts. A lot of the issues can be mitigated with containerization. However, bundling Python applications for deployment is not an easy task, especially when targeting platforms with different architectures.</p> <h3 id="resource-usage"><a class="zola-anchor" href="#resource-usage" aria-label="Anchor link for: resource-usage">Resource Usage</a></h3> <p>Python has a relatively manageable memory profile, but it can be inefficient for certain workloads. For example, Python’s memory overhead can be significant for large-scale data processing or long-running services. CPU-bound tasks often get offloaded to C extensions or to worker processes, adding complexity and overhead.</p> <h2 id="key-challenges-in-transitioning-to-rust"><a class="zola-anchor" href="#key-challenges-in-transitioning-to-rust" aria-label="Anchor link for: key-challenges-in-transitioning-to-rust">Key Challenges in Transitioning to Rust</a></h2> <p>The transition from Python to Rust presents unique challenges:</p> <h3 id="syntax"><a class="zola-anchor" href="#syntax" aria-label="Anchor link for: syntax">Syntax</a></h3> <p>Python is very syntax-light, which makes it easy to read and write. By comparison, Rust is full of “symbols” and keywords that can be intimidating at first.</p> <p>Developers need to see through the syntax and understand the underlying semantics to become productive. This is a critical step in the transition process.</p> <p>Here is an example of a simple list comprehension in Python:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="python"><span class="giallo-l"><span style="color: #6272A4;"># A list of bands</span></span> <span class="giallo-l"><span>bands</span><span style="color: #FF79C6;"> =</span><span> [</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Metallica</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Iron Maiden</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">AC/DC</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Judas Priest</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Megadeth</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span>]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># A list comprehension to filter for bands that start with &quot;M&quot;</span></span> <span class="giallo-l"><span>m_bands</span><span style="color: #FF79C6;"> =</span><span> [band</span><span style="color: #FF79C6;"> for</span><span> band</span><span style="color: #FF79C6;"> in</span><span> bands</span><span style="color: #FF79C6;"> if</span><span> band.startswith(</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">M</span><span style="color: #E9F284;">&quot;</span><span>)]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># A list comprehension to uppercase the bands</span></span> <span class="giallo-l"><span>uppercased</span><span style="color: #FF79C6;"> =</span><span> [band.upper()</span><span style="color: #FF79C6;"> for</span><span> band</span><span style="color: #FF79C6;"> in</span><span> m_bands]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># We get [&quot;METALLICA&quot;, &quot;MEGADETH&quot;] </span></span></code></pre> <p>Rust does not have a direct equivalent to list comprehensions. Instead, <a href="/blog/iterators">iterator patterns</a> are used to achieve the same result:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> bands</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Metallica&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Iron Maiden&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;AC/DC&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Judas Priest&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Megadeth&quot;</span><span>,</span></span> <span class="giallo-l"><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> uppercased</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;_&gt;</span><span style="color: #FF79C6;"> =</span><span> bands</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">starts_with</span><span>(</span><span style="color: #F1FA8C;">&quot;M&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_uppercase</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// uppercased = vec![&quot;METALLICA&quot;, &quot;MEGADETH&quot;]</span></span></code></pre><h3 id="ownership-and-borrowing"><a class="zola-anchor" href="#ownership-and-borrowing" aria-label="Anchor link for: ownership-and-borrowing">Ownership and Borrowing</a></h3> <p>Python developers need to adjust to start “thinking in Rust” to avoid common pitfalls. Plan for a 3-4 month learning period where developers will need to understand concepts like:</p> <ul> <li>Stack vs heap</li> <li>Borrowing and move semantics</li> <li>Trait-based composition (instead of Python’s OOP model)</li> </ul> <p>These are fundamental concepts in Rust that Python developers are not used to, and it’s important to get them right to become really effective.</p> <p>Lifetimes are another concept that can be challenging to grasp initially, but you can get a long way without fully understanding them. <a href="/blog/lifetimes">Don’t worry about lifetimes</a> when you’re just starting out. <a href="/blog/simple">Keep it simple</a>.</p> <p>Pointer handling and boxing is another area where Python developers need to adjust. However, beginners can often get by without understanding this in detail.</p> <h3 id="type-system-adaptation"><a class="zola-anchor" href="#type-system-adaptation" aria-label="Anchor link for: type-system-adaptation">Type System Adaptation</a></h3> <p>Moving from Python’s dynamic typing to Rust’s static typing requires another mindset shift. Developers suddenly need to:</p> <ul> <li>Think about types upfront</li> <li>Understand generics and traits</li> <li>Lean into <code>Option&lt;T&gt;</code> and <code>Result&lt;T, E&gt;</code> for error handling</li> <li>Use enums for modeling complex states</li> </ul> <p>This can feel intimidating at first, but it’s actually a lot of fun once you get the hang of it. The compiler is helpfully guiding you along the way, and you can start without a deep understanding of all the concepts.</p> <p>The pattern matching syntax in Rust can be a game-changer for developers coming from Python and is often cited as one of the most enjoyable features of Rust.</p> <h2 id="integration-strategies"><a class="zola-anchor" href="#integration-strategies" aria-label="Anchor link for: integration-strategies">Integration Strategies</a></h2> <p>There are several ways to integrate Rust into your Python codebase:</p> <h3 id="1-pyo3-python-rust-bindings"><a class="zola-anchor" href="#1-pyo3-python-rust-bindings" aria-label="Anchor link for: 1-pyo3-python-rust-bindings">1. PyO3 (Python-Rust Bindings)</a></h3> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pyo3.rs/">PyO3</a> lets you write Python extensions in Rust or call Rust functions from Python.</p> <p>This is ideal for:</p> <ul> <li>Optimizing performance-critical components</li> <li>Gradually introducing Rust while maintaining Python interfaces</li> <li>Creating Python packages with Rust internals</li> </ul> <h3 id="2-microservices"><a class="zola-anchor" href="#2-microservices" aria-label="Anchor link for: 2-microservices">2. Microservices</a></h3> <p>For distributed systems, you can:</p> <ul> <li>Build new services in Rust</li> <li>Migrate existing services one at a time</li> <li>Use REST or gRPC for inter-service communication</li> </ul> <p>If you already have a microservices architecture, this can be a great way to start. You can build new services in Rust and gradually replace old Python services as needed. The new services can be deployed alongside the old ones, and you can ensure that the APIs are compatible.</p> <h3 id="3-cli-tools-and-utilities"><a class="zola-anchor" href="#3-cli-tools-and-utilities" aria-label="Anchor link for: 3-cli-tools-and-utilities">3. CLI Tools and Utilities</a></h3> <p>If you’re just starting out, I recommend to write a command-line tool, which is an excellent candidate for getting your feet wet.</p> <p>CLI tools have all the positive indicators for a successful first project:</p> <ul> <li>They are self-contained, so you don’t have to worry about integrating with the rest of the codebase</li> <li>The deployment is simple, as you can just ship a single binary</li> <li>Rust shines in this area, as it’s very convenient to write command-line tools in Rust</li> <li>There is no “startup cost” when a CLI tool runs with Rust (as opposed to Python where the interpreter needs to start up)</li> </ul> <h3 id="4-worker-processes"><a class="zola-anchor" href="#4-worker-processes" aria-label="Anchor link for: 4-worker-processes">4. Worker Processes</a></h3> <p>Let’s say you have a web application that needs to do some heavy lifting. One common way is to offload the work to a worker queue. That’s a great place to test out Rust, as you can directly compare the performance and developer experience with Python.</p> <p>You can use a message queue like RabbitMQ or Kafka to communicate between the Python web application and the Rust worker.</p> <h3 id="data-processing-pipelines"><a class="zola-anchor" href="#data-processing-pipelines" aria-label="Anchor link for: data-processing-pipelines">Data Processing Pipelines</a></h3> <p>Are you using Python for data science or ETL tasks? For example, you might be using Pandas or Dask for data processing.</p> <p>Rust has some excellent libraries for data processing, like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pola.rs/">Polars</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://arrow.apache.org/">Apache Arrow</a>. A lot of teams start by moving the data preprocessing and ETL tasks to Rust, and they like it so much that they move more and more of the business logic over.</p> <p>That worked extremely well for a few clients I worked with, as they could leverage Rust’s performance and reliability for the most critical parts of their data processing pipeline. After a short learning period, the team was as productive in Rust as they were in Python.</p> <h2 id="planning-your-migration"><a class="zola-anchor" href="#planning-your-migration" aria-label="Anchor link for: planning-your-migration">Planning Your Migration</a></h2> <p>A successful migration requires careful planning:</p> <ol> <li> <p><strong>Start Small</strong></p> <ul> <li>Choose non-critical components first</li> <li>Focus on areas where Rust’s benefits are most valuable</li> <li>Build team confidence through early wins</li> </ul> </li> <li> <p><strong>Invest in Training</strong></p> <ul> <li>Allocate time for learning Rust fundamentals</li> <li>Consider bringing in <a href="/services">external expertise</a> for guidance</li> <li>Set realistic expectations for the learning curve</li> </ul> </li> <li> <p><strong>Measure Success</strong></p> <ul> <li>Define clear metrics (performance, resource usage, development velocity)</li> <li>Document improvements and challenges</li> <li>Adjust strategy based on results</li> </ul> </li> </ol> <h2 id="practical-migration-tips"><a class="zola-anchor" href="#practical-migration-tips" aria-label="Anchor link for: practical-migration-tips">Practical Migration Tips</a></h2> <p>Based on real-world experience from helping teams migrate from Python to Rust, here are some tips for a successful transition:</p> <h3 id="identify-bounded-contexts"><a class="zola-anchor" href="#identify-bounded-contexts" aria-label="Anchor link for: identify-bounded-contexts">Identify Bounded Contexts</a></h3> <p>Focus on modules with clear interfaces to the rest of your system. No tangled spaghetti code! (That also means that you should refactor your Python codebase in case it’s a mess.)</p> <ul> <li>Look for self-contained parts of your codebase that share common functionality</li> <li>Document the data flow and dependencies between these contexts. This will help you understand the impact of migration and can serve as a blueprint for the migration process and a reference for future developers.</li> <li>Map out how these components communicate with each other: which functions are called, which data is passed around, and which interfaces are used.</li> </ul> <h3 id="prioritize-cpu-bound-tasks-first"><a class="zola-anchor" href="#prioritize-cpu-bound-tasks-first" aria-label="Anchor link for: prioritize-cpu-bound-tasks-first">Prioritize CPU-Bound Tasks First</a></h3> <p>Start with computationally intensive operations that don’t require heavy I/O. That’s where Rust shines the most, as it can provide significant performance improvements over Python.</p> <ul> <li>Look for tasks that are currently bottlenecked by Python’s performance (measure first!).</li> <li>Avoid beginning with components that make heavy use of async/IO operations. Async Python is quite efficient and Rust might not provide a significant improvement. Be cautious with async operations between languages, as they can introduce significant overhead.</li> </ul> <h3 id="minimize-calls-between-language-boundaries"><a class="zola-anchor" href="#minimize-calls-between-language-boundaries" aria-label="Anchor link for: minimize-calls-between-language-boundaries">Minimize Calls Between Language Boundaries</a></h3> <p>Evaluate how frequently your Rust code needs to call back into Python and try to minimize the number of cross-language calls.</p> <p>If you have a large number of small calls, the overhead of crossing the language boundary can add up. Instead, consider batching operations to reduce the number of transitions</p> <h3 id="baby-steps"><a class="zola-anchor" href="#baby-steps" aria-label="Anchor link for: baby-steps">Baby Steps</a></h3> <p>Break down the migration into small, measurable pieces. You want quick wins to keep the team motivated.</p> <ul> <li>Start with a single component and validate its performance.</li> <li>Add functionality piece by piece rather than attempting a complete rewrite.</li> <li>Maintain comprehensive tests throughout the migration process.</li> </ul> <h3 id="continuously-monitor-performance"><a class="zola-anchor" href="#continuously-monitor-performance" aria-label="Anchor link for: continuously-monitor-performance">Continuously Monitor Performance</a></h3> <p>Do you have a performance baseline for your Python code? If not, set one up before you start the migration. It’s very easy to get lost in the weeds and lose track of the performance improvements. If that happens, you have no clear way to measure the success of the migration.</p> <ul> <li>Set up benchmarks before starting the migration.</li> <li>Track performance metrics for each migrated component.</li> <li>Use tools like <code>cspeed</code> to monitor improvements.</li> <li>Document performance gains and any unexpected bottlenecks.</li> <li>Make performance monitoring part of your PR review process.</li> <li>Choose components where you can easily compare performance.</li> <li>Look for opportunities to run old and new implementations in parallel.</li> </ul> <h2 id="common-pitfalls-to-avoid"><a class="zola-anchor" href="#common-pitfalls-to-avoid" aria-label="Anchor link for: common-pitfalls-to-avoid">Common Pitfalls to Avoid</a></h2> <p>Rust’s ecosystem is smaller than Python’s.</p> <p>On top of that, Rust has a much smaller standard library compared to Python. This means you’ll commonly rely on third-party crates for functionality that’s built into Python.</p> <p>Depending on your use case, here are some comparisons between Python packages and their Rust equivalents:</p> <h3 id="data-science"><a class="zola-anchor" href="#data-science" aria-label="Anchor link for: data-science">Data Science</a></h3> <p>Python dominates data science with libraries like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://numpy.org/">NumPy</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pandas.pydata.org/">Pandas</a>. However, Rust is making inroads with libraries like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pola.rs/">Polars</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://arrow.apache.org/">Apache’s Arrow</a>.</p> <p>You don’t have to migrate your entire data science stack to Rust. Chances are, you have experts on your team who are comfortable with doing data analysis in Python. You can start by using the Rust libraries for data preprocessing and ETL tasks. They have Python bindings, so you get a lot of the benefits of Rust without having to do a full migration.</p> <h3 id="backend-services"><a class="zola-anchor" href="#backend-services" aria-label="Anchor link for: backend-services">Backend Services</a></h3> <p>Rust wasn’t initially planned to be a strong contender in the web development space. This has changed in recent years with the rise of frameworks like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://axum.rs/">Axum</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://loco.rs/">Loco</a>. Now, Rust is a viable option for building high-performance APIs and web applications. It is one key area the Rust team is investing in, and the ecosystem is maturing rapidly.</p> <p>In combination with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx">sqlx</a> for database access and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://serde.rs/">serde</a> for serialization, Rust is a very effective choice for web backends. What surprises many Python developers is how similar it is to working with other web frameworks like Flask or FastAPI. Another surprise is how robust the final product is, as it catches many bugs at compile time and scales extremely well. Production Rust web applications are extremely robust. This lifts a lot of the burden from the operations team. I expect more backend services to be written in Rust in the future – especially for high-performance applications.</p> <h2 id="keeping-python-s-strengths"><a class="zola-anchor" href="#keeping-python-s-strengths" aria-label="Anchor link for: keeping-python-s-strengths">Keeping Python’s Strengths</a></h2> <p>Not everything needs to be migrated! Python excels at:</p> <ul> <li><a href="/blog/prototyping">I personally prototype in Rust</a>, but Python is still a fine choice for prototyping.</li> <li>Data analysis and visualization are great in Python (e.g., Pandas, Matplotlib)</li> <li>Machine learning workflows (e.g., TensorFlow, PyTorch)</li> <li>Admin interfaces and tools (e.g., Django admin)</li> </ul> <p>Consider a hybrid approach where each language handles what it does best.</p> <p>One winning strategy is to explore a space in Python and moving production-workloads to Rust once the requirements are clear and the project can benefit from performance and scale. Speaking of which…</p> <h2 id="expected-big-performance-improvements"><a class="zola-anchor" href="#expected-big-performance-improvements" aria-label="Anchor link for: expected-big-performance-improvements">Expected Big Performance Improvements</a></h2> <p>Actual performance numbers vary significantly based on workload and implementation, so take these numbers with a grain of salt.</p> <p>Based on my experience helping teams migrate, here are typical improvements:</p> <ul> <li><strong>CPU Usage</strong>: 2-10x reduction in CPU utilization</li> <li><strong>Memory Usage</strong>: 30-70% reduction in memory footprint</li> <li><strong>Latency</strong>: 50-90% improvement in response times</li> <li><strong>Throughput</strong>: 2-5x increase in requests/second</li> </ul> <p>Especially the P90 latency improvements are often surprising to teams. <strong>There are very few outliers and things tend to run smoothly, no matter the load.</strong> In Python, this is a common source of frustration, where a single request can take significantly longer than the rest. Production payloads are extremely boring in Rust. The DevOps team will thank you.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Migrating to a different programming language is a significant undertaking that requires careful planning and execution. The step from Python to Rust is no exception.</p> <p>While the learning curve is steep, the benefits in terms of performance, reliability, and maintainability can be substantial.</p> <p>Success depends on:</p> <ul> <li>Realistic timeline expectations</li> <li>Strong team support and training</li> <li>Clear understanding of migration goals</li> <li>A pragmatic approach to choosing what to migrate</li> </ul> <p>Remember that this isn’t an all-or-nothing decision! Many organizations successfully use Python and Rust together, leveraging each language’s strengths. Write down your reasoning for the migration. Many issues can be solved in Python, and the migration might not be necessary. However, if you’re hitting the limits of Python, Rust is a strong replacement.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Ready to Make the Move to Rust?</p> </h4> </div> <p>I help teams make successful transitions from Python to Rust. My clients moved critical workloads to Rust and saw significant improvements in performance and reliability. Whether you need training, architecture guidance, or migration planning, <a href="/services">let’s talk about your needs</a>.</p> </div> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-1"> <p>See discussions on large-scale Python applications on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/Python/comments/a7zrjn/why_do_people_say_that_python_is_not_good_for/">Reddit</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=25073308">HN</a>. <a href="#fr-1-1">↩</a></p> </li> </ol> </section> Fri, 13 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/migration-guides/typescript-to-rust/ https://corrode.dev/learn/migration-guides/typescript-to-rust/ <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>A Practical Guide for Decision Makers</p> </h4> </div> <p>I wrote this guide for technical leaders and developers considering a move from TypeScript to Rust. After years of helping teams make this transition, I’ll share what works, what doesn’t, and how to make your migration successful.</p> </div> <p>TypeScript excels at making JavaScript more maintainable, but teams often hit scaling challenges as their codebases grow. You might be facing performance bottlenecks, reliability issues, or maintenance overhead. Rust offers compelling solutions to these problems, but migration needs careful planning and execution. Let me show you how to evaluate if Rust is right for your team, plan a successful migration, and keep your team productive during the transition.</p> <p>In this article, you’ll learn:</p> <ul> <li>How to evaluate if Rust is right for your team</li> <li>Practical strategies for TypeScript-to-Rust migration</li> <li>Common pitfalls and how to avoid them</li> <li>Ways to maintain productivity during transition</li> </ul> <h2 id="key-differences-between-typescript-and-rust"><a class="zola-anchor" href="#key-differences-between-typescript-and-rust" aria-label="Anchor link for: key-differences-between-typescript-and-rust">Key Differences Between TypeScript and Rust</a></h2> <table><thead><tr><th>Aspect</th><th>TypeScript</th><th>Rust</th></tr></thead><tbody> <tr><td>1.0 Release</td><td>2014</td><td>2015</td></tr> <tr><td>Packages</td><td>3 million+ (npm)</td><td>160,000+ (crates.io)</td></tr> <tr><td>Type System</td><td>Optional</td><td>Mandatory</td></tr> <tr><td>Tooling</td><td>Rich ecosystem, frequent updates</td><td>Stable, integrated toolchain</td></tr> <tr><td>Memory Management</td><td>Garbage collected</td><td>Ownership system, compile-time checks</td></tr> <tr><td>Speed</td><td>Moderate</td><td>Fast</td></tr> <tr><td>Error Handling</td><td>Exceptions</td><td>Explicit handling with <code>Result</code></td></tr> <tr><td>Learning Curve</td><td>Moderate</td><td>Steep</td></tr> </tbody></table> <h2 id="why-teams-consider-rust"><a class="zola-anchor" href="#why-teams-consider-rust" aria-label="Anchor link for: why-teams-consider-rust">Why Teams Consider Rust</a></h2> <p>TypeScript is a great language, but many teams hit a wall around the 10k to 100k lines of code mark. At this scale, the codebase becomes hard to maintain and teams start to feel the pain. The honeymoon phase with TypeScript codebases is surprisingly short - when working with larger applications, adding functionality or performing large-scale refactoring becomes increasingly challenging.</p> <p>The problems are clear and specific. While TypeScript has a type system, it remains a dynamically typed language built on JavaScript. Types are optional and can be <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dev.to/martinpersson/a-guide-to-using-the-option-type-in-typescript-ki2">bypassed using <code>any</code> or <code>unknown</code></a> or by freely <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://medium.com/livefront/to-cast-or-not-to-cast-a-typescript-dilemma-c0c20c53c6d9">casting</a> between types. Without enough discipline, this leads to runtime errors and bugs.</p> <p>Memory leaks and security vulnerabilities become more common, especially in large, long-running backend services. Some companies I’ve worked with needed regular service restarts to manage memory leaks.</p> <p>External packages often have security vulnerabilities and need regular updates. Breaking changes are common, and packages frequently become <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.aquasec.com/blog/deceptive-deprecation-the-truth-about-npm-deprecated-packages/">unmaintained</a>. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.propelauth.com/post/nextjs-challenges">Frameworks like Next.js introduce frequent breaking changes</a>, forcing teams to spend time on updates instead of business logic.</p> <p>Performance isn’t guaranteed. TypeScript is fast enough for most cases, but performance-critical applications will hit limitations. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dev.to/mpiorowski/typescript-with-gorust-errors-no-trycatch-heresy-49mf">Error handling through exceptions and promises can be hard to reason about.</a> Large TypeScript codebases become difficult to refactor and maintain, even with type safety.</p> <h2 id="typescript-as-a-bridge-to-rust"><a class="zola-anchor" href="#typescript-as-a-bridge-to-rust" aria-label="Anchor link for: typescript-as-a-bridge-to-rust">TypeScript as a Bridge to Rust</a></h2> <p>TypeScript’s type system creates an excellent foundation for Rust adoption. Your team already understands static typing and values its benefits. This gives you a head start with Rust, which takes these concepts further and adds more powerful guarantees.</p> <p>The developer experience differs in two key ways: Rust has stronger type guarantees but slower compile times compared to TypeScript. Many developers find this tradeoff worthwhile, especially because you can write high-level Rust code without dropping into systems-level programming. Rust’s powerful abstractions like the trait system and generics allow you to model behavior in just the right way.</p> <h2 id="understanding-rust-s-learning-curve"><a class="zola-anchor" href="#understanding-rust-s-learning-curve" aria-label="Anchor link for: understanding-rust-s-learning-curve">Understanding Rust’s Learning Curve</a></h2> <p>Rust enforces stronger guarantees than TypeScript through its ownership system and borrow checker. You’ll need to plan for an adjustment period. Most developers need 2-4 months to become comfortable with Rust’s ownership model. They’ll go through a phase of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=ZNFdkTIzdXM">“fighting the borrow checker”</a> – this is normal and temporary. Your job is to keep the team motivated during this learning curve. I’ve seen time and again that developers who push through this phase become the strongest Rust advocates. These developers then become valuable mentors for their teammates.</p> <h2 id="rust-has-its-roots-in-systems-programming"><a class="zola-anchor" href="#rust-has-its-roots-in-systems-programming" aria-label="Anchor link for: rust-has-its-roots-in-systems-programming">Rust Has Its Roots In Systems Programming</a></h2> <p>Rust pushes your team to understand systems concepts better than TypeScript ever required. You need to know the difference between stack and heap allocation. You’ll work with different string types like <code>String</code> and <code>&amp;str</code>. And you should be willing to learn what a pointer or a mutex is.</p> <p>These concepts might seem intimidating at first, but they make Rust fast. Rust won’t hide these details from you. The idea is that explicit is better than implicit.</p> <p>Your team will write more efficient code because Rust makes these low-level details explicit and manageable.</p> <p>You don’t need to be a systems programmer to use Rust and yet, you will need to learn these concepts to become proficient in Rust.</p> <h2 id="safety-and-reliability"><a class="zola-anchor" href="#safety-and-reliability" aria-label="Anchor link for: safety-and-reliability">Safety and Reliability</a></h2> <p>The strict Rust compiler is your strongest ally. You can refactor without fear because the compiler catches mistakes early and consistently. You won’t deal with <code>null</code> or <code>undefined</code> errors. Error handling becomes explicit and predictable with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/result/"><code>Result</code></a>.</p> <h2 id="ecosystem-maturity"><a class="zola-anchor" href="#ecosystem-maturity" aria-label="Anchor link for: ecosystem-maturity">Ecosystem Maturity</a></h2> <p>NPM gives you more packages, but Rust’s ecosystem prioritizes quality.</p> <blockquote> <p>In September 2022 over 2.1 million packages were reported being listed in the npm registry, making it the biggest single language code repository on Earth – Source: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nodejs.org/en/learn/getting-started/an-introduction-to-the-npm-package-manager">Nodejs.org</a></p> </blockquote> <p>A small portion of these packages provide type definitions (i.e. TypeScript support). Many packages are outdated or are actively maintained. According to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.scworld.com/news/npm-registry-users-download-2-1b-deprecated-packages-weekly-researchers-say">SC Media</a>, “NPM registry users download 2.1B deprecated packages weekly”.</p> <p>Compare that to Rust’s crate ecosystem. At the time of writing, it lists <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/">170.435 crates</a>. That is a fraction of NPM’s packages. Crates also can’t be easily removed from the registry:</p> <blockquote> <p>Take care when publishing a crate, because a publish is permanent. The version can never be overwritten, and the code cannot be deleted. There is no limit to the number of versions which can be published, however.</p> </blockquote> <p>That’s a feature, not a bug. It means that your build pipelines won’t break due to a missing dependency. You can <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/publishing.html#cargo-yank">yank</a> a version to indicate that it’s no longer supported, but the code remains available for those who depend on it.</p> <p>Libraries maintain strong backward compatibility. Breaking changes are rare. Rust itself releases new <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/edition-guide/editions/">editions</a> every three years with opt-in changes.</p> <p>The quality difference becomes especially noticeable in larger applications. While the Rust ecosystem may be smaller, the crates are typically more reliable and provide better documentation compared to the TypeScript ecosystem. When you build a large application, that higher quality standard makes a significant difference.</p> <p>Many Rust crates stay in 0.x versions longer than you might expect. Don’t let this worry you – Rust’s type system ensures robust functionality even before reaching 1.0. The ecosystem grows fast, and the existing libraries work reliably. For specific use cases, writing your own library is common and well-supported.</p> <h2 id="rust-vs-typescript-for-backend-services"><a class="zola-anchor" href="#rust-vs-typescript-for-backend-services" aria-label="Anchor link for: rust-vs-typescript-for-backend-services">Rust vs TypeScript For Backend Services</a></h2> <p>TypeScript is a great language for backend services. A lot of companies use it successfully. There are many frameworks to choose from, like Express, NestJS, or Fastify. These frameworks are mature and well-documented.</p> <p>By comparison, Rust’s backend ecosystem is smaller. You have Axum, Actix, and Rocket, among others. These frameworks are fast and reliable, but they don’t provide a “batteries-included” experience like Express.</p> <p>That said, Rust’s ecosystem is growing fast and most companies find the available libraries sufficient. I personally recommend <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/axum">axum</a> as it has the largest momentum and is backed by the Tokio team.</p> <p>Deployment is straightforward. You can build your Rust service into a single binary and deploy it to a container or a server. Rust binaries are small and have no runtime dependencies. This makes deployment easy and reliable.</p> <h2 id="rust-is-really-fast"><a class="zola-anchor" href="#rust-is-really-fast" aria-label="Anchor link for: rust-is-really-fast">Rust is Really Fast</a></h2> <p>Teams are often shocks that Rust is so fast. They go in expecting Rust to be fast, but the reality still surprises them. You can expect an order of magnitude better CPU and memory usage if you’re coming from JS/TS. The effects of that are very real: reduced cloud costs, less hardware, and faster response times.</p> <p>Most importantly, <strong>your runtime behavior becomes predictable</strong>. Production incidents decrease. Your operations team will thank you for the reduced overhead.</p> <h2 id="planning-your-migration"><a class="zola-anchor" href="#planning-your-migration" aria-label="Anchor link for: planning-your-migration">Planning Your Migration</a></h2> <p>Write down why you want to migrate before you start:</p> <ul> <li>What problems do you face today?</li> <li>Why will Rust solve these problems?</li> <li>Could you fix them in TypeScript instead?</li> </ul> <p>This clarity helps when things get tough.</p> <p>I know this evaluation isn’t easy. We often struggle to see our codebase’s problems clearly. Politics and inertia hold us back. Sometimes you need an outside perspective. I can help you evaluate your situation objectively and create a solid migration plan. This might sound expensive, but think about your team’s salaries and the cost of making the wrong decision. Good consulting pays for itself quickly. <a href="/services">Reach out for a free consultation</a>.</p> <h2 id="integration-strategies"><a class="zola-anchor" href="#integration-strategies" aria-label="Anchor link for: integration-strategies">Integration Strategies</a></h2> <p>You have two main ways to integrate Rust with TypeScript.</p> <h3 id="webassembly"><a class="zola-anchor" href="#webassembly" aria-label="Anchor link for: webassembly">WebAssembly</a></h3> <p>You can use WebAssembly (WASM) to compile your Rust code to a library and call it directly from TypeScript. This works great for speeding up performance-critical components. Teams often start here and expand their Rust usage as they see the benefits.</p> <h3 id="standalone-web-service"><a class="zola-anchor" href="#standalone-web-service" aria-label="Anchor link for: standalone-web-service">Standalone Web-Service</a></h3> <p>Alternatively, you can deploy Rust as separate services. This fits well with microservice architectures. Your TypeScript and Rust components communicate over the network. This gives you a clean separation and lets you migrate gradually.</p> <h2 id="find-a-rust-champion"><a class="zola-anchor" href="#find-a-rust-champion" aria-label="Anchor link for: find-a-rust-champion">Find A Rust Champion</a></h2> <p>You need a Rust champion in your team. This person should have some prior Rust experience and be excited about the language.</p> <p>Outside help can get you started, but keep the knowledge in-house. You know your codebase and business domain best. A consultant helps with the tricky Rust parts, team augmentation, and training, but your team maintains and extends the codebase in the long run.</p> <p><strong>They need to believe in the mission.</strong></p> <p>In order to succeed, your Rust champion needs to be able to motivate the team, answer questions, and guide the team through the learning curve. They work hand-in-hand with the consultant to ensure the team’s success.</p> <h2 id="starting-your-journey"><a class="zola-anchor" href="#starting-your-journey" aria-label="Anchor link for: starting-your-journey">Starting Your Journey</a></h2> <p>Don’t rewrite everything at once! Start small. Maybe pick a monitoring service or CLI tool – something important but not critical. Perhaps you’ll give it a shot during a hackathon or a sprint. Build confidence through early wins.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Ready to make the switch to Rust?</p> </h4> </div> <p>I help teams make successful transitions from TypeScript to Rust. Whether you need training, architecture guidance, or migration planning, <a href="/services">let’s talk about your needs</a>.</p> </div> Thu, 12 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e05-zoo/ https://corrode.dev/podcast/s03e05-zoo/ <div><script id="letscast-player-34099980" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/zoo-with-jessie-frazelle/player.js?size=s"></script></div> <p>Think about this: software engineers have modern code editors, parallel processing, continuous integration, and countless tools that make their work efficient. But hardware engineers? They’re often working with single-threaded tools, limited automation, and workflows that haven’t fundamentally changed in decades. Zoo is building the infrastructure to change that, creating a modern set of tools and APIs that will allow companies and engineers to build better hardware design tools and accelerate the development of physical products.</p> Mon, 09 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/migration-guides/java-to-rust/ https://corrode.dev/learn/migration-guides/java-to-rust/ <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>A Practical Guide for Decision Makers</p> </h4> </div> <p>This article is aimed at technical product managers and CTOs who are considering migrating a production Java application — or part of it — to Rust. I will give an <strong>honest overview</strong> of the challenges and benefits of such a migration, as well as practical tips to make it successful based on years of experience and successful transitions.</p> </div> <p>Java is an amazing language. It’s a true workhorse, powering some of the world’s most critical systems. Even so, large organizations are increasingly looking to Rust as a way to improve reliability, resource usage, and reduce costs. Decision makers need to weigh the benefits and risks of migrating to Rust, and it’s not always an easy choice.</p> <p>In this article, you’ll learn:</p> <ul> <li>How to plan and execute a successful Java-to-Rust migration</li> <li>Common pitfalls to avoid during the transition</li> <li>Practical strategies for managing mixed Java/Rust codebases</li> <li>How to measure success and maintain productivity during migration</li> </ul> <p>By the end, you’ll have a clear idea if Rust is the right choice for your organization and if so, how to make the transition as smooth as possible.</p> <h2 id="get-your-customized-migration-plan"><a class="zola-anchor" href="#get-your-customized-migration-plan" aria-label="Anchor link for: get-your-customized-migration-plan">Get Your Customized Migration Plan</a></h2> <p>I help teams migrate from Java to Rust, providing tailored guidance and training. If you’re considering a migration, answer a few questions about your project, and I’ll reach out with a customized plan.</p> <div class="quiz-container"> <div class="quiz-progress-container"> <div class="progress-bar" id="progress-bar" style="width: 0%"></div> </div> <div id="quiz-question-container"></div> <div id="quiz-navigation-container"> <button class="quiz-navbutton" id="quiz-prev-question" style="display: none" > ← Previous </button> <button class="quiz-navbutton" id="quiz-next-question">Next →</button> </div> <div id="quiz-results" style="display: none"> <h2>Thank you for your interest!</h2> <p> I'll send you a customized migration strategy based on your responses. </p> <p> In the meantime, feel free to check out my <a href="/blog">other articles about Rust</a>. </p> </div> </div> <script> const languageOptions = [ "Python", "Java", "C++", "Go", "TypeScript", "JavaScript", "C#", "Ruby", "PHP", "Swift", "Kotlin", "Other", ]; const questions = [ { type: "multipleChoice", question: "Which languages are currently used in your codebase?", id: "currentLanguages", options: languageOptions, }, { type: "multipleChoice", question: "Which types of applications are you looking to migrate?", id: "applicationType", direction: "column", options: [ "Web services / APIs", "Desktop applications", "CLI tools", "Embedded systems", "WebAssembly modules", "Data processing pipelines", "Machine learning systems", "Other", ], }, { type: "radio", question: "What's the size of your codebase?", id: "codebaseSize", options: ["< 10k lines", "< 100k lines", "> 100k lines"], }, { type: "radio", question: "What's your team's experience with Rust?", id: "rustExperience", direction: "column", options: [ "No experience yet", "Some team members have experimented with it", "We have one or more small projects in production", "We have significant production experience", ], }, { type: "multipleChoice", question: "What are your main motivations for migrating to Rust?", direction: "column", id: "motivations", options: [ "Performance improvements", "Better type safety", "Memory efficiency", "Production reliability", "Cross-platform deployment", "WebAssembly support", "Embedded systems development", "Microservices migration", "Other", ], }, { type: "multipleChoice", question: "What are your main concerns about migrating to Rust?", id: "concerns", direction: "column", options: [ "Learning curve for the team", "Migration complexity", "Maintaining productivity during transition", "Finding Rust developers", "Integration with existing Java code", "Third-party library availability", "Build times", "Testing and deployment changes", "None/Other", ], }, { type: "radio", question: "What's your timeline for the migration?", id: "timeline", options: [ "Immediate (next 3 months)", "Medium-term (3-12 months)", "Long-term (12+ months)", ], }, { type: "multipleChoice", question: "What kind of support is most important for your team?", id: "supportNeeded", direction: "column", options: [ "Planning and strategy", "Project audit", "Training and workshops", "Code reviews and mentoring", "Java integration support", "Performance optimization", "Architecture design", "Best practices guidance", "Team hiring support", ], }, { type: "radio", question: "How many developers would be involved in the migration?", options: ["1", "2-3", "4-9", "10+"], id: "teamSize", }, { type: "input", question: "Anything else you'd like to share about your migration plans?", id: "additionalComments", placeholder: "Share your thoughts...", optional: true, }, { type: "email", question: "What's your email? I'll send you a customized migration strategy based on your responses.", id: "email", placeholder: "Your email address", }, ]; const formUrl = "https://submit-form.com/OH6mf241q"; // Quiz state let answers = {}; let currentQuestionIndex = 0; let totalQuestions; // DOM elements const progressBar = document.getElementById("progress-bar"); const questionContainer = document.getElementById("quiz-question-container"); const prevButton = document.getElementById("quiz-prev-question"); const nextButton = document.getElementById("quiz-next-question"); function initQuiz() { totalQuestions = questions.length; nextButton.addEventListener("click", nextQuestion); prevButton.addEventListener("click", previousQuestion); // Handle browser back/forward buttons window.addEventListener("popstate", (event) => { if (event.state) { currentQuestionIndex = event.state.index; answers = event.state.answers || {}; displayQuestion(currentQuestionIndex); } else { resetQuiz(); } }); displayQuestion(0); } function resetQuiz() { answers = {}; currentQuestionIndex = 0; displayQuestion(0); } function updateProgressBar() { const progressPercentage = ((currentQuestionIndex + 1) / totalQuestions) * 100; progressBar.style.width = `${progressPercentage}%`; } function createQuestionElement(question) { const element = document.createElement("div"); element.className = "question"; element.innerHTML = `<h3>${question.question}${ question.optional ? " (Optional)" : "" }</h3>`; let inputContainer; switch (question.type) { case "multipleChoice": inputContainer = document.createElement("div"); if (question.direction) { inputContainer.style.display = "flex"; inputContainer.style.flexDirection = question.direction; } else { inputContainer.className = "checkbox-grid"; } question.options.forEach((option) => { const label = document.createElement("label"); label.className = "checkbox-label"; const input = document.createElement("input"); input.type = "checkbox"; input.name = question.id; input.value = option; label.appendChild(input); label.append(` ${option}`); inputContainer.appendChild(label); }); break; case "radio": inputContainer = document.createElement("div"); inputContainer.className = "quiz-flex-container"; if (question.direction) { inputContainer.style.flexDirection = question.direction; } question.options.forEach((option) => { const label = document.createElement("label"); label.className = "quiz-button"; label.textContent = option; const input = document.createElement("input"); input.type = "radio"; input.name = question.id; input.value = option; input.addEventListener("change", () => { saveCurrentAnswers(); nextButton.disabled = false; // Auto-advance if (currentQuestionIndex < totalQuestions - 1) { nextQuestion(); } }); label.appendChild(input); inputContainer.appendChild(label); }); break; case "input": case "email": inputContainer = document.createElement("input"); inputContainer.type = question.type; inputContainer.id = question.id; inputContainer.name = question.id; inputContainer.placeholder = question.placeholder || ""; if (question.type === "email") { inputContainer.required = true; } if (!question.optional) { inputContainer.required = true; } break; } element.appendChild(inputContainer); return { element, inputContainer }; } function saveCurrentAnswers() { const inputs = questionContainer.querySelectorAll("input"); const questionId = questions[currentQuestionIndex].id; delete answers[questionId]; inputs.forEach((input) => { if (input.type === "checkbox") { if (input.checked) { answers[questionId] = answers[questionId] || []; answers[questionId].push(input.value); } } else if ( (input.type === "radio" && input.checked) || input.type === "text" || input.type === "email" ) { if (input.value.trim()) { answers[questionId] = input.value; } } }); } function restorePreviousAnswers(question, container) { const previousAnswer = answers[question.id]; if (!previousAnswer) return; const inputs = container.querySelectorAll("input"); inputs.forEach((input) => { if (input.type === "checkbox") { input.checked = previousAnswer.includes(input.value); } else if (input.type === "radio") { input.checked = input.value === previousAnswer; } else { input.value = previousAnswer; } }); } function updateNavigationState() { prevButton.style.display = currentQuestionIndex > 0 ? "" : "none"; const question = questions[currentQuestionIndex]; nextButton.disabled = !isQuestionAnswered(question); } function isQuestionAnswered(question) { if (question.optional) return true; const answer = answers[question.id]; if (!answer) return false; if (Array.isArray(answer)) return answer.length > 0; if (question.type === "email") { const input = document.getElementById(question.id); return input && input.checkValidity() && answer.trim().length > 0; } return answer.trim().length > 0; } function nextQuestion() { if (currentQuestionIndex < totalQuestions - 1) { saveCurrentAnswers(); currentQuestionIndex++; displayQuestion(currentQuestionIndex); } else { submitQuiz(); } } function previousQuestion() { if (currentQuestionIndex > 0) { saveCurrentAnswers(); currentQuestionIndex--; displayQuestion(currentQuestionIndex); } } function displayQuestion(index) { const question = questions[index]; if (!question) return; history.pushState( { index, answers: { ...answers } }, `Question ${index + 1}`, `?question=${index + 1}` ); questionContainer.innerHTML = ""; const { element, inputContainer } = createQuestionElement(question); questionContainer.appendChild(element); restorePreviousAnswers(question, inputContainer); updateProgressBar(); updateNavigationState(); if (question.type === "input" || question.type === "email") { const input = inputContainer; input.addEventListener("input", () => { if (question.type === "email") { nextButton.disabled = !input.checkValidity() && !question.optional; } else { nextButton.disabled = !input.value.trim() && !question.optional; } }); } else if (question.type === "multipleChoice") { const inputs = inputContainer.querySelectorAll("input"); inputs.forEach((input) => { input.addEventListener("change", () => { const anyChecked = Array.from(inputs).some((i) => i.checked); nextButton.disabled = !anyChecked && !question.optional; }); }); } if (question.type === "radio") { nextButton.disabled = !answers[question.id] && !question.optional; } } async function submitQuiz() { saveCurrentAnswers(); // Hide the quiz questionContainer.innerHTML = ""; document.getElementById("quiz-navigation-container").style.display = "none"; // Show the thank you message const resultsContainer = document.getElementById("quiz-results"); resultsContainer.style.display = "block"; try { // Using Formspark as an example const response = await fetch(formUrl, { method: "POST", headers: { "Content-Type": "application/json", Accept: "application/json", }, body: JSON.stringify(answers), }); if (!response.ok) { throw new Error("Failed to submit"); } } catch (error) { console.error("Failed to submit form:", error); // Optionally show an error message to the user } } document.addEventListener("DOMContentLoaded", initQuiz); </script> <style> .quiz-container { margin: 0 auto; overflow: hidden; } .quiz-progress-container { width: 100%; background-color: #ddd; height: 5px; margin-bottom: 20px; } .progress-bar { height: 100%; background-color: #ee3856; transition: width 0.5s ease-in-out; } #quiz-navigation-container { width: 100%; margin-top: 10px; display: flex; justify-content: flex-end; gap: 10px; } .quiz-navbutton { padding: 10px 20px; background-color: #111; color: white; cursor: pointer; border: none; } .quiz-flex-container { display: flex; gap: 10px; flex-wrap: wrap; } .quiz-button { padding: 14px; border-radius: 4px; background-color: #111; color: white; white-space: nowrap; cursor: pointer; flex: 1; text-align: center; font-size: large; } .quiz-button:hover { background-color: #ee3856; } input, .checkbox-label, .quiz-button:hover { cursor: pointer; } #quiz-next-question:disabled { cursor: not-allowed; opacity: 0.5; } .quiz-button input[type="radio"] { display: none; } .quiz-container input[type="input"], .quiz-container input[type="text"], .quiz-container input[type="email"] { font-size: larger; width: 100%; padding: 15px; border: 1px solid #000; box-sizing: border-box; margin-bottom: 20px; } .quiz-container input::placeholder { color: #ccc; } .question h2 { margin: 0; } .question .checkbox-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 10px; } .checkbox-label { display: flex; align-items: center; gap: 8px; } .question input[type="checkbox"] { -webkit-appearance: none; -moz-appearance: none; appearance: none; flex-shrink: 0; /* Prevent checkbox from shrinking */ width: 20px; height: 20px; border: 2px solid #111; border-radius: 4px; margin: 0; /* Remove margin, we're using gap instead */ } .question input[type="checkbox"]:checked { border: 2px solid #111; background-color: #ee3856; } @media (max-width: 600px) { .quiz-container input[type="text"], .quiz-container input[type="email"] { width: calc(100% - 30px); } } @media (prefers-color-scheme: dark) { .quiz-button { background-color: #fab71c; color: #111; } .question input[type="checkbox"] { border-color: #fff; } .question input[type="checkbox"]:checked { border: 2px solid #fff; background-color: #ee3856; } } </style> <h2 id="differences-between-java-and-rust"><a class="zola-anchor" href="#differences-between-java-and-rust" aria-label="Anchor link for: differences-between-java-and-rust">Differences Between Java and Rust</a></h2> <p>Before diving into migration tips, let’s look at key differences between Java and Rust:</p> <table><thead><tr><th>Aspect</th><th>Java</th><th>Rust</th></tr></thead><tbody> <tr><td>Memory Management</td><td>Garbage collector; possible memory leaks and GC pauses</td><td>Borrow checker at compile time; no GC pauses</td></tr> <tr><td>Performance</td><td>JVM bytecode, requires runtime</td><td>Native machine code via LLVM</td></tr> <tr><td>Default Mutability</td><td>Mutable by default</td><td>Immutable by default, requires <code>mut</code></td></tr> <tr><td>Null Safety</td><td>Allows null pointers</td><td>No null pointers, uses <code>Option&lt;T&gt;</code></td></tr> <tr><td>Code Organization</td><td>Classes with inheritance and interfaces</td><td>Structs with traits (no inheritance)</td></tr> <tr><td>Package Management</td><td>Gradle/Maven</td><td>Cargo (integrated build + deps)</td></tr> <tr><td>Concurrency</td><td>Thread-based with synchronized blocks</td><td>Built-in safety via ownership system; async/await</td></tr> <tr><td>Error Handling</td><td>Checked exceptions</td><td>Result and Option types</td></tr> <tr><td>Compilation Speed</td><td>Fast to medium</td><td>Slow</td></tr> <tr><td>Learning Curve</td><td>Moderate</td><td>Steep</td></tr> <tr><td>Deployment</td><td>Requires JVM runtime</td><td>Small, self-contained binaries</td></tr> </tbody></table> <p>These differences highlight why organizations might consider migrating to Rust, particularly for performance-critical or resource-constrained applications. However, migration isn’t just about technical differences - it requires careful planning and execution. Let’s look at how to make this transition successful.</p> <h2 id="mindset-shifts-for-java-developers"><a class="zola-anchor" href="#mindset-shifts-for-java-developers" aria-label="Anchor link for: mindset-shifts-for-java-developers">Mindset Shifts for Java Developers</a></h2> <p>Moving from Java to Rust requires some fundamental shifts in how you think about programming. Here are the key changes that will help your team succeed.</p> <h3 id="from-objects-to-ownership"><a class="zola-anchor" href="#from-objects-to-ownership" aria-label="Anchor link for: from-objects-to-ownership">From Objects to Ownership</a></h3> <p>Java lets you pass objects freely between methods and classes. Rust doesn’t. Each piece of data has exactly one owner, and the compiler enforces this strictly. While this feels limiting at first, it prevents entire categories of memory issues at compile time rather than runtime. Instead of relying on garbage collection to clean up, you plan your memory usage upfront. Most developers find this leads to more predictable and efficient code once they adapt to the mindset.</p> <p><strong>The ownership model also forces better data structure design.</strong> Rust’s has stricter memory rules, which encourage you to think more carefully about how you organize data and pass it between functions. This often leads to more efficient algorithms and cleaner architectures.</p> <h3 id="embracing-immutability"><a class="zola-anchor" href="#embracing-immutability" aria-label="Anchor link for: embracing-immutability">Embracing Immutability</a></h3> <p>Java makes everything mutable by default, which is arguably its single biggest issue. In large codebases, this mutability makes maintenance nearly impossible - you have to trace through deeply nested call trees to ensure variables aren’t modified somewhere unexpected. Code reviews become nightmarish exercises in hunting down potential side effects.</p> <p>Rust does the opposite - everything stays immutable unless marked with <code>mut</code>. This simple change has profound effects on code quality. You think more carefully about what really needs to change, leading to fewer bugs and easier concurrent programming. <strong>This also enables better compiler optimizations</strong> since the compiler can make stronger assumptions about your data.</p> <p>Many developers find they write better code in all languages after working with Rust’s immutability model.</p> <h3 id="rethinking-null"><a class="zola-anchor" href="#rethinking-null" aria-label="Anchor link for: rethinking-null">Rethinking Null</a></h3> <p>Rust eliminates <code>null</code> entirely. Instead of <code>null</code> checks and <code>NullPointerExceptions</code>, you work with <code>Option&lt;T&gt;</code>. This type makes uncertainty explicit in your code, forcing you to handle cases where values might not exist. The compiler ensures you handle both success and failure paths.</p> <p>In Java, defensive programming requires null checks at every public interface. It adds overhead even when you know the value can’t be null. With Rust’s references and ownership system, you can guarantee non-null values without runtime checks, making your interfaces both safer and faster.</p> <h3 id="from-inheritance-to-composition"><a class="zola-anchor" href="#from-inheritance-to-composition" aria-label="Anchor link for: from-inheritance-to-composition">From Inheritance to Composition</a></h3> <p><strong>Rust doesn’t have class inheritance at all.</strong> There’s no equivalent to extending a class in Java. Instead, Rust uses traits, which are much closer to Java interfaces than to inheritance.</p> <p>This is actually the better approach. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://softwareengineering.stackexchange.com/a/370519">Even James Gosling, Java’s creator, has said he would have preferred pure interfaces over class inheritance if he could redesign Java.</a> Rust implements this vision through traits. You can even have trait inheritance by requiring one trait to implement another, but it’s all trait-based composition rather than implementation inheritance.</p> <p><strong>Traits encourage more flexible and maintainable code design.</strong> Rather than building rigid inheritance hierarchies, you <strong>compose behavior</strong> through trait implementations. This leads to systems that are easier to test, modify, and extend.</p> <p>It takes a while to get used to that approach. The key is to think in terms of capabilities (traits). For example, instead of a <code>Dog</code> class extending an <code>Animal</code> class, you might have a <code>Bark</code> trait that both <code>Dog</code> and <code>Wolf</code> implement. This leads to more reusable and modular code.</p> <h3 id="compiler-as-collaborator"><a class="zola-anchor" href="#compiler-as-collaborator" aria-label="Anchor link for: compiler-as-collaborator">Compiler as Collaborator</a></h3> <p>The Rust compiler catches far more issues than Java’s. It identifies race conditions, memory leaks, and thread safety problems before they reach production. While its strictness can feel frustrating initially, the detailed error messages actually help you learn. Most teams find that working with the compiler rather than against it leads to faster development in the long run.</p> <h3 id="memory-management-mindset"><a class="zola-anchor" href="#memory-management-mindset" aria-label="Anchor link for: memory-management-mindset">Memory Management Mindset</a></h3> <p>Instead of relying on garbage collection, Rust makes you think explicitly about memory lifecycles. You consider who owns data and how long it needs to live. The borrow checker ensures these decisions are correct at compile time. This leads to more efficient resource usage and eliminates many common runtime errors. Despite the learning curve, most developers find this explicit memory model makes them better programmers overall.</p> <p>These changes take time to internalize. Plan for an adjustment period, but know that the investment typically pays off in more reliable and efficient code. The key is understanding these differences upfront so you can help your team adapt effectively.</p> <h2 id="tip-1-flatten-the-learning-curve"><a class="zola-anchor" href="#tip-1-flatten-the-learning-curve" aria-label="Anchor link for: tip-1-flatten-the-learning-curve">Tip 1: Flatten The Learning Curve</a></h2> <p>Migrating to a new language is always tough at first, and Rust is no exception. It has a <a href="/blog/flattening-rusts-learning-curve/">famously steep learning curve</a> and requires a different mindset from Java. Plan 4-6 months for your engineers to get comfortable with Rust, and expect a few bumps along the way.</p> <p>That said, there’s plenty of material to help your team get up to speed. Resources like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustlings">Rustlings</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/">Rust By Example</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mainmatter/100-exercises-to-learn-rust">100 Exercises To Learn Rust</a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustfinity.com/">Rustfinity</a> are all great for self-learning.</p> <p>If you’re looking for a more structured approach, <a href="/services">consider hiring a Rust consultant or trainer</a>. Bringing in experts can make the transition even faster and smoother. Your team will not only learn Rust but also feel more confident working with it in production.</p> <h2 id="tip-2-have-a-clear-migration-plan"><a class="zola-anchor" href="#tip-2-have-a-clear-migration-plan" aria-label="Anchor link for: tip-2-have-a-clear-migration-plan">Tip 2: Have A Clear Migration Plan</a></h2> <p>Migrating to Rust comes with some risks, but careful planning will minimize them. Here’s how to ensure success:</p> <ol> <li> <p><strong>Start Small</strong><br /> Pick a small, non-critical part of your application for the first Rust implementation. This lets your team experiment and build confidence without affecting core systems. Expand gradually as you see results.</p> </li> <li> <p><strong>Prepare Your Team</strong><br /> Don’t just decide this for your developers—decide together. Get the team ready with training or external expertise, and focus on integration with your existing Java system. Rust will likely need new dependencies, so research the ecosystem and be ready to roll up your sleeves to contribute if necessary. Take a look at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blessed.rs">blessed.rs</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lib.rs/std">lib.rs</a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-unofficial/awesome-rust">awesome-rust</a> for a curated list of libraries.</p> </li> <li> <p><strong>Evaluate Dependencies Upfront</strong><br /> Consider potential constraints like proprietary tools or databases that may complicate integration with Rust. Make sure the libraries you need are available, or be prepared to write your own.</p> </li> <li> <p><strong>Have a Plan B</strong><br /> Rust migration doesn’t need to be all-or-nothing. Keep Java components running while testing and migrating. If issues arise, you can scale back or swap components as needed.</p> </li> <li> <p><strong>Set Clear KPIs</strong><br /> Establish your own definition of success—don’t just follow industry benchmarks. Whether it’s performance, resource savings, or developer experience, make sure you know what you want from Rust and measure it.</p> </li> <li> <p><strong>Training Pays Off</strong><br /> Even if you eventually decide against Rust, the training will improve your team’s programming skills. It’s an investment that pays dividends in the long run.</p> </li> <li> <p><strong>Monitor and Test</strong><br /> Use monitoring and automated tests throughout the migration. Rust’s safety guarantees help, but you still need to test thoroughly and catch any issues early.</p> </li> </ol> <h2 id="tip-3-choose-the-right-migration-strategy"><a class="zola-anchor" href="#tip-3-choose-the-right-migration-strategy" aria-label="Anchor link for: tip-3-choose-the-right-migration-strategy">Tip 3: Choose The Right Migration Strategy</a></h2> <p>Initially, you will likely be dealing with a mix of Java and Rust. Where should you start? <strong>Look at the boundaries in your application—network layers, APIs, or microservices.</strong> These natural seams are perfect places to migrate first.</p> <p>For Java-to-Rust migration, you have a few options:</p> <ol> <li>Set up inter-process communication (IPC) via <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://grpc.io/">gRPC</a> between Java and Rust services.</li> <li>Use a message broker like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kafka.apache.org/">Kafka</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nats.io/">NATS</a> in between the two languages.</li> <li>Use a REST API as the communication layer.</li> <li>Use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/jni/latest/jni/">JNI</a> to call Rust functions from Java.</li> </ol> <p>Each approach has its pros and cons, so choose the one that fits your use case best. How do you decide? This is something you should discuss with your team and possibly a Rust consultant. They can help you weigh the trade-offs and make the right choice.</p> <p>If you’d like to get a primer on Java-to-Rust interop, check out <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=fYaaBoKbDQs">this talk</a> from Rust Nation UK 2024 by Konstantin Grechishchev.</p> <h2 id="tip-4-partial-migration-might-be-enough"><a class="zola-anchor" href="#tip-4-partial-migration-might-be-enough" aria-label="Anchor link for: tip-4-partial-migration-might-be-enough">Tip 4: Partial Migration Might Be Enough</a></h2> <p>Big organizations often have large, complex Java codebases. A full rewrite is not feasible and can be risky.</p> <p><strong>Consider rewriting the most CPU- or memory-hungry parts of your application in Rust while leaving the rest untouched.</strong></p> <p>Perhaps you find that you only need to migrate a tiny portion, say 10-20%, to Rust for a significant performance boost. In that case, you can keep the rest of the application in Java and gradually migrate more parts over time if you see benefits. This incremental approach ensures that your team can slowly adapt to Rust and share some quick wins along the way, which is great for morale.</p> <p>A good way to test the waters is with isolated components — CLI tools or monitoring sidecars. These smaller parts let your team gain experience with Rust without affecting critical system functions.</p> <h2 id="tip-5-evaluate-the-ecosystem"><a class="zola-anchor" href="#tip-5-evaluate-the-ecosystem" aria-label="Anchor link for: tip-5-evaluate-the-ecosystem">Tip 5: Evaluate The Ecosystem</a></h2> <p>When migrating to a different language, the new tooling is just as important as the language itself. However, it’s often overlooked in the decision-making process.</p> <p>Rust’s tooling is excellent, and among the most loved advantages of the language. The tooling is best in class, mature and easy to adopt. Here’s how it stacks up:</p> <ul> <li><strong>Package Management</strong>: Rust’s package manager, cargo, simplifies dependencies and builds. No more convoluted Gradle configurations.</li> <li><strong>IDEs</strong>: Rust’s integration with VS Code and IntelliJ (via rust-analyzer) is seamless, making it easy for your developers to dive right in.</li> <li><strong>CI/CD</strong>: GitHub Actions and other CI tools work beautifully with Rust, with dedicated actions for testing and deployment.</li> <li><strong>Debugging</strong>: Debugging tools work out of the box, and IDE integrations are robust by now.</li> <li><strong>Linting and Formatting</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/">Rustfmt</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/stable/index.html">clippy</a> ensure consistent code style and catch common errors early. They actively help your team write better code.</li> </ul> <p>However, also consider the constraints and risks your project might face—proprietary tools, unusual databases, or special dependencies. Do the research upfront to avoid surprises. And if you need new libraries, be prepared to get your hands dirty and write your own.</p> <p>For example, if you’re building a web application, Rust has several frameworks to choose from, with the most popular being <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/axum">axum</a>, but none as mature as Spring Boot. Projects like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/LukeMathWalker/pavex">Pavex</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://loco.rs/">Loco</a> could fill this gap, but they’re still in early stages.</p> <h2 id="tip-6-simplify-your-deployment-pipeline"><a class="zola-anchor" href="#tip-6-simplify-your-deployment-pipeline" aria-label="Anchor link for: tip-6-simplify-your-deployment-pipeline">Tip 6: Simplify Your Deployment Pipeline</a></h2> <p>Rust shines when it comes to cross-platform builds. Unlike Java, where you often need to install a runtime (like the JVM) on every machine, Rust’s binaries are small, self-contained, and ready to run anywhere.</p> <p>Rust compiles directly to machine code, which means you don’t need to worry about dependencies that are typically required by dynamic runtimes. The only consideration might be system libraries (like OpenSSL), but this is manageable with established solutions. <sup class="footnote-reference" id="fr-1-1"><a href="#fn-1">1</a></sup></p> <p>In containerized environments, Docker works just as well with Rust as with any other language, and it’s easier to scale because of Rust’s low overhead. Whether you’re running on AWS, Cloud Run, or any other platform, the experience is reliable and consistent.</p> <p>Rust supports a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/nightly/rustc/platform-support.html">wide variety of platforms</a>, including ARM and x64, and can be used seamlessly across development machines, servers, and the cloud.</p> <h2 id="tip-7-don-t-focus-on-raw-performance-alone"><a class="zola-anchor" href="#tip-7-don-t-focus-on-raw-performance-alone" aria-label="Anchor link for: tip-7-don-t-focus-on-raw-performance-alone">Tip 7: Don’t Focus On Raw Performance Alone</a></h2> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.sergetoro.com/microbench-go-java-rust-js-python/">Yes, Rust has awesome runtime performance.</a> But you shouldn’t focus on raw numbers alone. Thanks to technologies like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.graalvm.org/">GraalVM</a>, Java can be very fast as well, especially for long-running applications.</p> <a href="https://blog.consol.de/software-engineering/web-application-development/rust-vs-quarkus-native-vs-spring-native/"> <img src="bench.png" alt="Rust vs Quarkus"> </a> <p>The image above shows a comparison between Rust, Quarkus-Native, and Spring-Native. In terms of raw performance, Rust is the clear winner. Rust uses 12 MB RAM and less than a third of the CPU power of both Quarkus-Native and Spring-Native.</p> <p>When you migrate to Rust, also consider the secondary effects of improved performance:</p> <ul> <li><strong>Lower Latency</strong>: Rust doesn’t have the pauses or unpredictability that garbage collection introduces in Java. This makes it easier to predict system performance, especially during peak load.</li> <li><strong>Higher Throughput</strong>: Rust’s memory model and zero-cost abstractions make it ideal for handling high-volume, high-concurrency applications. Expect performance boosts, often between 2x and 3x, depending on the workload.</li> <li><strong>Lower Resource Usage</strong>: After migrating to Rust, you’ll likely need fewer CPUs or instances to handle the same load. This means less infrastructure to manage and lower costs in production.</li> <li><strong>Fast Scalability</strong>: Rust’s low overhead means you can scale up or down quickly. Whether you’re running on Kubernetes or a traditional VM, Rust’s efficiency makes it easier to manage your infrastructure. In contrast, this is a common pain point for Java applications in the cloud. It can take 30 seconds or more until a new JVM instance <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ibm.com/docs/en/sdk-java-technology/8?topic=reference-jit-compiler">JIT-compiles</a> your code, which can lead to cold start issues.</li> </ul> <p>Based on my experience helping teams migrate to Rust, here are some ballpark improvements you might see:</p> <ul> <li> <p><strong>Memory Usage</strong>: For data-heavy applications, expect to see 30-50% reduction in heap size for most services. This is a very conservative estimate. Depending on your workload, you might see even more significant improvements.</p> </li> <li> <p><strong>Startup Time</strong>: While Java services often need 20-30 seconds to warm up in production, equivalent Rust services typically start in under a second. This makes a big difference for scaling containerized deployments.</p> </li> <li> <p><strong>Latency</strong>: The exact numbers vary widely, but you’ll often see P95 latency improve by 40-60%. The biggest win is usually in tail latencies (P99.9) due to the lack of GC pauses.</p> </li> <li> <p><strong>Throughput</strong>: Again, this depends heavily on your workload, but teams I’ve worked with typically see:</p> <ul> <li>CPU-bound tasks: 2-3x improvement</li> <li>I/O-bound tasks with high concurrency: 1.5-2x improvement</li> <li>Most importantly, throughput becomes more consistent and predictable</li> </ul> </li> <li> <p><strong>Resource Costs</strong>: Several teams have managed to cut their cloud costs by 40-60% after migration, mainly due to lower CPU and memory requirements.</p> </li> </ul> <p>These are rough numbers from my consulting experience, and your results may vary significantly depending on your specific use case. The key takeaway isn’t the exact numbers, but rather that teams consistently see meaningful improvements across different metrics.</p> <p>Rust helps you get more done with less, making it easier to scale and manage your infrastructure.</p> <h2 id="tip-8-fearless-concurrency"><a class="zola-anchor" href="#tip-8-fearless-concurrency" aria-label="Anchor link for: tip-8-fearless-concurrency">Tip 8: Fearless Concurrency</a></h2> <p>Rust’s concurrency model is a major advantage. Traditional Java applications tend to be thread-heavy, and while this works on modern Linux systems, Rust offers more flexibility. On top of that, concurrency in Java can be tricky to get right and is therefore often avoided.</p> <p>Rust gives you both thread-based concurrency and async execution. With libraries like Tokio, you can use async/await without worrying about the underlying mechanics. It scales incredibly well, often in ways that Java simply can’t match due to its reliance on threads.</p> <p>What’s powerful about Rust’s concurrency is how it’s baked into the language itself. It’s not something your team has to think about too much. The libraries handle most of the heavy lifting, and once you structure your code properly, Rust’s runtime handles the rest.</p> <p>Rust’s memory management ensures that concurrency is safe, so you won’t need to worry about thread synchronization issues like you would in Java.</p> <h2 id="tip-9-reliable-production-environments"><a class="zola-anchor" href="#tip-9-reliable-production-environments" aria-label="Anchor link for: tip-9-reliable-production-environments">Tip 9: Reliable Production Environments</a></h2> <p>One of Rust’s underrated strengths is developer ergonomics.</p> <p>With Rust’s strict compiler checks, a lot of potential bugs are caught during development, meaning fewer bugs in production. This leads to fewer code reviews and a smoother development process overall. You can move faster with more confidence.</p> <p>Over time, this leads to <strong>more reliable code in production</strong>. Rust’s emphasis on memory safety and strict typing means that, once your system is built, you’re less likely to face random crashes or bugs. This saves on-call costs and reduces the risk of downtime.</p> <p>There are no garbage collector pauses to worry about, and the code has a predictable performance profile. You’ll have a “boring” production environment in the best way possible — things will work consistently and predictably.</p> <p>Rust is committed to stability. While some core libraries haven’t reached a stable 1.0 version yet, the 0.x versions are highly reliable, with breaking changes becoming less frequent over time. When Rust releases new versions, they follow <strong>semantic versioning</strong>, so updates are usually predictable and don’t introduce surprises.</p> <p>If you’re worried about future-proofing your application, Rust’s ecosystem is built with long-term support in mind. If you do encounter missing functionality, you’ll often need to contribute back to the community—this is part of the Rust philosophy.</p> <p>Training your team in Rust isn’t just about the immediate migration. Even if you eventually decide to stick with Java, Rust’s focus on good practices will make your developers better overall.</p> <h2 id="tip-10-make-the-decision-together"><a class="zola-anchor" href="#tip-10-make-the-decision-together" aria-label="Anchor link for: tip-10-make-the-decision-together">Tip 10: Make The Decision Together</a></h2> <p>Adopting Rust is a big commitment. Don’t make the decision in a vacuum — involve your team in the process. They’re the ones who will be working with Rust day in and day out, so their input is crucial.</p> <p>If you’re considering a migration, start by discussing the benefits and challenges of Rust. What are your hopes for Rust? What are the alternatives considered? What are your key KPIs for success? What is the skill level of your team, and how can you support them in learning Rust? It helps to put your thoughts into writing and share them with the team.</p> <p>On that note, hiring Rust developers can be challenging. It’s a relatively new language, and most Rust developers don’t have any production experience yet. Instead, consider upskilling your existing Java developers. They already know your systems and can learn Rust with the right training and support.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>At the end of the day, Rust’s investment pays off. Even if you don’t go full Rust, the knowledge gained will make your developers better programmers.</p> <p>If you’d like to discuss this further, feel free to book a call with me. I offer consulting services to help you make the right decisions for your project – even if that means sticking with Java.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Make the most of Rust</p> </h4> </div> <p>Is your company considering to migrate from Java to Rust? I offer consulting services to get you up to speed with your Rust projects, from training your team to code reviews and architecture consulting. <a href="/services">Get in touch for a free consultation</a>.</p> </div> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-1"> <p>For example, you can <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/openssl/latest/openssl/#vendored">vendor OpenSSL to build it statically</a>. <a href="#fr-1-1">↩</a></p> </li> </ol> </section> Mon, 09 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/learn/migration-guides/scala-to-rust/ https://corrode.dev/learn/migration-guides/scala-to-rust/ <p>There’s been increasing <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://degoes.net/articles/scala-resurrection">discussion about companies moving from Scala to Rust</a>). The Scala ecosystem faces, and while solutions are proposed, many organizations are evaluating Rust as an alternative path forward.</p> <p>Even former Scala advocates like Twitter or LinkedIn have <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=13478361">expressed concerns about their choice of Scala</a>:</p> <blockquote> <p>“We’ve recently made the decision to minimize our dependence on Scala in our next generation front end infrastructure which is rolling out this year.” — LinkedIn’s SVP of Eng Kevin Scott</p> </blockquote> <p>People are looking for guidance on how to navigate this transition, which is why I’ve written this guide for organizations considering migrating from Scala or Clojure to Rust. We will take a cold hard look at the benefits and challenges of moving to Rust, and provide practical advice for making the switch.</p> <h2 id="why-consider-rust"><a class="zola-anchor" href="#why-consider-rust" aria-label="Anchor link for: why-consider-rust">Why Consider Rust?</a></h2> <h3 id="industry-adoption-and-momentum"><a class="zola-anchor" href="#industry-adoption-and-momentum" aria-label="Anchor link for: industry-adoption-and-momentum">Industry Adoption and Momentum</a></h3> <p>The most striking difference between Rust and JVM functional languages is the <strong>pace of adoption</strong>. Rust has seen extraordinary growth, with over 2.8 million developers using it professionally. <a href="/blog/why-rust">Major tech companies including Microsoft, Google, and Meta have embraced Rust</a>, particularly for performance-critical systems. This widespread adoption has created a virtuous cycle: the larger talent pool makes hiring easier, which encourages more companies to adopt Rust, which in turn drives more developers to learn the language. The ecosystem grows more robust by the day, with new tools and libraries constantly emerging to solve real-world problems.</p> <p>In comparison, Scala and Clojure have seen slower growth and more limited industry adoption. While both languages have passionate communities and are well-suited to certain domains like data processing and Spark applications, they lack the broad appeal and momentum that Rust has achieved. This difference in adoption rates can affect your organization’s ability to hire and retain talent, which is a risk factor for any company.</p> <p>In fairness, the RedMonk rankings show that Scala has maintained a consistent position in the top 20 languages, while Rust has just recently broken into the top 20.</p> <a href="https://redmonk.com/rstephens/2024/09/12/top20-jun2024/"> <img src="redmonk-jun-2024.png" alt="RedMonk Language Popularity"> </a> <h3 id="stability-and-backward-compatibility"><a class="zola-anchor" href="#stability-and-backward-compatibility" aria-label="Anchor link for: stability-and-backward-compatibility">Stability and Backward Compatibility</a></h3> <p>One of Rust’s strongest selling points is its commitment to stability. Since its 1.0 release in 2015, Rust has maintained backward compatibility across <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://releases.rs/"><strong>more than 105 releases</strong></a>.</p> <p>Releases are cut every six weeks and roughly every 3 years a new edition is released, which allows the language to evolve while preserving compatibility with existing code. This stability is a significant advantage for organizations that need to maintain long-lived codebases or have strict requirements around backward compatibility.</p> <p><strong>Rust’s stability is a fundamental business advantage.</strong></p> <p>Code written in Rust 1.0 continues to compile and run today, protecting your investment in both code and developer training. Documentation and learning resources remain relevant for years, significantly reducing the ongoing cost of maintaining expertise in your organization. This stands in stark contrast to the breaking changes that have characterized many language ecosystems, including Scala’s transition from 2.x to 3.x.</p> <h3 id="superior-tooling-experience"><a class="zola-anchor" href="#superior-tooling-experience" aria-label="Anchor link for: superior-tooling-experience">Superior Tooling Experience</a></h3> <p>Rust’s tooling ecosystem, centered around Cargo, provides a remarkably smooth developer experience. Cargo unifies building, testing, and dependency management into a single, coherent tool that just works. The compiler’s error messages are legendary for their clarity and helpfulness, often telling developers exactly how to fix issues. IDE support through rust-analyzer and RustRover is rock-solid, providing a reliable development experience that boosts productivity. This tooling excellence isn’t an accident — it’s the result of deliberate design decisions and years of community investment.</p> <p>In Scala, build tools like sbt and dependency management tools like Maven can be complex and error-prone. IDE support, while improving, can be inconsistent across different editors and might not support all language features. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.scala-lang.org/t/what-are-some-of-the-advantages-of-using-scala-over-rust-c-and-other-native-languages/2556/10">The overall developer experience in Rust is more polished and consistent.</a></p> <h3 id="performance-with-safety"><a class="zola-anchor" href="#performance-with-safety" aria-label="Anchor link for: performance-with-safety">Performance with Safety</a></h3> <p>While Scala and Clojure offer good performance for JVM languages, Rust provides performance comparable to C/C++ while guaranteeing memory safety at compile time. This combination is particularly valuable in an era of cloud computing, where every millisecond of latency and every megabyte of memory directly affects operating costs. However, Scala developers should note that writing truly immutable code can actually be more challenging in Rust than in Scala.</p> <p>Rust’s predictable resource usage and lack of garbage collection pauses make it ideal for systems that require consistent performance. Organizations often find that moving performance-critical components to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/blog/why-rust/#cost-savings">Rust can significantly reduce their infrastructure costs</a>.</p> <h2 id="making-the-business-case"><a class="zola-anchor" href="#making-the-business-case" aria-label="Anchor link for: making-the-business-case">Making the Business Case</a></h2> <p>The business case for Rust extends beyond technical merits.</p> <ul> <li><strong>Infrastructure costs often decrease</strong> due to better performance and resource utilization.</li> <li><strong>Maintenance becomes more predictable</strong> thanks to superior tooling and compile-time guarantees.</li> <li><strong>The risk of production issues decreases</strong> due to Rust’s strong type system and ownership model catching many common bugs at compile time.</li> </ul> <p>Scala and Clojure developers typically transition well to Rust because the languages share many fundamental concepts. The emphasis on strong type systems, functional programming patterns, and correctness creates a natural bridge. While Rust’s ownership system presents a learning curve, developers coming from functional programming backgrounds often find they already think in ways that align well with Rust’s model.</p> <h2 id="migration-strategy"><a class="zola-anchor" href="#migration-strategy" aria-label="Anchor link for: migration-strategy">Migration Strategy</a></h2> <p>A successful migration to Rust typically starts small and grows organically. New microservices or standalone components are excellent candidates for initial Rust projects. Performance-critical systems that would benefit from lower latency or reduced resource usage are another natural starting point. Command-line tools and utilities offer low-risk opportunities to build team expertise.</p> <p>The key to successful migration is maintaining optionality. Rust’s excellent interop capabilities mean you can gradually introduce it alongside existing JVM services. This allows teams to learn and validate Rust’s benefits in your specific context without committing to a wholesale rewrite.</p> <h2 id="addressing-challenges"><a class="zola-anchor" href="#addressing-challenges" aria-label="Anchor link for: addressing-challenges">Addressing Challenges</a></h2> <p>The transition to Rust does present challenges. The ownership and borrowing concepts take time to master, though the compiler’s excellent error messages help guide developers through the learning process. The ecosystem, while growing rapidly, may not yet have direct equivalents for all specialized JVM libraries. Some internal tooling may need to be rebuilt or adapted.</p> <p>However, these challenges should be viewed in context. The learning curve, while steep, is finite — developers with a strong functional programming background typically become productive in Rust within a few months. The ecosystem limitations often push teams toward simpler, more maintainable solutions. And the need to rebuild tools can be an opportunity to improve and modernize development workflows.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>The decision to migrate from Scala/Clojure to Rust should be driven by specific business needs rather than following trends.</p> <p><strong>Consider Rust when performance and resource efficiency are crucial, when you need predictable latency and memory usage, when your team is ready for a new technical challenge, or when long-term stability and maintenance are priorities.</strong></p> <p>The transition requires investment, but Rust’s growing ecosystem, excellent tooling, and strong industry adoption make it an increasingly attractive option for organizations looking to move beyond the JVM while maintaining the benefits of strong typing and functional programming paradigms.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Is Your Team Considering a Migration to Rust?</p> </h4> </div> <p>I can help you evaluate your current systems, design a migration strategy, and help you make an informed decision about moving to Rust. I offer consulting services to help you assess the technical and business implications of a migration, and I can train your developers to succeed with Rust. <a href="/services">Get in touch for a free consultation</a>.</p> </div> Tue, 03 Dec 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/rust-conferences-2025/ https://corrode.dev/blog/rust-conferences-2025/ <div class="info"> <div class="info-header"> <span class="icon icon-ferris"></span> <h4><p>Looking for upcoming Rust conferences?</p> </h4> </div> <p>This page covers Rust conferences in 2025. For upcoming events, check out our <a href="/blog/rust-conferences-2026/">Rust Conferences 2026</a> page with dates, locations, ticket prices, CFP deadlines, and more.</p> </div> <p>Rustaceans like to mingle, learn, and share their knowledge at conferences. With 13 conferences happening in 2025, it was a busy year for the Rust community.</p> <h2 id="q1-2025"><a class="zola-anchor" href="#q1-2025" aria-label="Anchor link for: q1-2025">Q1 2025</a></h2> <h3 id="rust-nation-london-uk"><a class="zola-anchor" href="#rust-nation-london-uk" aria-label="Anchor link for: rust-nation-london-uk">Rust Nation (London, UK)</a></h3> <a href="https://www.rustnationuk.com/" target="_blank"> <img src="rustnation.jpg" alt="Rust Nation" /> </a> <p>Rust Nation has evolved into a staple event in the Rust community. The organization, speaker lineup, and recordings are always top-notch. It’s a great conference for Rust developers of all levels. As per tradition, they kick off the year of Rust conferences.</p> <button onclick="window.open('https://www.youtube.com/watch?v=fmtykJT1acM&list=PL1AoGvxomykSSFFL4Qav3wKzL-dsi9I5L', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: February 19-20, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/QakezC3gjkyo7sNr9">The Brewery, 52 Chiswell Street, London, EC1Y 4SD, UK</a></li> <li><strong>Format</strong>: 2 days (workshops + conference)</li> <li><strong>Focus</strong>: Rust ecosystem and community</li> <li><strong>Pricing</strong>: <ul> <li>Conference: $304 (early bird)</li> <li>Workshops: Starting at $300</li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustnationuk.com/schedule">Schedule</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustnationuk">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hachyderm.io/@Rustnationuk">Mastodon</a></li> </ul> <h3 id="rust-in-paris-france"><a class="zola-anchor" href="#rust-in-paris-france" aria-label="Anchor link for: rust-in-paris-france">Rust in Paris (France)</a></h3> <a href="https://rustinparis.com/" target="_blank"> <img src="rustinparis.jpg" alt="Rust in Paris" /> </a> <p>“When Safety Meets Elegance” is the tagline for Rust in Paris. It features 12 speakers, 1 day of talks, and 250 attendees.</p> <ul> <li><strong>When</strong>: March 14, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/VDAktMFd8KHMeZ36A">Maison.A Verso, 52 rue de la victoire, 75009 Paris - France</a></li> <li><strong>Format</strong>: 1 day conference</li> <li><strong>Focus</strong>: Building secure, high-performing software with Rust</li> <li><strong>Pricing</strong>: <ul> <li>Standard: $311 (early bird)</li> <li>Student: $124</li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustinparis.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustinparis.com/schedule">Schedule</a></li> </ul> <h3 id="rustmeet-gliwice-poland"><a class="zola-anchor" href="#rustmeet-gliwice-poland" aria-label="Anchor link for: rustmeet-gliwice-poland">RUSTMEET (Gliwice, Poland)</a></h3> <a href="https://rustmeet.eu/" target="_blank"> <img src="rustmeet.jpg" alt="RUSTMEET" /> </a> <p>An event in Poland, actively co-created by Rust enthusiasts.</p> <button onclick="window.open('https://www.youtube.com/watch?v=v3bpw7fcjp0&list=PLp10ZrVkzfVqLOjf9KXe25igeZXPNCwhL', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: March 15-16, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/38cqAgQBnDG7nNvM7">Gliwice, Poland</a></li> <li><strong>Format</strong>: 2 days (talks + workshops)</li> <li><strong>Focus</strong>: Rust programming language</li> <li><strong>Pricing</strong>: <ul> <li>Standard: $120</li> <li>Student: $20</li> </ul> </li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.confreg.pl/events/30-rustmeet-2025">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmeet.eu/">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/rustmeet/">LinkedIn</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://c.im/@rustmeet">Mastodon</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustmeet.bsky.social">BlueSky</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://discord.com/invite/CsVnFrYVzm">Discord</a></li> </ul> <h3 id="rustikon-warsaw-poland"><a class="zola-anchor" href="#rustikon-warsaw-poland" aria-label="Anchor link for: rustikon-warsaw-poland">Rustikon (Warsaw, Poland)</a></h3> <a href="https://www.rustikon.dev/" target="_blank"> <img src="rustikon.jpg" alt="Rustikon" /> </a> <p>Aims to bring together Rust developers from the region and beyond. Expect a developer-friendly atmosphere with ~15 expert talks in a single-track format, perfect for staying connected and engaged. After a day of learning, unwind with us in a local pub and network with fellow devs.</p> <button onclick="window.open('https://www.youtube.com/watch?v=4QkLD7JhD_I&list=PL8NC5lCgGs6MnMLJvhFH2jLa8bLYwCzmI', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: March 26, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/XKR76zuE2D8XbZMp6">POLIN Conference Centre, Warsaw</a></li> <li><strong>Format</strong>: 1 day conference</li> <li><strong>Focus</strong>: Rust adoption in Poland and beyond</li> <li><strong>Pricing</strong>: <ul> <li>Standard: $172</li> <li>Student: $12</li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustikon.dev/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustikon.dev/tickets">Tickets</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://softwaremill.com/why-attend-a-rust-conference-for-developers-rustikon/">Announcement</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustikonconf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.social/@Rustikon">Mastodon</a></li> </ul> <h3 id="rustasia-hong-kong"><a class="zola-anchor" href="#rustasia-hong-kong" aria-label="Anchor link for: rustasia-hong-kong">RUSTAsia (Hong Kong)</a></h3> <a target="_blank"> <img src="rustasia.jpg" alt="RUSTAsia" /> </a> <p>Another first-time event, RUSTAsia is a conference for Rust developers in Asia. After many years without a Rust conference in Asia (the last one being RustCon Asia in 2019), the community is excited to have a new event in Hong Kong.</p> <ul> <li><strong>When</strong>: March 28, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/fcQqo9YCpnDgjjnP6">InnoCentre, Kowloon Tong, Hong Kong</a></li> <li><strong>Format</strong>: Hybrid (in-person + online)</li> <li><strong>Focus</strong>: Rust in Asia</li> <li><strong>Pricing</strong>: <ul> <li>Online: $68</li> <li>Standard: $245 (early bird)</li> <li>VIP: $375</li> <li>Corporate: $450</li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: Website offline</li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustasiaconf">Twitter</a></li> </ul> <h2 id="q2-2025"><a class="zola-anchor" href="#q2-2025" aria-label="Anchor link for: q2-2025">Q2 2025</a></h2> <h3 id="rust-konf-turkiye-istanbul"><a class="zola-anchor" href="#rust-konf-turkiye-istanbul" aria-label="Anchor link for: rust-konf-turkiye-istanbul">Rust Konf Türkiye (Istanbul)</a></h3> <a href="https://kommunity.com/turkiye-rust-community/events/rust-konf-turkiye-@-april-20-2025" target="_blank"> <img src="rustkonf-turkiye.jpg" alt="Rust Konf Türkiye" /> </a> <p>The first-ever Rust conference in Turkey, bringing together Rust developers and enthusiasts for a day of technical talks, workshops, and networking. The event will feature in-depth technical sessions on low-level programming, performance optimization, system-level development, and eBPF.</p> <ul> <li><strong>When</strong>: April 20, 2025</li> <li><strong>Where</strong>: Istanbul, Turkey (venue TBA)</li> <li><strong>Format</strong>: 1 day (talks + workshops)</li> <li><strong>Focus</strong>: Low-level programming, system development, and Rust ecosystem</li> <li><strong>Pricing</strong>: Free</li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kommunity.com/turkiye-rust-community/events/rust-konf-turkiye-91f7b3a6">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/turkiyerustcom">Twitter</a></li> </ul> <h3 id="rustweek-utrecht-netherlands"><a class="zola-anchor" href="#rustweek-utrecht-netherlands" aria-label="Anchor link for: rustweek-utrecht-netherlands">RustWeek (Utrecht, Netherlands)</a></h3> <a href="https://rustweek.org/" target="_blank"> <img src="rustweek.jpg" alt="RustWeek" /> </a> <p>RustWeek is a week-long event that combines talks, workshops, and social events. It’s located in cozy Utrecht, the fourth-largest city in the Netherlands. This is organized by the team behind RustNL. RustWeek takes place during the 10 year anniversary of Rust 1.0. All Rustaceans are welcome to attend and submit talks.</p> <button onclick="window.open('https://www.youtube.com/playlist?list=PL8Q1w7Ff68DCEXiGidlM0DMn8ztjlUlez', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: May 12-17, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/NfdQrMmPHEpy3ZZMA">Kinepolis Utrecht</a></li> <li><strong>Format</strong>: Full week (2 days talks + 1 day workshops + social events)</li> <li><strong>Focus</strong>: Broad, open to everyone</li> <li><strong>Pricing</strong> (Early Bird): <ul> <li>Standard: $197</li> <li>Company: $390</li> <li>Conference + Workshop: $343 (Individual) / $592 (Company)</li> <li>Student: $31</li> </ul> </li> <li><strong>CfP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.papercall.io/rust-week">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustweek.org/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustnederlandrustnl">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustnl.bsky.social">BlueSky</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fosstodon.org/@rustnl">Mastodon</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/rustnl/">LinkedIn</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/Rust_NL">Twitter</a></li> </ul> <h3 id="rust-summit-belgrade-serbia"><a class="zola-anchor" href="#rust-summit-belgrade-serbia" aria-label="Anchor link for: rust-summit-belgrade-serbia">Rust Summit (Belgrade, Serbia)</a></h3> <a href="https://rustsummit.com/" target="_blank"> <img src="rustsummit.jpg" alt="Rust Summit" /> </a> <p>The first conference for Rust blockchain professionals.</p> <p>The Rust Summit is first-of-its-kind chain-agnostic conference, featuring expert talks, workshops, and networking opportunities for Rust blockchain professionals. It is open to all Rust developers active in the web3 and blockchain sectors and those who are interested in it.</p> <ul> <li><strong>When</strong>: June 7, 2025</li> <li><strong>Where</strong>: Belgrade, Serbia</li> <li><strong>Format</strong>: 1 day conference</li> <li><strong>Focus</strong>: Blockchain</li> <li><strong>Pricing</strong>: $73 (General Admission)</li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://forms.gle/3VTuvYHhXmzwTLeU9">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustsummit.com/">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rust_summit">Twitter</a></li> </ul> <h2 id="q3-2025"><a class="zola-anchor" href="#q3-2025" aria-label="Anchor link for: q3-2025">Q3 2025</a></h2> <h3 id="rustforge-wellington-new-zealand"><a class="zola-anchor" href="#rustforge-wellington-new-zealand" aria-label="Anchor link for: rustforge-wellington-new-zealand">RustForge (Wellington, New Zealand)</a></h3> <a href="https://rustforgeconf.com/" target="_blank"> <img src="rustforge.jpg" alt="RustForge" /> </a> <p>RustForge is the first conference in the Asia/Pacific region that focuses on Rust.</p> <button onclick="window.open('https://www.youtube.com/watch?v=es48dmNWMVQ', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: August 27-30, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/PDbFTB5Gqs5iVmeNA">Shed 6, Wellington, New Zealand</a></li> <li><strong>Format</strong>: 4 days (2 days workshops + 2 days conference)</li> <li><strong>Focus</strong>: Community-focused conference with emphasis on hallway track</li> <li><strong>Pricing</strong>: <ul> <li>Conference: $225</li> <li>Workshops: $425</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-forge-2025.lilregie.com/booking/attendees/new">Get tickets here</a></li> </ul> </li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://pretalx.com/rust-forge-2025/cfp">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustforgeconf.com/">Website</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustforgeconf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/company/rustforgeconf/">LinkedIn</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.instagram.com/rustforgeconf/">Instagram</a></li> </ul> <h3 id="rustconf-seattle-washington-usa"><a class="zola-anchor" href="#rustconf-seattle-washington-usa" aria-label="Anchor link for: rustconf-seattle-washington-usa">RustConf (Seattle, Washington, USA)</a></h3> <a href="https://rustconf.com/" target="_blank"> <img src="rustconf.jpg" alt="RustConf" /> </a> <p>RustConf is the official Rust conference organized by the Rust Foundation. It’s a great place to meet the Rust core team and other community members. The last edition was held in Montreal, Canada and the 2025 edition will be announced soon.</p> <button onclick="window.open('https://www.youtube.com/watch?v=dA-uv3yCMZc&list=PL2b0df3jKKiRFEuVNk76ufXagOgEJ9sBZ', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: September 2-5, 2025</li> <li><strong>Where</strong>: Seattle, Washington, USA</li> <li><strong>Format</strong>: 4 days (1 day workshops + 3 days talks)</li> <li><strong>Focus</strong>: Official Rust conference</li> <li><strong>Pricing</strong>: <ul> <li>Regular: $525</li> <li>Corporate: $775</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustconf.com/register/">Get tickets here</a></li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustconf.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustfoundation">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hachyderm.io/@rustconf">Mastodon</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bsky.app/profile/rustconf.com">BlueSky</a></li> </ul> <h3 id="oxidize-berlin-germany"><a class="zola-anchor" href="#oxidize-berlin-germany" aria-label="Anchor link for: oxidize-berlin-germany">Oxidize (Berlin, Germany)</a></h3> <a href="https://oxidizeconf.com/" target="_blank"> <img src="oxidize.jpg" alt="Oxidize" /> </a> <p>Two days of applied Rust insights from industry innovators. Topics range from cross-platform GUI development to Rust in safety-critical systems.</p> <button onclick="window.open('https://www.youtube.com/watch?v=jyGVk2aMEjE&list=PLilpJp3WAOvcn5_VDv3VIkQzniMWl_BfO', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: September 16-18, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/Q3SzoU7EDJv4kxnHA">Tagungswerk, Berlin, Germany</a></li> <li><strong>Format</strong>: 3 days (1 day workshops + 2 days talks)</li> <li><strong>Focus</strong>: Applied Rust insights</li> <li><strong>Pricing</strong>: <ul> <li>Conference only: €505.75</li> <li>Workshop + Conference: €653.31</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ti.to/asquera-event-ug/oxidize-conference-2025">Get tickets here</a></li> </ul> </li> <li><strong>CFP</strong>: Closed</li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://oxidizeconf.com/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@OxidizeConf">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/OxidizeConf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://social.ferrous-systems.com/@oxidize">Mastodon</a></li> </ul> <h2 id="q4-2025"><a class="zola-anchor" href="#q4-2025" aria-label="Anchor link for: q4-2025">Q4 2025</a></h2> <h3 id="eurorust-paris-france"><a class="zola-anchor" href="#eurorust-paris-france" aria-label="Anchor link for: eurorust-paris-france">EuroRust (Paris, France)</a></h3> <a href="https://eurorust.eu/" target="_blank"> <img src="eurorust.jpg" alt="EuroRust" /> </a> <p>One of the largest Rust conferences in Europe and a well-established event in the Rust community. It’s a 2 day conference that covers all things Rust: from Rust patterns and idioms to system programming and CLI tooling, servers WASM and embedded systems.</p> <p>The conference travels to a different European city each year. This time, it’s in Paris, France. 🥖</p> <button onclick="window.open('https://www.youtube.com/watch?v=4sYzxv6YijI&list=PLH6-VpZ3SvUUO_lfxniFmyKxUMngBOWFg', '_blank')" class="button" style="display: inline-flex; align-items: center; gap: 8px;"> <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor"> <path d="M8 5v14l11-7z"/> </svg> Recordings Available </button> <ul> <li><strong>When</strong>: October 9-10, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maps.app.goo.gl/4SNzfvFVF3VqMDY5A">Cité des Sciences et de l’Industrie, Paris, France</a></li> <li><strong>Format</strong>: 2 days talks</li> <li><strong>Focus</strong>: Rust patterns, idioms, system programming, CLI tooling, servers, WASM, embedded systems</li> <li><strong>Pricing</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ti.to/events-matter/eurorust-2025">Get tickets here</a></li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.papercall.io/eurorust-2025">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://eurorust.eu/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@eurorust">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/euro_rust">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fosstodon.org/@eurorust">Mastodon</a></li> </ul> <h3 id="rustlab-florence-italy"><a class="zola-anchor" href="#rustlab-florence-italy" aria-label="Anchor link for: rustlab-florence-italy">RustLab (Florence, Italy)</a></h3> <a href="https://rustlab.it/" target="_blank"> <img src="rustlab.jpg" alt="RustLab" /> </a> <p>The Italian Rust conference traditionally takes place in Florence. It’s lovingly organized featuring delicious italian food and a great community.</p> <ul> <li><strong>When</strong>: November 2-4, 2025</li> <li><strong>Where</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://goo.gl/maps/8ZRuugSHEfebowwi7">Grand Hotel Mediterraneo Lungarno del Tempio, 44, 50121 Florence, Italy</a></li> <li><strong>Format</strong>: 3 days (1 day workshops + 2 days talks)</li> <li><strong>Focus</strong>: Rust in Italy and beyond</li> <li><strong>Pricing</strong>: <ul> <li>270€ Regular Ticket</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustlab.it/tickets25">Get tickets here</a></li> </ul> </li> <li><strong>CFP</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://sessionize.com/rustlab-2025/">Closed</a></li> <li><strong>Links</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustlab.it/">Website</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/@rustlabconference3671">Past Talks</a></li> <li><strong>Social</strong>: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/rustlab_conf">Twitter</a> | <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.uno/@rustlab">Mastodon</a></li> </ul> <hr /> <p>That was the complete lineup of Rust conferences for 2025! From London to Hong Kong to Seattle, there was something for every Rustacean. See you at the next conference! 🦀</p> Thu, 28 Nov 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e04-gitbutler/ https://corrode.dev/podcast/s03e04-gitbutler/ <div><script id="letscast-player-4553b0d1" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/gitbutler-with-scott-chacon-and-kiril-videlov/player.js?size=s"></script></div> Version control is a critical part of any modern software project and git is the most popular tool for the job. But it can be complex and confusing, especially for beginners. <p>The team behind GitButler believes there is a better way.</p> <p>They are building a modern Git client that streamlines the process of managing branches, backing up your work, and more. We hear from co-founders Scott Chacon and Kiril Videlov about how they’re making Git easier for everyone – all without sacrificing the power and flexibility that makes Git so popular in the first place.</p> Thu, 14 Nov 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e03-oxide/ https://corrode.dev/podcast/s03e03-oxide/ <div><script id="letscast-player-97aa1056" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/oxide-s-steve-klabnik/player.js?size=s"></script></div> <p>What’s even cooler than writing your own <a href="/podcast/s03e01-zed/">text editor</a> or your own <a href="/podcast/s02e07-system76/">operating system</a>? Building your own hardware from scratch with all the software written in Rust – including firmware, the scheduler, and the hypervisor. Oxide Computer Company is one of the most admired companies in the Rust community. They are building “servers as they should be” with a focus on security and performance to serve the needs of modern on-premise data centers.</p> <p>In this episode, I talk to Steve Klabnik, a software engineer at Oxide and renowned Rustacean, about the advantages of building hardware and software in tandem, the benefits of using Rust for systems programming, and the state of the Rust ecosystem.</p> Thu, 31 Oct 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e02-infinyon/ https://corrode.dev/podcast/s03e02-infinyon/ <div><script id="letscast-player-6790863d" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/infinyon-s-debadyuti-roy-chowdhury/player.js?size=s"></script></div> <p>Picture this: Your organization’s data infrastructure resembles a busy kitchen with too many cooks. You’re juggling Kafka for messaging, Flink for processing, Spark for analytics, Airflow for orchestration, and various Lambda functions scattered about. Each tool excellent at its job, but together they’ve created a complex feast of integration challenges. Your data teams are spending more time managing tools than extracting value from data.</p> <p>InfinyOn reimagines this chaos with a radically simple approach: a unified system for data streaming that runs everywhere. Unlike traditional solutions that struggle at the edge, InfinyOn gracefully handles data streams from IoT devices to cloud servers. And instead of cobbling together different tools, developers can build complete data pipelines using their preferred languages - be it Rust, Python, or SQL - with built-in state management.</p> <p>At the heart of InfinyOn is Fluvio, a Rust-based data streaming platform that’s fast, reliable, and easy to use.</p> Thu, 17 Oct 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s03e01-zed/ https://corrode.dev/podcast/s03e01-zed/ <div><script id="letscast-player-b1a26f96" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/zed-with-conrad-irwin/player.js?size=s"></script></div> <p><a href="/podcast/s02e07-system76/">Next to writing their own operating system</a>, another dream shared by many developers is building their own text editor. Conrad Irwin, a software engineer at Zed, is doing just that. Zed is a fully extensible, open-source text editor written entirely in Rust. It’s fast, lightweight, and comes with excellent language support out of the box.</p> <p>In the first episode of the third season, I sit down with Conrad to discuss Zed’s mission to build a next-generation text editor and why it was necessary to rebuild the very foundation of text editing software from scratch to achieve their goals.</p> Thu, 29 Aug 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/rust-option-handling-best-practices/ https://corrode.dev/blog/rust-option-handling-best-practices/ <p>I noticed that handling the <code>None</code> variant of <code>Option</code> without falling back on <code>unwrap()</code> is a common papercut in Rust. More specifically, the problem arises when you want to return early from a function that returns a <code>Result</code> if you encounter <code>None</code>.</p> <p>It has been discussed a million times already, but, surprisingly, not even the Rust book mentions my favorite approach to handling that, and many forum posts are outdated.</p> <p>With a bit of practice, robust handling of <code>None</code> can become as easy as <code>unwrap()</code>, but safer.</p> <p>Jump to the end if you’re in a hurry and just need a quick recommendation.</p> <h2 id="the-problem"><a class="zola-anchor" href="#the-problem" aria-label="Anchor link for: the-problem">The Problem</a></h2> <p>Very commonly, people write code like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Assume that this fetches the user from somewhere</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with `user`</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The goal here is to return early if you encounter <code>None</code> in an <code>Option</code>, so they use the <code>?</code> operator to propagate errors.</p> <p>Alas, this code doesn’t compile. Instead, you get a dreaded error message:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>error[</span><span style="color: #8BE9FD;font-style: italic;">E0277</span><span>]</span><span style="color: #FF79C6;">:</span><span> the `</span><span style="color: #FF79C6;">?</span><span>` operator can only be used on `</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>`s, not `</span><span style="color: #8BE9FD;font-style: italic;">Option</span><span>`s,</span><span style="color: #FF79C6;"> in</span><span> a function that returns `</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>`</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> --&gt;</span><span> src</span><span style="color: #FF79C6;">/</span><span>lib</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">10</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">26</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #BD93F9;">9</span><span style="color: #FF79C6;"> | fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ------------------------------------</span><span> this function returns a `</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>`</span></span> <span class="giallo-l"><span style="color: #BD93F9;">10</span><span style="color: #FF79C6;"> | let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ^ use</span><span> `</span><span style="color: #FF79C6;">.</span><span>ok_or(</span><span style="color: #FF79C6;">...</span><span>)</span><span style="color: #FF79C6;">?</span><span>` to provide an error compatible with `std</span><span style="color: #FF79C6;">::</span><span>result</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt;&gt;`</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> =</span><span> help</span><span style="color: #FF79C6;">:</span><span> the </span><span style="color: #FF79C6;">trait</span><span> `</span><span style="color: #8BE9FD;font-style: italic;">FromResidual</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Infallible</span><span>&gt;&gt;` is not implemented </span><span style="color: #FF79C6;">for</span><span> `std</span><span style="color: #FF79C6;">::</span><span>result</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt;&gt;`</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> =</span><span> help</span><span style="color: #FF79C6;">:</span><span> the following other types implement </span><span style="color: #FF79C6;">trait</span><span> `</span><span style="color: #8BE9FD;font-style: italic;">FromResidual</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">R</span><span>&gt;`</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span> &lt;std</span><span style="color: #FF79C6;">::</span><span>result</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> F</span><span>&gt;</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> FromResidual</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Yeet</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">E</span><span>&gt;&gt;&gt;</span></span> <span class="giallo-l"><span> &lt;std</span><span style="color: #FF79C6;">::</span><span>result</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> F</span><span>&gt;</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> FromResidual</span><span>&lt;std</span><span style="color: #FF79C6;">::</span><span>result</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Infallible</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> E</span><span>&gt;&gt;&gt;</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=7001ff6af6c0bcbf44249691d65b086f">Rust Playground</a>)</p> <p>Ouch. This is scary-looking!</p> <p>There’s a lot of visual noise in this error message. The <code>FromResidual</code> and <code>Yeet</code> are implementation details which could be confusing to a new user, and the relevant details are somewhat obscured.</p> <p><strong>And all we did was try to use the <code>?</code> operator for our <code>Option</code>.</strong></p> <p>My main gripe with this error message is that it doesn’t explain <em>why</em> the <code>?</code> operator doesn’t work with <code>Option</code> in that case… just that it doesn’t.</p> <h2 id="what-people-end-up-doing"><a class="zola-anchor" href="#what-people-end-up-doing" aria-label="Anchor link for: what-people-end-up-doing">What People End Up Doing</a></h2> <p>The most common approach I see is this:</p> <ul> <li>People are confused for a bit.</li> <li>They try to understand the error message.</li> <li>Eventually, they give up and just add <code>unwrap()</code>.</li> <li>They make a mental note to come back to it later.</li> <li>‘Later’ never comes.</li> </ul> <p>Here’s what they end up with:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap</span><span>();</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with `user`</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In trainings, I noticed that people are often too embarrassed to ask for help. They think people are supposed to <em>“get this”</em> and they are the only ones who don’t.</p> <p>This just defers the problem. The user of the function might hit a <code>panic</code> at runtime. That user might be their future self.</p> <p><code>unwrap</code> is fine in many cases, but it shouldn’t be the first intuition for dealing with unexpected situations. Especially when you’re writing a library or a function that is part of a larger codebase, you should strive to handle such situations gracefully. And in production code, it sets a bad example: one <code>unwrap</code> attracts another and the codebase becomes more fragile as you continue down this path. <sup class="footnote-reference" id="fr-2-1"><a href="#fn-2">1</a></sup></p> <p>Okay, I’ve kept you waiting long enough. Let’s demystify this error message.</p> <h2 id="the-actual-problem"><a class="zola-anchor" href="#the-actual-problem" aria-label="Anchor link for: the-actual-problem">The Actual Problem</a></h2> <p>What the compiler is trying to tell us is that <strong>you can’t propagate optionals within functions which return <code>Result</code></strong>.</p> <p>Everything works just fine if you’re returning an <code>Option</code> instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Works :)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with `user`</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>So if you can change the outer function to return an <code>Option</code> instead, you won’t run into the above error message. There’s more info in the Rust documentation <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/option/index.html#the-question-mark-operator-">here</a>.</p> <p>But what if the final return type of your function has to be a <code>Result</code> or if you want to convey more information about the missing value to the caller? After all, communicating the distinction between different <code>None</code> values can be helpful to the user of your function.</p> <p>So, what if you <em>really</em> want your code to look like this?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Doesn&#39;t work because we return a `Result`</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Some more, fallible operations, here</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Return a `Result`</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Well, that’s just a type error: <code>get_user()</code> returns an <code>Option</code>, but the outer function expects a <code>Result</code>.</p> <p>Our problem statement becomes easier:<br /> <strong>How to return a helpful error message when an <code>Option</code> is <code>None</code> in this case?</strong></p> <p>Turns out, there are multiple solutions!</p> <h2 id="solution-1-change-the-return-type"><a class="zola-anchor" href="#solution-1-change-the-return-type" aria-label="Anchor link for: solution-1-change-the-return-type">Solution 1: change the return type</a></h2> <p>If “not having a value” is truly an error condition in your program’s logic, you should use <code>Result</code> instead of <code>Option</code>. <code>Option</code> is best used when the absence of a value is a normal, expected possibility, not an error state.</p> <p>In our case, if you can change <code>get_user()</code> to return a <code>Result</code> instead of an <code>Option</code>, you can use the <code>?</code> operator as you intended:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #F1FA8C;">&quot;Alice&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with `user`</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>However, you might not be able to change <code>get_user()</code> to return a <code>Result</code> for various reasons, for example, if it’s part of a library or if it’s used in many places or if other callers don’t treat the absence of a user as an error.</p> <p>In that case, read on!</p> <h2 id="solution-2-ok-or-else-ok-or"><a class="zola-anchor" href="#solution-2-ok-or-else-ok-or" aria-label="Anchor link for: solution-2-ok-or-else-ok-or">Solution 2: <code>ok_or_else</code> / <code>ok_or</code></a></h2> <p>The initial error message, while cryptic, gave us a hint:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> `</span><span style="color: #FF79C6;">.</span><span>ok_or(</span><span style="color: #FF79C6;">...</span><span>)</span><span style="color: #FF79C6;">?</span><span>` to provide an error compatible with `</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;(),</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt;&gt;`</span><span style="color: #FF79C6;">.</span></span></code></pre> <p>The <code>ok_or</code> method converts an <code>Option</code> into a <code>Result</code> and allows us to specify what error should be returned when the <code>Option</code> is <code>None</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_user</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Convert Option to Result with a descriptive error</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or</span><span>(</span><span style="color: #F1FA8C;">&quot;User not found&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Continue processing with the unwrapped value</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #50FA7B;">format!</span><span>(</span><span style="color: #F1FA8C;">&quot;Processing user: {}&quot;</span><span>, user))</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This pattern is particularly useful when working with functions that return <code>Result</code> but need to handle values from functions that return <code>Option</code>. It also chains well in sequential operations:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_settings</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Settings</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or</span><span>(</span><span style="color: #F1FA8C;">&quot;User not found&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> profile</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_profile</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>user)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or</span><span>(</span><span style="color: #F1FA8C;">&quot;Profile not available&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> settings</span><span style="color: #FF79C6;"> =</span><span> profile</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">settings</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or</span><span>(</span><span style="color: #F1FA8C;">&quot;Settings missing&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(settings)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=d7d36e61c154e0380cce1f855c1e5067">Playground</a>)</p> <p>For cases where creating the error value involves expensive operations or side effects, prefer <code>ok_or_else</code> instead. It takes a closure that’s only evaluated if the <code>Option</code> is <code>None</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> authenticate_user</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">User</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This code only runs if get_user() returns None</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> log_auth_failure</span><span>();</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> format!</span><span>(</span><span style="color: #F1FA8C;">&quot;Authentication failed at {}&quot;</span><span>,</span><span style="color: #50FA7B;"> current_timestamp</span><span>())</span></span> <span class="giallo-l"><span> })</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If in doubt, use <code>ok_or_else</code>, because it only evaluates the closure if the <code>Option</code> is <code>None</code>, which is typically more efficient.</p> <p>The name <code>ok_or</code> might not be immediately intuitive to everyone. I find it a bit confusing myself and needed to look it up many times. That’s because <code>Ok</code> is commonly associated with the <code>Result</code> type, not <code>Option</code>. There’s <code>Option::Some</code>, so it could have been called <code>some_or</code>, which was <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/pull/17469#issuecomment-56919911">actually suggested in 2014</a>, but the name <code>ok_or</code> won out, because <code>ok_or(MyError)</code> reads nicely. Guess we have to live with the minor inconsistency now.</p> <p>I think <code>ok_or</code> and <code>ok_or_else</code> are quick solutions to the problem, but there are alternatives that might be more readable.</p> <p><strong>Side note:</strong> If you want to provide a fallback value (rather than propagate an error) when an <code>Option</code> is <code>None</code>, use <code>unwrap_or</code> or <code>unwrap_or_else</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Use a fallback value without error propagation</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> username</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap_or_else</span><span>(</span><span style="color: #FF79C6;">||</span><span style="color: #50FA7B;"> get_default_username</span><span>());</span></span></code></pre><h2 id="solution-3-match"><a class="zola-anchor" href="#solution-3-match" aria-label="Anchor link for: solution-3-match">Solution 3: <code>match</code></a></h2> <p>In the past, I used to recommend people to not be clever and just use a <code>match</code> statement.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> = match</span><span style="color: #50FA7B;"> get_user</span><span>() {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(user)</span><span style="color: #FF79C6;"> =&gt;</span><span> user,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> None</span><span style="color: #FF79C6;"> =&gt; return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;No user&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into</span><span>()),</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p><code>match</code> works in combination with <code>Option</code>, because it’s just an enum and we can pattern match on it. As long as we cover all cases, the compiler is happy. In this situation, we only have two cases: <code>Some</code> and <code>None</code>. In the <code>None</code> case, we return early with an error. In the <code>Some</code> case, we continue with the value. (<code>match</code> is an expression and the value of the last expression in the block is returned. In our case it’s <code>user</code> and it gets assigned to the <code>user</code> variable in the outer scope.)</p> <p>This is already more explicit and easier to understand for beginners. The one issue I had when teaching this was that it looked a bit more verbose for simple cases.</p> <h2 id="solution-4-let-else"><a class="zola-anchor" href="#solution-4-let-else" aria-label="Anchor link for: solution-4-let-else">Solution 4: <code>let-else</code></a></h2> <p>With Rust 1.65, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2022/11/03/Rust-1.65.0.html#let-else-statements">the <code>let-else</code> expression was stabilized</a>, so now you can write this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(user)</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;No user&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into</span><span>());</span></span> <span class="giallo-l"><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Do something with `user`</span></span></code></pre> <p>In my opinion, that’s the best of both worlds: it’s compact while still being easy to understand. It’s unanimously loved by beginners and experienced Rustaceans alike.</p> <p>For some explanation: if <code>get_user()</code> returns <code>Some</code>, the <code>let</code> statement will destructure the <code>Some</code> variant and assign the value to the <code>user</code> variable. If <code>get_user()</code> returns <code>None</code>, the <code>else</code> block will be executed and we return early with an error.</p> <p><strong>My favorite thing about <code>let-else</code> is that it clearly highlights the ‘happy path’ of your code.</strong></p> <p>Unlike a <code>match</code> statement where you need to read both arms to understand the intended flow, <code>let-else</code> makes it immediately clear what the expected case is, with the <code>else</code> block handling the exceptional case.</p> <p>This is a clear winner. It is way more intuitive for beginners; once they understand the pattern, they use it all the time!</p> <h2 id="bonus-anyhow"><a class="zola-anchor" href="#bonus-anyhow" aria-label="Anchor link for: bonus-anyhow">Bonus: <code>anyhow</code></a></h2> <p>I wanted to add one honorable mention here.</p> <p>If you’re writing an application (not a library) and you’re using the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/anyhow"><code>anyhow</code></a> crate already, you can also use their <code>context</code> method to handle <code>None</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> anyhow</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">Context</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> get_user_name</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> get_user</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">context</span><span>(</span><span style="color: #F1FA8C;">&quot;No user&quot;</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Do something with `user`</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(user)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>It’s slightly less verbose than <code>let-else</code>, which makes it appealing. Just remember that <code>anyhow</code> is an external dependency. It’s probably fine for applications, but you might not want to use it in a library as users of your library can no longer match on the concrete error variant then.</p> <p>That’s why I believe that <code>let-else</code> is the best solution for handling <code>None</code> in most cases.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>For most cases, I prefer this syntax:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(value)</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> some_function</span><span>()</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Descriptive error message&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into</span><span>());</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>To me, <code>let-else</code> is the best solution for handling <code>None</code> because:</p> <ul> <li>It’s part of the standard library.</li> <li>It works for both libraries and applications.</li> <li>It’s easy to understand for beginners.</li> <li>It’s reasonably compact.</li> <li>It allows for more complex error handling logic in the <code>else</code> block if needed.</li> <li>Learning the mechanics behind it is helpful in other places in Rust.</li> </ul> <p>I hope this helps more people handle <code>Option</code> in a more robust way. If it helps a single person avoid one <code>unwrap</code>, it was already worth it.</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-2"> <p>Sometimes, <code>unwrap()</code> can make code more readable by reducing noise, especially when the success case is overwhelmingly likely. It’s okay to use <code>unwrap()</code> when you can prove that a failure is impossible or when a panic is actually the desired behavior for failures. Andrew Gallant <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.burntsushi.net/unwrap/">wrote an article on this</a> where he goes into more detail. <a href="#fr-2-1">↩</a></p> </li> </ol> </section> Wed, 14 Aug 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/cpp-rust-interop/ https://corrode.dev/blog/cpp-rust-interop/ <p>The real-world implications of choosing a programming language over another are often nuanced. This is especially true for the ongoing debate between Rust and C++. It’s easy to get lost in theoretical arguments about safety, performance, and language features, but what does it really boil down to when rubber hits the road?</p> <p>I recently sat down with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tylerjw.dev">Tyler Weaver</a>, Co-Organizer of the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.meetup.com/boulder-rust-meetup/">Boulder Rust Meetup</a> and software engineer with a decade of C++ experience and several years of Rust under his belt. He shared some great insights on the practical aspects of working with both languages in production, which I thought would be valuable to share.</p> <p>While Tyler’s perspective is based on his personal experience, I believe his insights are quite valuable for anyone looking for hands-on experiences with both languages. The quotes below are taken verbatim from our conversation.</p> <h2 id="rust-is-a-force-multiplier"><a class="zola-anchor" href="#rust-is-a-force-multiplier" aria-label="Anchor link for: rust-is-a-force-multiplier">Rust is a Force Multiplier</a></h2> <p>One of Tyler’s most striking observations is that “Rust is a force multiplier.” In C++ projects, developers often find themselves barely having time to get things working, let alone optimizing or improving their code. Rust, on the other hand, handles many low-level details by design, allowing developers to focus on higher-level concerns instead. As Tyler puts it, you can “spend more time on useful things because Rust handles the details for you.”</p> <p>This effect extends to code reviews as well. Tyler estimates that “code reviews take half the time” in Rust compared to C++. This efficiency gain is not just about saving time; it allows for more thorough reviews and potentially catches more issues before they make it into production.</p> <p>This aligns well with an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/6mZRWFQRvmw?t=27012">observation by Google</a> on re-writing C++ into Rust:</p> <blockquote> <p>In every case, we’ve seen a decrease by more than 2x in the amount of effort required to both build the services written in Rust, as well as maintain and update those services. […] C++ is very expensive for us to maintain.</p> </blockquote> <h2 id="painless-refactoring"><a class="zola-anchor" href="#painless-refactoring" aria-label="Anchor link for: painless-refactoring">Painless Refactoring</a></h2> <p>Perhaps one of the areas where Rust shines the most is during large-scale refactoring. Tyler emphasizes that “Rust makes refactoring painless” and allows developers to “trust your refactors.” This “worry-free refactoring” is a stark contrast to C++, where making significant changes can be risky and time-consuming.</p> <p>“In C++, removing things is so expensive,” both in terms of development time and the potential for introducing bugs. Rust’s ownership system and compiler checks make it much easier to make sweeping changes with confidence. This capability is particularly valuable for large-scale projects where regular refactoring is essential for maintaining code quality and adapting to changing requirements.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=21980890">Mozilla twice attempted to parallelize Firefox’s CSS layout engine in C++</a>, but abandoned both efforts. Eventually, they succeeded on the third attempt using Rust in the Servo project, which was later integrated into Firefox as part of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://hacks.mozilla.org/2017/08/inside-a-super-fast-css-engine-quantum-css-aka-stylo/">Project Quantum</a>. The team credited Rust’s safety guarantees as the reason why they were able to be successful on the third attempt. Here’s the section from the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=Y6SSTRr2mFU">talk</a> by Josh Matthews from the Servo team.</p> <p>Jeremy Soller from System76 recently <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s02e07-system76/?t=1%3A13%3A18">shared a similar sentiment in our Rust in Production podcast</a>:</p> <blockquote> <p>Rust [has] capability [of] doing extremely, extremely concurrent things safely. There was no way to write this kind of code in C or C++ without considerable time planning beforehand.</p> </blockquote> <h2 id="the-cost-of-complexity"><a class="zola-anchor" href="#the-cost-of-complexity" aria-label="Anchor link for: the-cost-of-complexity">The Cost of Complexity</a></h2> <p>Tyler points out that “accidental complexity is quite high in C++.” This complexity often manifests in subtle ways that can accumulate over time, making codebases increasingly difficult to maintain. In our conversation, Tyler mentioned that there is a lot of upfront knowledge required to be productive in C++. One has to read a lot of books and watch talks to become an expert because a lot of the best practices are passed on as tribal knowledge and there is a lot of historical baggage in C++.</p> <p>In contrast, Rust’s design encourages simplicity and clarity from the start, allowing developers to “focus on the right things.”</p> <p>Tyler emphasizes that “none of our software projects are as simple as they could be.” Rust’s approach to memory management and its emphasis on explicit handling of side effects can lead to simpler, more maintainable code structures.</p> <p>If you are curious to learn more about maintaining large C++ codebases and migrating to Rust, listen to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s02e03-thunderbird">this interview with Brendan Abolivier from Thunderbird</a> from our “Rust in Production” podcast series.</p> <h2 id="tooling"><a class="zola-anchor" href="#tooling" aria-label="Anchor link for: tooling">Tooling</a></h2> <p>Better tooling leads to better projects, and Rust has a significant edge in this area. From cargo, Rust’s package manager and build tool, to the language server protocol implementation, Rust’s tooling ecosystem is modern and integrated. This cohesive tooling environment contributes to more efficient development workflows and higher-quality output.</p> <h2 id="acknowledging-rust-s-current-limitations"><a class="zola-anchor" href="#acknowledging-rust-s-current-limitations" aria-label="Anchor link for: acknowledging-rust-s-current-limitations">Acknowledging Rust’s Current Limitations</a></h2> <p>While Tyler’s perspective paints a very positive picture of Rust, it’s important to address some common criticisms of the language:</p> <ol> <li> <p><strong>Learning Curve</strong>: Rust is known for having a steeper learning curve than C++, particularly for developers accustomed to more traditional programming paradigms. The borrow checker, while powerful, can be frustrating for newcomers. However, according to Google’s experience, more than 2/3 of respondents are confident in contributing to a Rust codebase within two months or less when learning Rust. Further, a third of respondents become as productive using Rust as other languages in two months or less. Within four months, that number increased to over 50%. Read more about the learning curve in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/blog/why-rust/">Why Rust</a>.</p> </li> <li> <p><strong>Ecosystem Maturity</strong>: Rust’s ecosystem is still not as mature yet as C++’s in some domains. Certain specialized libraries or frameworks may not be available or as feature-complete in Rust.</p> </li> <li> <p><strong>Industry Adoption</strong>: Despite growing interest, Rust has not yet achieved the same level of industry-wide adoption as C++, which may be a consideration for some projects or companies. C++ is still dominant in domains like game development, high-performance computing, and embedded systems.</p> </li> </ol> <h2 id="c-and-rust-interop"><a class="zola-anchor" href="#c-and-rust-interop" aria-label="Anchor link for: c-and-rust-interop">C++ and Rust Interop</a></h2> <p>Recognizing that a complete switch from C++ to Rust is not always feasible or desirable, Tyler suggests that “dumb interop is the best strategy for C++ and Rust to work together.” This approach allows teams to gradually introduce Rust into existing C++ codebases, leveraging the strengths of both languages. He mentioned, that while people often raise concerns about C++/Rust interop, it’s rarely an issue in practice.</p> <p>Tyler wrote a series of blog posts on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tylerjw.dev/posts/rust-cpp-interop/">Rust and C++ interop</a> that go into great detail about integrating Rust into C++ projects, which covers FFI bindings, CMake (a build system generator for C++ projects), Cxx (a code generation tool), Conan (a C++ package manager), and more.</p> <p>For an up-to-date, step-by-step guide on the tooling and strategies involved in this process, see <a href="/blog/rust-ffi-incremental-migration/">How to Introduce Rust into a C++ Codebase</a>.</p> <p>It is recommended to start with the most safety-critical or unreliable parts of your codebase:</p> <blockquote> <p>What you have to do is think about how important security is at each level of the stack and how to address it in small incremental ways. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/podcast/s02e07-system76/?t=47%3A52">Jeremy Soller in the Rust in Production podcast</a></p> </blockquote> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <p>Here are some key takeaways from Tyler’s experiences with Rust and C++:</p> <ul> <li>You have more time to focus on the big picture when using Rust.</li> <li>Refactoring is easier and less risky in Rust.</li> <li>Removing things is hard in C++. It’s easier in Rust thanks to the borrow checker.</li> <li>Rust doesn’t have the historical baggage of C++. It comes with sane defaults.</li> <li>Rust’s integrated tooling contributes to more efficient development workflows.</li> <li>Interop between Rust and C++ is best done by keeping interfaces simple.</li> </ul> <p>As Tyler’s experiences illustrate, the benefits of Rust often become most apparent in the “day two operations” of software development – in code reviews, refactoring, and managing complexity.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Make the most of Rust</p> </h4> </div> <p>Is your company considering to migrate from C++ to Rust? I offer consulting services to get you up to speed with your Rust projects, from training your team to code reviews and architecture consulting. Check out my <a href="/services">services page</a> to learn more.</p> </div> <h2 id="recommended-reading"><a class="zola-anchor" href="#recommended-reading" aria-label="Anchor link for: recommended-reading">Recommended Reading</a></h2> <p>For those interested in diving deeper into the topics discussed in this article, here are a few book recommendations:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.manning.com/books/grokking-simplicity">“Grokking Simplicity”</a> by Eric Normand. Published by Manning.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/">“Programming Rust”</a> by Jim Blandy and Jason Orendorff. Published by O’Reilly.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.oreilly.com/library/view/effective-modern-c/9781491908419/">“Effective Modern C++”</a> by Scott Meyers. Published by O’Reilly.</li> </ul> <p>These three books teach you how to write clean, maintainable code no matter the language.</p> <p>If you like to learn more about Tyler’s work, check out his <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tylerjw.dev/">blog</a> and GitHub <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tylerjw">profile</a>.</p> Thu, 08 Aug 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e08-season-finale/ https://corrode.dev/podcast/s02e08-season-finale/ <div><script id="letscast-player-7ae4f95b" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-15-season-finale/player.js?size=s"></script></div> As we approach the finale of our second season, it's time for another recap. <p>Could we shed some light on the current state of Rust’s usage in the industry? What has changed in our perception of Rust in production since our last season?</p> <p>While more companies started to embrace Rust, some of the magic of Rust’s early days is gone. I expect more ripple effects as the community clashes with the industry’s demands.</p> <p>This episode takes on a more somber tone, as we peer into the massive tech debt we have accumulated as an industry. And in the dark: a faint glow, a narrow golden path that points us towards a more hopeful future.</p> Mon, 29 Jul 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/dont-use-preludes-and-globs/ https://corrode.dev/blog/dont-use-preludes-and-globs/ <p>Have you ever wondered why you don’t have to import <code>std::result::Result</code> before you can use it?</p> <p>The reason is Rust’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/prelude/index.html">prelude</a>, which re-exports a bunch of types that automatically get added to your program’s namespace. A more correct definition is: <em>Preludes are collections of names automatically brought into scope in every module of a crate.</em></p> <p>In fact, there are multiple preludes like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/prelude/v1/index.html"><code>std::prelude::v1</code></a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/prelude/rust_2015/index.html"><code>std::prelude::rust_2015</code></a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/nightly/std/prelude/rust_2024/index.html"><code>std::prelude::rust_2024</code></a>, and more in the future.</p> <p>It would be jarring to import those basic types over and over again so I’d say it’s a win to have a prelude for the standard library.</p> <p>Maybe that’s the reason why popular libraries started to provide their own preludes: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/rayon/latest/rayon/prelude/index.html">Rayon has one</a> and so do <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/pyo3/latest/pyo3/prelude/index.html">pyo3</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/bevy/latest/bevy/prelude/index.html">bevy</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/ratatui/latest/ratatui/prelude/index.html">ratatui</a>.</p> <p>Some people consider preludes and glob imports<sup class="footnote-reference" id="fr-1-1"><a href="#fn-1">1</a></sup> to be antipatterns – I’m one of them. Let me explain why.</p> <h2 id="i-don-t-like-preludes"><a class="zola-anchor" href="#i-don-t-like-preludes" aria-label="Anchor link for: i-don-t-like-preludes">I don’t like preludes</a></h2> <p>Preludes help beginners start quickly and with zero boilerplate, but they also prevent users from understanding the full picture of a crate. For larger projects, preludes can cause namespace pollution and naming conflicts.</p> <p>I have a hard time reviewing code which uses preludes: looking up a definition might not work in my code review tool, and I’d have to manually track down where types came from.</p> <p>Explicit imports bring clarity.</p> <p>Speaking of which! A good compromise between convenience and clarity is to import whole modules instead of individual items, such as <code>use std::fmt</code>. Then you can say <code>fmt::Debug</code> instead of <code>std::fmt::Debug</code>. It’s a little easier on the eyes, but still provides clarity.</p> <p>Unless you write a highly critical framework which uses well-established types, which are <em>absolutely positively always</em> mandatory in every (or at least most) interaction with your library, don’t add a prelude. Even then, make sure that prelude carries its own weight. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/tokio/issues/3257">Tokio removed their prelude because that wasn’t the case</a>.</p> <p>An explicit import might not be that bad. In fact, it might even clear things up for your users, because it’s easier to see where imports come from.</p> <p>If you’re worried about ergonomics, why not re-export common types in root? Then they can get imported with <code>use mycrate::SomeType;</code> instead of <code>use mycrate::mymodule::SomeType;</code>.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Re-export a type in your lib.rs</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub use</span><span> mymodule</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">SomeType</span><span>;</span></span></code></pre> <p>On the same note, avoid glob imports (like <code>use prelude::*</code> or <code>use mycrate::mymodule::*</code>). The reasons are the same: they hide dependencies and make it harder to grep for usages of a type or function.</p> <h2 id="common-arguments-for-preludes"><a class="zola-anchor" href="#common-arguments-for-preludes" aria-label="Anchor link for: common-arguments-for-preludes">Common Arguments for Preludes</a></h2> <p>Let’s address some common arguments in favor of preludes and glob imports and see if there’s a better way to achieve the same goal.</p> <h3 id="preludes-in-examples"><a class="zola-anchor" href="#preludes-in-examples" aria-label="Anchor link for: preludes-in-examples">Preludes in examples</a></h3> <p>Some people like to use preludes in their documentation examples.</p> <p>This can be sweet when you quickly want to show how to use your library without too much boilerplate. But at what cost?</p> <p>Users <em>can and will</em> start to copy-paste that prelude into their code, at which point you’ll have to support it. It’s convenient in the beginning, but can result in a maintenance burden in the long run.</p> <p>One way to avoid that is to hide code lines for imports in your documentation examples. With that, examples are still easy to read, while users can’t copy-paste the imports:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">//! # Examples</span></span> <span class="giallo-l"><span style="color: #6272A4;">//!</span></span> <span class="giallo-l"><span style="color: #6272A4;">//! ```</span></span> <span class="giallo-l"><span style="color: #6272A4;">//! # use mycrate::SomeType;</span></span> <span class="giallo-l"><span style="color: #6272A4;">//! # fn main() {</span></span> <span class="giallo-l"><span style="color: #6272A4;">//! let t = SomeType::new(); </span></span> <span class="giallo-l"><span style="color: #6272A4;">//! # }</span></span> <span class="giallo-l"><span style="color: #6272A4;">//! ```</span></span></code></pre> <p>This will render as:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> t</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> SomeType</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span></code></pre><div class="info"> <div class="info-header"> <span class="icon icon-warning"></span> <h4><p>Caution When Hiding Code in Examples</p> </h4> </div> <p>Be careful with this approach and don’t overdo it. Try to keep your examples simple and don’t hide too much code because it can be a frustrating experience for your users if they copy-paste your examples and they don’t work.</p> </div> <p>To address the root cause: If you feel the urge to add a prelude because your crate requires importing many modules to be usable, consider whether your public API is too large. Try reducing the number of modules and types by refactoring your public API. This way, you won’t need to hide imports in the first place.</p> <h3 id="reducing-boilerplate"><a class="zola-anchor" href="#reducing-boilerplate" aria-label="Anchor link for: reducing-boilerplate">Reducing boilerplate</a></h3> <p>Another common argument for preludes is that they reduce friction when importing types.</p> <p>I don’t think that’s true anymore. Editor support for Rust has made great strides in the last years. Nowadays, your editor will just auto-import the type for you. (Largely thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-analyzer.github.io/">Rust Analyzer</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.jetbrains.com/rust/">Rust Rover</a>). Problem solved! <sup class="footnote-reference" id="fr-editor-1"><a href="#fn-editor">2</a></sup></p> <h3 id="trait-only-preludes"><a class="zola-anchor" href="#trait-only-preludes" aria-label="Anchor link for: trait-only-preludes">Trait-only preludes</a></h3> <p>Preludes which only bring traits into scope might be acceptable. This trick is sometimes used in combination with extension traits, which add extra functionality to common types. <code>rayon</code> does that, for example, and it’s quite magical if you can suddenly parallelize an iterator by just swapping <code>iter</code> with <code>par_iter</code>.</p> <p>From their documentation:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> rayon</span><span style="color: #FF79C6;">::</span><span>prelude</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> sum_of_squares</span><span>(input</span><span style="color: #FF79C6;">: &amp;</span><span>[</span><span style="color: #8BE9FD;font-style: italic;">i32</span><span>])</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span> {</span></span> <span class="giallo-l"><span> input</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">par_iter</span><span>()</span><span style="color: #6272A4;"> // &lt;-- just change that!</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|&amp;</span><span>i</span><span style="color: #FF79C6;">|</span><span> i</span><span style="color: #FF79C6;"> *</span><span> i)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">sum</span><span>()</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>I think that’s a solid use case for a prelude, but I’ve never had such a clear-cut case in my own libraries.</p> <h3 id="flexibility-for-library-authors"><a class="zola-anchor" href="#flexibility-for-library-authors" aria-label="Anchor link for: flexibility-for-library-authors">Flexibility For Library Authors</a></h3> <p>Preludes can let library authors refactor their code without causing unnecessary churn for users: If you often reorganize your internal structure, a prelude can provide a stable public API for common types. The Bevy game engine uses this pattern, for example.</p> <p>But hold on! This doesn’t mean the internal logic stays the same, and a prelude doesn’t guarantee API stability either. These hidden changes might cause subtle bugs (e.g., when the prelude contains extension traits) which are hard to pin down.</p> <p>Ask yourself: why does my public API change so much? There seems to be a deeper-rooted problem here. For example, you might have leaked internal details into your public API, which you now want to change.</p> <p>One way to provide stability without a prelude is to embrace semantic versioning. Before 1.0, you’re free to change your API frequently, with users expecting some churn. Once you’re happy with the API, switch to 1.0 and promise to maintain backwards compatibility. This approach gives you the flexibility of early prototyping paired with the stability guarantees of more mature libraries.</p> <h3 id="sane-defaults-out-of-the-box"><a class="zola-anchor" href="#sane-defaults-out-of-the-box" aria-label="Anchor link for: sane-defaults-out-of-the-box">Sane Defaults Out of the Box</a></h3> <p>For complex libraries, a well-designed prelude can improve clarity by curating important types. This seems appealing in security-sensitive domains to prevent misuse of incorrect types.</p> <p>For example, a crypto library might provide a prelude with only the most secure algorithms. This way, users are guided towards secure defaults without needing to understand the intricacies of each algorithm.</p> <p>That’s a valid argument, but I’d argue that it’s a slippery slope. First off, switching an algorithm is still a breaking change and it might still require changes in user code. Second, a prelude is no substitute for good documentation, examples, and a “Getting Started” guide.</p> <p>Consider using Rust’s <code>#[deprecated]</code> attribute to phase out old behavior. This way, users get time to adapt to the new API. Leverage Rust’s type system: Use newtypes, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://predr.ag/blog/definitive-guide-to-sealed-traits-in-rust/">sealed traits</a>, and visibility modifiers (like <code>pub(crate)</code>) to guide users towards correct usage without relying on a prelude.</p> <p>My rule of thumb here is to avoid hiding complexity behind a prelude and err on the side of explicitness.</p> <h2 id="common-arguments-for-glob-imports"><a class="zola-anchor" href="#common-arguments-for-glob-imports" aria-label="Anchor link for: common-arguments-for-glob-imports">Common Arguments for Glob Imports</a></h2> <p>Now that we’ve covered preludes, let’s look at some common arguments for why people use glob imports and why you should be careful.</p> <h3 id="preludes-are-convenient-for-beginners"><a class="zola-anchor" href="#preludes-are-convenient-for-beginners" aria-label="Anchor link for: preludes-are-convenient-for-beginners">Preludes are convenient for beginners</a></h3> <p>Some people argue that preludes are beginner-friendly. The argument goes that beginners don’t have to worry about importing types and can focus on learning the core concepts of a library.</p> <p>As we will see, this can backfire quickly.</p> <p>Here’s the catch: when you use glob imports, you’re opening yourself up to potential build breaks from minor version updates. Adding new public items is considered a minor change according to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://semver.org">semantic versioning</a> rules. That means when a crate bumps its version from, say, 1.2.0 to 1.3.0, it’s allowed to add new public items without breaking backwards compatibility.</p> <p>Now, picture this scenario: You’re using a crate with a glob import, bringing all its public items into scope. You update the crate to the latest minor version, and suddenly your code doesn’t compile anymore. Ouch.</p> <p>Well, that new minor version might have added a new public item that conflicts with a name in your code.</p> <p>Here’s a quick example to illustrate:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// In your code you update some_crate from 1.2.0 to 1.3.0</span></span> <span class="giallo-l"><span style="color: #6272A4;">// In 1.3.0, some_crate added a new public item called Ferris.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> some_crate</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// In your own code, you have a struct called Ferris</span></span> <span class="giallo-l"><span style="color: #6272A4;">// Now you have a naming conflict, and your code won&#39;t compile!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Ferris</span><span>;</span></span></code></pre> <p>The crate author didn’t break any promises – adding new public items is allowed in minor versions. But because of the glob import, what should have been a harmless update turned into a breaking change for your codebase and a minor headache for you.</p> <p>Explicit imports protect you from these unexpected conflicts and make your code more resilient to changes in your dependencies.</p> <h3 id="glob-imports-in-tests"><a class="zola-anchor" href="#glob-imports-in-tests" aria-label="Anchor link for: glob-imports-in-tests">Glob imports in tests</a></h3> <p>It’s common to see <code>use super::*;</code> in tests to bring all functions from the parent module into scope. This can be a helpful mechanism to reduce boilerplate. That’s the only exception I can think of where glob imports are acceptable.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 42</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> tests {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span style="color: #BD93F9;font-style: italic;"> super</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_something</span><span>() {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(</span><span style="color: #50FA7B;">foo</span><span>(),</span><span style="color: #BD93F9;"> 42</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>In your own code, avoid preludes and, by extension, glob imports.</p> <p>Here are the main disadvantages:</p> <ul> <li>Makes it harder to know where types and functions come from</li> <li>Can lead to naming conflicts, especially in larger codebases and when using multiple crates</li> <li>Complicates security audits because it’s hard to see where code came from</li> <li>May hide module hierarchy and structure, which is useful if you want to learn how a crate is designed</li> <li>Can make IDE name resolution less reliable: if you have a name conflict, the IDE might not know which one you mean or might not be able to find the definition</li> <li>Hides imports in documentation examples, making it harder to understand</li> </ul> <p>As you can see, the list of downsides is long. The only upside is that it saves a few keystrokes when writing code, which isn’t worth it in the long run.</p> <p><strong>Pro tips:</strong></p> <ul> <li>Enable the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/rust-clippy/master/index.html#/wildcard_imports">clippy lint for wildcard imports</a> to catch glob imports in your code.</li> <li>If you really want to create a prelude, at least use it for traits and macros only, not for types. Extending behavior of existing types (like adding a <code>par_iter</code> method to iterators with Rayon) is an acceptable use case for preludes if used in moderation. To avoid naming conflicts, consider using a unique prefix for extension traits like <code>CrateNameHashmapExt</code> instead of <code>HashMapExt</code>.</li> <li>If you depend on a crate which has a prelude, consider not using it and instead importing the types you need explicitly. This way, you can avoid conflicts down the road and make it easier to see where a type comes from.</li> </ul> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-1"> <p>A glob import (also called a wildcard import) is an import that brings all items of a module into scope. For example, <code>use std::collections::HashMap;</code> vs <code>use std::collections::*;</code>. <a href="#fr-1-1">↩</a></p> </li> <li id="fn-editor"> <p>I should mention that many modern editors can often show you the fully qualified path of a type, even when it’s imported via a prelude. This does away with some of the clarity concerns associated with preludes. <a href="#fr-editor-1">↩</a></p> </li> </ol> </section> Thu, 25 Jul 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e07-system76/ https://corrode.dev/podcast/s02e07-system76/ <div><script id="letscast-player-e4782127" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-14-system76-s-jeremy-soller/player.js?size=s"></script></div> <p>Many devs dream of one day writing their own operating system. Ideally in their favorite language: Rust. For many of us, this dream remains just that: a dream.</p> <p>Jeremy Soller from System76, however, didn’t just contribute kernel code for Pop!_OS, but also started his own operating system, RedoxOS, which is completely written in Rust. One might get the impression that he likes to tinker with low-level code!</p> <p>In this episode of Rust in Production, Jeremy talks about his journey. From getting hired as a kernel developer at Denver-based company System76 after looking at the job ad for 1 month and finally applying, to being the maintainer of not one but two operating systems, additional system tools, and the Rust-based Cosmic desktop. We’ll talk about why it’s hard to write correct C code even for exceptional developers like Jeremy and why Rust is so great for refactoring and sharing code across different levels of abstraction.</p> Wed, 24 Jul 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/hiring-rust-engineers/ https://corrode.dev/blog/hiring-rust-engineers/ <h2 id="the-rust-hiring-mismatch"><a class="zola-anchor" href="#the-rust-hiring-mismatch" aria-label="Anchor link for: the-rust-hiring-mismatch">The Rust Hiring Mismatch</a></h2> <p>There’s a curious mismatch in the Rust hiring market where some companies believe there’s a shortage of qualified candidates, while many Rust programmers struggle to find jobs. Why is that?</p> <p>Most Rust jobs are for senior roles, leaving newcomers and mid-level devs out in the cold. Many of whom would be a great fit for these roles with a little bit of training.</p> <p>The crypto industry is a notable exception, where Rust developers are in high demand, but not everyone wants to work in that space. On top of that, crypto companies have inflated Rust developer salaries to unsustainable levels, making it difficult for other industries to compete for talent.</p> <p>It’s not impossible, though! However, many companies want unicorns with years of Rust experience in an industry where that’s rare. Meanwhile, eager developers worldwide are ready to work but face barriers like location restrictions (US only), job security concerns (contract work only), or lack of “professional” Rust experience. It’s a classic case of supply and demand completely missing each other, with both sides frustrated and opportunities lost.</p> <h2 id="but-isn-t-this-just-the-dev-job-market-in-general"><a class="zola-anchor" href="#but-isn-t-this-just-the-dev-job-market-in-general" aria-label="Anchor link for: but-isn-t-this-just-the-dev-job-market-in-general">But Isn’t this just the dev job market in general?</a></h2> <p>Partially! However, I think it’s more pronounced in Rust because it’s a relatively new language and companies add it to their job ads because it generates interest.</p> <p>The moment you try to get your foot in the door as a less experienced Rust developer, though, this mismatch becomes apparent. In tough market situations with fewer positions, companies tend to be more conservative and look for “safe bets” which means experts they are sure can hit the ground running – much to the detriment of less experienced developers.</p> <h2 id="why-write-this-guide"><a class="zola-anchor" href="#why-write-this-guide" aria-label="Anchor link for: why-write-this-guide">Why Write This Guide?</a></h2> <p>As a Rust consultant, it’s in my best interest to grow the hiring pool for Rust developers: if we want to grow the real-world usage of Rust, we need to get way more developers into the ecosystem. There are signs that this is happening, but with some tweaking, the process can be highly accelerated.</p> <p>The broader consequence is that many companies are hesitant about adopting Rust and are therefore missing out on a rich ecosystem for building reliable and efficient services. This misconception is frustrating, as it often comes up when I talk to companies not yet using Rust.</p> <p><strong>A common statement I hear is: “The community is still too small.”</strong></p> <p>In reality, the Rust community has more than tripled in size over the past two years and currently has <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.developernation.net/resources/reports/state-of-the-developer-nation-24th-edition-q1-2023">3.7M users, of which 0.6M joined in the last six months alone.</a></p> <a href="https://www.developernation.net/resources/reports/state-of-the-developer-nation-24th-edition-q1-2023" target="_blank"> <img src="communities.svg" class="invert" alt="Programming Language Communities Size"> </a> <p>In contrast, companies that already use Rust in production rarely struggle with these issues and are generally very happy with their choice. If you’re still evaluating Rust for your organization, check out our guide on <a href="/blog/why-rust/">Why Rust in Production</a>.</p> <p>Here are some of the quotes from the <a href="/podcast/s01e07-season-finale/?t=23%3A06">season 1 finale of the ‘Rust in Production’ podcast</a>:</p> <blockquote> <p>I announced that we’re working on this new core of the database in November of 2020 in a talk I did. And I said we were hiring and basically like we got a bunch of inbound interestbecause of the fact that it was written in Rust. – Paul Dix, Founder and CTO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxData</a></p> </blockquote> <blockquote> <p>Because as a small company, you can attract people because they want to work in Rust. And that’s a big incentive to work for you. – Micah Wylde, Founder of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://arroyo.dev/">Arroyo</a></p> </blockquote> <p>Because I saw many companies make the same mistakes over and over again, I wrote a guide to help companies find Rust talent.</p> <p>If you are a hiring manager or a team lead looking to hire Rust developers, this guide is for you. Feel free to pass it on internally to help improve your hiring process.</p> <h2 id="setting-talent-expectations"><a class="zola-anchor" href="#setting-talent-expectations" aria-label="Anchor link for: setting-talent-expectations">Setting Talent Expectations</a></h2> <h4 id="avoid-unrealistic-demands"><a class="zola-anchor" href="#avoid-unrealistic-demands" aria-label="Anchor link for: avoid-unrealistic-demands">Avoid Unrealistic Demands</a></h4> <p>Don’t expect 10 years of Rust experience, as Rust is a relatively new language. (Rust 1.0 was released in 2015.) Such exaggerated expectations can significantly (and unnecessarily) narrow your pool of potential candidates. Even worse, experienced developers might consider this a red flag as it shows a lack of understanding of the Rust community.</p> <p>Instead, it might be enough to look for the <em>willingness</em> to learn Rust or, at most, non-production experience with the language.</p> <h4 id="clearly-specify-tasks-and-responsibilities"><a class="zola-anchor" href="#clearly-specify-tasks-and-responsibilities" aria-label="Anchor link for: clearly-specify-tasks-and-responsibilities">Clearly Specify Tasks and Responsibilities</a></h4> <p>Don’t just add ‘Rust’ as a keyword to attract more candidates. If you don’t (plan to) use Rust in any meaningful way, this will reflect poorly on your company and waste the time of both the candidate and the hiring team.</p> <p>Will the candidate have to work with other languages or technologies? Outline the specific tasks and responsibilities that involve Rust. Ideally, even mention the specific Rust libraries or frameworks you are using. This helps candidates understand what is expected of them and which other ecosystems they might need to interact with.</p> <h2 id="finding-candidates"><a class="zola-anchor" href="#finding-candidates" aria-label="Anchor link for: finding-candidates">Finding Candidates</a></h2> <p>Granted, the Rust job market is still relatively small compared to other languages like Python or JavaScript, but I found that most companies limit themselves by only looking for senior Rust developers. That’s a mistake.</p> <p>With some training, you can save a lot of time and money by hiring mid-level developers or smart juniors who are eager to learn Rust. Yes, <a href="/blog/flattening-rusts-learning-curve/">there is a learning curve</a>, but it’s probably less expensive to train a junior/mid-level developer in Rust compared to hiring a senior/staff Rust developer. For training resources, see our curated list of <a href="/blog/rust-learning-resources-2026/">Rust Learning Resources</a>.</p> <p>Currently, the best way to find Rust devs is</p> <ol> <li>in your company (if you have a training program).</li> <li>through your network (ask around).</li> </ol> <p>From experience, you probably won’t have a lot of trouble finding interested candidates as many developers are trying to move into Rust. However, constraints like location, salary, industry, and job security can be a deal-breaker for many.</p> <p>For more experienced Rust developers, perks like remote work, flexible hours, and a focus on work-life balance are often as important as the salary. Being able to work on open source or attend conferences can also be a big bonus. These folks are in high demand and can afford to be picky. If you can’t pay crypto money, at least give them some of the other perks and be willing to make compromises.</p> <p>If you’re looking for senior people or require a bigger pool of candidates, you might also want to consider sponsoring Rust-focused events, <a href="/blog/rust-conferences-2025/">conferences</a>, or <a href="/podcast">podcasts</a>. I found that sponsoring is a relatively underutilized channel with a lot of potential.</p> <p>You can post job listings on Rust-specific job boards like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://filtra.io/rust">Filtra.io</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustjobs.dev/">RustJobs.dev</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rustjobs.fyi/">RustJobs.fyi</a>, or boards with a dedicated Rust section like and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://remoteok.com/remote-rust-jobs">RemoteOK</a>. Also post in the monthly “who is hiring” threads on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/">Hacker News</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/182f6dv/official_rrust_whos_hiring_thread_for_jobseekers/">Reddit</a>.</p> <h2 id="assessing-candidates-for-rust-roles"><a class="zola-anchor" href="#assessing-candidates-for-rust-roles" aria-label="Anchor link for: assessing-candidates-for-rust-roles">Assessing Candidates for Rust Roles</a></h2> <p>Hiring itself is a very complex topic, so don’t make it harder than it needs to be.</p> <p><strong>The number one mistake is to just look at raw Rust experience!</strong> Instead, there are many other indicators that can help you identify great candidates who are a good fit for Rust work, even if they currently don’t have much experience with the language.</p> <img src="evaluation.svg" alt="Diagram for assessing Rust candidates - details below"> <p>Let’s look at the points in more detail:</p> <ul> <li> <p><strong>Adaptability:</strong> Look for candidates who have a proven track record to quickly adapt and learn new technologies. For example, if they worked with many different languages and know more than one programming paradigm, they might be a good fit.</p> </li> <li> <p><strong>Systems Understanding:</strong> A strong grasp of fundamental concepts such as stack vs heap, threading, and data structures is a good indicator of a candidate who hits the ground running with Rust.</p> </li> <li> <p><strong>Evaluate Troubleshooting Skills:</strong> A good proxy for Rust knowledge is the ability to debug and reason about code in general. Assess a candidates’ ability to understand and resolve compile errors in Rust, focusing on common issues with ownership and borrowing. Provide scenarios that require light debugging and refactoring of Rust code.</p> </li> <li> <p><strong>Rust Reasoning:</strong> For those without Rust experience, test their ability to reason about Rust code. Provide sample Rust code and ask them to explain what it does. Looking up documentation is allowed. Ask clarifying questions to gauge their interest and to see how quickly they can learn.</p> </li> <li> <p><strong>Ask to use the Rust documentation:</strong> Rust takes documentation seriously. Show candidates some Rust documentation and ask follow-up questions to gauge their ability to understand basic concepts. Ask them to document a piece of code themselves or explain it in their own words.</p> </li> <li> <p><strong>Related Languages:</strong> Be open to candidates transitioning from C++, Java, Kotlin, or TypeScript, which have an equally strong emphasis on enterprise-grade software development. Haskell, OCaml, and other functional programming languages can also be a good fit, because of their focus on the type system and correctness. Rust has <a href="/blog/paradigms/">functional aspects</a>, which are similar to these languages.</p> </li> <li> <p><strong>Industry and Domain Knowledge:</strong> Consider candidates with experience in Rust’s key domains, such as backend development, infrastructure, real-time data processing, and systems programming. Depending on your niche, assess their expertise in these areas.</p> </li> <li> <p><strong>Open Source Work</strong> (Optional): If a candidate mentions open source work, review the code quality and communication skills in issues and pull requests. Keep in mind that many great developers lack time for open source work, though.</p> </li> </ul> <h2 id="takeaways"><a class="zola-anchor" href="#takeaways" aria-label="Anchor link for: takeaways">Takeaways</a></h2> <p><strong>If you’re a hiring manager</strong> don’t just look at raw Rust expertise; think outside the box and consider related skills and experience. The current hiring market is challenging, with an imbalance between eager developers and limited job opportunities. However, this presents a unique opportunity for forward-thinking companies to invest in talent. People exceed expectations when given trust and opportunity. For a comprehensive guide on adopting Rust in your organization, check out our <a href="/blog/successful-rust-business-adoption-checklist/">Business Adoption Checklist</a>.</p> <p><strong>If you’re a professional Rust developer</strong> looking to improve the situation, work with your hiring manager to help them understand how to hire more Rust devs. Perhaps this guide can help you get started.</p> <p>Good luck with your Rust hiring process!</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Is your company adopting Rust?</p> </h4> </div> <p>Let me help you make the most of Rust. I offer consulting services to get you up to speed with your Rust projects, from training your team to code reviews and architecture consulting. Check out my <a href="/services">services page</a> to learn more.</p> </div> Thu, 11 Jul 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e06-fusion-engineering/ https://corrode.dev/podcast/s02e06-fusion-engineering/ <div><script id="letscast-player-446cf898" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-13-fusion-engineering-s-jakub-valtar/player.js?size=s"></script></div> <p>Rust can run everywhere, and by everywhere, we don’t just mean on all operating systems, but also in all kinds of harsh environments: from the depths of the ocean to the vastness of space. Today we talk to a company that is using Rust to conquer the air. Fusion Engineering is building drone control systems for the next generation of drones.</p> <p>Jakub Valtar walks us through how Fusion Engineering came to use Rust as the foundation of their company. He explains why Rust is the safest choice for building drone control systems and what it takes to get into drone development.</p> Thu, 27 Jun 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e05-oxidos/ https://corrode.dev/podcast/s02e05-oxidos/ <div><script id="letscast-player-18346472" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-12-oxidos-alexandru-radovici/player.js?size=s"></script></div> <p>It has become a trope by now: “Cars are computers on wheels.” In modern cars, not only the infotainment system but also the engine, brakes, and steering wheel are controlled by software. Better make sure that software is safe.</p> <p>Alexandru Radovici is a Software Engineer at OxidOS, a company that builds a secure, open-source operating system for cars built on Rust and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tockos.org/">Tock</a>. We talk about the challenges of certifying Rust code for the automotive industry and the new possibilities with Rust-based car software.</p> Mon, 24 Jun 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/rust-in-ten-years/ https://corrode.dev/blog/rust-in-ten-years/ <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Will Rust still exist, and have proper support, 10, 20 or even 30 years from now?</p> </h4> </div> <p>We’ve been asked this question multiple times in the last year. It is a fair question, as adopting any new technology requires an investment and comes with uncertainties, one of them being the durability of the technology. This article explains why we expect Rust to stand the test of time.</p> <p><em>This article is a friendly collaboration between Tweede golf (author: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tweedegolf.nl/en/about/9/hugo">Hugo</a>) and corrode Rust Consulting (author: <a href="/services/">Matthias</a>). For more insights on Rust, also visit <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tweedegolf.nl/en/blog">the Tweede golf blog</a>.</em></p> </div> <p>Wondering whether Rust will still be around is only relevant once you’ve determined that the language is technically the best solution for your project, so for the sake of this blog, we’re assuming that you have indeed already made this assessment. If you are still wondering whether Rust is for you, or how this potentially costly tech switch can actually save you money, check out <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.dev/why-rust/">this blog post</a> instead.</p> <p>In this article, we’ll go over the current state of the language (how old or young is it, really?), what we consider the three markers of longevity (spoiler, Rust does well on all three), and an honest disclaimer (what might still go wrong?).</p> <h2 id="is-it-hype-or-is-it-real"><a class="zola-anchor" href="#is-it-hype-or-is-it-real" aria-label="Anchor link for: is-it-hype-or-is-it-real">Is it hype or is it real?</a></h2> <p>You might recognize the image below as the well-known <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Technology_adoption_life_cycle">Technology Adoption Lifecycle</a>. It goes without saying that Rust is still in the early stages.</p> <p><img src="https://corrode.dev/blog/rust-in-ten-years/tech-adoption-lifecycle.svg" alt="tech-adoption-lifecycle" /></p> <p><em>Technology Adoption Lifecycle (<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://medium.com/@shivayogiks/what-is-technology-adoption-life-cycle-and-chasm-e07084e7991f">image credits</a>)</em></p> <p>The question of Rust’s exact adoption status is too broad to answer with any precision or validity. This is because Rust is being used in many different industries, for various purposes, and each of these industries and uses has its own timeline.</p> <p>Broadly speaking, we can say that Rust is somewhere in the Early Adopters stage in most domains like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.theregister.com/2024/03/31/rust_google_c/">web/backend</a> and systems programming, as companies like Google, Facebook, and Microsoft are heavily investing in Rust and have large systems written in it, powering their cloud offerings. For instance, Mark Russinovich, CTO of Microsoft Azure, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/markrussinovich/status/1571995117233504257">stated</a> that new projects should be written in Rust in preference to C or C++. Both the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.kernel.org/rust/">Linux kernel</a> as well as the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/markrussinovich/status/1656416376125538304">Windows kernel</a> contain Rust code now.</p> <p>In embedded development, we have to separate the various industries. For example, in automotive projects, thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ferrocene.dev">Ferrocene</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://oxidos.io">OxidOS</a>, Rust is past the Innovators stage and into the Early Adopters stage. As for other industries like the aerospace, defense, and medical industries, Rust is still in the Innovators stage.</p> <p>Some games like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://store.steampowered.com/app/1110620/Way_of_Rhea/">Way of Rhea</a> have been written in Rust and are available on Steam, but the gaming industry as a whole is still in the Innovators stage.</p> <p>We do think that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2024/02/19/2023-Rust-Annual-Survey-2023-results/">the broad penetration of Rust across industries</a> is rather impressive for a language that saw its first stable release just 9 years ago.</p> <p>For a technology to cross the chasm, or to become mainstream, it needs to be recognized for being <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/4RFBdcJRdbA?feature=shared&amp;t=299">highly effective</a> in a very specific area or use case.</p> <p>And it is; Enter the relevance of memory safety in our digital infrastructure. It has been established (by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://security.googleblog.com/2019/05/queue-hardening-enhancements.html">Google</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://msrc.microsoft.com/blog/2019/07/we-need-a-safer-systems-programming-language/">Microsoft</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://langui.sh/2019/07/23/apple-memory-safety/">Apple</a>, a.o.) that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.chromium.org/Home/chromium-security/memory-safety/">~70% of all security bugs in large C/C++ code bases are memory safety issues</a>, which means that memory unsafety is a problem that needs to be addressed in all the software we rely on. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html">Rust has proven to eliminate this class of bugs</a> and this is why it can now count organizations such as the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.memorysafety.org/docs/memory-safety/">Internet Security Research Group</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.archive.org/web/2024*/https://www.whitehouse.gov/oncd/briefing-room/2024/02/26/press-release-technical-report/">The White House</a>, and the German government-backed <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.sovereigntechfund.de/news/on-rust-memory-safety-open-source-infrastructure">Sovereign Tech Fund</a> among its advocates.</p> <p>Having established that Rust is at least ‘highly successful’ in solving the memory safety issues prevalent in our critical infrastructure, and thus capable of growing beyond the chasm, the question remains: will Rust be alive in 10 years?</p> <h2 id="why-rust-is-here-to-stay"><a class="zola-anchor" href="#why-rust-is-here-to-stay" aria-label="Anchor link for: why-rust-is-here-to-stay">Why Rust is here to stay</a></h2> <p>In order to answer The Question, we first have to consider what we mean, exactly, when we refer to a programming language as being ‘alive’. What do we want from this language, 10 years down the line, that would make us feel confident in investing in it now?</p> <p>We’ve narrowed our definition down to three criteria. A programming language is ‘alive’ if:</p> <ul> <li>there is significant usage by companies (and not just hobbyists);</li> <li>there is a stable and mature ecosystem;</li> <li>there is ongoing development not only in its core but also in peripheral tools and libraries.</li> </ul> <p>We’ll go into each of these criteria to describe the status quo of Rust, as we see it.</p> <h3 id="significant-usage"><a class="zola-anchor" href="#significant-usage" aria-label="Anchor link for: significant-usage">Significant usage</a></h3> <p>For a language to remain in significant usage in the long run, it needs to be adopted by industry leaders and applied across diverse fields, which would speak to its reliability and versatility respectively. A strong job market, an active community, and solid educational resources underscore its widespread acceptance and vitality. At this point, Rustaceans (that’s how Rust users are referred to in the community) are pointing at the screen, going ‘that’s us!’</p> <p>Not all of these requirements are quantifiable, but let’s look at the ones that we can actually address.</p> <h4 id="investments-by-major-corporations"><a class="zola-anchor" href="#investments-by-major-corporations" aria-label="Anchor link for: investments-by-major-corporations">Investments by major corporations</a></h4> <p>Some major corporations (i.e. Google, Facebook, Microsoft, Amazon) are already betting big on Rust. Not only are they using the language in their code bases, they’re also investing in its ecosystem. This company backing is important for the long-term sustainability of the language.</p> <p>Some examples of recent investments:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/1ajm56w/google_donates_1m_to_the_rust_foundation_to/">Google donated $1M</a> to the Rust Foundation for the Interop Initiative, to improve the tooling for interoperability.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.com/dwizzzleMSFT/status/1720134540822520268/photo/2">Microsoft invested in Rust</a>, including a $10M investment in Rust developer tooling and a $1M contribution to the Rust Foundation.</li> </ul> <h4 id="commercial-offerings-and-support"><a class="zola-anchor" href="#commercial-offerings-and-support" aria-label="Anchor link for: commercial-offerings-and-support">Commercial offerings and support</a></h4> <p>Several safety-aimed toolchains have been developed in and for Rust and they come with long-term commercial support.</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ferrous-systems.com/ferrocene/">Ferrocene</a> is a Rust compiler for safety-critical use in the automotive industry and has been ISO 26262 certified.</li> <li>AdaCore developed <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.adacore.com/gnatpro-rust">Gnat Pro for Rust</a> and are targeting the aerospace industry.</li> <li>HighTec has developed an ISO 26262-certified Rust compiler development platform for Infineon AURIX, which is essential for the automotive industry.</li> <li>Just this month, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://foundation.rust-lang.org/news/announcing-the-safety-critical-rust-consortium/">The Safety-Critical Rust Consortium</a> was founded by AdaCore, Arm, Woven by Toyota, and others, with the goal of supporting the responsible use of the Rust programming language in safety-critical software.</li> </ul> <h3 id="ecosystem-maturity"><a class="zola-anchor" href="#ecosystem-maturity" aria-label="Anchor link for: ecosystem-maturity">Ecosystem maturity</a></h3> <p>The maturity of the Rust ecosystem is difficult to quantify, but it has been growing steadily since its inception. It has gained attention, use, and support from ‘big tech’, professionals, and hobbyists alike. Driven by the idealistic goal of making software great again, Rust continues to evolve and thrive.</p> <h4 id="growth"><a class="zola-anchor" href="#growth" aria-label="Anchor link for: growth">Growth</a></h4> <p>Let’s quantify what we can.</p> <p>As is widely known, Rust has been Stack Overflows ‘most loved language’ since 2016, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.blog/2024/03/04/in-rust-we-trust-white-house-office-urges-memory-safety/">became ‘most admired’ in 2023</a>. In the same vein, Rust (together with Dart) was the fastest growing community (i.e. number of developers) in 2023, nearly doubling in size from 2022 to 2024:</p> <blockquote> <p>“Dart and Rust grew at an average annual rate of more than 30% in 2023.”<br /> — from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://research.slashdata.co/reports/65b90140343d024fbe70f369">SlashData’s State of the Developer Nation 25th Edition</a></p> </blockquote> <blockquote> <p>“Rust has nearly doubled in size over the past two years, growing from 2M to 4M users.”<br /> — from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://research.slashdata.co/reports/66546c6a78c13bcad12eac6e">SlashData’s Sizing Programming Languages Communities</a></p> </blockquote> <p>In 2024 alone, there are 8 conferences dedicated to Rust: Rust Nation (London, UK), RustNL (Delft, the Netherlands), RustFest (Zürich, Switzerland), RustConf (Montreal, Canada), EuroRust (Vienna, Austria), RustLab (Florence, Italy), Oxidize (Berlin, Germany), Rust Summit (Belgrade, Serbia).</p> <p>And the number of crates (libraries) downloaded from crates.io has grown exponentially:</p> <p><img src="https://corrode.dev/blog/rust-in-ten-years/crate-downloads.jpg" alt="jakub-beranek-slides-package-downloads-v2" /></p> <p><em>Slide from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tweedegolf.nl/images/jakub-beranek-rustnl2024-slides.pdf">Jakub Beránek’s RustNL 2024 talk</a></em></p> <p>As of today, there are <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/search?q=language%3Arust&amp;type=repositories">355k</a> Rust projects on GitHub (including archived repositories).</p> <h4 id="funding"><a class="zola-anchor" href="#funding" aria-label="Anchor link for: funding">Funding</a></h4> <p>Most programming languages are backed by a single big-tech giant. Consider Go, curated by Google, and Swift, supported by Apple.</p> <p>Rust is a different story, intentionally so. After the COVID pandemic had hit language creator Mozilla hard, they realized that the vulnerable position of the company (a quarter of its employees had to be fired) could directly affect the language. Mozilla joined forces with four(!) other big tech names (AWS, Huawei, Google and Microsoft) to create <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://foundation.rust-lang.org/">the Rust Foundation</a>:</p> <blockquote> <p>“The Rust Foundation is an independent non-profit organization dedicated to stewarding the Rust programming language, nurturing the Rust ecosystem, and supporting the set of maintainers governing and developing the project.”</p> </blockquote> <p>This means that there isn’t one company pulling all the strings. In addition, many of the volunteers who helped shape the language are now being employed by companies like Amazon and Huawei to work on the compiler full-time. The foundations that Rust is built on (both financial and technical) are thus much stronger and more diverse than those of most other languages.</p> <h4 id="memory-safety"><a class="zola-anchor" href="#memory-safety" aria-label="Anchor link for: memory-safety">Memory-safety</a></h4> <p>Rust is the only language that combines memory safety with C-like performance and the capabilities of a systems language. And we are seeing that the <em>need</em> for memory safety is becoming much more prevalent (dare we say, mainstream) in the software that we use and rely on on a daily basis. Consider the White House’s call to action:</p> <blockquote> <p>“We, as a nation, have the ability – and the responsibility – to reduce the attack surface in cyberspace and prevent entire classes of security bugs from entering the digital ecosystem but that means we need to tackle the hard problem of moving to memory safe programming languages.” - <em><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.archive.org/web/2024*/https://www.whitehouse.gov/oncd/briefing-room/2024/02/26/press-release-technical-report/">Harry Coker, US National Cyber Director</a></em></p> </blockquote> <p>Clearly, memory safety is considered a national priority by the White House. (Of course, we’d like to argue that ‘The Internet’ and our digital infrastructure is never a mere national matter; the scope of this issue is far greater than that, but we understand that for the sake of politics, it sometimes must be reduced to a national issue.) It goes to show that awareness of the issue is no longer niche. It is a matter of time before the implications of it (actually writing memory safe software) will also become ‘mainstream’.</p> <p>We’re not the only ones who expect that Rust will continue to grow because of this:</p> <blockquote> <p>The USA and its international partners have made the case in the last six months for adopting memory-safe languages. While Rust is not unique in this capability, its performance benefits alongside being memory-safe are likely to lead to further growth in this developer community. - <em>From <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://research.slashdata.co/reports/66546c6a78c13bcad12eac6e">SlashData’s Sizing Programming Languages Communities</a></em></p> </blockquote> <h3 id="ongoing-development"><a class="zola-anchor" href="#ongoing-development" aria-label="Anchor link for: ongoing-development">Ongoing development</a></h3> <p>Rust is a language with a wide surface area; engineers use it for projects ranging from embedded devices over backend services to high-performance storage engines and even space projects. This is possible due to Rust’s high adaptability. It can be integrated into existing codebases thanks to its excellent C/C++-compatible foreign function interface. It also has best-in-class WebAssembly support through multiple runtimes like Wasmtime and Cloudflare’s wrangler. And as we’re learning how to use the language to its full potential, new areas of Rust usage keep popping up, such as game development (e.g. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://bevyengine.org/">Bevy</a>).</p> <p>We previously noted that Rust package downloads are growing at an exponential rate, but creators are getting more productive too; The number of crates available <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lib.rs/stats">doubles</a> each year! And traffic on crates.io is 2.8x higher on weekdays than over the weekend, which indicates that most Rust development takes place in work-related projects.</p> <p>Continuous development doesn’t stop at the ecosystem level though. The language itself also keeps evolving.</p> <p>Rust’s approach to steady innovation is meant to ensure stability and it is achieved through its edition system. Editions are Rust releases, which are allowed to deprecate features and introduce breaking changes. Editions are rare, though. They happen roughly every three years (2018, 2021, and later this year).</p> <h2 id="challenges-to-rust-s-longevity"><a class="zola-anchor" href="#challenges-to-rust-s-longevity" aria-label="Anchor link for: challenges-to-rust-s-longevity">Challenges to Rust’s longevity</a></h2> <p>While it seems obvious to us that Rust does well on all three ‘markers of longevity’ - there is significant usage, the ecosystem is growing and rests on a solid foundation, and there is structural and ongoing development - we can’t predict the future. And ‘things happen’. So what could go wrong?</p> <ul> <li>Sponsorship could dry up. As we’ve mentioned before, Rust’s sponsorship doesn’t rely on a single big tech company, but rather a consortium of them, so we don’t think this scenario is a likely one, but it isn’t impossible.</li> <li>The ecosystem could split. It’s happened before to the Node ecosystem (and there already was a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/crablang/crab">Rust fork</a>). This is certainly not something for us to make any predictions about.</li> <li>Something better comes around, weakening Rust’s ‘raison d’être’. but that would actually be great! It would improve the status quo of our digital world (which is really what we Rust developers want most of all) and a rising tide lifts all. It’s highly unlikely that this would happen in the short term, as development of a language takes years. But we cannot guarantee that it won’t happen, of course (and we wouldn’t want to stop it if it did).</li> <li>Rust might become too complex. While we acknowledge the potential for Rust to increase in complexity as it evolves, we have the impression that the Rust community actively works to balance new features with maintainability and usability. In fact, except for async Rust, the language has reached a point of relative maturity.</li> <li>Hiring Rust devs is a challenge. This one, we have to cop to. The situation is getting better, there are solutions out there (train your own devs to use Rust, use educational materials like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-edu.org/">Rust Edu</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tweedegolf/teach-rs">teach-rs</a>), and this is a growing market, underscoring the ecosystem maturity… But it still isn’t easy.</li> </ul> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Rust is at an exciting point in its history. With large corporations investing heavily in Rust and engineers embracing the language, we believe Rust has a bright future ahead.</p> <p>If your organization is considering migrating to Rust and is unsure about the language’s long-term viability, we hope this information (be sure to check out some of the resources/links!) helps ease your decision-making process.</p> <p>And if you need assistance along the way, why not reach out to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tweedegolf.nl/en/expertise/rust-engineering">Tweede golf</a> and <a href="/services">corrode</a>?</p> Fri, 14 Jun 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/successful-rust-business-adoption-checklist/ https://corrode.dev/blog/successful-rust-business-adoption-checklist/ <p>Rust has quickly become a popular choice for teams seeking to write safe and efficient systems. Its unique blend of performance, safety, and concurrency makes it an attractive option for various applications, from embedded systems to web development.</p> <p>However, adopting Rustlang for your first production project requires careful planning and strategy. After all, this is a big deal: betting on a new programming language could be a business decision that you base the next ten years of your company on.</p> <p>The goal of this guide is to provide you with a comprehensive checklist and actionable advice to make your first real-world Rust project a success.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Looking for a Detailed Rust Project Plan?</p> </h4> </div> <p>Get my proven Rust project plan that I use for my consulting projects.<br /> <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.notion.site/8e2457230e75438f95e0620fcf09b034">Access it here</a> and customize it to fit your needs.</p> </div> <h2>Table of Contents</h2> <details class="toc"> <summary> Click here to expand the table of contents. </summary> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#know-why-you-are-considering-rust">Know Why You Are Considering Rust</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#get-the-buy-in-from-stakeholders">Get The Buy-In From Stakeholders</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#your-team-must-be-on-board">Your Team Must Be On Board</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#keep-an-eye-on-the-bus-factor">Keep an Eye on The Bus Factor</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#find-a-rust-champion">Find a Rust Champion</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#run-a-survey-to-gauge-interest-and-concerns">Run a Survey to Gauge Interest and Concerns</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#address-concerns-and-answer-questions-in-a-relaxed-setting">Address Concerns and Answer Questions in a Relaxed Setting</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#project-planning">Project Planning</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#finding-the-right-project">Finding The Right Project</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#choose-the-right-integration-method">Choose The Right Integration Method</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#check-the-ecosystem">Check the Ecosystem</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#set-standards-for-crates">Set Standards for Crates</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#establish-a-policy-on-async-rust">Establish a Policy on Async Rust</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#have-a-migration-strategy">Have a Migration Strategy</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#become-an-active-member-of-the-community">Become An Active Member Of The Community</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#project-setup">Project Setup</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#fully-embrace-rust-tooling">Fully Embrace Rust Tooling</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#consider-an-internal-styleguide">Consider An Internal Styleguide</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#team-building">Team Building</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#start-with-a-small-team">Start With a Small Team</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#start-a-team-channel">Start a Team Channel</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#consider-expert-mentorship">Consider Expert Mentorship</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#allocate-time-for-learning">Allocate Time for Learning</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#learning-resources">Learning Resources</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#budgeting">Budgeting</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#on-hiring-talent">On Hiring Talent</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#people-with-production-experience-are-hard-to-find-and-expensive">People with Production Experience Are Hard to Find and Expensive</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#source-talent-from-your-existing-teams-instead">Source Talent From Your Existing Teams Instead</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#scaling-the-team">Scaling The Team</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#ongoing-maintenance">Ongoing Maintenance</a> <ul> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#emphasize-code-reviews-and-pair-programming">Emphasize Code Reviews and Pair Programming</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#encourage-refactoring">Encourage Refactoring</a></li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#regularly-review-progress-and-adjust-strategies">Regularly Review Progress and Adjust Strategies</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/successful-rust-business-adoption-checklist/#next-steps">Next Steps</a></li> </ul> </details> <h2 id="know-why-you-are-considering-rust"><a class="zola-anchor" href="#know-why-you-are-considering-rust" aria-label="Anchor link for: know-why-you-are-considering-rust">Know Why You Are Considering Rust</a></h2> <p>Understanding <em>why</em> you are considering adopting Rust is crucial.</p> <ul> <li>Define clear goals and expectations for the project — this is a good idea, no matter if you decide on Rust or another language in the end.</li> <li>Set out to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=DnT-LUQgc7s">compare all the available options by fairly evaluating the pros and cons of each language</a> in a table or a document. Share this document with your team and stakeholders to fill in the gaps and ensure transparency.</li> <li>Focus on business value and long-term benefits, not personal preferences.</li> <li>Rust needs a catalyst for success, i.e., a clear benefit, which will be the driving force behind the adoption. Good catalysts are higher service stability, reduced operational costs, and better security. Don’t focus on performance alone.</li> <li>Write down your success criteria, such as improved robustness (lower number of bugs), developer productivity, and better scalability.</li> </ul> <h2 id="get-the-buy-in-from-stakeholders"><a class="zola-anchor" href="#get-the-buy-in-from-stakeholders" aria-label="Anchor link for: get-the-buy-in-from-stakeholders">Get The Buy-In From Stakeholders</a></h2> <h3 id="your-team-must-be-on-board"><a class="zola-anchor" href="#your-team-must-be-on-board" aria-label="Anchor link for: your-team-must-be-on-board">Your Team Must Be On Board</a></h3> <p>Introducing Rust will be a disruptive change, and it’s vital to have the backing from both the team and leadership. One side is not enough. Make sure everyone understands the <a href="/blog/why-rust">benefits and challenges of using Rust</a>.</p> <p>Rust is an organization-wide commitment, and it’s vital to have a long-term mindset. If you need to get something done quickly and can afford tech debt, consider using another language. However, for long-term projects, Rust’s benefits will offset the initial learning curve.</p> <p>Management should understand the benefits of Rust and be willing to invest in training, hiring, and tooling. They should also be aware of the potential challenges (e.g., delayed project timelines, increased costs, etc.) and have a clear understanding of the trade-offs involved.</p> <p>The magnitude of this decision should not be underestimated. Therefore, at the beginning of your adoption journey, consider bringing in a consultancy (<a href="/">like corrode</a>) to help decision-makers fully understand the costs and benefits of Rust. This can be crucial for assessing risks and avoiding major surprises down the road. While this means a higher upfront cost, it ultimately provides clarity and allows your team to focus on the technical aspects, setting the project up for success.</p> <h3 id="keep-an-eye-on-the-bus-factor"><a class="zola-anchor" href="#keep-an-eye-on-the-bus-factor" aria-label="Anchor link for: keep-an-eye-on-the-bus-factor">Keep an Eye on The Bus Factor</a></h3> <p>The <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Bus_factor">bus factor</a> is the number of people on your team who need to be hit by a bus before your project is in trouble. Make sure this bus factor is bigger than 1.</p> <p>Rust adoption should not be driven by ego or your CV but by business needs. If you love Rust, but your organization is not ready for it, don’t force it on them — it will fall back on you. There should always be more than one person who knows the system well enough to maintain it.</p> <p>Similarly, if you are the manager who has merely heard about the benefits of Rust, but your team is perfectly happy with the current technology stack, there might be no need to switch. Don’t choose Rust because of the hype; listen to your team.</p> <h3 id="find-a-rust-champion"><a class="zola-anchor" href="#find-a-rust-champion" aria-label="Anchor link for: find-a-rust-champion">Find a Rust Champion</a></h3> <p>Find a Rust champion within your team who is passionate about Rust, good at teaching, and willing to lead the adoption effort. They will serve as the cornerstone for your Rust adoption process and can significantly ease the learning process for the rest of the team.</p> <p>They don’t have to be a Rust expert, but ideally, a good champion already has some experience with Rust in production or has built a few larger side projects with it.</p> <p>If there is nobody willing to take on that role, reconsider if Rust is the right choice; perhaps the team is not ready for the transition yet or is satisfied with the current technology stack. An external consultant cannot replace an internal champion (if anything, they work in tandem). The initial motivation has to come from within.</p> <h3 id="run-a-survey-to-gauge-interest-and-concerns"><a class="zola-anchor" href="#run-a-survey-to-gauge-interest-and-concerns" aria-label="Anchor link for: run-a-survey-to-gauge-interest-and-concerns">Run a Survey to Gauge Interest and Concerns</a></h3> <p>Run a survey to gauge the team’s initial interest in Rust. Ask questions like:</p> <ul> <li>What is your current language of choice?</li> <li>On a scale from 1 to 5, how interested are you in learning Rust?</li> <li>What are your main concerns about adopting Rust?</li> <li>Which other languages would you consider for the project?</li> <li>What are the main benefits of choosing Rust for this project?</li> <li>Would you be willing to take on a Rust project? If so, in what capacity?</li> </ul> <p>If you need a comprehensive survey template to get started, feel free to <a href="/services">reach out to me</a>. The template includes detailed questions that can help uncover your team’s readiness and potential challenges for adopting Rust.</p> <h3 id="address-concerns-and-answer-questions-in-a-relaxed-setting"><a class="zola-anchor" href="#address-concerns-and-answer-questions-in-a-relaxed-setting" aria-label="Anchor link for: address-concerns-and-answer-questions-in-a-relaxed-setting">Address Concerns and Answer Questions in a Relaxed Setting</a></h3> <p>If you get mixed results, consider holding a Rust Q&amp;A session with the team on a Friday afternoon. This way, you can address concerns and answer questions in a relaxed environment.</p> <h2 id="project-planning"><a class="zola-anchor" href="#project-planning" aria-label="Anchor link for: project-planning">Project Planning</a></h2> <h3 id="finding-the-right-project"><a class="zola-anchor" href="#finding-the-right-project" aria-label="Anchor link for: finding-the-right-project">Finding The Right Project</a></h3> <p>My number one rule is: start small, but not too small.</p> <p>Begin with a project that is close to your core business but not mission-critical. This approach allows your team to gain experience with Rust with less disruption to the business.</p> <p>Choose a project in a domain you know very well. This way, you can focus on learning Rust and not on understanding the domain. On top of that, you can compare the performance of Rust with the existing system and see if it lives up to the expectations. It will be easier to onboard new team members if they are already familiar with the domain.</p> <h3 id="choose-the-right-integration-method"><a class="zola-anchor" href="#choose-the-right-integration-method" aria-label="Anchor link for: choose-the-right-integration-method">Choose The Right Integration Method</a></h3> <p>There are various ways to integrate Rust into your existing infrastructure:</p> <ul> <li><strong>CLI Tool</strong>: Develop a command-line tool in Rust.</li> <li><strong>FFI Layer</strong>: Call Rust code from another language using the Foreign Function Interface.</li> <li><strong>Microservice / Network Layer</strong>: Implement a microservice in Rust.</li> <li><strong>WebAssembly</strong>: Use Rust to compile to WebAssembly (e.g. for frontend).</li> <li><strong>Embedded System</strong>: Develop an embedded system in Rust.</li> </ul> <p>Pick the integration method which best aligns with your project’s requirements and team’s expertise. Choose a method that allows you to leverage Rust’s strengths while minimizing risks. Rust can be a great fit for performance-critical parts of your application, such as networking and data processing. Once the team sees the benefits of Rust, they will be more open to using it in other parts of the business. Pick a project with a huge upside and one that is easy to replace if things go wrong.</p> <p><strong>A microservice</strong> is a good candidate for this. In the worst case, you can rewrite it in another language. You can gradually shift over traffic to the Rust service and see how it performs in production.</p> <p>However, starting with a <strong>CLI tool</strong> might be easier for the team to manage and understand, even if it is not central to the core business. It can be a quick win and a manageable way to introduce Rust without significant risk, helping the team to see its potential.</p> <p>Beginning with <strong>WebAssembly</strong> can be challenging due to its complexity. The team might get frustrated with the tooling and ecosystem, and there might not be any immediate benefits, such as faster performance. This could lead to a negative impression of Rust.</p> <p>I saw some great results with Rust for <strong>embedded systems</strong>, where the tooling is excellent, and there is a clear project boundary. Tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://probe.rs/">probe-rs</a> are often considered best-in-class.</p> <p>The <strong>FFI layer</strong> is a good choice if you have a large codebase in another language and want to gradually replace parts of it with Rust. For example, some teams rewrite a performance-critical section of their Java monolith in Rust for 2-3x performance improvements. The <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/jni">jni crate</a> allows you to create a compatible library.</p> <h3 id="check-the-ecosystem"><a class="zola-anchor" href="#check-the-ecosystem" aria-label="Anchor link for: check-the-ecosystem">Check the Ecosystem</a></h3> <p>Before starting a Rust project, check the ecosystem for libraries, tools, and resources you will need. Make sure that the libraries are available and well-maintained. Look at the issues and documentation of critical crates for your project. Get familiar with the maintainers. Join the Discord or Matrix channels of the main crates you plan to use. This will give you a good idea of the health of the ecosystem and the community.</p> <h3 id="set-standards-for-crates"><a class="zola-anchor" href="#set-standards-for-crates" aria-label="Anchor link for: set-standards-for-crates">Set Standards for Crates</a></h3> <p>Some companies are fine with using any crate from crates.io, while others are more conservative and only use crates that have been around for a while and have a good reputation. I find <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blessed.rs/">blessed.rs</a> to be a good resource for finding high-quality crates.</p> <p>Choosing the right crates can have a big impact on the <a href="/blog/long-term-rust-maintenance/">long-term maintainability</a> of your project.</p> <p>Run <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/cargo-audit/latest/cargo_audit/">cargo-audit</a> regularly to check for security vulnerabilities in your dependencies.</p> <h3 id="establish-a-policy-on-async-rust"><a class="zola-anchor" href="#establish-a-policy-on-async-rust" aria-label="Anchor link for: establish-a-policy-on-async-rust">Establish a Policy on Async Rust</a></h3> <p>Async Rust requires proficiency in the language and can be challenging for beginners. <a href="/blog/async">Navigating the space is hard.</a></p> <p>Establish early on if you want to use async Rust in your project because it can have a big impact on your project. Some companies are fine with using async Rust everywhere, while others use it only when there is no other choice (e.g. the ecosystem does not provide a synchronous alternative). I saw success in keeping the core of the application synchronous while using async for I/O-bound tasks. For example, you could have a lib, which is synchronous and a wrapper around it that is async. This makes testing easier and allows you to use the synchronous lib in other projects.</p> <p>Either way, establish a policy early on and make sure everyone is on the same page.</p> <h3 id="have-a-migration-strategy"><a class="zola-anchor" href="#have-a-migration-strategy" aria-label="Anchor link for: have-a-migration-strategy">Have a Migration Strategy</a></h3> <p>Answer the following questions before starting the migration:</p> <ul> <li>What are the milestones for the migration?</li> <li>How will you handle the transition period? E.g., will you run both systems in parallel?</li> <li>How will you ensure that the team is productive during the migration?</li> <li>What is your fallback plan if the migration fails? Can you roll back to the old system?</li> <li>How will you measure the success of the migration? What are the key metrics?</li> <li>How will you ensure that the team is productive with the new technology?</li> </ul> <p>Document your position on these questions for future reference and to ensure that everyone is on the same page.</p> <h3 id="become-an-active-member-of-the-community"><a class="zola-anchor" href="#become-an-active-member-of-the-community" aria-label="Anchor link for: become-an-active-member-of-the-community">Become An Active Member Of The Community</a></h3> <p>If you’re starting to get serious about Rust, don’t stand on the sidelines! Engage with the Rust community through <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/">forums</a>, and share your insights on your developer blog. Subscribe to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://this-week-in-rust.org/">This Week in Rust</a> to stay up-to-date on the latest news and developments in the Rust ecosystem. Keep an eye on the announcements on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/">Rust blog</a> as well as the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://foundation.rust-lang.org/">Rust Foundation</a>. Being an active community member can provide valuable support and keep you updated on best practices.</p> <h2 id="project-setup"><a class="zola-anchor" href="#project-setup" aria-label="Anchor link for: project-setup">Project Setup</a></h2> <h3 id="fully-embrace-rust-tooling"><a class="zola-anchor" href="#fully-embrace-rust-tooling" aria-label="Anchor link for: fully-embrace-rust-tooling">Fully Embrace Rust Tooling</a></h3> <p>Rust has some of the best tooling in the industry. Make good use of it! Use <code>cargo fmt</code> to format your code, <code>cargo clippy</code> to catch common mistakes, and <code>cargo test</code> or <code>cargo nextest</code> to test your project.</p> <p>Use <code>rust-analyzer</code> for code completion and <code>rustup</code> to manage your Rust toolchain. There are also many other tools available, such as <code>cargo-watch</code> for automatically recompiling your code when it changes.</p> <p>For CI/CD, consider using GitHub Actions, GitLab CI, or Azure Pipelines. They all have good support for Rust. For GitHub Actions in particular, take a look at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/rust-toolchain">dtolnay/rust-toolchain</a>. Enforce <code>cargo fmt --check</code> and <code>cargo clippy</code> in your CI pipeline.</p> <p>Have these tools in place from the start and encourage all team members to routinely use them while developing. There should be no exceptions.</p> <h3 id="consider-an-internal-styleguide"><a class="zola-anchor" href="#consider-an-internal-styleguide" aria-label="Anchor link for: consider-an-internal-styleguide">Consider An Internal Styleguide</a></h3> <p>You can get pretty far with the above-mentioned tools. However, one often overlooked aspect is the social side of Rust. In languages like Python or Go, there typically is one idiomatic way to do things. That makes it easier to work in a group as the code looks coherent between authors and style discussions are reduced to a minimum.</p> <p>In Rust, that is not the case as there tend to be multiple ways to solve a problem, which all end up being valid. This can lead to style discussions and code reviews that are more about personal preference than actual issues. Ultimately, these discussions end up not creating business value and can be a source of frustration for the team.</p> <p>Typical areas of churn are:</p> <ul> <li>Zero-cost abstractions vs. explicitness: are <code>.clone()</code>s okay or should you introduce lifetimes instead?</li> <li>Generics: when does it make sense to introduce them? How many type parameters are too many?</li> <li>Static vs dynamic dispatch: is it okay to use <code>Box&lt;dyn Trait&gt;</code> or should you always use <code>impl Trait</code>?</li> <li>Macros: when are they okay and when should you avoid them? How complex can they get?</li> <li>Functional vs. imperative style: e.g. when is it okay to use <code>for</code> loops and when should you use iterators?</li> </ul> <p>It’s better to be upfront about these decisions and make them explicit.</p> <p>As the project evolves, try to document your standpoints on these topics in an internal style guide. This can be as simple as a markdown file in your repository. It will help new team members to get up to speed faster and reduce the amount of churn in code reviews.</p> <p>Here is my take on the above topics:</p> <ul> <li>Prefer explicitness over zero-cost abstractions. Only introduce lifetimes when necessary. <code>.clone()</code> is okay most of the time. If not, consider <code>Rc</code> or <code>Arc</code>. Always measure the performance impact before introducing lifetimes. In general, beginners <a href="/blog/lifetimes/">worry about lifetimes too much</a></li> <li>Generics are okay, but don’t overdo it. If you have more than 3 type parameters, consider if you can reduce them. If not, it might be a sign that your function is doing too much.</li> <li>Prefer <code>impl Trait</code> over <code>Box&lt;dyn Trait&gt;</code>, but don’t be religious about it. If a trait object reduces complexity, it’s okay to use it.</li> <li>Macros are okay for repetitive tasks (such as writing out an <code>impl</code> block for a long list of types), but avoid them for complex logic. Macros are hard to debug and can lead to cryptic error messages. They are almost like a language within a language.</li> <li>Use OOP/iterative style for global control flow and functional style for local transformations. Get acquainted with iterator patterns, but don’t overdo it. Sometimes a simple <code>for</code> loop is more readable than a chain of iterators. Read my post on <a href="/blog/iterators">thinking in iterators</a> to learn more.</li> </ul> <p>In general, resist the urge to be clever. Don’t expect everyone on the team to know every Rust feature like higher-level trait bounds or non-trivial lifetimes. Stuff like <code>impl &lt;T, U, V&gt; SomeTrait for YourType&lt;T, U, V&gt; where T: ....</code> is challenging to read and understand for most people.</p> <p>If you have to use advanced features, try to hide them behind a simple interface for the rest of the team.</p> <p>Don’t underestimate documentation. Perhaps you have a rule that you should always document public structs and functions and you enforce this in your CI pipeline. You can do so by adding <code>#![deny(missing_docs)]</code> at the top of your <code>lib.rs</code> or <code>main.rs</code> and the compiler will refuse to compile code if there is any public item without documentation.</p> <h2 id="team-building"><a class="zola-anchor" href="#team-building" aria-label="Anchor link for: team-building">Team Building</a></h2> <h3 id="start-with-a-small-team"><a class="zola-anchor" href="#start-with-a-small-team" aria-label="Anchor link for: start-with-a-small-team">Start With a Small Team</a></h3> <p>Start with a small team of 2-3 developers who are excited about Rust. They will be the pioneers and can help spread the word about Rust within the organization. Once the team has gained experience and confidence and has delivered a minimum viable product (MVP), you can expand the Rust team.</p> <h3 id="start-a-team-channel"><a class="zola-anchor" href="#start-a-team-channel" aria-label="Anchor link for: start-a-team-channel">Start a Team Channel</a></h3> <p>Create a dedicated channel for the Rust team on your company’s communication platform (e.g., Slack, Discord, or Microsoft Teams). This channel can be used to share resources, ask questions, and discuss Rust-related topics. It’s a great way to build a sense of community and encourage knowledge sharing among team members.</p> <h3 id="consider-expert-mentorship"><a class="zola-anchor" href="#consider-expert-mentorship" aria-label="Anchor link for: consider-expert-mentorship">Consider Expert Mentorship</a></h3> <p>Many companies wait too long to get professional help for their Rust projects. Some may have been burned in the past by hiring consultants who didn’t deliver what they promised. Other organizations think they can do it all by themselves, but this often leads to a hard-to-maintain codebase, poor developer experience, frustration, and in the worst case, the discontinuation of the project.</p> <p>On the other hand, a good instructor can be an accelerator. They can help avoid costly mistakes, ask the hard questions around Rust adoption, and set the team up for success. Hiring consultants can accelerate the exploration process and mitigate risks. Experts can scaffold the project architecture, implement best practices like testing and CI/CD, and train the team, ensuring a smooth transition for everyone involved.</p> <p>Most importantly, bringing in a consultant early in the project can eliminate the “unknown unknowns” for your team and back up your decisions with expert advice.</p> <p>Many companies fear the cost of hiring consultants. However, clarifying things early on and avoiding costly mistakes can be more economical in the long run. The team will benefit the most early on, starting with a solid foundation.</p> <p>Even if it turns out that Rust is not the right choice for your project, it’s better to know that sooner rather than later. You can document the reasons which led to this decision and share them with the team for transparency. When the question comes up again in the future, you can refer back to this document and save time.</p> <div style="display: flex; justify-content: space-evenly; align-items: stretch; gap: 20px;"> <p style="flex: 1; margin: 0; display: flex; align-items: center;"> Think of it like this: if you were to go rock climbing for the first time, would you rather have a seasoned climbing partner or go it alone? The guide can help you avoid dangerous routes, give you some tips, and make the experience much more pleasant for everyone involved. </p> <img src="climb.svg" alt="A good consultant is like a climbing partner or belayer" width="100" height="153"> </div> <h3 id="allocate-time-for-learning"><a class="zola-anchor" href="#allocate-time-for-learning" aria-label="Anchor link for: allocate-time-for-learning">Allocate Time for Learning</a></h3> <p>Once an initial prototype is in place, it’s time to bring on the rest of the team.</p> <p>The biggest concern about Rust that I hear from engineers is that they are worried they won’t have enough time to properly learn Rust. Set aside dedicated learning time for your team to get up to speed with Rust. Encourage your team to work on small Rust projects or contribute to open-source projects to gain practical experience. It takes around <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html">4 months to get comfortable with Rust</a>, so plan accordingly.</p> <p>This might be a good time to compare Rust workshops and training programs. Some consultancies (like <a href="/">corrode</a>) offer dedicated Rust training for teams and provide discounts for larger groups. An on-site training can be a great way to kick off your Rust project and get everyone excited about the opportunity to work on the project. Remember to plan some time to schedule the training and to get the budget approved, so reach out to the training provider early.</p> <h3 id="learning-resources"><a class="zola-anchor" href="#learning-resources" aria-label="Anchor link for: learning-resources">Learning Resources</a></h3> <p>No matter how you plan to integrate Rust into your project, make sure to read up on the language and its ecosystem. Here are the best resources I know of right now:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/">The Rust Book</a>: A must-read for every developer on the team. Make sure that everyone on the team gets a copy or reads it online.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustlings">Rustlings</a>: Fun, short exercises to get started with Rust.</li> </ul> <p>Which resources I would recommend after that depends on the team’s background and the project’s requirements. Take a look at this <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/sger/RustBooks">Rust books list</a>, our <a href="/blog/rust-learning-resources-2026/">curated Rust learning resources</a>, and resources for <a href="/blog/idiomatic-rust-resources/">idiomatic Rust</a>.</p> <h2 id="budgeting"><a class="zola-anchor" href="#budgeting" aria-label="Anchor link for: budgeting">Budgeting</a></h2> <p>To avoid any surprises, it’s essential to plan your budget carefully. Be aware of the (hidden) costs associated with adopting Rust. And there’s quite a few of them.</p> <details> <summary>Click here to expand the list.</summary> <ol> <li> <p><strong>Initial Setup and Planning</strong></p> <ul> <li>Rust exploration and evaluation (conducting surveys, research)</li> <li>Alignment between stakeholders (meetings, design documents)</li> <li>Planning and architecture</li> <li>Feasibility study (proof of concept for your domain)</li> <li>Transition management (project management resources)</li> </ul> </li> <li> <p><strong>Opportunity costs</strong></p> <ul> <li>Costs of delaying other projects and features: time spent on Rust could be devoted to other projects.</li> </ul> </li> <li> <p><strong>Training and Team Preparation</strong></p> <ul> <li>Training (4 months of dedicated time)</li> <li>Rust training and resources (books, online courses, conferences)</li> <li>Mentorship and coaching</li> <li>Team building activities (team lunches, offsites)</li> </ul> </li> <li> <p><strong>Hiring and Team Expansion</strong></p> <ul> <li>Staffing costs for Rust developers (recruiting, job postings, onboarding)</li> <li>Hiring people in infrastructure roles (SREs, DevOps)</li> </ul> </li> <li> <p><strong>Setup Costs</strong></p> <ul> <li>Project structure</li> <li>Workflows and tools (IDEs, linters, formatters)</li> <li>Tooling setup (initial configuration of development environments)</li> <li>CI/CD pipelines</li> </ul> </li> <li> <p><strong>Development and Implementation</strong></p> <ul> <li>Costs of fast development machines (<a href="/blog/tips-for-faster-rust-compile-times/">Rust builds are hardware-intensive</a>)</li> <li>Development costs (coding, testing, debugging)</li> <li>Documentation</li> <li>Writing guidelines and best practices</li> <li>Code reviews and pair programming (to ensure code quality and knowledge sharing)</li> <li>Performance tuning (if needed)</li> <li>Security audits</li> <li>Compliance and legal reviews (regulations and standards, e.g. GDPR or software licenses)</li> </ul> </li> <li> <p><strong>Infrastructure and Tooling</strong></p> <ul> <li>Licensing for proprietary tools (rarely needed, but consider it)</li> <li>Additional hardware during migration (a separate set of infrastructure for the new system)</li> <li>Monitoring and alerting tools (tools for monitoring performance and reliability)</li> </ul> </li> <li> <p><strong>Ongoing Maintenance and Support</strong></p> <ul> <li>Cloud costs (compute, storage, networking)</li> <li>Ongoing maintenance costs (monitoring, logging, on-call, CI/CD pipelines)</li> <li>Refactoring and cleaning up technical debt</li> </ul> </li> <li> <p><strong>Communication and Marketing</strong></p> <ul> <li>Internal communication (presentations)</li> <li>External communication (blog posts, conference talks)</li> </ul> </li> <li> <p><strong>Risk Management</strong></p> <ul> <li>Account for the cost of failure</li> <li>Consider costs of rollback mechanisms</li> <li>Costs of rollback if the migration fails</li> <li>Contingency funds (allocating a budget for unforeseen expenses)</li> </ul> </li> </ol> </details> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>How Much Will Your Rust Project Cost?</p> </h4> </div> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.notion.site/862b591975e64a72aba3f8c66e01a3f1">Here’s my detailed checklist for budgeting Rust projects.</a></p> <p>I use this list to help my clients plan their Rust projects and avoid any surprises. By going through this checklist, you can make sure that you have considered all major costs associated with adopting Rust and have a clear plan for your project.</p> <p>Feel free to make a copy and adapt it to suit your project’s needs.</p> </div> <h2 id="on-hiring-talent"><a class="zola-anchor" href="#on-hiring-talent" aria-label="Anchor link for: on-hiring-talent">On Hiring Talent</a></h2> <p>Hiring Rust talent takes time and effort. This section provides insights into hiring strategies and what to look for in candidates for Rust projects specifically.</p> <p>For a comprehensive guide on hiring Rust developers, see our dedicated article on <a href="/blog/hiring-rust-engineers/">How to Hire Rust Engineers</a>.</p> <h3 id="people-with-production-experience-are-hard-to-find-and-expensive"><a class="zola-anchor" href="#people-with-production-experience-are-hard-to-find-and-expensive" aria-label="Anchor link for: people-with-production-experience-are-hard-to-find-and-expensive">People with Production Experience Are Hard to Find and Expensive</a></h3> <p>It’s challenging to find developers with Rust <em>production</em> experience. Competing with the crypto industry, which heavily uses Rust, makes it even harder. Salaries for Rust developers in crypto can be 2-3 times higher than in other industries, and the pool of talent is small.</p> <p>Unless you are a hot new startup or have a big budget, finding people with Rust production experience can be challenging and costly. Consider training your own team instead.</p> <h3 id="source-talent-from-your-existing-teams-instead"><a class="zola-anchor" href="#source-talent-from-your-existing-teams-instead" aria-label="Anchor link for: source-talent-from-your-existing-teams-instead">Source Talent From Your Existing Teams Instead</a></h3> <p>Instead of focusing solely on experience, consider finding junior- to mid-level developers who are smart, curious, and eager to learn. From my experience, good candidates often have experience in related areas (like Kotlin or TypeScript) and are known for being quick learners. Place them near your Rust champion or an expert mentor to help them get up to speed quickly.</p> <p>People in infrastructure roles are also a great fit. Those who tend to have an interest in scalability, performance, and networking can also be great additions to your team. Look for those with previous admin roles, who have worked close to the metal and have a good understanding of how things work under the hood. These people are often excited to pick up Rust as their background aligns well with the language’s strengths.</p> <h3 id="scaling-the-team"><a class="zola-anchor" href="#scaling-the-team" aria-label="Anchor link for: scaling-the-team">Scaling The Team</a></h3> <p>Once your project reaches a certain level of maturity, you can start hiring Rust developers to scale your team and maintain the project.</p> <p>Using Rust can be a competitive advantage for smaller companies, as it attracts developers who are excited about the language’s potential. Companies like InfluxData have seen a notable increase in interest from developers after announcing projects involving Rust:</p> <blockquote> <p>I announced that we’re working on this new core of the database in November of 2020 in a talk I did. And I said we were hiring and we got a bunch of inbound interest because of the fact that it was written in Rust. — Paul Dix, InfluxData</p> </blockquote> <p>If you’re interested in learning more about hiring Rust developers, don’t miss the season finale of ‘Rust in Production.’ Paul Dix from InfluxData and Micah Wylde from Arroyo share insights on why smaller companies find hiring Rust talent a competitive advantage while larger companies face unique challenges.</p> <p>Find the section from the episode about hiring Rust engineers <a href="/podcast/s01e07-season-finale/?t=23%3A06">here</a>.</p> <h2 id="ongoing-maintenance"><a class="zola-anchor" href="#ongoing-maintenance" aria-label="Anchor link for: ongoing-maintenance">Ongoing Maintenance</a></h2> <p>I wrote a separate <a href="/blog/long-term-rust-maintenance/">blog post on long-term Rust maintenance</a>, which might be helpful for you, but here are some specific tips for your first Rust project:</p> <h3 id="emphasize-code-reviews-and-pair-programming"><a class="zola-anchor" href="#emphasize-code-reviews-and-pair-programming" aria-label="Anchor link for: emphasize-code-reviews-and-pair-programming">Emphasize Code Reviews and Pair Programming</a></h3> <p>Code reviews and pair programming are a great way to share knowledge and best practices among team members. Make sure that code reviews are a regular part of your development process and that everyone on the team understands the importance of them.</p> <p>Consider strategies like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Mob_programming">mob programming</a> to get the team up to speed quickly. This can be especially helpful for new team members who are still learning Rust and might be too shy to ask questions in a code review or on a team channel.</p> <h3 id="encourage-refactoring"><a class="zola-anchor" href="#encourage-refactoring" aria-label="Anchor link for: encourage-refactoring">Encourage Refactoring</a></h3> <p>Encourage your team to refactor code regularly to keep it clean and maintainable. Make sure it is a regular part of your development process and that everyone on the team can change the codebase without fear. Unless you work in a safety-critical environment, everyone should be able to make changes to the codebase without asking for permission.</p> <h3 id="regularly-review-progress-and-adjust-strategies"><a class="zola-anchor" href="#regularly-review-progress-and-adjust-strategies" aria-label="Anchor link for: regularly-review-progress-and-adjust-strategies">Regularly Review Progress and Adjust Strategies</a></h3> <p>As you go, adjust your strategies as needed. Make sure that you are hitting your milestones and that the team feels productive.</p> <p>Some projects have the tendency to become overly complex, so regularly ask newcomers to review the codebase and give feedback on what they find confusing. Keep the code straightforward and fight abstractions. Focus on being readable, not clever.</p> <h2 id="next-steps"><a class="zola-anchor" href="#next-steps" aria-label="Anchor link for: next-steps">Next Steps</a></h2> <p>By acknowledging the challenges and following these strategies, you can ensure a successful Rust adoption for your first production project. With careful planning and a dedicated team, Rust can drive significant improvements in your organization.</p> <p>Check out our <a href="/podcast/">‘Rust in Production’ podcast</a> for insights from industry experts on how their teams successfully adopted Rust in production.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Need Help with Your Rust Project?</p> </h4> </div> <p>If you’re considering adopting Rust for your next project, I can help you get started. <a href="/#contact">Reach out for a free consultation</a> if you need help with your Rust project. I’m happy to help you get the most out of Rust and guide you through the process.</p> </div> Thu, 13 Jun 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e04-matic/ https://corrode.dev/podcast/s02e04-matic/ <div><script id="letscast-player-4581d80f" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-11-matic-s-eric-seppanen-d520caf8-fa28-43d4-863e-a3360e1b53d3/player.js?size=s"></script></div> <p>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.</p> <p>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.</p> Thu, 30 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e03-thunderbird/ https://corrode.dev/podcast/s02e03-thunderbird/ <div><script id="letscast-player-d02c0302" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-10-thunderbird-s-brendan-abolivier/player.js?size=s"></script></div> <p>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).</p> <p>Dealing with a legacy codebase that serves 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.</p> <p>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.</p> Wed, 29 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/lifetimes/ https://corrode.dev/blog/lifetimes/ <p>When people say that learning Rust is hard, they often mention lifetimes. However, even after seven years of writing Rust, 95% of my code, probably more, doesn’t have any lifetime annotations! It is one of the areas of the language that I definitely worried way too much about when learning Rust, and I see many beginners do the same.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Disclaimer: When Lifetimes Really Matter</p> </h4> </div> <p>The advice in this article is focused on common scenarios. There are cases where you <em>do</em> have to worry about lifetimes.</p> <p>If you’re working in areas like embedded systems, real-time applications, or other performance-critical environments, you might encounter scenarios where dealing with lifetimes is essential. In such cases, please consult the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/nomicon/lifetime-elision.html">section on lifetime elision in the Rustonomicon</a> for more detailed information.</p> </div> <h2 id="what-are-lifetimes"><a class="zola-anchor" href="#what-are-lifetimes" aria-label="Anchor link for: what-are-lifetimes">What are lifetimes?</a></h2> <p>Lifetimes tell the compiler how long a reference is valid.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt;(bar</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Here, I’m telling the compiler: “this reference <code>bar</code> is valid for the lifetime <code>'a</code>.” The compiler will then check that the reference is indeed not used after the lifetime <code>'a</code> ends. If this still sounds like gibberish to you, please continue reading.</p> <p>Rust has a concept of lifetime <em>elision</em>, which means that you don’t have to write lifetime annotations in most cases; the compiler will infer them for you.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Lifetime Elision Recap</p> </h4> </div> <p>The rules are simple:</p> <ol> <li>Every input reference to a function gets a distinct lifetime.</li> <li>If there’s exactly one input lifetime, it gets applied to all output references.</li> <li>If there are <em>multiple</em> input lifetimes but one of them is <code>&amp;self</code> or <code>&amp;mut self</code>, then the lifetime of <code>self</code> is applied to all output references.</li> </ol> <p>That means you only have to write out the lifetimes yourself if you have more than one input lifetime and none of them are <code>&amp;self</code> or <code>&amp;mut self</code>.</p> </div> <p>In the example above, we have one input lifetime, so we don’t have to write it out. This is equivalent (and easier on the eyes):</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>(bar</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>It turns out, lifetimes are <em>everywhere</em> in Rust, but they are just <em>implicit</em> most of the time. That’s a good thing.</p> <h2 id="lifetimes-are-contagious"><a class="zola-anchor" href="#lifetimes-are-contagious" aria-label="Anchor link for: lifetimes-are-contagious">Lifetimes are contagious!</a></h2> <p>The problem with lifetimes is that they spread in your codebase like a virus. Once you add a lifetime annotation, you have to add it to all the functions that call it, and all the functions that call those functions, and so on.</p> <p>For example, let’s say you have a struct that contains a <code>String</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span> {</span></span> <span class="giallo-l"><span> bar</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>And you want to optimize it by using a <code>&amp;str</code> instead to avoid allocations:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Foo</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt; {</span></span> <span class="giallo-l"><span> bar</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Now you have to add the lifetime annotation to all the functions that use <code>Foo</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> foo</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt;(foo</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a Foo</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This can get out of hand very quickly. The function signature is now more complex, and it is harder to understand what the function does. Refactoring gets harder because you have to carry over the lifetime annotations. Lifetimes are not free! It’s easy to back yourself into a corner where making fundamental changes to your code becomes difficult. As such, explicit lifetimes should be treated as a last resort because they increase tech debt and alienate beginners.</p> <h2 id="reasons-for-lifetimes"><a class="zola-anchor" href="#reasons-for-lifetimes" aria-label="Anchor link for: reasons-for-lifetimes">Reasons for lifetimes</a></h2> <p>Nowadays, I consider it an anti-pattern to prematurely add lifetime annotations to a piece of code without a good reason. There’s really only two situations where you should add lifetime annotations:</p> <ol> <li><strong>There is a performance bottleneck</strong>: You found a slow piece of code in your hot path, and you have profiled it and determined that the bottleneck is indeed because of allocations. In this case, it could make sense to use lifetimes to avoid allocations. (The alternative is to refactor your code to use a better algorithm to avoid the hot path in the first place.)</li> <li><strong>Code that you depend on requires lifetime annotations:</strong> There’s little you can do about this, other than to look for alternatives that don’t require lifetimes.</li> </ol> <h2 id="don-t-be-afraid-of-lifetimes-either"><a class="zola-anchor" href="#don-t-be-afraid-of-lifetimes-either" aria-label="Anchor link for: don-t-be-afraid-of-lifetimes-either">Don’t Be Afraid Of Lifetimes Either</a></h2> <p>What if you depend on a library that requires lifetime annotations?</p> <p>One example is Servo’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/servo/html5ever/"><code>html5ever</code></a>, a high-performance HTML parser written in Rust. It uses lifetimes extensively to ensure memory safety and performance. When using such a library, you have to deal with lifetimes, whether you like it or not. However, understanding the basics of lifetimes can help you navigate these situations more effectively. Remember that lifetimes are there to help you write safe and efficient code. They are not something to be afraid of but rather a powerful tool in your Rust toolbelt.</p> <p>It’s wise to get comfortable with lifetimes even if you don’t use them often.</p> <h2 id="a-practical-example"><a class="zola-anchor" href="#a-practical-example" aria-label="Anchor link for: a-practical-example">A Practical Example</a></h2> <p>Let’s look at a practical example where lifetimes need to be explicitly added. Consider a function that returns the longest of two string slices.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> longest</span><span>(x</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>, y</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> x</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt; y</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() {</span></span> <span class="giallo-l"><span> x</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> y</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If we tried to compile that, we’d get an error:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>error[E0106]: missing lifetime specifier</span></span> <span class="giallo-l"><span> --&gt; src/lib.rs:1:33</span></span> <span class="giallo-l"><span> |</span></span> <span class="giallo-l"><span>1 | fn longest(x: &amp;str, y: &amp;str) -&gt; &amp;str {</span></span> <span class="giallo-l"><span> | ---- ---- ^ expected named lifetime parameter</span></span> <span class="giallo-l"><span> |</span></span> <span class="giallo-l"><span> = help: this function&#39;s return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`</span></span> <span class="giallo-l"><span>help: consider introducing a named lifetime parameter</span></span> <span class="giallo-l"><span> |</span></span> <span class="giallo-l"><span>1 | fn longest&lt;&#39;a&gt;(x: &amp;&#39;a str, y: &amp;&#39;a str) -&gt; &amp;&#39;a str {</span></span> <span class="giallo-l"><span> | ++++ ++ ++ ++</span></span></code></pre> <p>What went wrong?</p> <h2 id="put-yourself-into-the-shoes-of-the-compiler"><a class="zola-anchor" href="#put-yourself-into-the-shoes-of-the-compiler" aria-label="Anchor link for: put-yourself-into-the-shoes-of-the-compiler">Put Yourself Into the Shoes of the Compiler</a></h2> <p>To understand the error, imagine you are the Rust compiler. Your job is to ensure that references are always valid and that no reference outlives the data it points to. In this example, the function <code>longest</code> takes two string slices and returns one of them.</p> <p>As the compiler, you see that the function signature promises to return a reference (<code>&amp;str</code>), but it doesn’t specify which input reference (<code>x</code> or <code>y</code>) it corresponds to. We face a dilemma: Will the returned string live as long as <code>x</code> or <code>y</code>?</p> <img src="ferris.svg" alt="Ferris the crab, the Rust mascot, pondering a dilemma about the function's lifetimes" class="noinvert"> <p>It depends on which of the two strings is longer and this can only be determined at runtime.</p> <p>Without this knowledge, you can’t confirm that the returned reference will be valid: You need to specify the <em>relationship</em> between the input and the output to make this guarantee. If you pick the wrong one, you might end up with a dangling reference. The ambiguity makes it impossible for the compiler to guarantee the safety of the returned reference. You need to provide more information to the compiler to resolve this ambiguity.</p> <p>To fix this, we need to add a lifetime parameter to the function signature:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> longest</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt;(x</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>, y</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> x</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt; y</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() {</span></span> <span class="giallo-l"><span> x</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> y</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>By adding <code>'a</code>, we specify that both input references <code>x</code> and <code>y</code> have the same lifetime <code>'a</code>, and the returned reference will also have this lifetime. This makes it clear to the compiler that the returned reference is guaranteed to be valid as long as <em>both</em> input references are valid. Now, the compiler can safely check and ensure that the references are used correctly throughout the code.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Side Note: Other Programming Languages</p> </h4> </div> <p>“Hold on,” you might say, “other programming languages don’t require me to think about lifetimes. Why does Rust make it so complicated?”</p> <p>The C programming language will happily let you access memory that has been freed, leading to undefined behavior. It will watch in silence as you walk off the edge of a cliff.</p> <p>Dangling pointers are a common source of bugs, and this is what lifetimes in Rust aim to prevent. The Rust compiler makes you stop and think about the ambiguity in your code and forces you to make relationships between data explicit.</p> <p>“But what about Python, PHP, or Java? We don’t have to worry about lifetimes there, right?”</p> <p>Yes, these languages have systems like reference counting or garbage collectors in place, which automatically manage memory for you. There is an overhead to these mechanisms, though. In some restricted environments, like embedded systems or real-time applications, automatic memory management is not even an option because it can introduce unpredictable garbage collector pauses or the environment doesn’t provide a runtime.</p> <p>Rust’s lifetimes are a way to ensure memory safety without overhead at the small cost of being explicit about lifetimes in the face of ambiguity.</p> </div> <h2 id="lifetimes-as-a-way-to-convey-intent"><a class="zola-anchor" href="#lifetimes-as-a-way-to-convey-intent" aria-label="Anchor link for: lifetimes-as-a-way-to-convey-intent">Lifetimes As A Way To Convey Intent</a></h2> <p>Part of why lifetimes can look scary is that they are often named <code>'a</code>, <code>'b</code>, or <code>'c</code>. This makes them look like some kind of academic, mathematical notation. That’s just a convention to make them quicker to write, though, and coming up with better names is hard!</p> <p>It can be helpful to think of lifetimes as “labels” — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.possiblerust.com/pattern/naming-your-lifetimes">you can name them however you want</a> to make your code more understandable. For instance:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Now it is clear that the processed data is tied to the input data</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> process_input</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">input</span><span>&gt;(data</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">input str</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">input str</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Naming lifetimes can be quite helpful if you need to juggle multiple borrow sources or when you want to express the origin of a reference more clearly. Serde uses this technique to great effect in its <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/serde/latest/serde/trait.Deserialize.html"><code>Deserialize</code></a> trait:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> deserialize</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">de</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> D</span><span>&gt;(deserializer</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> D</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> D</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> D</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Deserializer</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">de</span><span>&gt;,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Here, <code>'de</code> means “this lifetime is tied to the deserializer” or “this thing lives as long as the deserializer does.” Suddenly, that syntax makes a lot more sense!</p> <p>If you’re curious, see <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://serde.rs/lifetimes.html">serde’s detailed explanation of deserializer lifetimes </a>.</p> <p>Think of lifetimes as type signatures: most of the time, they can be inferred, but at times it’s clearer to spell them out to avoid mistakes. Plus, these explicit annotations double as useful documentation.</p> <h2 id="avoiding-lifetimes-with-smart-pointers"><a class="zola-anchor" href="#avoiding-lifetimes-with-smart-pointers" aria-label="Anchor link for: avoiding-lifetimes-with-smart-pointers">Avoiding Lifetimes With Smart Pointers</a></h2> <p>You might think that you have to introduce a lifetime if you want to avoid unnecessary copies; for example, when handling a big chunk of data.</p> <p>However, you can also use smart pointers like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/rc/struct.Rc.html"><code>Rc</code></a> (reference-counted) or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/sync/struct.Arc.html"><code>Arc</code></a> (atomic reference-counted) to share ownership of the data. This way, you don’t need to worry about explicit lifetimes while keeping the cost of cloning the data close to zero. It’s a good trade-off in many situations.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// We only pay for the allocation once</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> hello</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Rc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Hello&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// This is a cheap operation</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> hello2</span><span style="color: #FF79C6;"> =</span><span> hello</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">clone</span><span>();</span></span></code></pre> <p>Here’s how you could use <code>Rc</code> to avoid lifetimes in the <code>longest</code> function:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>rc</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Rc</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> longest</span><span>(x</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Rc</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;, y</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Rc</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Rc</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> x</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt; y</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() {</span></span> <span class="giallo-l"><span> x</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span> y</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>That’s just a silly example (and you’d probably use <code>String</code> anyway in that case), but it shows how you can sidestep lifetimes by using reference-counted pointers.</p> <h2 id="when-not-to-use-lifetimes"><a class="zola-anchor" href="#when-not-to-use-lifetimes" aria-label="Anchor link for: when-not-to-use-lifetimes">When (Not) To Use Lifetimes</a></h2> <p>Sometimes, the compiler is a bit too eager in suggesting lifetimes. More often than not, the better alternative is to refactor your code. It might not always be clear how to do this, so here’s a flowchart to help you decide when lifetime annotations are truly necessary or which refactoring strategies are available.</p> <img src="decision-tree.svg" alt="Flow chart on how to decide on using lifetimes or not"> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>All references (borrows) in Rust have lifetimes. The compiler tracks them, whether they’re explicit or not.</p> <p>At the start of my Rust journey, I worried way too much about lifetimes. I thought they were the key to understanding Rust and that I need to master them to write idiomatic code. But it turns out you don’t need to worry about lifetimes all that much.</p> <p>Nowadays, most of my code is free of explicit lifetimes. I only have to add lifetimes in two kinds of situations: returning references from a function and storing a reference in a struct.</p> <p>In all other cases, the compiler does a great job of inferring lifetimes for you, and you should only add them when you have a good reason to do so, i.e. when the compiler tells you to, when optimizing for performance, or when you want to explicitly describe the relationships in your code to humans.</p> Thu, 16 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e02-amp/ https://corrode.dev/podcast/s02e02-amp/ <div><script id="letscast-player-8087b1dc" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-9-amp-s-carter-schultz/player.js?size=s"></script></div> <p>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.</p> <p>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.</p> Wed, 15 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/iterators/ https://corrode.dev/blog/iterators/ <p>Python has this really neat feature called <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions">list comprehensions</a>.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="python"><span class="giallo-l"><span style="color: #6272A4;"># A list of bands</span></span> <span class="giallo-l"><span>bands</span><span style="color: #FF79C6;"> =</span><span> [</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Metallica</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Iron Maiden</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">AC/DC</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Judas Priest</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Megadeth</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span>]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># A list comprehension to filter for bands that start with &quot;M&quot;</span></span> <span class="giallo-l"><span>m_bands</span><span style="color: #FF79C6;"> =</span><span> [band</span><span style="color: #FF79C6;"> for</span><span> band</span><span style="color: #FF79C6;"> in</span><span> bands</span><span style="color: #FF79C6;"> if</span><span> band.startswith(</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">M</span><span style="color: #E9F284;">&quot;</span><span>)]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># A list comprehension to uppercase the bands</span></span> <span class="giallo-l"><span>uppercased</span><span style="color: #FF79C6;"> =</span><span> [band.upper()</span><span style="color: #FF79C6;"> for</span><span> band</span><span style="color: #FF79C6;"> in</span><span> m_bands]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># We get [&quot;METALLICA&quot;, &quot;MEGADETH&quot;] </span></span></code></pre> <p>List comprehensions are a concise way to create lists from other lists, but they work with any iterable, like dicts!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="python"><span class="giallo-l"><span>books</span><span style="color: #FF79C6;"> =</span><span> {</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">The Lord of the Rings</span><span style="color: #E9F284;">&quot;</span><span>:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">J. R. R. Tolkien</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">The Hobbit</span><span style="color: #E9F284;">&quot;</span><span>:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">J. R. R. Tolkien</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Harry Potter</span><span style="color: #E9F284;">&quot;</span><span>:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">J. K. Rowling</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span>tolkien_books</span><span style="color: #FF79C6;"> =</span><span> [</span></span> <span class="giallo-l"><span> book</span><span style="color: #FF79C6;"> for</span><span> book, author</span><span style="color: #FF79C6;"> in</span><span> books.items()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Tolkien</span><span style="color: #E9F284;">&quot;</span><span style="color: #FF79C6;"> in</span><span> author</span></span> <span class="giallo-l"><span>]</span></span> <span class="giallo-l"><span style="color: #6272A4;"># tolkien_books = [&quot;The Lord of the Rings&quot;, &quot;The Hobbit&quot;]</span></span></code></pre> <p>As a Pythonista, list comprehensions became second nature to me. Their elegance is hard to beat. For a long time, I wished Rust had something similar. It was one of the few things I <em>profoundly</em> missed from Python — until I learned more about the philosophy behind Rust’s iterator patterns.</p> <h2 id="enter-rust-s-iterators"><a class="zola-anchor" href="#enter-rust-s-iterators" aria-label="Anchor link for: enter-rust-s-iterators">Enter Rust’s Iterators</a></h2> <p>Rust has a notion of <em>chainable operations</em> on iterators, forming a pipeline where each operation is applied to every element in sequence. Two of the most common operations are <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map"><code>map</code></a>, which applies a function to each item, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter"><code>filter</code></a>, which selectively includes items that meet a certain condition.</p> <p>Here’s the equivalent Rust code for the first Python example above:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> bands</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Metallica&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Iron Maiden&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;AC/DC&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Judas Priest&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #F1FA8C;"> &quot;Megadeth&quot;</span><span>,</span></span> <span class="giallo-l"><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> uppercased</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;_&gt;</span><span style="color: #FF79C6;"> =</span><span> bands</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">starts_with</span><span>(</span><span style="color: #F1FA8C;">&quot;M&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_uppercase</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// uppercased = vec![&quot;METALLICA&quot;, &quot;MEGADETH&quot;]</span></span></code></pre> <p>Sure, it’s a tad more verbose than Python’s list comprehensions, but oh, the versatility!</p> <p>For example, debugging an iterator chain is as simple as inserting an <code>inspect</code> wherever you want to peek at the elements:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> uppercased</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;_&gt;</span><span style="color: #FF79C6;"> =</span><span> bands</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">starts_with</span><span>(</span><span style="color: #F1FA8C;">&quot;M&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">inspect</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Found band that starts with M: {band}&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>band</span><span style="color: #FF79C6;">|</span><span> band</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_uppercase</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span></code></pre> <p>Achieving the same effect with list comprehensions in Python is quite tricky.</p> <p>I often find myself chaining iterator operations in Rust. And honestly? It’s pretty intuitive. Over time, I’ve even grown fond of its explicitness. (Or, you know, maybe it’s just some form of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Stockholm_syndrome">Stockholm syndrome</a>.)</p> <p>What I like the most is the flexibility of this pattern. Let me demonstrate!</p> <h2 id="collecting-into-different-types"><a class="zola-anchor" href="#collecting-into-different-types" aria-label="Anchor link for: collecting-into-different-types">Collecting into different types</a></h2> <p>In Python, you can collect into different types like a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.python.org/3/tutorial/datastructures.html#sets"><code>set</code></a>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="python"><span class="giallo-l"><span>tolkien_books</span><span style="color: #FF79C6;"> =</span><span> {</span></span> <span class="giallo-l"><span> book</span><span style="color: #FF79C6;"> for</span><span> book, author</span><span style="color: #FF79C6;"> in</span><span> books.items()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">Tolkien</span><span style="color: #E9F284;">&quot;</span><span style="color: #FF79C6;"> in</span><span> author</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"><span style="color: #6272A4;"># It&#39;s a set!</span></span> <span class="giallo-l"><span style="color: #6272A4;"># tolkien_books = {&quot;The Lord of the Rings&quot;, &quot;The Hobbit&quot;}</span></span></code></pre> <p>Note that the notation is irritatingly different from a list comprehension. Instead of square brackets, we suddenly use curly braces now.</p> <p>In contrast, to collect into different types in Rust, just specify the <em>type</em> you want to collect into; easy as cake!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> books</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> HashMap</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_iter</span><span>(</span><span style="color: #50FA7B;">vec!</span><span>[</span></span> <span class="giallo-l"><span> (</span><span style="color: #F1FA8C;">&quot;The Lord of the Rings&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;J. R. R. Tolkien&quot;</span><span>),</span></span> <span class="giallo-l"><span> (</span><span style="color: #F1FA8C;">&quot;The Hobbit&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;J. R. R. Tolkien&quot;</span><span>),</span></span> <span class="giallo-l"><span> (</span><span style="color: #F1FA8C;">&quot;Harry Potter&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;J. K. Rowling&quot;</span><span>),</span></span> <span class="giallo-l"><span>]);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Collect into a vector</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> tolkien_books</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;_&gt;</span><span style="color: #FF79C6;"> =</span><span> books</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Look at the second element of the tuple, which is the author</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>(_, author)</span><span style="color: #FF79C6;">|</span><span> author</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #F1FA8C;">&quot;Tolkien&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Now only take the first element of the tuple, which is the book</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>(book, _)</span><span style="color: #FF79C6;">|</span><span> book)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Collect into a vector</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Alternatively, collect into a set.</span></span> <span class="giallo-l"><span style="color: #6272A4;">// This works because `collect` can collect into any type that implements</span></span> <span class="giallo-l"><span style="color: #6272A4;">// `FromIterator`, which `HashSet` does.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> tolkien_books</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> HashSet</span><span>&lt;_&gt;</span><span style="color: #FF79C6;"> =</span><span> books</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>(_, author)</span><span style="color: #FF79C6;">|</span><span> author</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #F1FA8C;">&quot;Tolkien&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>(book, _)</span><span style="color: #FF79C6;">|</span><span> book)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span></code></pre> <p>What if we wanted to count the number of bands that start with the same letter?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> first_letters</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> HashMap</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">char</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span> bands</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Filter out bands that don&#39;t have a first letter.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // (Yes, that&#39;s possible because we accept any string as input.)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // `filter_map` is like `map` but it filters out `None` values.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // If the band is empty, `chars().next()` will return `None`.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(</span><span style="color: #FF79C6;">|</span><span>name</span><span style="color: #FF79C6;">|</span><span> name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chars</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">next</span><span>())</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Start counting the occurrences of each letter</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">fold</span><span>(HashMap</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(),</span><span style="color: #FF79C6;"> |mut</span><span> acc, c</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Use the entry API to insert a new key or increment the value</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // https://doc.rust-lang.org/std/collections/hash_map/enum.Entry.html</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Gets the entry for the character `c` and inserts 0 if it</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // doesn&#39;t exist</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> *</span><span>acc</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">entry</span><span>(c)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">or_insert</span><span>(</span><span style="color: #BD93F9;">0</span><span>)</span><span style="color: #FF79C6;"> +=</span><span style="color: #BD93F9;"> 1</span><span>;</span></span> <span class="giallo-l"><span> acc</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Printing the result</span></span> <span class="giallo-l"><span style="color: #FF79C6;">for</span><span> (letter, count)</span><span style="color: #FF79C6;"> in &amp;</span><span>first_letters {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;{}: {}&quot;</span><span>, letter, count);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Which gives us:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>M: 2</span></span> <span class="giallo-l"><span>I: 1</span></span> <span class="giallo-l"><span>A: 1</span></span> <span class="giallo-l"><span>J: 1</span></span></code></pre> <p>Neat!</p> <p>In Python, you would probably stop using list comprehensions altogether and use the builtin <code>Counter</code> for this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="python"><span class="giallo-l"><span style="color: #FF79C6;">from</span><span> collections</span><span style="color: #FF79C6;"> import</span><span> Counter</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Note that we handle the case where a band </span></span> <span class="giallo-l"><span style="color: #6272A4;"># is an empty string with the `if len(band)` condition</span></span> <span class="giallo-l"><span>first_letters</span><span style="color: #FF79C6;"> =</span><span> Counter([band[</span><span style="color: #BD93F9;">0</span><span>]</span><span style="color: #FF79C6;"> for</span><span> band</span><span style="color: #FF79C6;"> in</span><span> bands</span><span style="color: #FF79C6;"> if</span><span style="color: #8BE9FD;"> len</span><span>(band)])</span></span></code></pre> <p>That’s another API to learn and remember.</p> <p>Rust also has a <code>Counter</code> implementation, but it lives outside the standard library in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/counter">counter</a> crate. Nevertheless, it fits right in – like a natural extension of the standard library.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> counter</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Counter</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> first_letters</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">char</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span> bands</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(</span><span style="color: #FF79C6;">|</span><span>name</span><span style="color: #FF79C6;">|</span><span> name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chars</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">next</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span></code></pre> <p>We still use the same patterns that we used before and we didn’t have to refactor our code. It was all very seamless. Again, we just changed the type we collect into!</p> <p>Such a deep integration into the the iterator API would be much harder, impossible even, in Python.</p> <p>In Rust you get the best of both worlds: the flexibility of the ecosystem and the native feel of the standard library.</p> <h2 id="behind-the-scenes-of-collect"><a class="zola-anchor" href="#behind-the-scenes-of-collect" aria-label="Anchor link for: behind-the-scenes-of-collect">Behind the Scenes of <code>collect</code></a></h2> <p>The convenience of collecting into a <code>Counter</code> is made possible by the fact that <code>Counter</code> implements <code>FromIterator</code>. That’s all the compiler needs to know to be able to use <code>collect</code> with <code>Counter</code>.</p> <p>Let’s peek behind the curtain and see how it works.</p> <p>Here is a code snippet from the <code>counter</code> crate:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt; iter</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">FromIterator</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Hash</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Eq</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> N</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AddAssign</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Zero</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> One</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Produce a `Counter` from an iterator of items. This is called automatically</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// by [`Iterator::collect()`].</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// [`Iterator::collect()`]:</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// ```rust</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// # use counter::Counter;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// # use std::collections::HashMap;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// let counter = &quot;abbccc&quot;.chars().collect::&lt;Counter&lt;_&gt;&gt;();</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// let expect = [(&#39;a&#39;, 1), (&#39;b&#39;, 2), (&#39;c&#39;, 3)].iter().cloned().collect::&lt;HashMap&lt;_, _&gt;&gt;();</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// assert_eq!(counter.into_map(), expect);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// ```</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> from_iter</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">I</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> IntoIterator</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>&gt;&gt;(iter</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> I</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span style="color: #FF79C6;">::</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt;</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">init</span><span>(iter)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>You can see that it just calls <code>Counter::init</code> where <code>init</code> is defined as:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> T</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Hash</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Eq</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> N</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AddAssign</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> Zero</span><span style="color: #FF79C6;"> +</span><span style="color: #8BE9FD;font-style: italic;"> One</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Create a new `Counter` initialized with the given iterable.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> init</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">I</span><span>&gt;(iterable</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> I</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> I</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> IntoIterator</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>&gt;,</span></span> <span class="giallo-l"><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> counter</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Counter</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span> <span class="giallo-l"><span> counter</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">update</span><span>(iterable);</span></span> <span class="giallo-l"><span> counter</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Add the counts of the elements from the given iterable to this counter.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> update</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">I</span><span>&gt;(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, iterable</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> I</span><span>)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> I</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> IntoIterator</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>&gt;,</span></span> <span class="giallo-l"><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> item</span><span style="color: #FF79C6;"> in</span><span> iterable {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> entry</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>map</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">entry</span><span>(item)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">or_insert_with</span><span>(N</span><span style="color: #FF79C6;">::</span><span>zero);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> *</span><span>entry</span><span style="color: #FF79C6;"> +=</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">one</span><span>();</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>That might look a little intimidating at first, but if you squint, you’ll see that <code>Counter</code> uses a <code>for</code> loop to iterate over the elements of the iterator and also uses the <code>entry</code> API to insert a new key or increment the value; just like we did manually before.</p> <p>The final, missing piece can be found in the Rust standard library in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.Iterator.html"><code>Iterator</code> trait</a>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> collect</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">B</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> FromIterator</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span>&gt;&gt;(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> B</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Sized</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> FromIterator</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_iter</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>As you can see, the <code>collect</code> method is implemented for all types that implement <code>FromIterator</code> and it’s just a thin wrapper around <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.FromIterator.html"><code>FromIterator::from_iter</code></a>.</p> <p>The <code>Counter</code> crate implements <code>FromIterator</code> and therefore we can use it in combination with <code>collect</code>. It’s simple and effective — and without knowing all the details, it can feel like magic. In reality though, the flexibility is made possible by the trait system and the iterator API.</p> <p>If you want to learn more, the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/coriolinus/counter-rs/blob/master/src/lib.rs"><code>counter</code> source code</a> makes for an interesting read.</p> <p>What’s important is that this integration needs to be done only once and then it can be used by everyone. So as a mere user, you don’t need to know how <code>collect</code> works, just that it does.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>It may be just a personal anecdote, but I feel like more experienced Rust developers tend to prefer iterators over other methods of iteration like <code>for</code> loops.</p> <p>One reason might be that iterators are more versatile because they can be chained and collected into custom types as we have seen and they scale well with the complexity of the problem: at no point are you forced to use a different API or pattern.</p> <p>Another reason why I like iterator chains is that naming things is hard. With iterators, you don’t need to come up with a name for the intermediate steps.</p> <p>Just do me a favor and don’t create pipelines which are super hard to read. If the iterator chain is too long, or a step in the chain is longer than a few lines, there’s no shame in breaking it up into multiple steps.</p> <p>My hope is that I was able to show you how powerful iterator patterns in Rust are and they are a powerful stand-in for those list comprehensions you might know and love from Python.</p> <p>I encourage you to explore the iterator API in Rust and see how you can use it to make your code more expressive and concise.</p> Mon, 13 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/long-term-rust-maintenance/ https://corrode.dev/blog/long-term-rust-maintenance/ <p>Rust has reached a level of maturity where it is being used for critical infrastructure, replacing legacy systems written in C or C++. This means, <strong>some Rust projects need to be maintained for years or even decades to come</strong>.</p> <p>By some estimates, the cost of maintaining a product is more than <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3610582/">90% of the software’s total cost</a>.</p> <p>Critical software demands minimal downtime and high reliability, so it is reassuring that the Rust core team highlights its commitment to these values in their post <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2014/10/30/Stability.html">“Stability as a Deliverable.”</a></p> <p>The following is a collection of best practices and advice for maintaining Rust projects over a very long timeframe. It covers topics like team dynamics, managing dependencies, software architecture, and tooling.</p> <p>This guide is based on my experience assisting clients with medium to large Rust projects. While much of the advice may be applicable to other languages, I will emphasize aspects specific to Rust.</p> <h2>Table of Contents</h2> <details class="toc"> <summary> Click here to expand the table of contents. </summary> <ul> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#your-team-needs-to-be-on-board">Your Team Needs to be On Board</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#building-for-rust-stability-and-longevity">Building for Rust Stability and Longevity</a> <ul> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#prefer-stable-rust-over-nightly">Prefer Stable Rust Over Nightly</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#regularly-update-your-compiler">Regularly Update Your Compiler</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#editions">Editions</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#use-rust-language-features-conservatively">Use Rust Language Features Conservatively</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#be-conservative-about-async-rust">Be Conservative About Async Rust</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#managing-dependencies">Managing Dependencies</a> <ul> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#dependencies-are-a-liability">Dependencies are a Liability</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#limit-the-number-of-dependencies">Limit The Number Of Dependencies</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#how-to-choose-dependencies">How To Choose Dependencies</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#do-not-pin-dependencies">Do Not Pin Dependencies</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#stick-to-std-where-possible">Stick to <code>std</code> Where Possible</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#use-stable-dependencies">Use Stable Dependencies</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#disable-unnecessary-features">Disable Unnecessary Features</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#building-on-solid-foundations">Building On Solid Foundations</a> <ul> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#software-architecture">Software Architecture</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#api-design">API design</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#testing">Testing</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#documentation">Documentation</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#about-unsafe-code">About Unsafe Code</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#tooling-and-infrastructure">Tooling and Infrastructure</a> <ul> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#use-boring-technology">Use Boring Technology</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#use-linters-and-formatters">Use Linters and Formatters</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#make-releases-boring">Make Releases Boring</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#invest-in-the-rust-ecosystem">Invest in the Rust Ecosystem</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#stick-to-a-regular-maintenance-schedule">Stick To A Regular Maintenance Schedule</a></li> <li><a href="https://corrode.dev/blog/long-term-rust-maintenance/#conclusion">Conclusion</a></li> </ul> </details> <h2 id="your-team-needs-to-be-on-board"><a class="zola-anchor" href="#your-team-needs-to-be-on-board" aria-label="Anchor link for: your-team-needs-to-be-on-board">Your Team Needs to be On Board</a></h2> <p>First, make sure that your team buys into the <a href="/blog/why-rust">decision to use Rust</a> and that they have the necessary skills to work with the language.</p> <p>Introducing Rust is often a disruptive change and requires a long-term mindset. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mainmatter.com/blog/2023/12/13/rust-adoption-playbook-for-ctos-and-engineering-managers/">It is important to have the backing of both the team and leadership to make this transition successful.</a></p> <p>On top of that, every language comes with its own set of tools, libraries, and idioms. It takes time for a team to become proficient in a new environment, and Rust is well-known for its steep learning curve.</p> <p>Investing in Rust training and team-augmentation is a good way to accelerate this process. While it means higher upfront costs, it will pay off in the long run, because the team will feel confident in their ability to maintain the codebase.</p> <p><img src="https://corrode.dev/blog/long-term-rust-maintenance/scale.svg" alt="Rust Maintenance" /></p> <h2 id="building-for-rust-stability-and-longevity"><a class="zola-anchor" href="#building-for-rust-stability-and-longevity" aria-label="Anchor link for: building-for-rust-stability-and-longevity">Building for Rust Stability and Longevity</a></h2> <h3 id="prefer-stable-rust-over-nightly"><a class="zola-anchor" href="#prefer-stable-rust-over-nightly" aria-label="Anchor link for: prefer-stable-rust-over-nightly">Prefer Stable Rust Over Nightly</a></h3> <p>Rust has a stable release every six weeks, which brings new features and bug fixes to the language.</p> <p>The stable release is the most reliable and well-tested version of Rust. In contrast, the nightly release is a daily snapshot of the Rust compiler and is more likely to break your code.</p> <p>For long-term maintenance, it’s important to stick to the stable release of Rust if at all possible. This ensures that your code will continue to compile and run without modification, even as the language evolves.</p> <p>There are only very few cases where nightly Rust is still necessary and you should carefully evaluate if the benefits outweigh the risks.</p> <blockquote> <p>If you are writing code that should live for a while, or a library that is aimed to be widely used, avoiding nightly features is likely your best bet. — Andre Bogus in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.archive.org/web/2022*/https://www.getsynth.com/docs/blog/2021/10/11/nightly">The nightly elephant in the room</a></p> </blockquote> <h3 id="regularly-update-your-compiler"><a class="zola-anchor" href="#regularly-update-your-compiler" aria-label="Anchor link for: regularly-update-your-compiler">Regularly Update Your Compiler</a></h3> <p>Dependencies can specify a minimum version of the Rust compiler they require. Keeping your compiler up-to-date ensures you can use the latest versions of your dependencies.</p> <p>Additionally, continuous integration tools, like the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/rust-toolchain"><code>dtolnay/rust-toolchain</code></a> GitHub Action, default to the latest stable Rust version. Therefore, it’s adivsable to keep your compiler current.</p> <p>Updating your compiler toolchain is simple. Do it regularly:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">rustup</span><span style="color: #F1FA8C;"> update</span></span></code></pre><h3 id="editions"><a class="zola-anchor" href="#editions" aria-label="Anchor link for: editions">Editions</a></h3> <p>An often underrated feature which is not found in other languages is Rust’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/edition-guide/editions/">edition system</a>. It ensures <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2014/10/30/Stability.html#the-plan">stability without stagnation</a>: every three years, a new edition is released, which allows the language to evolve without breaking existing code. For example, the 2018 edition introduced the <code>async</code> and <code>await</code> keywords, which are now widely used in Rust codebases; but code written in the 2015 edition still compiles and runs without modification. Mixing crates from different editions is possible as well.</p> <p>As a result, organizations have time to migrate their codebase to the new edition at their own pace.</p> <p>That said, try to keep your codebase up-to-date with the latest edition, as it will make it easier to benefit from new features and improvements in the language.</p> <h3 id="use-rust-language-features-conservatively"><a class="zola-anchor" href="#use-rust-language-features-conservatively" aria-label="Anchor link for: use-rust-language-features-conservatively">Use Rust Language Features Conservatively</a></h3> <p>Rust comes with a wealth of powerful features, such as macros, traits, generics, and lifetimes. While these features can make code more expressive and efficient, they can also make code harder to read and maintain.</p> <p>For long-term maintenance, it’s important to be conservative about using advanced language features. At times, this might come at the cost of performance or verbosity, but the benefit is code that is easier to understand by a larger part of the team.</p> <p>Here are a few examples of conservative use of Rust language features:</p> <ul> <li><strong>Use macros only for boilerplate code</strong>: Macros can be powerful tools for code generation, but can be hard to read and debug and take a toll on compile times. Use them sparingly and only for code that is repetitive. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://earthly.dev/blog/rust-macros/">Know When to Use Macros vs. Functions</a></li> <li><strong>Avoid complex trait bounds</strong>: Traits are a common way to abstract over types in Rust, but complex <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/generics/bounds.html">trait bounds</a> can lead to hard-to-understand error messages and obfuscate business logic. Some code duplication is often preferable to complex trait bounds.</li> <li><strong><code>clone</code> is fine</strong>: While <code>clone</code> can be a performance bottleneck, it is often the simplest way to avoid lifetimes and keep code readable. In many cases, the performance overhead is negligible. If you are considering to introduce lifetimes to avoid <code>clone</code>, ask yourself if the added complexity is worth the performance gain.</li> </ul> <p>I discussed these and other antipatterns in my talk <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://fosdem.org/2024/schedule/event/fosdem-2024-2434-the-four-horsemen-of-bad-rust-code/">The Four Horsemen of Bad Rust Code</a>.</p> <h3 id="be-conservative-about-async-rust"><a class="zola-anchor" href="#be-conservative-about-async-rust" aria-label="Anchor link for: be-conservative-about-async-rust">Be Conservative About Async Rust</a></h3> <p>There is one point in particular that is worth calling out in the context of long-term maintenance in Rust: <strong>keep your core business logic synchronous</strong>.</p> <p>This ensures that you don’t have to clutter your types with trait bounds like <code>Send</code> and <code>Sync</code>, and that you can easily test your code without having to deal with asynchronous runtimes.</p> <p>Especially in core libraries, it’s important to be conservative about exposing async functions in the public API. This ensures that your library can be used in both synchronous and asynchronous contexts and does not impose a specific runtime on the user.</p> <p>To learn more about the tradeoffs of the async Rust ecosystem, I recommend reading <a href="/blog/async/">The State of Async Rust</a>.</p> <h2 id="managing-dependencies"><a class="zola-anchor" href="#managing-dependencies" aria-label="Anchor link for: managing-dependencies">Managing Dependencies</a></h2> <h3 id="dependencies-are-a-liability"><a class="zola-anchor" href="#dependencies-are-a-liability" aria-label="Anchor link for: dependencies-are-a-liability">Dependencies are a Liability</a></h3> <p>One of the most important aspects of long-term Rust maintenance is being conservative about dependencies.</p> <p>Rust has a very active ecosystem, with thousands of crates available on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/">crates.io</a>, but there is no guarantee that a crate will be maintained in the long term; and even if it is, you need to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tweedegolf.nl/en/blog/104/dealing-with-dependencies-in-rust">trust the team behind it</a>. Security fixes in dependencies could take a long time to be released, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/marshallpierce/rust-base64/issues/213">the API of a dependency could change in undesirable ways</a>.</p> <p>As a consequence, every dependency should be seen as a liability.</p> <h3 id="limit-the-number-of-dependencies"><a class="zola-anchor" href="#limit-the-number-of-dependencies" aria-label="Anchor link for: limit-the-number-of-dependencies">Limit The Number Of Dependencies</a></h3> <p>Rust’s standard library is intentionally small to avoid issues like those in Python’s extensive standard library, where certain parts are discouraged from use:</p> <blockquote> <p>Python’s standard library is piling up with cruft, unnecessary duplication of functionality, and dispensable features. — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://peps.python.org/pep-0594/">PEP 594</a></p> </blockquote> <p>Rust encourages using small, focused packages called crates, promoting modular development and simplifying the core library’s maintenance. However, over-reliance on many third-party packages can create maintenance challenges. <strong>Keep the number of dependencies low</strong>.</p> <p>Each dependency increases:</p> <ul> <li>Compile times</li> <li>Complexity in build scripts and CI</li> <li>Documentation to read</li> <li>Attack surface</li> <li>Etc.</li> </ul> <h3 id="how-to-choose-dependencies"><a class="zola-anchor" href="#how-to-choose-dependencies" aria-label="Anchor link for: how-to-choose-dependencies">How To Choose Dependencies</a></h3> <p>Now that we’ve established the importance of limiting dependencies, how do you choose the right ones? Here are some factors to consider when choosing a crate:</p> <ul> <li><strong>Popularity</strong>: The more popular a crate is, the more likely it is to be maintained. Check the number of downloads, the number of open issues, and the last commit date. Here is a list of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lib.rs/std">popular Rust crates</a>.</li> <li><strong>License</strong>: Make sure the crate’s license is compatible with your project’s license. The most common licenses in the Rust ecosystem are MIT and Apache 2.0, which are both permissive licenses. However, some crates come with more restrictive licenses, such as GPL or AGPL. These licenses can pose challenges for closed source software projects, as they require you to release your source code if you distribute the software. For open source projects, these licenses can be a viable option, but it’s important to understand the implications for your specific use case.</li> <li><strong>Maintenance</strong>: Check the crate’s GitHub repository for signs of active maintenance. Are issues being addressed? Are pull requests being merged? Is the crate following best practices? While it’s important to see activity, keep in mind that a repository with a last commit from a few months ago isn’t necessarily unmaintained, especially for small and stable crates. Prefer crates from well-known community members or companies who have gained trust over time.</li> <li><strong>Security</strong>: Make sure the crate has a good security track record and that<br /> the maintainers are responsive to security issues. Check <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustsec.org/">RustSec</a> for known vulnerabilities in Rust crates before adding them to your project. Run <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/cargo-audit">cargo-audit</a> for known vulnerabilities in your dependencies.</li> </ul> <p>Take a look at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blessed.rs/">blessed.rs</a> for a list of recommended crates in the Rust ecosystem. Use tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/commands/cargo-tree.html">cargo-tree</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/est31/cargo-udeps">cargo udeps</a> to find duplicate, outdated, or unused dependencies.</p> <p>For a case study on how to reduce the number of dependencies in a real-world Rust project, read <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.memorysafety.org/blog/reducing-dependencies-in-sudo/">Sudo-rs dependencies: when less is better</a> by Ruben Nijveld from Prossimo.</p> <h3 id="do-not-pin-dependencies"><a class="zola-anchor" href="#do-not-pin-dependencies" aria-label="Anchor link for: do-not-pin-dependencies">Do Not Pin Dependencies</a></h3> <p>A common reaction to hedge the risks of exposing your project to breaking changes is to pin dependencies to a specific version. While this sounds like a good idea, it can in fact result in the opposite: a project with outdated dependencies that are no longer maintained and have known security vulnerabilities. This is a big maintenance burden.</p> <p>Instead, it is better to be proactive about keeping dependencies up-to-date:</p> <ul> <li><strong>Use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/kbknapp/cargo-outdated"><code>cargo outdated</code></a></strong>: This command shows you which dependencies are out of date. Run it regularly to keep track of new versions.</li> <li><strong>Automate dependency updates</strong>: Use tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dependabot.com/">Dependabot</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.mend.io/renovate/">Renovate</a> to receive automated pull requests for dependency updates.</li> <li><strong>Regularly run <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/commands/cargo-update.html"><code>cargo update</code></a></strong>: It updates your dependencies to the latest version that matches the version constraints in your <code>Cargo.toml</code>.</li> <li><strong>Use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/commands/cargo-tree.html"><code>cargo tree</code></a></strong>: This shows you a tree of your dependencies, to help you find duplicate- or outdated dependencies — including transitive dependencies.</li> <li>Try not to skip any major versions of your dependencies, as this can make it harder to upgrade in the future.</li> <li>Be proactive about replacing deprecated or unmaintained dependencies with a more recent alternative.</li> </ul> <p>For major dependencies (like the web framework or your async runtime) it’s a good idea to follow the release notes or blog posts to stay up-to-date with upcoming changes. For example, you <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.github.com/en/account-and-profile/managing-subscriptions-and-notifications-on-github/managing-subscriptions-for-activity-on-github/viewing-your-subscriptions">can watch for new releases (including the changelog) on GitHub</a> or subscribe to the project’s newsletter.</p> <p>Keep in mind that it takes time for the broader ecosystem to catch up with new releases of these major dependencies, so it can take a while before you can safely upgrade. In such a case, it’s a good idea to add regular reminders to your calendar to handle the upgrade.</p> <h3 id="stick-to-std-where-possible"><a class="zola-anchor" href="#stick-to-std-where-possible" aria-label="Anchor link for: stick-to-std-where-possible">Stick to <code>std</code> Where Possible</a></h3> <p>The Rust standard library is well-maintained and has a strong focus on backwards compatibility. It is a good idea to stick to <code>std</code> where possible.</p> <p>For example, the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/collections/"><code>std::collections</code></a> module provides a good selection of data structures, such as <code>HashMap</code>, <code>Vec</code>, and <code>HashSet</code>, which are well-tested. While there are great third-party crates that provide similar data structures, which might be faster or have additional features, it is often better to stick to the standard library, as it is used by a wide range of projects and guaranteed to be maintained in the long term.</p> <h3 id="use-stable-dependencies"><a class="zola-anchor" href="#use-stable-dependencies" aria-label="Anchor link for: use-stable-dependencies">Use Stable Dependencies</a></h3> <p>Crates which <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/semver.html">follow semver</a> and reach version 1.0 are considered stable and should be preferred over non-stable crates. This is because crates below version 1.0 are allowed to make breaking changes in minor versions, which can lead to unexpected breakage in your project.</p> <p>Since the Rust ecosystem is still relatively young, many crates have not reached a stable 1.0 version release yet. Nonetheless, it is a good idea to prefer stable crates over unstable ones where possible.</p> <h3 id="disable-unnecessary-features"><a class="zola-anchor" href="#disable-unnecessary-features" aria-label="Anchor link for: disable-unnecessary-features">Disable Unnecessary Features</a></h3> <p>Many crates offer optional features that can be enabled or disabled. These features can add additional functionality to the crate, but they can also increase compile times and the complexity of the crate. If you don’t need a feature, it’s a good idea to disable it. You can find the available features in the crate’s <code>Cargo.toml</code> file or on the crate’s documentation page. For example, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/crate/tokio/latest/features">here are the <code>tokio</code> features</a>.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Pro Tip: Quickly Discovering Unnecessary Features</p> </h4> </div> <p>A nice trick is to use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/features.html#the-default-feature"><code>default-features = false</code></a> option for each dependency in your <code>Cargo.toml</code>, which disables all features, which are enabled by default.</p> <p>This way you can inspect which features are crucial for your project and carefully add them back one by one. It’s a good way to avoid unnecessary bloat.</p> <p>For example:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">dependencies</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">flate2</span><span style="color: #FF79C6;"> =</span><span> {</span><span style="color: #8BE9FD;"> version</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">1.0.30</span><span style="color: #E9F284;">&quot;</span><span>,</span><span style="color: #8BE9FD;"> default-features</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> false</span><span>,</span><span style="color: #8BE9FD;"> features</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">zlib</span><span style="color: #E9F284;">&quot;</span><span>] }</span></span></code></pre> </div> <h2 id="building-on-solid-foundations"><a class="zola-anchor" href="#building-on-solid-foundations" aria-label="Anchor link for: building-on-solid-foundations">Building On Solid Foundations</a></h2> <h3 id="software-architecture"><a class="zola-anchor" href="#software-architecture" aria-label="Anchor link for: software-architecture">Software Architecture</a></h3> <p>Conversely, maintaining a codebase for a long time <em>doesn’t</em> mean you should leave it untouched; quite the opposite: it requires constant effort and work.</p> <p>Some of the most robust codebases in the world are continuously updated. Projects like the Linux kernel, which has been in development for over 30 years, or Mozilla Firefox, are constantly being improved and refactored.</p> <p>Here are some principles for durable software design:</p> <ol> <li>Learn about <a href="/blog/idiomatic-rust-resources">idiomatic Rust</a> and follow the best practices of the Rust community.</li> <li>Heavily lean into the type system: prefer a type-first design, where you use the <a href="/blog/compile-time-invariants">type system to enforce invariants</a> and prevent bugs. For example, here is how to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cliffle.com/blog/rust-typestate/">use the typestate pattern to guarantee object behavior at compile-time</a>.</li> <li>Don’t be afraid to take ownership: refactor and rewrite where necessary. Rust makes it <em>easy</em> to refactor and you should take advantage of that.</li> <li>Strive for <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://highassurance.rs/chp16_appendix/components.html">low coupling and high cohesion</a> between your modules and crates. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Coupling_(computer_programming)"><img src="https://corrode.dev/blog/long-term-rust-maintenance/CouplingVsCohesion.svg" alt="Low coupling and high cohesion" /></a></li> <li>Learn about <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/patterns/additional_resources/design-principles.html">design principles such as SOLID</a>.</li> <li>Avoid premature optimization and over-engineering.</li> <li>Consider <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-cqrs.org/theory_ddd.html">Domain-driven design</a>. It is a way to express your business logic in a common business language that everyone on the team understands.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://alexis-lozano.com/hexagonal-architecture-in-rust-1/">Study hexagonal architecture</a> (a.k.a onion Architecture or ‘Ports and Adapters’). This architecture separates the core business logic from the infrastructure, making it easier to test and maintain.</li> </ol> <p>The Rust ecosystem continues to develop, with new frameworks frequently being introduced. To avoid chasing a moving target, it’s a good idea to keep the core of your application framework-agnostic. This way, you can replace your web framework or UI layer without having to rewrite the entire application. The above mentioned design principles can help you with that.</p> <h3 id="api-design"><a class="zola-anchor" href="#api-design" aria-label="Anchor link for: api-design">API design</a></h3> <p>API design is part of software architecture, but it deserves its own section.</p> <p>Software that gets maintained for a long time is often critical and heavily used by other software. Changing an API can break downstream users and cause churn. Defensive API design minimizes the risk of these breaking changes.</p> <p>Here are some tips for designing APIs that stand the test of time:</p> <ul> <li><strong>Minimize the public API surface</strong>: It’s very hard to remove features once they are public. Only expose what is absolutely necessary for users to interact with your system. While this sounds obvious, it’s easy to expose too much in a public API. Keeping functions and structs private prevents implementation details from leaking out of modules, making future refactoring easier since you can change the internals without affecting the public API.</li> <li><strong>Consider making enums non-exhaustive</strong>: For enums that may introduce new variants in the future, use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/attributes/type_system.html"><code>#[non_exhaustive]</code></a> attribute. This allows adding new variants without breaking existing code. However, this approach encourages catch-all patterns, which can be problematic if new variants require specific handling. Use <code>non_exhaustive</code> only if a catch-all pattern is acceptable. If your enum represents a fixed set of options with no foreseeable additions, it’s better to keep it exhaustive. Breaking changes in such cases ensure the code is updated to handle new cases explicitly, maintaining correctness and clarity. (See this <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/hyperium/http/issues/188">discussion in the hyperium/http crate</a>.)</li> <li><strong>Hide implementation details behind own types</strong>: Use the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-unofficial.github.io/patterns/patterns/behavioural/newtype.html#motivation">newtype pattern</a> to hide implementation details and prevent users from relying on them. For example, instead of exposing that you depend on a specific crate, wrap it in a newtype, so use <code>pub Request(reqwest::Request)</code> instead of exposing the dependency directly. Don’t be afraid to introduce your own types around basic types. E.g. <code>Miles(u64)</code> and <code>Kilometers(u64)</code> are both <code>u64</code> under the hood, but their explicit types make it harder to mix them up.</li> <li><strong>Use semver</strong>: Follow the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://semver.org/">Semantic Versioning</a> guidelines to communicate changes to your users. This will help them understand the impact of a new release and make it easier to upgrade. Consider using <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/obi1kenobi/cargo-semver-checks">cargo-semver-checks</a> to detect breaking changes in your code.</li> </ul> <p>For more information, the Rust team has published a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/api-guidelines/checklist.html">Rust API Guidelines Checklist</a>, which is well worth a read.</p> <h3 id="testing"><a class="zola-anchor" href="#testing" aria-label="Anchor link for: testing">Testing</a></h3> <p>Tests are a form of documentation that gets verified automatically. If you have a hard time writing tests, it’s a sign that your code is too complex and needs refactoring. If you can’t explain what a struct or function does, it might do too much. Split it up into smaller parts and test those parts individually.</p> <p>In Rust, unit tests reside alongside the code within the same module, which is where the majority of testing should happen.</p> <p>Make sure that the tests are easy to run without any manual setup (ideally, just a <code>cargo test</code> should be enough), and that they run quickly (think seconds, not minutes) and mostly without external dependencies. If tests are slow, they won’t be run as often, and you’ll lose the benefits of having them. Integrate your tests into a continuous integration pipeline on GitHub Actions or GitLab CI to ensure that they run automatically on every commit.</p> <h3 id="documentation"><a class="zola-anchor" href="#documentation" aria-label="Anchor link for: documentation">Documentation</a></h3> <p>Rust has great support for documentation. You can write documentation as Markdown comments right next to your code, and it gets rendered into a nice HTML page with <code>cargo doc</code>. Make extensive use of this!</p> <p>Here are some tips for writing good documentation:</p> <ul> <li>Don’t expect to be around to explain your code. Even if you are, you might not remember why you wrote something a certain way.</li> <li>It’s easiest to write documentation as soon as you start writing code. Update it as your mental model of the code evolves.</li> <li>Take the time to document, why certain optimizations were <em>not</em> done and the trade-offs of your design decisions.</li> </ul> <p>Some tooling can help you with this:</p> <ul> <li>Enforce documentation for public functions and types with clippy’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rustdoc/write-documentation/what-to-include.html"><code>#![deny(missing_docs)]</code></a> lint.</li> <li>Run <code>cargo doc --open</code> from time to time to see how your documentation looks like and fill in the gaps.</li> <li>Add doctests to your documentation. This way, you can ensure that the examples in your documentation are correct and up-to-date.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://frehberg.com/2022/12/docs-as-code-mermaid-inline-diagrams/">Add mermaid diagrams to your documentation</a> to visualize complex concepts.</li> <li>Use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/GuillaumeGomez/doc-comment">doc-comment</a> to ensure that your examples in the <code>README.md</code> are up-to-date.</li> </ul> <p>As an example, here is the documentation for the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/axum/latest/axum">Axum web framework</a>, which is generated from comments in the code:</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/axum/latest/axum/"><img src="https://corrode.dev/blog/long-term-rust-maintenance/axum-docs.png" alt="Axum Documentation" /></a></p> <p>Here are the things I like about this introduction:</p> <ul> <li><input disabled="" type="checkbox" checked=""/> It’s approachable and easy to read.</li> <li><input disabled="" type="checkbox" checked=""/> It immediately shows how to use the library for simple, real-world scenarios.</li> <li><input disabled="" type="checkbox" checked=""/> It explains core concepts and how they relate to each other.</li> <li><input disabled="" type="checkbox" checked=""/> It provides links to more detailed information.</li> <li><input disabled="" type="checkbox" checked=""/> It includes a table of contents for easy navigation.</li> </ul> <p>If you feel intrigued, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.guillaume-gomez.fr/articles/2020-03-12+Guide+on+how+to+write+documentation+for+a+Rust+crate">here is a great guide on how to write documentation in Rust</a>.</p> <h3 id="about-unsafe-code"><a class="zola-anchor" href="#about-unsafe-code" aria-label="Anchor link for: about-unsafe-code">About Unsafe Code</a></h3> <p>Unsafe code relies on the author to ensure its correctness and adherence to current and future rules. Due to the inherent complexity, errors in unsafe code are typically difficult to detect and debug.</p> <ul> <li>Minimize the use of unsafe code and encapsulate it in a safe API. This way, the unsafe code can at least be isolated and its behavior can be more easily understood and tested.</li> <li>If you find yourself using unsafe code to improve performance, consider using better algorithms or data structures instead. Rust’s performance is often competitive with C and C++ without resorting to unsafe code. See <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=uUu9eFNNbjg">this video on datastructures in the Zed Text Editor, which shows how <code>Rope</code>s and <code>SumTree</code>s get used for performant and safe code</a>.</li> <li>Use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/geiger-rs/cargo-geiger">cargo-geiger</a> to check for unsafe code.</li> </ul> <p><img src="https://corrode.dev/blog/long-term-rust-maintenance/cargo-geiger.png" alt="cargo-geiger" /></p> <h2 id="tooling-and-infrastructure"><a class="zola-anchor" href="#tooling-and-infrastructure" aria-label="Anchor link for: tooling-and-infrastructure">Tooling and Infrastructure</a></h2> <h3 id="use-boring-technology"><a class="zola-anchor" href="#use-boring-technology" aria-label="Anchor link for: use-boring-technology">Use Boring Technology</a></h3> <p>Based on personal experience, the latest technology can be tempting, but for long-term codebase maintenance in a production environment, it’s wise to use reliable, well-established tools like JSON and SQL. These tools offer abundant documentation and support, making it easier to find help when needed.</p> <p>The same principle applies when choosing Virtual Machines or Containers over newer options like WebAssembly or Edge Computing, as the former have more providers and established ecosystems.</p> <p>Overall, proven technologies change less frequently, allowing you to focus on your business rather than constantly chasing the latest trends.</p> <h3 id="use-linters-and-formatters"><a class="zola-anchor" href="#use-linters-and-formatters" aria-label="Anchor link for: use-linters-and-formatters">Use Linters and Formatters</a></h3> <p>There are a number of well-established tools that can help you maintain a consistent code style and catch common errors:</p> <ul> <li> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustfmt">rustfmt</a> formats your code according to the Rust style guidelines.</p> </li> <li> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/clippy/">clippy</a> is a collection of lints to catch common mistakes and improve your code.</p> <p>I use the most pedantic clippy settings in my projects. To enable them, add the following lines to the top of your <code>main.rs</code> or <code>lib.rs</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#![deny(clippy</span><span style="color: #FF79C6;">::</span><span>all)]</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>pedantic)]</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>restriction)]</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>nursery)]</span></span> <span class="giallo-l"><span>#![warn(clippy</span><span style="color: #FF79C6;">::</span><span>cargo)]</span></span></code></pre> <p>This will enable all lints, including the pedantic ones, which are not enabled by default. Chances are, you will get a lot of warnings when you first enable them. But fixing them will make your code more idiomatic and less error-prone. You can disable specific lints if you find them too noisy.</p> <p>More detailed information on pedantic clippy settings can be found <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://zhauniarovich.com/post/2021/2021-09-pedantic-clippy/">here</a>.</p> </li> <li> <p>Also check this <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://analysis-tools.dev/tag/rust">list of Rust static analysis tools</a>.</p> </li> </ul> <h3 id="make-releases-boring"><a class="zola-anchor" href="#make-releases-boring" aria-label="Anchor link for: make-releases-boring">Make Releases Boring</a></h3> <p>Run your CI pipeline on a regular basis to ensure that your codebase is always in a deployable state. The worst time to find out that something is broken is when you’re trying to deploy a fix.</p> <p>Look into <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/MarcoIeni/release-plz">release-plz</a> for release automation. It can create pull requests for new releases, which you can review and merge when you’re ready.</p> <p><img src="https://corrode.dev/blog/long-term-rust-maintenance/release-plz.png" alt="release-plz" /></p> <p>If you are afraid of triggering a release, it’s a sign that your release process is too complex or too slow. Simplify it until you are confident that you can release at any time and <a href="/blog/tips-for-faster-ci-builds/">speed up your Rust CI builds</a>.</p> <h2 id="invest-in-the-rust-ecosystem"><a class="zola-anchor" href="#invest-in-the-rust-ecosystem" aria-label="Anchor link for: invest-in-the-rust-ecosystem">Invest in the Rust Ecosystem</a></h2> <p>If you depend on the Rust ecosystem for your business, it is in your best interest to invest in it. Being an active member of the Rust community will ensure that your voice gets heard, and you can influence the direction of the language and ecosystem.</p> <p>This can be done in a number of ways:</p> <ul> <li>Report bugs and contribute code to the crates you use.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/sponsors/explore?account=mre&amp;ecosystems=RUST&amp;sort_by=MOST_USED">Sponsor crates that you depend on</a>.</li> <li>Give talks and write blog posts about your experiences with Rust.</li> <li>Support the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://foundation.rust-lang.org/">Rust Foundation</a> and core team members.</li> <li>Encourage your team to contribute to the Rust ecosystem.</li> </ul> <h2 id="stick-to-a-regular-maintenance-schedule"><a class="zola-anchor" href="#stick-to-a-regular-maintenance-schedule" aria-label="Anchor link for: stick-to-a-regular-maintenance-schedule">Stick To A Regular Maintenance Schedule</a></h2> <p>It’s quite easy to let things slip when you’re focused on new features and high-priority tasks. That’s why it’s important to set aside regular time for maintenance.</p> <p>For example, you could schedule a <strong>quarterly project review</strong> to check for outdated dependencies, security vulnerabilities, and code smells. Find a time that works for your team and stick to it.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Download My Free Maintenance Checklist</p> </h4> </div> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://corrode.notion.site/Rust-Maintenance-Checklist-3fa116db4c6149cbacbe3c16f81c6bb0">Here is my own checklist for regular maintenance.</a> Feel free to create a copy and adapt it to your needs. If you have any suggestions for improvements, please let me know and I’ll update the list.</p> </div> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p><img src="https://corrode.dev/blog/long-term-rust-maintenance/conclusion.svg" alt="Conclusion" /></p> <p>Maintaining a long-term codebase is challenging, regardless of the programming language. However, Rust excels in this area due to its focus on safety, solid tooling, and active community.</p> <p>By following the principles outlined in this post, you can ensure that your codebase remains robust and maintainable for years to come.</p> <div class="info"> <div class="info-header"> <span class="icon icon-radio"></span> <h4><p>Supercharge Your Rust Adoption</p> </h4> </div> <p>If you want to learn from top companies that have successfully adopted Rust, consider subscribing to the <a href="/podcast">Rust In Production Podcast</a>.</p> <p>In case your company is considering to adopt Rust for a new project, feel free to reach out for a <a href="/#contact">consultation</a>.</p> </div> Thu, 02 May 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s02e01-curl/ https://corrode.dev/podcast/s02e01-curl/ <div><script id="letscast-player-82930892" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-8-curl-s-daniel-stenberg/player.js?size=s"></script></div> <p>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.</p> Thu, 07 Mar 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e07-season-finale/ https://corrode.dev/podcast/s01e07-season-finale/ <div><script id="letscast-player-6c8ce152" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-7-season-finale/player.js?size=s"></script></div> <p>In the season finale of ‘Rust in Production’, we take a cold, hard look at our goals and achievements during the first season.</p> <p>Did we manage to answer the tough questions about Rust’s usage in the industry? Were we able to provide a balanced view of the challenges and benefits of using Rust? Or did we end up merely preaching to the choir?</p> <p>As it turns out, the answers align nicely with the main themes from the Rust 2023 survey: the hiring market, the learning curve, the reasons for choosing Rust, the costs of adoption, and the complexity of the language. Either way, there were definitely some surprises and unexpected turns along the way!</p> Thu, 22 Feb 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e06-sentry/ https://corrode.dev/podcast/s01e06-sentry/ <div><script id="letscast-player-e098acdf" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-6-sentry-s-arpad-borsos/player.js?size=s"></script></div> <p>In this episode, we talk to Arpad Borsos, Systems Software Engineer at Sentry, about how they use Rust to build a modern error monitoring platform for developers.</p> Wed, 21 Feb 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/async/ https://corrode.dev/blog/async/ <p>Recently, I found myself returning to a compelling series of blog posts titled <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aturon.github.io/blog/2016/08/11/futures/">Zero-cost futures in Rust</a> by Aaron Turon about what would become the foundation of Rust’s async ecosystem and the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">Tokio</a> runtime.</p> <p>This series stands as a cornerstone in writings about Rust. People like Aaron are the reason why I wanted to be part of the Rust community in the first place.</p> <p>While 2016 evokes nostalgic memories of excitement and fervor surrounding async Rust, my sentiments regarding the current state of its ecosystem are now somewhat ambivalent.</p> <h2 id="why-bother"><a class="zola-anchor" href="#why-bother" aria-label="Anchor link for: why-bother">Why Bother?</a></h2> <p>Through this series, I hope to address two different audiences:</p> <ul> <li>Newcomers to async Rust, seeking to get an overview of the current state of the ecosystem.</li> <li>Library maintainers and contributors to the async ecosystem, in the hope that my perspective can be a basis for discussion about the future of async Rust.</li> </ul> <p>In the first article, we will focus on the current state of async Rust runtimes, their design choices, and their implications on the broader Rust async ecosystem.</p> <h2 id="one-true-runtime"><a class="zola-anchor" href="#one-true-runtime" aria-label="Anchor link for: one-true-runtime">One True Runtime</a></h2> <p>An inconvenient truth about async Rust is that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/areweasyncyet.rs/issues/34">libraries still need to be written against individual runtimes</a>. Writing your async code in a runtime-agnostic fashion requires <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx/blob/d0fbe7feff4b3a200cf0453417d5e53bd011643a/sqlx-core/src/rt/mod.rs#L116-L136">conditional compilation</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/async-compat/latest/async_compat">compatibility layers</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest/issues/719#issuecomment-558758637">handling edge-cases</a>.</p> <p>This is the rationale behind most libraries gravitating towards the One True Runtime — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">Tokio</a>.</p> <p>Executor coupling is a big problem for async Rust as it breaks the ecosystem into silos. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/f10tcq/confusion_with_rusts_async_architecture_and_how/fh1oagw/">Documentation and examples for one runtime don’t work with the other runtimes</a>.</p> <p>Moreover, much of the existing documentation on async Rust feels outdated or incomplete. For example, the async book remains in draft, with concepts like cancellation, timeouts, and <code>FuturesUnordered</code> yet to be covered. (There is an open <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/async-book/pull/96">pull request</a>, though.)</p> <p>That leaves us with a situation that is unsatisfactory for everyone involved:</p> <ul> <li>For new users, it is a big ask to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kevinhoffman.medium.com/rust-async-and-the-terrible-horrible-no-good-very-bad-day-348ebc836274">navigate this space</a> and make future-proof decisions.</li> <li>For experienced users and library maintainers, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx/issues/1669#issuecomment-1032132220">supporting multiple runtimes is an additional burden</a>. It’s no surprise that popular crates like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest"><code>reqwest</code></a> <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest/blob/master/Cargo.toml#L109">simply insist on Tokio as a runtime</a>.</li> </ul> <p>This close coupling, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/wg-async/issues/45">recognized by the async working group</a>, has me worried about its potential long-term impact on the ecosystem.</p> <h2 id="the-case-of-async-std"><a class="zola-anchor" href="#the-case-of-async-std" aria-label="Anchor link for: the-case-of-async-std">The case of <code>async-std</code></a></h2> <p><code>async-std</code> was an attempt to create an alternative runtime that is closer to the Rust standard library. Its promise was that you could almost use it as a drop-in replacement.</p> <p>Take, for instance, this straightforward synchronous file-reading code:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>fs</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">File</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Read</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span> std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;()&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> file</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> File</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">open</span><span>(</span><span style="color: #F1FA8C;">&quot;foo.txt&quot;</span><span>)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[];</span></span> <span class="giallo-l"><span> file</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">read_to_end</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span> data)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In <code>async-std</code>, it is an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/async-std/latest/async_std/fs/struct.File.html#method.open">async operation</a> instead:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> async_std</span><span style="color: #FF79C6;">::</span><span>prelude</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> async_std</span><span style="color: #FF79C6;">::</span><span>fs</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">File</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> async_std</span><span style="color: #FF79C6;">::</span><span>io;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">async fn</span><span style="color: #50FA7B;"> read_file</span><span>(path</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;()&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> file</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> File</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">open</span><span>(path)</span><span style="color: #FF79C6;">.await?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> data</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[];</span></span> <span class="giallo-l"><span> file</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">read_to_end</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span> data)</span><span style="color: #FF79C6;">.await?</span><span>;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The only difference is the <code>await</code> keyword.</p> <p>While the name might suggest it, <code>async-std</code> is not a drop-in replacement for the standard library as there are many <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest/issues/719#issuecomment-558758637">subtle differences between the two</a>.</p> <p>Here are some examples of issues that are still open:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/async-rs/async-std/issues/731">New thread is spawned for every I/O request</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/async-rs/async-std/issues/914">OpenOptionsExt missing for Windows?</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/async-rs/async-std/issues/900">Spawned task is stuck during flushing in File.drop()</a></li> </ul> <p>It is hard to create a runtime that is fully compatible with the standard library. Even if it <em>were</em> a drop-in replacement, I’d still ponder its actual merit.</p> <p>Rust is a language that values explicitness. This is especially true for reasoning about runtime behavior, such as allocations and blocking operations. The async-std’s teams proposal to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/ebfj3x/stop_worrying_about_blocking_the_new_asyncstd/">“Stop worrying about blocking”</a> was <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/ebpzqx/do_not_stop_worrying_about_blocking_in_async">met with noticeable community skepticism</a> and later retracted.</p> <p>As of this writing, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lib.rs/crates/async-std/rev">1754 public crates have a dependency on <code>async-std</code></a> and there are companies that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx/issues/1669#issuecomment-1028879475">rely on it in production</a>.</p> <p>However, looking at the commits over time <code>async-std</code> is essentially abandoned as there is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/async-rs/async-std/graphs/contributors">no active development anymore</a>:</p> <p><img src="https://corrode.dev/blog/async/async-std-github.svg" alt="Fading async-std contribution graph on Github" /></p> <p><strong>Update</strong>: as of March 1, 2025, <code>async-std</code> has <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/async-rs/async-std/commit/fb56bffdbb4699e1add70a0f834dee6f57c398eb">officially been discontinued</a>. The suggested replacement is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/smol-rs/smol/">smol</a>, which is a<br /> lightweight, much more explicit runtime, that is different to <code>async-std</code> in many ways.</p> <p>This leaves those reliant on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/async-std/latest/async_std/"><code>async-std</code> API</a> – be it for concurrency mechanisms, extension traits, or otherwise – in an unfortunate situation, as is the case for libraries developed on top of <code>async-std</code>, such as <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/http-rs/surf"><code>surf</code></a>. The core of <code>async-std</code> has long been powered by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/smol-rs/smol"><code>smol</code></a>, but it is probably best to use it directly for new projects.</p> <h2 id="can-t-we-just-embrace-tokio"><a class="zola-anchor" href="#can-t-we-just-embrace-tokio" aria-label="Anchor link for: can-t-we-just-embrace-tokio">Can’t we just embrace Tokio?</a></h2> <p>Tokio stands as Rust’s canonical async runtime. But to label Tokio merely as a runtime would be an understatement. It has extra modules for <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/fs/index.html">fs</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/io/index.html">io</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/net/index.html">net</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/process/index.html">process-</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/signal/index.html">signal handling</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/#modules">more</a>. That makes it more of a framework for asynchronous programming than just a runtime.</p> <p>Partially, this is because Tokio had a pioneering role in async Rust. It explored the design space as it went along. And while you could exclusively use the runtime and ignore the rest, it is easier and more common to buy into the entire ecosystem.</p> <p>Yet, my main concern with Tokio is that it makes a lot of assumptions about how async code should be written and where it runs.</p> <p>For example, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/">at the beginning of the Tokio documentation</a>, they state:</p> <p>“The easiest way to get started is to enable all features. Do this by enabling the <code>full</code> feature flag”:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>tokio</span><span style="color: #FF79C6;"> =</span><span> { version</span><span style="color: #FF79C6;"> =</span><span style="color: #F1FA8C;"> &quot;1&quot;</span><span>, features</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #F1FA8C;">&quot;full&quot;</span><span>] }</span></span></code></pre> <p>By doing so, one would set up a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustmagazine.org/issue-4/how-tokio-schedule-tasks/">work-stealing</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/tokio/latest/tokio/attr.main.html">multi-threaded runtime</a> which mandates that types are <code>Send</code> and <code>'static</code> and makes it necessary to use synchronization primitives such as <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/sync/struct.Arc.html"><code>Arc</code></a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/sync/struct.Mutex.html"><code>Mutex</code></a> for all but the most trivial applications.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Understanding ’static Lifetimes in Async Rust</p> </h4> </div> <p>A <code>'static</code> trait bound mandates that the type does not contain any non-static references. This means the receiver can hold on to the type <em>indefinitely</em> without it becoming invalid until they decide to drop it.</p> <p>Here is an example of an async function that has a <code>'static</code> lifetime bound:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">async fn</span><span style="color: #50FA7B;"> process_data</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span style="color: #FF79C6;">:</span><span> &#39;</span><span style="color: #8BE9FD;font-style: italic;">static</span><span>&gt;(data</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Owned data passes a <code>'static</code> lifetime bound if it, and all of its contents, do not contain any non-static references — but, crucially, a <em>reference</em> to that owned data generally does not.</p> <p>Since tasks in async runtimes may outlive the scope they were created in (especially in multi-threaded contexts), ensuring that references remain valid for the duration of the task’s execution is challenging. This is why async tasks often require <code>'static</code> data, to guarantee that the data lives long enough or to ensure ownership is transferred to the task.</p> <p>This makes it hard to use references in async code, as borrowed data must live as long as the task.</p> <p>For most practical use-cases, this means that futures cannot borrow data from the scope they are spawned from, unless the data lives long enough or ownership is transferred.</p> <p>This requirement marks a significant departure from synchronous Rust, where borrowing data across function calls is commonplace. It represents a fundamental shift in how we manage data lifetimes and ownership in asynchronous compared to synchronous Rust.</p> </div> <blockquote> <p>The Original Sin of Rust async programming is making it multi-threaded by default. If premature optimization is the root of all evil, this is the mother of all premature optimizations, and it curses all your code with the unholy <code>Send + 'static</code>, or worse yet <code>Send + Sync + 'static</code>, which just kills all the joy of actually writing Rust.</p> <p>— <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maciej.codes/2022-06-09-local-async.html">Maciej Hirsz</a></p> </blockquote> <p>Any time we reach for an <code>Arc</code> or a <code>Mutex</code> it’s good idea to stop for a moment and think about the future implications of that decision.</p> <p>The choice to use <code>Arc</code> or <code>Mutex</code> might be indicative of a design that hasn’t fully embraced the ownership and borrowing principles that Rust emphasizes. It’s worth reconsidering if the shared state is genuinely necessary or if there’s a simpler design that could minimize or eliminate the need for shared mutable state (for instance by using channels).</p> <p>The problem, of course, is that Tokio imposes this design on you. It’s not your choice to make.</p> <p>Beyond the complexities of architecting async code atop these synchronization mechanisms, they carry a performance cost: Locking means runtime overhead and additional memory usage; in embedded environments, these mechanisms are often not available at all.</p> <p><strong>Multi-threaded-by-default runtimes cause accidental complexity completely unrelated to the task of writing async code.</strong> This additional complexity can also impact build times, as discussed in our guide on <a href="/blog/tips-for-faster-rust-compile-times/">Tips for Faster Compile Times</a>.</p> <p>Futures should be designed for brief, scoped lifespans rather than the <code>'static</code> lifetime. Ideally, we’d lean on an explicit <code>spawn::async</code> instead of <code>spawn::blocking</code>.</p> <p>Maciej suggested to use a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://maciej.codes/2022-06-09-local-async.html">local async runtime</a> which is single-threaded by default and does <strong>not</strong> require types to be <code>Send</code> and <code>'static</code>.</p> <p>I fully agree.</p> <p>However, I have little hope that the Rust community will change course at this point. Tokio’s roots run deep within the ecosystem and it feels like for better or worse we’re stuck with it.</p> <p>In the realms of networking and web operations, it’s likely that one of your dependencies integrates Tokio, effectively nudging you towards its adoption. At the time of writing, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lib.rs/crates/tokio/rev">Tokio is used at runtime in 20,768 crates (of which 5,245 depend on it optionally)</a>.</p> <p><img src="https://corrode.dev/blog/async/runtimes.svg" alt="Runtime popularity bar chart between tokio, async-std, and smol with Tokio greatly dominating" /></p> <p>In spite of all this, we should not stop innovating in the async space!</p> <h2 id="other-runtimes"><a class="zola-anchor" href="#other-runtimes" aria-label="Anchor link for: other-runtimes">Other Runtimes</a></h2> <p>Going beyond Tokio, several other runtimes deserve more attention:</p> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/smol-rs/smol">smol</a>: A small async runtime, which is easy to understand. The entire executor is around <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/smol-rs/async-executor/blob/master/src/lib.rs">1000 lines of code</a> with other parts of the ecosystem being similarly small.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/embassy-rs/embassy">embassy</a>: An async runtime for embedded systems.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/DataDog/glommio">glommio</a>: An async runtime for I/O-bound workloads, built on top of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lwn.net/Articles/810414/">io_uring</a> and using a thread-per-core model.</li> </ul> <p>These runtimes are important, as they explore alternative paths or open up new use cases for async Rust. Drawing a parallel with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mastodon.social/@mre/111019994687648975">Rust’s error handling story</a>, the hope is that competing designs will lead to a more robust foundation overall. Especially, iterating on smaller runtimes that are less invasive and single-threaded by default can help improve Rust’s async story.</p> <h2 id="async-vs-threads"><a class="zola-anchor" href="#async-vs-threads" aria-label="Anchor link for: async-vs-threads">Async vs Threads</a></h2> <blockquote> <p>If you don’t need async for performance reasons, threads can often be the simpler alternative. — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rust-lang.github.io/async-book/01_getting_started/02_why_async.html#async-vs-threads-in-rust">the Async Book</a></p> </blockquote> <p>Modern operating systems come with highly optimized schedulers that are excellent at multitasking and support async I/O through <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lwn.net/Articles/776703/">io_uring</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mre/fcat">splice</a>. We should make better use of these capabilities. At least we should fully lean into the capabilities of modern operating systems.</p> <p>Take our sync code to read a file from above for example. We can call this function inside the new <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/thread/fn.scope.html">scoped threads</a>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>fs;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Read</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>{thread, time};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span> thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">scope</span><span>(</span><span style="color: #FF79C6;">|</span><span>scope</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // worker thread 1</span></span> <span class="giallo-l"><span> scope</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> contents</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(</span><span style="color: #F1FA8C;">&quot;foo.txt&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // do something with contents</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // worker thread 2</span></span> <span class="giallo-l"><span> scope</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> contents</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(</span><span style="color: #F1FA8C;">&quot;bar.txt&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // worker thread 3</span></span> <span class="giallo-l"><span> scope</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> contents</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(</span><span style="color: #F1FA8C;">&quot;baz.txt&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // No join; threads get joined</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // automatically once the scope ends</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=1bb9bbd9fdd4626bae93ac3d2cd81165">Link to playground</a>)</p> <p>Or, perhaps more aptly,</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> files</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #F1FA8C;">&quot;foo.txt&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;bar.txt&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;baz.txt&quot;</span><span>];</span></span> <span class="giallo-l"><span> thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">scope</span><span>(</span><span style="color: #FF79C6;">|</span><span>scope</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> file</span><span style="color: #FF79C6;"> in</span><span> files {</span></span> <span class="giallo-l"><span> scope</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">move ||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> contents</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(file);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If this code were placed into a function, it would serve both synchronous and asynchronous callers, completely removing the need for an asynchronous runtime. The scheduling burden would shift to the operating system.</p> <p>Async Rust promises efficient resource handling, at the cost of complexity and worse ergonomics. As an example, if the function were <em>async</em> and you called it <em>outside</em> of a runtime, it would compile, but not run. Futures do nothing unless being polled; a common footgun for newcomers.</p> <p>For teams evaluating async Rust for production use, it’s worth understanding the full trade-offs. See <a href="/blog/why-rust/">Why Rust in Production</a> for a broader perspective on when these complexities are justified.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> tokio</span><span style="color: #FF79C6;">::</span><span>fs;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[tokio</span><span style="color: #FF79C6;">::</span><span>main]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">async fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This will print a warning, but compile</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // and do nothing at runtime</span></span> <span class="giallo-l"><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(</span><span style="color: #F1FA8C;">&quot;foo.txt&quot;</span><span>);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=dac468c7e7ea0f224e91b56ccadc8e43">Link to playground</a>)</p> <p>If you find yourself needing to share state between threads, consider using a channel:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>error</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>fs;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Read</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>path</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>{thread, time};</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>sync</span><span style="color: #FF79C6;">::</span><span>mpsc;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> (tx, rx)</span><span style="color: #FF79C6;"> =</span><span> mpsc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">channel</span><span style="color: #FF79C6;">::</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> files</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #F1FA8C;">&quot;foo.txt&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;bar.txt&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;baz.txt&quot;</span><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> thread</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">scope</span><span>(</span><span style="color: #FF79C6;">|</span><span>scope</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> file</span><span style="color: #FF79C6;"> in</span><span> files {</span></span> <span class="giallo-l"><span> scope</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">spawn</span><span>(</span><span style="color: #FF79C6;">move ||</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> contents</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_to_string</span><span>(file);</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> });</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Receive messages from the channel</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> received</span><span style="color: #FF79C6;"> in</span><span> rx {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;Got: {:?}&quot;</span><span>, received);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=5b7fa587cf1796089ce7bb374539229e">Link to playground</a>)</p> <h2 id="common-prejudice-against-threads"><a class="zola-anchor" href="#common-prejudice-against-threads" aria-label="Anchor link for: common-prejudice-against-threads">Common Prejudice Against Threads</a></h2> <p>Asynchronous programming is often seen as the solution to improving performance and scalability of I/O-bound workloads.</p> <p>In a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://vorner.github.io/async-bench.html">recent benchmark</a>, traditional threading outperformed the async approach in scenarios with a limited number of threads. This underscores the core premise that, in real-world applications, the performance difference between the two approaches is often negligible, if not slightly favoring threads. Thus, it’s crucial not to gravitate towards async Rust driven solely by anticipated performance gains.</p> <p>Thread-based frameworks, like the now-inactive <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/iron/iron">iron</a>, showcased the capability to effortlessly handle <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/iron/iron/wiki/How-to-Benchmark-hello.rs-Example">tens of thousands of requests per second</a>. This is further complemented by the fact modern Linux systems can manage <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://thetechsolo.wordpress.com/2016/08/28/scaling-to-thousands-of-threads/">tens of thousands of threads</a>.</p> <p><strong>Traditional arguments against threads simply don’t apply to Rust.</strong> Threaded code in Rust is protected from data races, null dereferences, and dangling references, ensuring a level of safety that prevents many common pitfalls found in other languages.</p> <p>As an important caveat, threads are not available or feasible in all environments, such as embedded systems. My context for this article is primarily conventional server-side applications that run on top of platforms like Linux or Windows.</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <h3 id="use-async-rust-sparingly"><a class="zola-anchor" href="#use-async-rust-sparingly" aria-label="Anchor link for: use-async-rust-sparingly">Use Async Rust Sparingly</a></h3> <p>My original intention was to advise newcomers to sidestep async Rust for now, giving the ecosystem time to mature. However, I since acknowledged that this is not feasible, given that a lot of libraries are async-first and new users will encounter async Rust one way or another.</p> <p>Instead, I would recommend to use async Rust only when you really need it. Learn how to write good synchronous Rust first and then, if necessary, transition to async Rust. Learn to walk before you run.</p> <p>If you have to use async Rust, stick to Tokio and well-established libraries like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest">reqwest</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/launchbadge/sqlx">sqlx</a>.</p> <p>While it may seem surprising given the context of this article, we can’t overlook Tokio’s stronghold within the ecosystem. A vast majority of libraries are tailored specifically for it. Navigating compatibility crates can pose challenges, and sidestepping Tokio doesn’t guarantee your dependencies won’t bring it in. I’m hoping for a future shift towards leaner runtimes, but for now, Tokio stands out as the pragmatic choice for real-world implementations.</p> <p>However, it’s valuable to know that there are alternatives to Tokio and that they are worth exploring.</p> <h3 id="consider-the-alternatives"><a class="zola-anchor" href="#consider-the-alternatives" aria-label="Anchor link for: consider-the-alternatives">Consider The Alternatives</a></h3> <p>At its core, Rust and its standard library offer just the absolute essentials for <code>async/await</code>. The bulk of the work is done in crates developed by the Rust community. We should make more use of the ability to iterate on async Rust and experiment with different designs before we settle on a final solution.</p> <p>In binary crates, think twice if you really need to use async. It’s probably easier to just spawn a thread and get away with blocking I/O. In case you have a CPU-bound workload, you can use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rayon-rs/rayon">rayon</a> to parallelize your code.</p> <h3 id="isolate-async-code"><a class="zola-anchor" href="#isolate-async-code" aria-label="Anchor link for: isolate-async-code">Isolate Async Code</a></h3> <p>If async is truly indispensable, consider isolating your async code from the rest of your application.</p> <p>Keep your domain logic synchronous and only use async for I/O and external services. Following these guidelines will make your code <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/">more composable</a> and accessible. On top of that, the error messages of sync Rust are much easier to reason about than those of async Rust.</p> <p>In your public library code, avoid async-only interfaces to make downstream integration easier.</p> <h3 id="keep-it-simple"><a class="zola-anchor" href="#keep-it-simple" aria-label="Anchor link for: keep-it-simple">Keep It Simple</a></h3> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.chiark.greenend.org.uk/~ianmdlvl/rust-polyglot/async.html">Async Rust feels like a different dialect</a>, that is significantly more brittle than the rest of the language at the moment.</p> <p>When writing libraries, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nullderef.com/blog/rust-async-sync/">the maintenance overhead</a> of supporting both async and sync interfaces is not to be underestimated.</p> <p>The default mode for writing Rust should be <em>synchronous</em>. Freely after <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=22206779">Stroustrup</a>:<br /> <em>Inside Rust, there is a smaller, simpler language that is waiting to get out.</em> It is this language that most Rust code should be written in.</p> Thu, 08 Feb 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e05-tweede-golf/ https://corrode.dev/podcast/s01e05-tweede-golf/ <div><script id="letscast-player-b30f560a" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-5-tweede-golf-s-folkert-de-vries/player.js?size=s"></script></div> <p>In this episode, we talk to Folkert de Vries, Systems Software Engineer at Tweede Golf, about how they use Rust to modernize the NTP protocol and build a new generation of time synchronization services.</p> Sun, 28 Jan 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/idiomatic-rust-resources/ https://corrode.dev/blog/idiomatic-rust-resources/ <p>Here’s a curated list of resources to <strong>help you write ergonomic and idiomatic Rust code</strong>.</p> <p>The list is open source and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mre/idiomatic-rust">maintained on GitHub</a>, and contributions are always welcome!</p> <p>Discover a wealth of tutorials, workshops, and articles created by Rust experts, all aimed at helping you become a better Rust programmer. Each resource is peer-reviewed to ensure adherence to Rust best practices. Plus, you can easily filter, sort, and search by tags, year, and difficulty level to find exactly what you need.</p> <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script> <script src="https://cdn.datatables.net/1.13.7/js/jquery.dataTables.min.js"></script> <script src="dataTables.checkboxes.min.js"></script> <script src="table.js"></script> <div style="margin-bottom: 20px"> <button class="button reset-filter">Reset filters</button> </div> <div> Extra columns: <a class="toggle-vis" data-column="6">Official</a> - <a class="toggle-vis" data-column="7">Year</a> - <a class="toggle-vis" data-column="9">Duration</a> - <a class="toggle-vis" data-column="11">Free/Commercial</a> </div> <div> Click on the triangle <span style="font-family: Arial, sans-serif">▶</span> to show more details for each entry. </div> <table id="data-table" class="compact order-column hover stripe" style="width:100%"> </table> <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.13.7/css/jquery.dataTables.min.css" /> <style> /* DataTables overrides */ .dataTables_wrapper .dataTables_filter { margin: 20px 0 40px; } .dataTables_filter input[type="search"] { font-size: 18px; margin: 0 0 0 10px; padding: 8px 16px; width: 350px; color: #111; border: 2px solid rgba(17, 17, 17, 0.3); border-radius: 4px; background: transparent; } .dataTables_filter input[type="search"]:focus { outline: none; border-color: #111; } /* Tag badges - similar to conference badges */ .dataTables_wrapper code { cursor: pointer; } code { border-radius: 4px; padding: 5px 10px; margin: 3px; font-size: 0.85rem; font-family: JetBrainsMono; color: #111; background: transparent; border: 2px solid rgba(17, 17, 17, 0.2); cursor: pointer; display: inline-block; transition: all 0.2s ease; } code:hover { border-color: #111; background: rgba(17, 17, 17, 0.05); } code.active { color: white; background: #111; border-color: #111; } /* Reset filter button - minimal override of .button class */ .reset-filter { display: none; } .toggle-vis { cursor: pointer; text-decoration: underline; text-decoration-color: rgba(17, 17, 17, 0.3); } .toggle-vis:hover { text-decoration-color: #111; } .toggle-vis.active { font-weight: bold; } .dt-control { font-family: Arial, sans-serif; } table.dataTable td.dt-control::before { color: #111; } /* Dark mode support */ @media (prefers-color-scheme: dark) { .dataTables_filter input[type="search"] { color: white; border-color: rgba(255, 255, 255, 0.3); } .dataTables_filter input[type="search"]:focus { border-color: rgba(255, 255, 255, 0.6); } code { color: white; border-color: rgba(255, 255, 255, 0.2); } code:hover { border-color: rgba(255, 255, 255, 0.5); background: rgba(255, 255, 255, 0.1); } code.active { color: #111; background: white; border-color: white; } .toggle-vis { text-decoration-color: rgba(255, 255, 255, 0.3); } .toggle-vis:hover { text-decoration-color: white; } table.dataTable td.dt-control::before { color: white; } .difficultyLevel { color: transparent; text-shadow: 0 0 0 #ee3856; } } table.dataTable.dt-checkboxes-select tbody tr, table.dataTable thead th.dt-checkboxes-select-all, table.dataTable tbody td.dt-checkboxes-cell { cursor: pointer; } table.dataTable thead th.dt-checkboxes-select-all, table.dataTable tbody td.dt-checkboxes-cell { text-align: center; } div.dataTables_wrapper span.select-info, div.dataTables_wrapper span.select-item { margin-left: 0.5em; } @media screen and (max-width: 640px) { div.dataTables_wrapper span.select-info, div.dataTables_wrapper span.select-item { margin-left: 0; display: block; } } </style> Thu, 25 Jan 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e04-arroyo/ https://corrode.dev/podcast/s01e04-arroyo/ <div><script id="letscast-player-9614e85c" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-4-arroyo-s-micah-wylde/player.js?size=s"></script></div> <p>In this episode, we talk to Micah Wylde, Co-founder and CEO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.arroyo.dev/">Arroyo</a>, about how they simplified stream processing for data engineers with Rust.</p> Fri, 12 Jan 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/tips-for-faster-rust-compile-times/ https://corrode.dev/blog/tips-for-faster-rust-compile-times/ <p><strong>Slow Rust Builds?</strong></p> <p>Here are some tips to speed up your compile times. This list was originally released on my <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://endler.dev/">private blog</a>, but I decided to update it and move it here.</p> <p>All tips are roughly ordered by impact so you can start from the top and work your way down.</p> <h2>Table of Contents</h2> <details class="toc"> <summary> Click here to expand the table of contents. </summary> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#general-tips">General Tips</a> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#update-the-rust-compiler-and-toolchain">Update The Rust Compiler And Toolchain</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#use-cargo-check-instead-of-cargo-build">Use cargo check Instead Of cargo build</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#remove-unused-dependencies">Remove Unused Dependencies</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#update-dependencies">Update Dependencies</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#find-the-slow-crate-in-your-codebase">Find the slow crate in your codebase</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#profile-compile-times">Profile Compile Times</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#troubleshoot-slow-incremental-builds">Troubleshoot Slow Incremental Builds</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#replace-heavy-dependencies">Replace Heavy Dependencies</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#split-big-crates-into-smaller-ones-using-workspaces">Split Big Crates Into Smaller Ones Using Workspaces</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#disable-unused-features-of-crate-dependencies">Disable Unused Features Of Crate Dependencies</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#add-features-for-expensive-code">Add Features For Expensive Code</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#find-the-root-cause-for-rebuilds">Find The Root Cause For Rebuilds</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#cache-dependencies-with-sccache">Cache Dependencies With sccache</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#cranelift-the-alternative-rust-compiler">Cranelift: The Alternative Rust Compiler</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#switch-to-a-faster-linker">Switch To A Faster Linker</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#macos-only-faster-incremental-debug-builds">macOS Only: Faster Incremental Debug Builds</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#macos-only-exclude-rust-compilations-from-gatekeeper">macOS Only: Exclude Rust Compilations From Gatekeeper</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#windows-only-set-up-dev-drive-for-rust">Windows Only: Set Up Dev Drive For Rust</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#tweak-codegen-options-and-compiler-flags">Tweak Codegen Options And Compiler Flags</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#avoid-procedural-macro-crates">Avoid Procedural Macro Crates</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#find-expensive-proc-macros">Find Expensive Proc Macros</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#conditional-compilation-for-procedural-macros">Conditional Compilation for Procedural Macros</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#generics-use-an-inner-non-generic-function">Generics: Use an Inner Non-Generic Function</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#improve-workspace-build-times-with-cargo-hakari">Improve Workspace Build Times with cargo-hakari</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#speeding-up-incremental-rust-compilation-with-dylibs">Speeding up incremental Rust compilation with dylibs</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#switch-to-the-new-parallel-compiler-frontend">Switch To The New Parallel Compiler Frontend</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#use-a-scratch-disk-for-faster-builds">Use A Scratch Disk For Faster Builds</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#invest-in-better-hardware">Invest In Better Hardware</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#compile-in-the-cloud">Compile in the Cloud</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#cache-all-crates-locally">Cache All Crates Locally</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#test-execution">Test Execution</a> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#use-cargo-nextest-instead-of-cargo-test">Use Cargo Nextest Instead of <code>cargo test</code></a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#combine-all-integration-tests-into-a-single-binary">Combine All Integration Tests Into A Single Binary</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#put-slow-tests-behind-an-environment-variable">Put slow tests behind an environment variable</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#ci-builds">CI Builds</a> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#use-a-cache-for-your-dependencies">Use A Cache For Your Dependencies</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#split-up-compile-and-test-steps">Split Up Compile And Test Steps</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#disable-incremental-compilation-in-ci">Disable Incremental Compilation In CI</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#turn-off-debuginfo">Turn Off Debuginfo</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#deny-warnings-through-an-environment-variable">Deny Warnings Through An Environment Variable</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#switch-to-a-faster-github-actions-runner">Switch To A Faster Github Actions Runner</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#faster-docker-builds">Faster Docker Builds</a> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#use-cargo-chef-to-speed-up-docker-builds">Use <code>cargo-chef</code> To Speed Up Docker Builds</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#consider-earthly-for-better-build-caching">Consider Earthly For Better Build Caching</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#ide-specific-optimizations">IDE Specific Optimizations</a> <ul> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#slow-debug-sessions-in-visual-studio-code">Slow Debug Sessions In Visual Studio Code</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#close-unrelated-projects">Close Unrelated Projects</a></li> <li><a href="https://corrode.dev/blog/tips-for-faster-rust-compile-times/#fix-rust-analyzer-cache-invalidation">Fix Rust Analyzer Cache Invalidation</a></li> </ul> </li> </ul> </details> <h2 id="general-tips"><a class="zola-anchor" href="#general-tips" aria-label="Anchor link for: general-tips">General Tips</a></h2> <h3 id="update-the-rust-compiler-and-toolchain"><a class="zola-anchor" href="#update-the-rust-compiler-and-toolchain" aria-label="Anchor link for: update-the-rust-compiler-and-toolchain">Update The Rust Compiler And Toolchain</a></h3> <p>Make sure you use the latest Rust version:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>rustup update</span></span></code></pre> <p>Making the Rust compiler faster is an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.mozilla.org/nnethercote/2020/04/24/how-to-speed-up-the-rust-compiler-in-2020/">ongoing process</a>. Thanks to their hard work, compiler speed has improved <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/cezxjn/compiler_speed_has_improved_3040_across_the_board/">30-40% across the board year-to-date, with some projects seeing up to 45%+ improvements</a>. It pays off to keep your toolchain up-to-date.</p> <h3 id="use-cargo-check-instead-of-cargo-build"><a class="zola-anchor" href="#use-cargo-check-instead-of-cargo-build" aria-label="Anchor link for: use-cargo-check-instead-of-cargo-build">Use cargo check Instead Of cargo build</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #6272A4;"># Slow 🐢</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> build</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Fast 🐇 (2x-3x speedup)</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> check</span></span></code></pre> <p>Most of the time, you don’t even have to <em>compile</em> your project at all; you just want to know if you messed up somewhere. Whenever you can, <strong>skip compilation altogether</strong>. What you need instead is laser-fast code linting, type- and borrow-checking.</p> <p>Use <code>cargo check</code> instead of <code>cargo build</code> whenever possible. It will only check your code for errors, but not produce an executable binary.</p> <p>Consider the differences in the number of instructions between <code>cargo check</code> on the left and <code>cargo debug</code> in the middle. (Pay attention to the different scales.)</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/cargo-check.png" alt="Speedup factors: check 1, debug 5, opt 20" /></p> <p>A sweet trick I use is to run it in the background with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/passcod/cargo-watch"><code>cargo watch</code></a>. This way, it will <code>cargo check</code> whenever you change a file.</p> <p><strong>Bonus</strong>: Use <code>cargo watch -c</code> to clear the screen before every run.</p> <h3 id="remove-unused-dependencies"><a class="zola-anchor" href="#remove-unused-dependencies" aria-label="Anchor link for: remove-unused-dependencies">Remove Unused Dependencies</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #6272A4;"># Install cargo-machete 🔪️</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-machete</span><span> &amp;&amp;</span><span style="color: #50FA7B;"> cargo</span><span style="color: #F1FA8C;"> machete</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Install cargo-shear ✂️🐑</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-shear</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Install cargo-udeps 🧼🧹️</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-udeps</span><span style="color: #BD93F9;"> --locked</span></span></code></pre> <p>Dependencies sometimes become obsolete after refactoring. From time to time it helps to check if you can remove any unused dependencies.</p> <p>The above tools will list all unused dependencies in your project. Each tool has its limitations, producing both false positives and false negatives. Using all three tools together provides the best results.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">Analyzing</span><span style="color: #F1FA8C;"> dependencies of crates in this directory...</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo-machete</span><span style="color: #F1FA8C;"> found the following unused dependencies in</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #F1FA8C;">projec</span><span>t</span><span style="color: #FF79C6;">&gt;</span><span style="color: #F1FA8C;">:</span></span> <span class="giallo-l"><span style="color: #50FA7B;">crate1</span><span style="color: #BD93F9;"> --</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #F1FA8C;">projec</span><span>t</span><span style="color: #FF79C6;">&gt;</span><span style="color: #F1FA8C;">/Cargo.toml:</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> clap</span></span> <span class="giallo-l"><span style="color: #50FA7B;">crate2</span><span style="color: #BD93F9;"> --</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #F1FA8C;">projec</span><span>t</span><span style="color: #FF79C6;">&gt;</span><span style="color: #F1FA8C;">/crate2/Cargo.toml:</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> anyhow</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> async-once-cell</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> dirs</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> log</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> tracing</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> url</span></span></code></pre> <p>More info on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bnjbvr/cargo-machete">cargo-machete</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Boshen/cargo-shear">cargo-shear</a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/est31/cargo-udeps">cargo-udeps</a> project pages.</p> <p>Thanks for mentioning <code>cargo-shear</code> and <code>cargo-udeps</code> to reader <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/">Nicholas Nethercote</a> who is the author of the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/perf-book/">Rust Performance Book</a> and the famous <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/2025/05/22/how-to-speed-up-the-rust-compiler-in-may-2025.html">How to speed up the Rust compiler series</a>.</p> <h3 id="update-dependencies"><a class="zola-anchor" href="#update-dependencies" aria-label="Anchor link for: update-dependencies">Update Dependencies</a></h3> <ol> <li>Run <code>cargo update</code> to update to the latest <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://semver.org/">semver</a> compatible version.</li> <li>Run <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/kbknapp/cargo-outdated"><code>cargo outdated -wR</code></a> to find newer, possibly incompatible dependencies. Update those and fix code as needed.</li> <li>Run <code>cargo tree --duplicate</code> to find dependencies which come in multiple versions. Aim to consolidate to a single version by updating dependencies that rely on older versions. (Thanks to /u/dbdr for <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/hdb5m4/tips_for_faster_rust_compile_times/fvm1r2w/">pointing this out</a>.)</li> </ol> <p>(Instructions by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/gi7v2v/is_it_wrong_of_me_to_think_that_rust_crates_have/fqe848y">/u/oherrala on Reddit</a>.)</p> <p>On top of that, use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/RustSec/cargo-audit"><code>cargo audit</code></a> to get notified about any vulnerabilities which need to be addressed, or deprecated crates which need a replacement.</p> <h3 id="find-the-slow-crate-in-your-codebase"><a class="zola-anchor" href="#find-the-slow-crate-in-your-codebase" aria-label="Anchor link for: find-the-slow-crate-in-your-codebase">Find the slow crate in your codebase</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> build</span><span style="color: #BD93F9;"> --timings</span></span></code></pre> <p>This gives information about how long each crate takes to compile.</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/cargo-concurrency-over-time.png" alt="Diagram of cargo build –timings" /></p> <p>The red line in this diagram shows the number of units (crates) that are currently waiting to be compiled (and are blocked by another crate). If there are a large number of crates bottlenecked on a single crate, focus your attention on improving that one crate to improve parallelism.</p> <p>The meaning of the colors:</p> <ul> <li><em>Waiting</em> (red) — Crates waiting for a CPU slot to open.</li> <li><em>Inactive</em> (blue) — Crates that are waiting for their dependencies to finish.</li> <li><em>Active</em> (green) — Crates currently being compiled.</li> </ul> <p>More info <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/cargo/reference/timings.html">in the documentation</a>.</p> <h3 id="profile-compile-times"><a class="zola-anchor" href="#profile-compile-times" aria-label="Anchor link for: profile-compile-times">Profile Compile Times</a></h3> <p>If you like to dig deeper than <code>cargo --timings</code>, Rust compilation can be profiled with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/inside-rust/2020/02/25/intro-rustc-self-profile.html#profiling-the-compiler"><code>cargo rustc -- -Zself-profile</code></a>. The resulting trace file can be visualized with a flamegraph or the Chromium profiler:</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/chrome_profiler.png" alt="Image of Chrome profiler with all crates" /></p> <p>Another golden one is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/cargo-llvm-lines"><code>cargo-llvm-lines</code></a>, which shows the number of lines generated and the number of copies of each generic function in the final binary. This can help you identify which functions are the most expensive to compile.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>$ cargo llvm-lines | head -20</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> Lines Copies Function name</span></span> <span class="giallo-l"><span> ----- ------ -------------</span></span> <span class="giallo-l"><span> 30737 (100%) 1107 (100%) (TOTAL)</span></span> <span class="giallo-l"><span> 1395 (4.5%) 83 (7.5%) core::ptr::drop_in_place</span></span> <span class="giallo-l"><span> 760 (2.5%) 2 (0.2%) alloc::slice::merge_sort</span></span> <span class="giallo-l"><span> 734 (2.4%) 2 (0.2%) alloc::raw_vec::RawVec&lt;T,A&gt;::reserve_internal</span></span> <span class="giallo-l"><span> 666 (2.2%) 1 (0.1%) cargo_llvm_lines::count_lines</span></span> <span class="giallo-l"><span> 490 (1.6%) 1 (0.1%) &lt;std::process::Command as cargo_llvm_lines::PipeTo&gt;::pipe_to</span></span> <span class="giallo-l"><span> 476 (1.5%) 6 (0.5%) core::result::Result&lt;T,E&gt;::map</span></span> <span class="giallo-l"><span> 440 (1.4%) 1 (0.1%) cargo_llvm_lines::read_llvm_ir</span></span> <span class="giallo-l"><span> 422 (1.4%) 2 (0.2%) alloc::slice::merge</span></span> <span class="giallo-l"><span> 399 (1.3%) 4 (0.4%) alloc::vec::Vec&lt;T&gt;::extend_desugared</span></span> <span class="giallo-l"><span> 388 (1.3%) 2 (0.2%) alloc::slice::insert_head</span></span> <span class="giallo-l"><span> 366 (1.2%) 5 (0.5%) core::option::Option&lt;T&gt;::map</span></span> <span class="giallo-l"><span> 304 (1.0%) 6 (0.5%) alloc::alloc::box_free</span></span> <span class="giallo-l"><span> 296 (1.0%) 4 (0.4%) core::result::Result&lt;T,E&gt;::map_err</span></span> <span class="giallo-l"><span> 295 (1.0%) 1 (0.1%) cargo_llvm_lines::wrap_args</span></span> <span class="giallo-l"><span> 291 (0.9%) 1 (0.1%) core::char::methods::&lt;impl char&gt;::encode_utf8</span></span> <span class="giallo-l"><span> 286 (0.9%) 1 (0.1%) cargo_llvm_lines::run_cargo_rustc</span></span> <span class="giallo-l"><span> 284 (0.9%) 4 (0.4%) core::option::Option&lt;T&gt;::ok_or_else</span></span></code></pre><h3 id="troubleshoot-slow-incremental-builds"><a class="zola-anchor" href="#troubleshoot-slow-incremental-builds" aria-label="Anchor link for: troubleshoot-slow-incremental-builds">Troubleshoot Slow Incremental Builds</a></h3> <p>If your incremental builds are slower than expected, you might be bottlenecked on a particular crate in the rustc backend.</p> <p>To diagnose this, you can use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mstange/samply"><code>samply</code></a> combined with the <code>-Zhuman_readable_cgu_names=yes</code> flag to profile the compiler and identify which codegen units are taking the longest to compile:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">samply</span><span style="color: #F1FA8C;"> record cargo build</span></span></code></pre> <p>This will help you identify if a particular crate is the long pole in your build. Once you’ve identified the bottleneck, you may be able to improve compile times by refactoring or splitting the problematic crate.</p> <p>For more details on back-end parallelism in the Rust compiler, see <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/2023/07/11/back-end-parallelism-in-the-rust-compiler.html">Nicholas Nethercote’s blog post</a>.</p> <p>Another useful flag is <code>-Zprint-mono-items=yes</code>, which prints all <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustc-dev-guide.rust-lang.org/backend/monomorph.html">monomorphized items</a> during compilation. This can help you understand what’s being generated in each CGU.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #BD93F9;">RUSTFLAGS</span><span style="color: #FF79C6;">=</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">-Zprint-mono-items=yes</span><span style="color: #E9F284;">&quot;</span><span style="color: #50FA7B;"> cargo</span><span style="color: #F1FA8C;"> +nightly build ⏎</span></span></code></pre> <p><em>Thanks to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://slowrush.dev">Caspar</a> (asparck on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/1q8x25s/debugging_a_slowcompiling_codegen_unit/">Reddit</a>) for this tip!</em></p> <h3 id="replace-heavy-dependencies"><a class="zola-anchor" href="#replace-heavy-dependencies" aria-label="Anchor link for: replace-heavy-dependencies">Replace Heavy Dependencies</a></h3> <p>From time to time, it helps to shop around for more lightweight alternatives to popular crates.</p> <p>Again, <code>cargo tree</code> is your friend here to help you understand which of your dependencies are quite <em>heavy</em>: they require many other crates, cause excessive network I/O and slow down your build. Then search for lighter alternatives.</p> <p>Also, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/RazrFalcon/cargo-bloat"><code>cargo-bloat</code></a> has a <code>--time</code> flag that shows you the per-crate build time. Very handy!</p> <p>Here are a few examples:</p> <table><thead><tr><th style="text-align: left">Crate</th><th style="text-align: left">Alternative</th></tr></thead><tbody> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bnjbvr/cargo-machete">serde</a></td><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/miniserde">miniserde</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/not-fl3/nanoserde">nanoserde</a></td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/seanmonstar/reqwest">reqwest</a></td><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/algesten/ureq">ureq</a></td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/clap-rs/clap">clap</a></td><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/blyxxyz/lexopt">lexopt</a></td></tr> </tbody></table> <p>Here’s an example where switching crates reduced compile times <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.kodewerx.org/2020/06/the-rust-compiler-isnt-slow-we-are.html">from 2:22min to 26 seconds</a>.</p> <h3 id="split-big-crates-into-smaller-ones-using-workspaces"><a class="zola-anchor" href="#split-big-crates-into-smaller-ones-using-workspaces" aria-label="Anchor link for: split-big-crates-into-smaller-ones-using-workspaces">Split Big Crates Into Smaller Ones Using Workspaces</a></h3> <p>Cargo has that neat feature called <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html">workspaces</a>, which allow you to split one big crate into multiple smaller ones. This code-splitting is great for avoiding repetitive compilation because only crates with changes have to be recompiled. Bigger projects like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/servo/servo/blob/master/Cargo.toml">servo</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/timberio/vector/blob/1629f7f82e459ae87f699e931ca2b89b9080cfde/Cargo.toml#L28-L34">vector</a> make heavy use of workspaces to reduce compile times.</p> <h3 id="disable-unused-features-of-crate-dependencies"><a class="zola-anchor" href="#disable-unused-features-of-crate-dependencies" aria-label="Anchor link for: disable-unused-features-of-crate-dependencies">Disable Unused Features Of Crate Dependencies</a></h3> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/ToBinio/cargo-features-manager"><code>cargo-features-manager</code></a> is a relatively new tool that helps you to disable unused features of your dependencies.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-features-manager</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> features prune</span></span></code></pre> <p>From time to time, check the feature flags of your dependencies. A lot of library maintainers take the effort to split their crate into separate features that can be toggled off on demand. Maybe you don’t need all the default functionality from every crate?</p> <p>For example, <code>tokio</code> has <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tokio-rs/tokio/blob/2bc6bc14a82dc4c8d447521005e044028ae199fe/tokio/Cargo.toml#L26-L91">a ton of features</a> that you can disable if not needed.</p> <p>Another example is <code>bindgen</code>, which enables <code>clap</code> support by default for its binary usage. This isn’t needed for library usage, which is the common use-case. Disabling that feature <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-rocksdb/rust-rocksdb/pull/491">improved compile time of rust-rocksdb by ~13s and ~9s for debug and release builds respectively</a>. Thanks to reader <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/lilianmoraru">Lilian Anatolie Moraru</a> for mentioning this.</p> <div class="info"> <div class="info-header"> <span class="icon icon-warning"></span> <h4><p>Fair Warning</p> </h4> </div> <p>It seems that switching off features doesn’t always improve compile time. (See <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/tikv/tikv/pull/4453#issuecomment-481789292">tikv’s experiences here</a>.) It may still be a good idea for improving security by reducing the code’s attack surface. Furthermore, disabling features can help slim down the dependency tree.</p> </div> <p>You get a list of features of a crate when installing it with <code>cargo add</code>.</p> <p>If you want to look up the feature flags of a crate, they are listed on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/">docs.rs</a>. E.g. check out <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/crate/tokio/latest/features">tokio’s feature flags</a>.</p> <p>After you removed unused features, check the diff of your <code>Cargo.lock</code> file to see all the unnecessary dependencies that got cleaned up.</p> <h3 id="add-features-for-expensive-code"><a class="zola-anchor" href="#add-features-for-expensive-code" aria-label="Anchor link for: add-features-for-expensive-code">Add Features For Expensive Code</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">features</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #6272A4;"># Basic feature for default functionality</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">default</span><span style="color: #FF79C6;"> =</span><span> []</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Optional feature for JSON support</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">json</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">serde_json</span><span style="color: #E9F284;">&quot;</span><span>]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Another optional feature for more expensive or complex code</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">complex_feature</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">some-expensive-crate</span><span style="color: #E9F284;">&quot;</span><span>]</span></span></code></pre> <p>Not all the code in your project is equally expensive to compile. You can use Cargo features to split up your code into smaller chunks on a more granular level than crates. This way, you can compile only the functionality you need.</p> <p>This is a common practice for libraries. For example, <code>serde</code> has a feature called <code>derive</code> that enables code generation for serialization and deserialization. It’s not always needed, so it’s disabled by default. Similarly, <code>Tokio</code> and <code>reqwest</code> have a lot of features that can be enabled or disabled.</p> <p>You can do the same in your code. In the above example, the <code>json</code> feature in your <code>Cargo.toml</code> enables JSON support while the <code>complex_feature</code> feature enables another expensive code path.</p> <h3 id="find-the-root-cause-for-rebuilds"><a class="zola-anchor" href="#find-the-root-cause-for-rebuilds" aria-label="Anchor link for: find-the-root-cause-for-rebuilds">Find The Root Cause For Rebuilds</a></h3> <p>Sometimes many crates rebuild even when no code has changed, often due to environment variable differences between build processes (like your Makefile builds vs rust-analyzer vs CI builds).</p> <p>Use cargo’s fingerprint logging to identify exactly why rebuilds are triggered:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #FF79C6;">export</span><span style="color: #BD93F9;"> CARGO_LOG</span><span style="color: #FF79C6;">=</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">cargo::core::compiler::fingerprint=info</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">export</span><span style="color: #BD93F9;"> RUST_LOG</span><span style="color: #FF79C6;">=</span><span style="color: #BD93F9;">trace</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> build</span><span style="color: #BD93F9;"> -vv</span></span></code></pre> <p>Look for lines showing what caused the rebuild. For example:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>INFO prepare_target: cargo::core::compiler::fingerprint: dirty: EnvVarChanged { name: &quot;VIRTUAL_ENV&quot;, old_value: None, new_value: Some(&quot;/path/to/.venv&quot;) }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>Dirty pyo3-build-config v0.24.1: the env variable VIRTUAL_ENV changed</span></span></code></pre> <p>See that “Dirty” line? It tells you exactly what caused the rebuild. You can grep for that line to find all rebuild causes.</p> <p>Common culprits include:</p> <ul> <li>Environment variables (CC, CXX, VIRTUAL_ENV, PATH changes)</li> <li>Feature flag mismatches between different build tools</li> <li>Different cargo profiles being used</li> <li>Timestamp differences in generated files</li> </ul> <p>Once you identify the cause, ensure consistency across all your build processes. For rust-analyzer in VS Code, you can configure matching environment variables in <code>.vscode/settings.json</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="json"><span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">rust-analyzer.check.extraEnv</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">CC</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">clang</span><span style="color: #E9F284;">&quot;</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">CXX</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">clang++</span><span style="color: #E9F284;">&quot;</span><span>, </span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">VIRTUAL_ENV</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">/path/to/your/.venv</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span> },</span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">rust-analyzer.cargo.features</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">all</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This debugging approach can dramatically reduce unnecessary rebuilds when different tools use inconsistent environments.</p> <p>Credit: This technique was mentioned in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/twitu/twitu/blob/54a8915eac80562a15824988bac629583e6befd1/fixing-frequent-full-rust-builds-with-cargo-fingerprints.md">this write-up</a> by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/twitu">Ishan Bhanuka</a>.</p> <h3 id="cache-dependencies-with-sccache"><a class="zola-anchor" href="#cache-dependencies-with-sccache" aria-label="Anchor link for: cache-dependencies-with-sccache">Cache Dependencies With sccache</a></h3> <p>Another neat project is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mozilla/sccache">sccache</a> by Mozilla, which caches compiled crates to avoid repeated compilation.</p> <p>I had this running on my laptop for a while, but the benefit was rather negligible, to be honest. It works best if you work on a lot of independent projects that share dependencies (in the same version). A common use-case is shared build servers.</p> <h3 id="cranelift-the-alternative-rust-compiler"><a class="zola-anchor" href="#cranelift-the-alternative-rust-compiler" aria-label="Anchor link for: cranelift-the-alternative-rust-compiler">Cranelift: The Alternative Rust Compiler</a></h3> <p>Did you know that the Rust project is using an alternative compiler that runs in parallel with <code>rustc</code> for every CI build?</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustc_codegen_cranelift/">rustc_codegen_cranelift</a>, also called <code>CG_CLIF</code>, is an experimental backend for the Rust compiler that is based on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cranelift.dev/">Cranelift</a> compiler framework.</p> <p>Here is a comparison between <code>rustc</code> and Cranelift for some popular crates (blue means better):</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/cranelift.png" alt="LLVM compile time comparison between rustc and cranelift in favor of cranelift" /></p> <p>The compiler creates fully working executable binaries. They won’t be optimized as much, but they are great for local development.</p> <p>A more detailed write-up is on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://jason-williams.co.uk/a-possible-new-backend-for-rust">Jason Williams’ page</a>, and the project code is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bjorn3/rustc_codegen_cranelift">on Github</a>.</p> <h3 id="switch-to-a-faster-linker"><a class="zola-anchor" href="#switch-to-a-faster-linker" aria-label="Anchor link for: switch-to-a-faster-linker">Switch To A Faster Linker</a></h3> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>What is a linker?</p> </h4> </div> <p>A <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Linker_(computing)">linker</a> is a tool that combines multiple object files into a single executable.<br /> It’s the last step in the compilation process.</p> </div> <p>You can check if your linker is a bottleneck by running:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>cargo clean</span></span> <span class="giallo-l"><span>cargo +nightly rustc --bin &lt;your_binary_name&gt; -- -Z time-passes</span></span></code></pre> <p>It will output the timings of each step, including link time:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>...</span></span> <span class="giallo-l"><span>time: 0.000 llvm_dump_timing_file</span></span> <span class="giallo-l"><span>time: 0.001 serialize_work_products</span></span> <span class="giallo-l"><span>time: 0.002 incr_comp_finalize_session_directory</span></span> <span class="giallo-l"><span>time: 0.004 link_binary_check_files_are_writeable</span></span> <span class="giallo-l"><span>time: 0.614 run_linker</span></span> <span class="giallo-l"><span>time: 0.000 link_binary_remove_temps</span></span> <span class="giallo-l"><span>time: 0.620 link_binary</span></span> <span class="giallo-l"><span>time: 0.622 link_crate</span></span> <span class="giallo-l"><span>time: 0.757 link</span></span> <span class="giallo-l"><span>time: 3.836 total</span></span> <span class="giallo-l"><span> Finished dev [unoptimized + debuginfo] target(s) in 42.75s</span></span></code></pre> <p>If the <code>link</code> step is slow, you can try to switch to a faster alternative:</p> <table><thead><tr><th style="text-align: left">Linker</th><th style="text-align: left">Platform</th><th style="text-align: left">Production Ready</th><th style="text-align: left">Description</th></tr></thead><tbody> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lld.llvm.org/"><code>lld</code></a></td><td style="text-align: left">Linux/macOS</td><td style="text-align: left">Yes</td><td style="text-align: left">Drop-in replacement for system linkers</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rui314/mold"><code>mold</code></a></td><td style="text-align: left">Linux</td><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://news.ycombinator.com/item?id=29568454">Yes</a></td><td style="text-align: left">Optimized for Linux</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/michaeleisel/zld"><code>zld</code></a></td><td style="text-align: left">macOS</td><td style="text-align: left">No (deprecated)</td><td style="text-align: left">Drop-in replacement for Apple’s <code>ld</code> linker</td></tr> </tbody></table> <h3 id="macos-only-faster-incremental-debug-builds"><a class="zola-anchor" href="#macos-only-faster-incremental-debug-builds" aria-label="Anchor link for: macos-only-faster-incremental-debug-builds">macOS Only: Faster Incremental Debug Builds</a></h3> <p>Rust 1.51 added a flag for faster incremental debug builds on macOS. It can make debug builds multiple seconds faster (depending on your use-case). Some engineers <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://jakedeichert.com/blog/reducing-rust-incremental-compilation-times-on-macos-by-70-percent/">report</a> that this flag alone reduces compilation times on macOS by <strong>70%</strong>.</p> <p>Add this to your <code>Cargo.toml</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">profile</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">dev</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">split-debuginfo</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">unpacked</span><span style="color: #E9F284;">&quot;</span></span></code></pre> <p>The flag might become the standard for macOS soon. It is already the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/cargo/pull/9298">default on nightly</a>.</p> <h3 id="macos-only-exclude-rust-compilations-from-gatekeeper"><a class="zola-anchor" href="#macos-only-exclude-rust-compilations-from-gatekeeper" aria-label="Anchor link for: macos-only-exclude-rust-compilations-from-gatekeeper">macOS Only: Exclude Rust Compilations From Gatekeeper</a></h3> <p><strong>Gatekeeper</strong> is a system on macOS, which runs security checks on binaries. This can cause Rust builds to be slower by a few seconds for each iteration. The solution is to add your terminal to the Developer Tools, which will cause processes run by it to be excluded from Gatekeeper.</p> <ol> <li>Run <code>sudo spctl developer-mode enable-terminal</code> in your terminal.</li> <li>Go to System Preferences, and then to Security &amp; Privacy.</li> <li>Under the Privacy tab, go to <code>Developer Tools</code>.</li> <li>Make sure your terminal is listed and enabled. If you’re using any third-party terminals like iTerm or Ghostty, add them to the list as well.</li> <li>Restart your terminal.</li> </ol> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/developer-tools.png" alt="Excluding the terminal from Gatekeeper inspection in macOS Developer Tools" /></p> <p>Thanks to the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nexte.st/docs/installation/macos/">nextest</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://zed.dev/docs/development/macos#tips--tricks">Zed</a> developers for the tip.</p> <h3 id="windows-only-set-up-dev-drive-for-rust"><a class="zola-anchor" href="#windows-only-set-up-dev-drive-for-rust" aria-label="Anchor link for: windows-only-set-up-dev-drive-for-rust">Windows Only: Set Up Dev Drive For Rust</a></h3> <p>Windows 11 includes <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://learn.microsoft.com/en-us/windows/dev-drive/">Dev Drive</a>, a file system optimized for development. According to Microsoft, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://devblogs.microsoft.com/visualstudio/devdrive/">you can expect a speed boost of around 20-30%</a> by using Dev Drive:</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/DevDrivePerfChart.png" alt="Dev Drive Performance Chart" /></p> <p>To improve Rust compilation speed, move these to a Dev Drive:</p> <ul> <li>Rust toolchain folder (<code>CARGO_HOME</code>)</li> <li>Your project code</li> <li>Cargo’s <code>target</code> directory</li> </ul> <p>You can go one step further and <strong>add the above folders to your antivirus exclusions as well</strong> for another potential speedup. You can find exclusion settings in Windows Security under Virus &amp; threat protection settings.</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/windows-antivirus-exclusions.png" alt="Antivirus Exclusion Settings on Windows" /></p> <p>Thanks to the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nexte.st/docs/installation/windows/">nextest team</a> for the tip.</p> <h3 id="tweak-codegen-options-and-compiler-flags"><a class="zola-anchor" href="#tweak-codegen-options-and-compiler-flags" aria-label="Anchor link for: tweak-codegen-options-and-compiler-flags">Tweak Codegen Options And Compiler Flags</a></h3> <p>Rust comes with a huge set of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rustc/codegen-options">settings for code generation</a>. It can help to look through the list and tweak the parameters for your project.</p> <p>There are <strong>many</strong> gems in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rustc/codegen-options">full list of codegen options</a>. For inspiration, here’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bevyengine/bevy/blob/3a2a68852c0a1298c0678a47adc59adebe259a6f/.cargo/config_fast_builds">bevy’s config for faster compilation</a>.</p> <h3 id="avoid-procedural-macro-crates"><a class="zola-anchor" href="#avoid-procedural-macro-crates" aria-label="Anchor link for: avoid-procedural-macro-crates">Avoid Procedural Macro Crates</a></h3> <p>If you heavily use procedural macros in your project (e.g., if you use serde), it might be worth it to play around with opt-levels in your <code>Cargo.toml</code>.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">profile</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">dev</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">build-override</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">opt-level</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 3</span></span></code></pre> <p>As reader <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/jfmontanaro">jfmontanaro</a> mentioned on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/mre/endler.dev/issues/53">Github</a>:</p> <blockquote> <p>I think the reason it helps with build times is because it only applies to build scripts and proc-macros. Build scripts and proc-macros are unique because during a normal build, they are not only compiled but also executed (and in the case of proc-macros, they can be executed repeatedly). When your project uses a lot of proc-macros, optimizing the macros themselves can in theory save a lot of time.</p> </blockquote> <p>Another approach is to try and sidestep the macro impact on compile times with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/dtolnay/watt">watt</a>, a tool that offloads macro compilation to Webassembly.</p> <p>From the docs:</p> <blockquote> <p>By compiling macros ahead-of-time to Wasm, we save all downstream users of the macro from having to compile the macro logic or its dependencies themselves.</p> <p>Instead, what they compile is a small self-contained Wasm runtime (~3 seconds, shared by all macros) and a tiny proc macro shim for each macro crate to hand off Wasm bytecode into the Watt runtime (~0.3 seconds per proc-macro crate you depend on). This is much less than the 20+ seconds it can take to compile complex procedural macros and their dependencies.</p> </blockquote> <p>Note that this crate is still experimental.</p> <h3 id="find-expensive-proc-macros"><a class="zola-anchor" href="#find-expensive-proc-macros" aria-label="Anchor link for: find-expensive-proc-macros">Find Expensive Proc Macros</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #BD93F9;">RUSTFLAGS</span><span style="color: #FF79C6;">=</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">-Zmacro-stats</span><span style="color: #E9F284;">&quot;</span><span style="color: #50FA7B;"> cargo</span><span style="color: #F1FA8C;"> +nightly build</span></span></code></pre> <p>Some macros have a big compile-time cost; but exactly how big? It can help to quantify the costs to see if a macro is worth optimizing (or removing). One way is to understand exactly how much code they generate.</p> <p>One way is to use <code>cargo expand</code> to see the generated code, but that doesn’t scale to large codebases and the output is hard to quantify.</p> <p>The alternative is to use the <code>-Zmacro-stats</code> flag to identify proc macros that generate a lot of code. This tool has already led to successful optimizations in projects like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/bevyengine/bevy/issues/19873">Bevy</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/2025/08/16/speed-wins-when-fuzzing-rust-code-with-derive-arbitrary.html">Arbitrary</a>.</p> <p>For more information, read <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/2025/06/26/how-much-code-does-that-proc-macro-generate.html">Nicholas Nethercote’s blog post</a> on the topic.</p> <h3 id="conditional-compilation-for-procedural-macros"><a class="zola-anchor" href="#conditional-compilation-for-procedural-macros" aria-label="Anchor link for: conditional-compilation-for-procedural-macros">Conditional Compilation for Procedural Macros</a></h3> <p>Procedural macros need to parse Rust code, and that is a relatively complex task. Crates that depend on procedural macros will have to wait for the procedural macro to compile before they can compile. For example, <code>serde</code> can be a bottleneck in compilation times and can limit CPU utilization.</p> <p>To improve Rust compile times, consider a strategic approach to handling serialization with Serde, especially in projects with a shared crate structure. Instead of placing Serde directly in a shared crate used across different parts of the project, you can make Serde an optional dependency through Cargo features.</p> <p>Use the <code>cfg</code> or <code>cfg_attr</code> attributes to make Serde usage and <code>derive</code> in the shared crate feature-gated. This way, it becomes an optional dependency that is only enabled in leaf crates which actually perform serialization/deserialization.</p> <p>This approach prevents the entire project from waiting on the compilation of Serde dependencies, which would be the case if Serde were a non-optional, direct dependency of the shared crate.</p> <p>Let’s illustrate this with a simplified example. Imagine you have a Rust project with a shared library crate and a few other crates that depend on it. You don’t want to compile Serde unnecessarily when building parts of the project that don’t need it.</p> <p>Here’s how you can structure your project to use optional features in Cargo:</p> <p>In your <code>Cargo.toml</code> for the shared crate, declare serde as an optional dependency:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">package</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">name</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">shared</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">version</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">0.1.0</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">edition</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">2021</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">dependencies</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">serde</span><span style="color: #FF79C6;"> =</span><span> {</span><span style="color: #8BE9FD;"> version</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">1.0</span><span style="color: #E9F284;">&quot;</span><span>,</span><span style="color: #8BE9FD;"> optional</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> true</span><span> }</span></span></code></pre> <p>In this crate, use conditional compilation to include serde only when the feature is enabled:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[cfg(feature </span><span style="color: #FF79C6;">=</span><span style="color: #F1FA8C;"> &quot;serde&quot;</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">use</span><span> serde</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">Serialize</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Deserialize</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[cfg_attr(feature </span><span style="color: #FF79C6;">=</span><span style="color: #F1FA8C;"> &quot;serde&quot;</span><span>, derive(</span><span style="color: #8BE9FD;font-style: italic;">Serialize</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Deserialize</span><span>))]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> MySharedStruct</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Your struct fields</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In the other crates, enable the <code>serde</code> feature for the shared crate if needed:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">package</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">name</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">other</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">version</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">0.1.0</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">edition</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">2021</span><span style="color: #E9F284;">&quot;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">dependencies</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">shared</span><span style="color: #FF79C6;"> =</span><span> {</span><span style="color: #8BE9FD;"> path</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">../shared</span><span style="color: #E9F284;">&quot;</span><span>,</span><span style="color: #8BE9FD;"> features</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">serde</span><span style="color: #E9F284;">&quot;</span><span>] }</span></span></code></pre> <p>You can now use <code>MySharedStruct</code> with Serde’s functionality enabled without bloating the compilation of crates that don’t need it.</p> <h3 id="generics-use-an-inner-non-generic-function"><a class="zola-anchor" href="#generics-use-an-inner-non-generic-function" aria-label="Anchor link for: generics-use-an-inner-non-generic-function">Generics: Use an Inner Non-Generic Function</a></h3> <p>If you have a generic function, it will be compiled for every type you use it with. This can be a problem if you have a lot of different types.</p> <p>A common solution is to use an inner non-generic function. This way, the compiler will only compile the inner function once.</p> <p>This is a trick often used in the standard library. For example, here is the implementation of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust/blob/ae612bedcbfc7098d1711eb35bc7ca994eb17a4c/library/std/src/fs.rs#L295-L304"><code>read_to_string</code></a>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> read_to_string</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">P</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> AsRef</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>&gt;&gt;(path</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> P</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> inner</span><span>(path</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> file</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> File</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">open</span><span>(path)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> size</span><span style="color: #FF79C6;"> =</span><span> file</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">metadata</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>m</span><span style="color: #FF79C6;">|</span><span> m</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>()</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">ok</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> string</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">with_capacity</span><span>(size</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap_or</span><span>(</span><span style="color: #BD93F9;">0</span><span>));</span></span> <span class="giallo-l"><span> io</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">default_read_to_string</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span> file,</span><span style="color: #FF79C6;"> &amp;mut</span><span> string, size)</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(string)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> inner</span><span>(path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">as_ref</span><span>())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>You can do the same in your code: the outer function is generic, while it calls the inner non-generic function, which does the actual work.</p> <h3 id="improve-workspace-build-times-with-cargo-hakari"><a class="zola-anchor" href="#improve-workspace-build-times-with-cargo-hakari" aria-label="Anchor link for: improve-workspace-build-times-with-cargo-hakari">Improve Workspace Build Times with cargo-hakari</a></h3> <p>Do you have a large Rust workspace with dependencies that:</p> <ol> <li>Are used in multiple crates</li> <li>Have different feature sets across those crates?</li> </ol> <p>This situation can lead to long build times, as cargo will build each dependency multiple times with different features depending on which crate is being built. This is where <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/cargo-hakari/latest/cargo_hakari/about/index.html"><code>cargo-hakari</code></a> comes in. It’s a tool designed to automatically manage “workspace-hack” crates.</p> <p>In some scenarios, this can reduce consecutive build times by up to 50% or more. To learn more, check out the usage instructions and benchmarks in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/cargo-hakari/latest/cargo_hakari/about/index.html">official cargo-hakari documentation</a>.</p> <h3 id="speeding-up-incremental-rust-compilation-with-dylibs"><a class="zola-anchor" href="#speeding-up-incremental-rust-compilation-with-dylibs" aria-label="Anchor link for: speeding-up-incremental-rust-compilation-with-dylibs">Speeding up incremental Rust compilation with dylibs</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #6272A4;"># Install the tool</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-add-dynamic</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Add a dynamic library to your project</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> add-dynamic polars</span><span style="color: #BD93F9;"> --features</span><span style="color: #F1FA8C;"> csv-file,lazy,list,describe,rows,fmt,strings,temporal</span></span></code></pre> <p>This will create a wrapper-crate around <code>polars</code> that is compiled as a dynamic library (<code>.so</code> on Linux, <code>.dylib</code> on macOS, <code>.dll</code> on Windows).</p> <p>Essentially, it patches the dependency with</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">lib</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">crate-type</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">dylib</span><span style="color: #E9F284;">&quot;</span><span>]</span></span></code></pre> <p>With this trick, you can save yourself the linking time of a dependency when you only change your own code. The dependency itself will only be recompiled when you change the features or the version. Of course, this works for any crate, not just <code>polars</code>.</p> <p>Read more about this on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://robert.kra.hn/posts/2022-09-09-speeding-up-incremental-rust-compilation-with-dylibs/">this blog post by Robert Krahn</a> and the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rksm/cargo-add-dynamic">tool’s homepage</a>.</p> <h3 id="switch-to-the-new-parallel-compiler-frontend"><a class="zola-anchor" href="#switch-to-the-new-parallel-compiler-frontend" aria-label="Anchor link for: switch-to-the-new-parallel-compiler-frontend">Switch To The New Parallel Compiler Frontend</a></h3> <p><strong>In nightly</strong>, you can now enable the new parallel compiler frontend. To try it out, run the nightly compiler with the <code>-Z threads=8</code> option:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #BD93F9;">RUSTFLAGS</span><span style="color: #FF79C6;">=</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">-Z threads=8</span><span style="color: #E9F284;">&quot;</span><span style="color: #50FA7B;"> cargo</span><span style="color: #F1FA8C;"> +nightly build</span></span></code></pre> <p>If you find that it works well for you, you can make it the default by adding <code>-Z threads=8</code> to your <code>~/.cargo/config.toml</code> file:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">build</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">rustflags</span><span style="color: #FF79C6;"> =</span><span> [</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">-Z</span><span style="color: #E9F284;">&quot;</span><span>,</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">threads=8</span><span style="color: #E9F284;">&quot;</span><span>]</span></span></code></pre> <p>Alternatively, you can set an alias for <code>cargo</code> in your shell’s config file (e.g., <code>~/.bashrc</code> or <code>~/.zshrc</code>):</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #FF79C6;">alias</span><span style="color: #BD93F9;"> cargo</span><span style="color: #FF79C6;">=</span><span style="color: #E9F284;">&quot;</span><span style="color: #F1FA8C;">RUSTFLAGS=&#39;-Z threads=8&#39; cargo +nightly</span><span style="color: #E9F284;">&quot;</span></span></code></pre> <p>When the front-end is executed in a multi-threaded setting using <code>-Z threads=8</code>, benchmarks on actual code indicate that compilation times may decrease by as much as <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2023/11/09/parallel-rustc.html">50%</a>. However, the gains fluctuate depending on the code being compiled. It is certainly worth a try, though.</p> <p>Here is a visualization of the parallel compiler frontend in action:</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/samply-parallel.png" alt="Result of the parallel compiler" /></p> <p>Find out more on the official announcement <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2023/11/09/parallel-rustc.html">on the Rust blog</a>.</p> <h3 id="use-a-scratch-disk-for-faster-builds"><a class="zola-anchor" href="#use-a-scratch-disk-for-faster-builds" aria-label="Anchor link for: use-a-scratch-disk-for-faster-builds">Use A Scratch Disk For Faster Builds</a></h3> <p>Your filesystem might be the bottleneck. Consider using an in-memory filesystem like for your build directory.</p> <p>Traditional temporary filesystem like <code>tmpfs</code> is limited to your RAM plus swap space and can be problematic for builds creating large intermediate artifacts.</p> <p>Instead, on Linux, mount an <code>ext4</code> volume with the following options:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>-o noauto_da_alloc,data=writeback,lazytime,journal_async_commit,commit=999,nobarrier</span></span></code></pre> <p>This will store files in the page cache if you have enough RAM, with writebacks occurring later. Treat this as if it were a temporary filesystem, as data may be lost or corrupted after a crash or power loss.</p> <p>Credits go to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/1ddgatd/compile_rust_faster_some_tricks/l85gzy8/">/u/The_8472 on Reddit</a>.</p> <h3 id="invest-in-better-hardware"><a class="zola-anchor" href="#invest-in-better-hardware" aria-label="Anchor link for: invest-in-better-hardware">Invest In Better Hardware</a></h3> <p>If you reached this point, the easiest way to improve compile times even more is probably to spend money on top-of-the-line hardware.</p> <p>As for laptops, the <code>M-series</code> of Apple’s new Macbooks perform really well for Rust compilation.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/rikarends/status/1328598935380910082"><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/tweet.png" alt="Rik Arends on Twitter" /></a></p> <p>The <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/qgi421/doing_m1_macbook_pro_m1_max_64gb_compile/">benchmarks</a> for a Macbook Pro with M1 Max are absolutely <em>ridiculous</em> — even in comparison to the already fast M1:</p> <table><thead><tr><th style="text-align: left">Project</th><th style="text-align: left">M1 Max</th><th style="text-align: left">M1 Air</th></tr></thead><tbody> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/denoland">Deno</a></td><td style="text-align: left">6m11s</td><td style="text-align: left">11m15s</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/meilisearch/MeiliSearch">MeiliSearch</a></td><td style="text-align: left">1m28s</td><td style="text-align: left">3m36s</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/sharkdp/bat">bat</a></td><td style="text-align: left">43s</td><td style="text-align: left">1m23s</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/sharkdp/hyperfine">hyperfine</a></td><td style="text-align: left">23s</td><td style="text-align: left">42s</td></tr> <tr><td style="text-align: left"><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/BurntSushi/ripgrep">ripgrep</a></td><td style="text-align: left">16s</td><td style="text-align: left">37s</td></tr> </tbody></table> <p>That’s a solid 2x performance improvement.</p> <p>But if you rather like to stick to Linux, people also had great success with a multicore CPU like an <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/chqu4c/building_a_computer_for_fastest_possible_rust/">AMD Ryzen Threadripper and 32 GB of RAM</a>.</p> <p>On portable devices, compiling can drain your battery and be slow. To avoid that, I’m using my machine at home, a 6-core AMD FX 6300 with 12GB RAM, as a build machine. I can use it in combination with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://code.visualstudio.com/docs/remote/remote-overview">Visual Studio Code Remote Development</a>.</p> <h3 id="compile-in-the-cloud"><a class="zola-anchor" href="#compile-in-the-cloud" aria-label="Anchor link for: compile-in-the-cloud">Compile in the Cloud</a></h3> <p>If you don’t have a dedicated machine yourself, you can offload the compilation process to the cloud instead. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/features/codespaces">GitHub Codespaces</a> gives you a fully configured cloud development environment right inside GitHub. You can spin up a codespace from any repository by clicking the <strong>Code</strong> button and selecting <strong>Open with Codespaces</strong>. Machine sizes range from 2 cores all the way up to 32 cores, and every GitHub account includes a free monthly quota (currently 60 hours on a 2-core machine).</p> <p>Codespaces supports <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration">dev container configuration</a> via a <code>.devcontainer/devcontainer.json</code> file, which lets you pre-install the Rust toolchain and any other dependencies so the environment is ready the moment it starts. This is particularly useful when reviewing pull requests — open the PR directly in a codespace and everything is already set up for you.</p> <p>If you want more control over the build environment, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://northflank.com/pricing">Northflank</a> is another option. It lets you run arbitrary build jobs on dedicated cloud infrastructure, with plans ranging from shared 0.1 vCPU containers up to 32 dedicated vCPUs. There’s a free sandbox tier, and paid plans are billed per-second so you only pay for actual build time.</p> <h3 id="cache-all-crates-locally"><a class="zola-anchor" href="#cache-all-crates-locally" aria-label="Anchor link for: cache-all-crates-locally">Cache All Crates Locally</a></h3> <p>If you have a slow internet connection, a big part of the initial build process is fetching all those shiny crates from crates.io. To mitigate that, you can download <strong>all</strong> crates in advance to have them cached locally. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/the-lean-crate/criner">criner</a> does just that:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>git clone https://github.com/the-lean-crate/criner</span></span> <span class="giallo-l"><span>cd criner</span></span> <span class="giallo-l"><span>cargo run --release -- mine</span></span></code></pre> <p>The archive size is surprisingly reasonable, with roughly <strong>50GB of required disk space</strong> (as of today).</p> <h2 id="test-execution"><a class="zola-anchor" href="#test-execution" aria-label="Anchor link for: test-execution">Test Execution</a></h2> <h3 id="use-cargo-nextest-instead-of-cargo-test"><a class="zola-anchor" href="#use-cargo-nextest-instead-of-cargo-test" aria-label="Anchor link for: use-cargo-nextest-instead-of-cargo-test">Use Cargo Nextest Instead of <code>cargo test</code></a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="shellscript"><span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> install cargo-nextest</span></span> <span class="giallo-l"><span style="color: #50FA7B;">cargo</span><span style="color: #F1FA8C;"> nextest run</span></span></code></pre> <p>It’s nice that <code>cargo</code> comes with its own little test runner, but especially if you have to build multiple test binaries, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nexte.st/"><code>cargo nextest</code></a> can be up to 60% faster than <code>cargo test</code> thanks to its parallel execution model. Here are some quick <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nexte.st/book/benchmarks.html">benchmarks</a>:</p> <table><thead><tr><th>Project</th><th>Revision</th><th style="text-align: right">Test count</th><th style="text-align: right">cargo test (s)</th><th style="text-align: right">nextest (s)</th><th style="text-align: right">Improvement</th></tr></thead><tbody> <tr><td>crucible</td><td><code>cb228c2b</code></td><td style="text-align: right">483</td><td style="text-align: right">5.14</td><td style="text-align: right">1.52</td><td style="text-align: right">3.38×</td></tr> <tr><td>guppy</td><td><code>2cc51b41</code></td><td style="text-align: right">271</td><td style="text-align: right">6.42</td><td style="text-align: right">2.80</td><td style="text-align: right">2.29×</td></tr> <tr><td>mdBook</td><td><code>0079184c</code></td><td style="text-align: right">199</td><td style="text-align: right">3.85</td><td style="text-align: right">1.66</td><td style="text-align: right">2.31×</td></tr> <tr><td>meilisearch</td><td><code>bfb1f927</code></td><td style="text-align: right">721</td><td style="text-align: right">57.04</td><td style="text-align: right">28.99</td><td style="text-align: right">1.96×</td></tr> <tr><td>omicron</td><td><code>e7949cd1</code></td><td style="text-align: right">619</td><td style="text-align: right">444.08</td><td style="text-align: right">202.50</td><td style="text-align: right">2.19×</td></tr> <tr><td>penumbra</td><td><code>4ecd94cc</code></td><td style="text-align: right">144</td><td style="text-align: right">125.38</td><td style="text-align: right">90.96</td><td style="text-align: right">1.37×</td></tr> <tr><td>reqwest</td><td><code>3459b894</code></td><td style="text-align: right">113</td><td style="text-align: right">5.57</td><td style="text-align: right">2.26</td><td style="text-align: right">2.48×</td></tr> <tr><td>ring</td><td><code>450ada28</code></td><td style="text-align: right">179</td><td style="text-align: right">13.12</td><td style="text-align: right">9.40</td><td style="text-align: right">1.39×</td></tr> <tr><td>tokio</td><td><code>1f50c571</code></td><td style="text-align: right">1138</td><td style="text-align: right">24.27</td><td style="text-align: right">11.60</td><td style="text-align: right">2.09×</td></tr> </tbody></table> <h3 id="combine-all-integration-tests-into-a-single-binary"><a class="zola-anchor" href="#combine-all-integration-tests-into-a-single-binary" aria-label="Anchor link for: combine-all-integration-tests-into-a-single-binary">Combine All Integration Tests Into A Single Binary</a></h3> <p>Have any <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html">integration tests</a>? (These are the ones in your <code>tests</code> folder.) Did you know that the Rust compiler will create a binary for every single one of them? And every binary will have to be linked individually. This can take most of your build time because linking is slooow. 🐢 The reason is that many system linkers (like <code>ld</code>) are <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.com/questions/5142753/can-gcc-use-multiple-cores-when-linking">single threaded</a>.</p> <p>To make the linker’s job a little easier, you can put all your tests in one crate. (Basically create a <code>main.rs</code> in your test folder and add your test files as <code>mod</code> in there.)</p> <p>Then the linker will go ahead and build a single binary only. Sounds nice, but careful: it’s still a trade-off as you’ll need to expose your internal types and functions (i.e. make them <code>pub</code>).</p> <p>If you have a lot of integration tests, this can <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://azriel.im/will/2019/10/08/dev-time-optimization-part-1-1.9x-speedup-65-less-disk-usage/">result in a 50% speedup</a>.</p> <p><em>This tip was brought to you by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/algo_luca">Luca Palmieri</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/lucio_d_franco">Lucio Franco</a>, and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/im_azriel">Azriel Hoh</a>. Thanks!</em></p> <h3 id="put-slow-tests-behind-an-environment-variable"><a class="zola-anchor" href="#put-slow-tests-behind-an-environment-variable" aria-label="Anchor link for: put-slow-tests-behind-an-environment-variable">Put slow tests behind an environment variable</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> completion_works_with_real_standard_library</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> std</span><span style="color: #FF79C6;">::</span><span>env</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">var</span><span>(</span><span style="color: #F1FA8C;">&quot;RUN_SLOW_TESTS&quot;</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_err</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span>;</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If you have slow tests, you can put them behind an environment variable to disable them by default. This way, you can skip them locally and only run them on CI.</p> <p>(A nice trick I learned from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://matklad.github.io/2021/05/31/how-to-test.html">matklad’s (Alex Kladov) post</a>.)</p> <h2 id="ci-builds"><a class="zola-anchor" href="#ci-builds" aria-label="Anchor link for: ci-builds">CI Builds</a></h2> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Tips for CI Builds</p> </h4> </div> <p>Many of the techniques in this article also apply to CI builds. For CI-specific optimizations and best practices, check out my dedicated guide on <a href="/blog/tips-for-faster-ci-builds/">Tips for Faster CI Builds</a>, which covers caching strategies, workflow optimization, and GitHub Actions-specific improvements.</p> </div> <h3 id="use-a-cache-for-your-dependencies"><a class="zola-anchor" href="#use-a-cache-for-your-dependencies" aria-label="Anchor link for: use-a-cache-for-your-dependencies">Use A Cache For Your Dependencies</a></h3> <p>For GitHub actions in particular you can also use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/Swatinem/rust-cache">Swatinem/rust-cache</a>.</p> <p>It is as simple as adding a single step to your workflow:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">jobs</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> test</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> runs-on</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> ubuntu-latest</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> steps</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> actions/checkout@v4</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> dtolnay/rust-toolchain@stable</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> uses</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Swatinem/rust-cache@v2</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> -</span><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo test --all</span></span></code></pre> <p>With that, your dependencies will be cached between builds, and you can expect a significant speedup.</p> <h3 id="split-up-compile-and-test-steps"><a class="zola-anchor" href="#split-up-compile-and-test-steps" aria-label="Anchor link for: split-up-compile-and-test-steps">Split Up Compile And Test Steps</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #FF79C6;">-</span><span style="color: #8BE9FD;"> name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Compile</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo test --no-run --locked</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">-</span><span style="color: #8BE9FD;"> name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> Test</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> run</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> cargo test -- --nocapture --quiet</span></span></code></pre> <p>This makes it easier to find out how much time is spent on compilation and how much on running the tests.</p> <h3 id="disable-incremental-compilation-in-ci"><a class="zola-anchor" href="#disable-incremental-compilation-in-ci" aria-label="Anchor link for: disable-incremental-compilation-in-ci">Disable Incremental Compilation In CI</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> CARGO_INCREMENTAL</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span></span></code></pre> <p>Since CI builds are more akin to from-scratch builds, incremental compilation adds unnecessary dependency-tracking and IO overhead, reducing caching effectiveness. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-analyzer/rust-analyzer/blob/25368d24308d6a94ffe8b99f0122bcf5a2175322/.github/workflows/ci.yaml#L11">Here’s how to disable it.</a></p> <h3 id="turn-off-debuginfo"><a class="zola-anchor" href="#turn-off-debuginfo" aria-label="Anchor link for: turn-off-debuginfo">Turn Off Debuginfo</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="toml"><span class="giallo-l"><span style="color: #FF79C6;">[</span><span style="color: #8BE9FD;">profile</span><span style="color: #FF79C6;">.</span><span style="color: #8BE9FD;">dev</span><span style="color: #FF79C6;">]</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">debug</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 0</span></span> <span class="giallo-l"><span style="color: #8BE9FD;">strip</span><span style="color: #FF79C6;"> =</span><span style="color: #E9F284;"> &quot;</span><span style="color: #F1FA8C;">debuginfo</span><span style="color: #E9F284;">&quot;</span></span></code></pre> <p>Avoid linking debug info to speed up your build process, especially if you rarely use an actual debugger. There are two ways to avoid linking debug information: set <code>debug=0</code> to skip compiling it, or set <code>strip="debuginfo"</code> to skip linking it. Unfortunately, changing these options can trigger a full rebuild with Cargo.</p> <ul> <li>On Linux, set both for improved build times.</li> <li>On Mac, use <code>debug=0</code> since rustc uses an external strip command.</li> <li>On Windows, test both settings to see which is faster.</li> </ul> <p>Note that without debug info, backtraces will only show function names, not line numbers. If needed, use <code>split-debuginfo="unpacked"</code> for a compromise.</p> <p>As a nice side-effect, this will also help shrink the size of <code>./target</code>, improving caching efficiency.</p> <p>Here is a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-analyzer/rust-analyzer/blob/48f84a7b60bcbd7ec5fa6434d92d9e7a8eb9731b/Cargo.toml#L6-L10">sample config</a> for how to apply the settings.</p> <h3 id="deny-warnings-through-an-environment-variable"><a class="zola-anchor" href="#deny-warnings-through-an-environment-variable" aria-label="Anchor link for: deny-warnings-through-an-environment-variable">Deny Warnings Through An Environment Variable</a></h3> <p>Avoid using <code>#![deny(warnings)]</code> in your code to prevent repetitive declarations. Furthermore, it is fine to get warnings during local development.</p> <p>Instead, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-analyzer/rust-analyzer/blob/3dae94bf2b3e496adb049da589c7efef272a39b8/.github/workflows/ci.yaml#L15">add <code>-D warnings</code> to <code>RUSTFLAGS</code></a> to globally deny warnings in all crates on CI.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="yaml"><span class="giallo-l"><span style="color: #8BE9FD;">env</span><span style="color: #FF79C6;">:</span></span> <span class="giallo-l"><span style="color: #8BE9FD;"> RUSTFLAGS</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> -D warnings</span></span></code></pre><h3 id="switch-to-a-faster-github-actions-runner"><a class="zola-anchor" href="#switch-to-a-faster-github-actions-runner" aria-label="Anchor link for: switch-to-a-faster-github-actions-runner">Switch To A Faster Github Actions Runner</a></h3> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="diff"><span class="giallo-l"><span style="color: #FF5555;">- runs-on: ubuntu-latest</span></span> <span class="giallo-l"><span style="color: #50FA7B;">+ runs-on: ubicloud</span></span></code></pre> <p>Services like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.ubicloud.com/use-cases/github-actions">Ubicloud</a>, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://buildjet.com">BuildJet</a>, or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/runs-on/runs-on">RunsOn</a> provide you with faster workers for your Github Actions builds. Especially for Rust pipelines, the number of cores can have a significant big impact on compile times, so it might be worth a try.</p> <p>Here is an example from the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/facebook/folly">Facebook Folly</a> project using Ubicloud. Granted, this is a C++ project, but it shows the potential of faster runners:</p> <p><img src="https://corrode.dev/blog/tips-for-faster-rust-compile-times/ubicloud-facebook-folly.svg" alt="facebook/folly build times" /></p> <p>After signing up with the service, you only need to change the runner in your Github Actions workflow file.</p> <h2 id="faster-docker-builds"><a class="zola-anchor" href="#faster-docker-builds" aria-label="Anchor link for: faster-docker-builds">Faster Docker Builds</a></h2> <h3 id="use-cargo-chef-to-speed-up-docker-builds"><a class="zola-anchor" href="#use-cargo-chef-to-speed-up-docker-builds" aria-label="Anchor link for: use-cargo-chef-to-speed-up-docker-builds">Use <code>cargo-chef</code> To Speed Up Docker Builds</a></h3> <p>Building Docker images from your Rust code? These can be notoriously slow, because cargo doesn’t support building only a project’s dependencies yet, invalidating the Docker cache with every build if you don’t pay attention. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.lpalmieri.com/posts/fast-rust-docker-builds/"><code>cargo-chef</code></a> to the rescue! ⚡</p> <blockquote> <p><code>cargo-chef</code> can be used to fully leverage Docker layer caching, therefore massively speeding up Docker builds for Rust projects. On our commercial codebase (~14k lines of code, ~500 dependencies) we measured a <strong>5x speed-up</strong>: we cut Docker build times from <strong>~10 minutes to ~2 minutes.</strong></p> </blockquote> <p>Here is an example <code>Dockerfile</code> if you’re interested:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="docker"><span class="giallo-l"><span style="color: #6272A4;"># Step 1: Compute a recipe file</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> rust </span><span style="color: #FF79C6;">as</span><span> planner</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> app</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo install cargo-chef</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> . .</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo chef prepare --recipe-path recipe.json</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Step 2: Cache project dependencies</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> rust </span><span style="color: #FF79C6;">as</span><span> cacher</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> app</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo install cargo-chef</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=planner /app/recipe.json recipe.json</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo chef cook --release --recipe-path recipe.json</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Step 3: Build the binary</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> rust </span><span style="color: #FF79C6;">as</span><span> builder</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> app</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> . .</span></span> <span class="giallo-l"><span style="color: #6272A4;"># Copy over the cached dependencies from above</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=cacher /app/target target</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=cacher /usr/local/cargo /usr/local/cargo</span></span> <span class="giallo-l"><span style="color: #FF79C6;">RUN</span><span> cargo build --release --bin app</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"># Step 4:</span></span> <span class="giallo-l"><span style="color: #6272A4;"># Create a tiny output image.</span></span> <span class="giallo-l"><span style="color: #6272A4;"># It only contains our final binary.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">FROM</span><span> rust </span><span style="color: #FF79C6;">as</span><span> runtime</span></span> <span class="giallo-l"><span style="color: #FF79C6;">WORKDIR</span><span> app</span></span> <span class="giallo-l"><span style="color: #FF79C6;">COPY</span><span> --from=builder /app/target/release/app /usr/local/bin</span></span> <span class="giallo-l"><span style="color: #FF79C6;">ENTRYPOINT</span><span> [</span><span style="color: #F1FA8C;">&quot;/usr/local/bin/app&quot;</span><span>]</span></span></code></pre> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/LukeMathWalker/cargo-chef"><code>cargo-chef</code></a> can help speed up your continuous integration with Github Actions or your deployment process to Google Cloud.</p> <h3 id="consider-earthly-for-better-build-caching"><a class="zola-anchor" href="#consider-earthly-for-better-build-caching" aria-label="Anchor link for: consider-earthly-for-better-build-caching">Consider Earthly For Better Build Caching</a></h3> <p>Earthly is a relatively new build tool that is designed to be a replacement for Makefiles, Dockerfiles, and other build tools. It provides fast, incremental Rust builds for CI.</p> <blockquote> <p>Earthly speeds up Rust builds in CI by effectively implementing Cargo’s caching and Rust’s incremental compilation. This approach significantly reduces unnecessary rebuilds in CI, mirroring the efficiency of local Rust builds.</p> <p>Source: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://earthly.dev/rust">Earthly for Rust</a></p> </blockquote> <p>They use a system called Satellites, which are persistent remote build runners that retain cache data locally. This can drastically speed up CI build times by eliminating cache uploads and downloads. Instead of bringing the cache data to the compute, they colocate the cache data and compute, eliminating cache transfers altogether. Less I/O means faster builds.</p> <p>Earthly also provides a <code>lib/rust</code> library, which abstracts away cache configuration entirely. It ensures that Rust is caching correctly and building incrementally in CI. It can be used in your <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.earthly.dev/docs/earthfile"><code>Earthfile</code></a> like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="docker"><span class="giallo-l"><span>IMPORT github.com/earthly/lib/rust</span></span></code></pre> <p>If you’re curious, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://earthly.dev/rust">Earthly’s Guide for Rust</a> details a simple Rust example with optimized caching and compilation steps.</p> <h2 id="ide-specific-optimizations"><a class="zola-anchor" href="#ide-specific-optimizations" aria-label="Anchor link for: ide-specific-optimizations">IDE-Specific Optimizations</a></h2> <p>If you find that build times in your development environment are slow, here are a few additional tips you can try.</p> <h3 id="slow-debug-sessions-in-visual-studio-code"><a class="zola-anchor" href="#slow-debug-sessions-in-visual-studio-code" aria-label="Anchor link for: slow-debug-sessions-in-visual-studio-code">Slow Debug Sessions In Visual Studio Code</a></h3> <p>If you’re using Visual Studio Code and find that <strong>debug sessions</strong> are slow, make sure you don’t have too many breakpoints set. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/1ddktag/looking_for_some_help_where_it_takes_a_minute_to/">Each breakpoint can slow down the debug session</a>.</p> <h3 id="close-unrelated-projects"><a class="zola-anchor" href="#close-unrelated-projects" aria-label="Anchor link for: close-unrelated-projects">Close Unrelated Projects</a></h3> <p>In case you have multiple projects open in Visual Studio Code, <strong>each instance runs its own copy of rust-analyzer</strong>. This can slow down your machine. Close unrelated projects if they aren’t needed.</p> <h3 id="fix-rust-analyzer-cache-invalidation"><a class="zola-anchor" href="#fix-rust-analyzer-cache-invalidation" aria-label="Anchor link for: fix-rust-analyzer-cache-invalidation">Fix Rust Analyzer Cache Invalidation</a></h3> <p>If you’re using rust-analyzer in VS Code and find that you run into slow build times when saving your changes, it could be that the cache gets invalidated. This also results in dependencies like <code>serde</code> being rebuilt frequently.</p> <p>You can fix this by configuring a separate target directory for rust-analyzer. Add this to your VS Code settings (preferably user settings):</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="json"><span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #8BE9FE;"> &quot;</span><span style="color: #8BE9FD;">rust-analyzer.cargo.targetDir</span><span style="color: #8BE9FE;">&quot;</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> true</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This will make rust-analyzer build inside <code>target/rust-analyzer</code> instead of the default <code>target/</code> directory, preventing interference with your regular <code>cargo run</code> builds.</p> <p>Some users reported <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-analyzer/issues/6007#issuecomment-2563288106">significant speedups</a> thanks to that:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="plain"><span class="giallo-l"><span>before: 34.98s user 2.02s system 122% cpu 30.176 total</span></span> <span class="giallo-l"><span>after: 2.62s user 0.60s system 84% cpu 3.803 total</span></span></code></pre> <p>This could also help with <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rust-analyzer/issues/4616">rust analyzer blocking debug builds</a>.</p> <p>Credit: This tip was shared by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/1if5wpm/high_hopes_for_rust_where_are_we/majhmhe/">asparck on Reddit</a>.</p> <h1 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h1> <p>In this article, we’ve covered a lot of ground. We’ve looked at how to speed up your Rust builds by using better hardware, optimizing your code, and using better tools.</p> <p>For CI-specific optimizations, don’t forget to check out <a href="/blog/tips-for-faster-ci-builds/">Tips for Faster CI Builds</a>, which complements the techniques discussed here.</p> <p>I hope that you were able to use some of these tips to speed up your Rust builds. In case you found other ways to speed up your Rust builds, or if you have any questions or feedback, I’d love to hear from you.</p> <div class="info"> <div class="info-header"> <span class="icon icon-crab"></span> <h4><p>Get Professional Support</p> </h4> </div> <p>If you need support for commercial Rust projects, I can also help you with performance problems and reducing your build times. <a href="/services">Get in touch.</a></p> </div> Thu, 11 Jan 2024 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e03-apollo/ https://corrode.dev/podcast/s01e03-apollo/ <div><script id="letscast-player-b261a895" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-3-apollo-s-nicolas-moutschen/player.js?size=s"></script></div> <p>In this episode, we talk to Nicolas Moutschen, Staff Software Engineer at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.apollographql.com/">Apollo</a>, about how they use Rust to build the Apollo GraphQL Platform.</p> Thu, 28 Dec 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e02-pubnub/ https://corrode.dev/podcast/s01e02-pubnub/ <div><script id="letscast-player-99d93d84" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-2-pubnub-s-stephen-blum/player.js?size=s"></script></div> <p>In this episode, we talk to Stephen Blum, founder and CTO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.pubnub.com/">PubNub</a>, about how they use Rust to build the PubNub Data Stream Network. We discuss the challenges of building a global network that handles trillions of messages per month, the reasons for choosing Rust over C for future projects, and how Rust enables them to ship code to new platforms faster.</p> Thu, 14 Dec 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e01-influxdata/ https://corrode.dev/podcast/s01e01-influxdata/ <div><script id="letscast-player-4f3d94e8" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-ep-1-influxdata-s-paul-dix/player.js?size=s"></script></div> <p>In this episode, we talk to Paul Dix, founder and CTO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxData</a>, about how they use Rust to build the InfluxDB time series database and related products. We discuss the challenges of building a database that scales to handle millions of writes per second, the reasons for choosing Rust, and how Rust enables them to ship more reliable software that customers can depend on.</p> <div class="info dashed"> <div class="info-header"> <i class="icon icon-info"></i> <h4>Proudly Supported by CodeCrafters</h4> </div> <p> CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. </p> <p> Start for free today and enjoy 40% off any paid plan by using <a href="https://app.codecrafters.io/join?via=mre">this link</a>. </p> </div> <h2 id="show-notes">Show Notes</h2> <h3 id="about-influxdata">About InfluxData</h3> <p>InfluxData is the creator of InfluxDB, the leading open source time series database. They offer a cloud service, InfluxDB Cloud, and a commercial on-premise product, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/products/influxdb-enterprise/">InfluxDB Enterprise</a>.</p> <h3 id="about-paul-dix">About Paul Dix</h3> <p>Paul Dix is the founder and CTO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxData</a>. He has helped build software for startups, large companies and organizations like Microsoft, Google, McAfee, Thomson Reuters, and Air Force Space Command. He is the series editor for Addison Wesley’s <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.informit.com/imprint/series_detail.aspx?ser=4255387">Data &amp; Analytics book and video series</a>. In 2010 Paul wrote the book <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.oreilly.com/library/view/service-oriented-design-with/9780321700124/">“Service Oriented Design with Ruby and Rails”</a> for Addison Wesley’s Professional Ruby Series. In 2009 he started the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.meetup.com/nyc-machine-learning/">NYC Machine Learning Meetup</a>, which now has over 13,000 members. Paul holds a degree in computer science from Columbia University.</p> <p>You can find Paul on <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/pauldix">Twitter</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/pauldix">GitHub</a>.</p> <h3 id="official-links">Official Links</h3> <ul> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxData</a></li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/careers/">Careers at InfluxData</a></li> <li>Blog post: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/blog/meet-founders-who-rewrote-in-rust/">Meet the Founders Who Rewrote in Rust</a></li> <li>Reddit: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/16v13l5/influxdb_officially_made_the_switch_from_go_rust/">Details and discussion on the Rust rewrite</a></li> <li>Blog post: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/blog/the-plan-for-influxdb-3-0-open-source/">The Plan for InfluxDB 3.0 Open Source</a></li> </ul> Mon, 11 Dec 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/podcast/s01e00-teaser/ https://corrode.dev/podcast/s01e00-teaser/ <div><script id="letscast-player-ff3abca4" src="https://letscast.fm/podcasts/rust-in-production-82281512/episodes/rust-in-production-series-teaser/player.js?size=s"></script></div> <p>There are a lot of awesome podcasts about Rust. We loved listening to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://newrustacean.com/">New Rustacean</a> and are excited about the new <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustacean-station.org/">Rustacean Station</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.marcoieni.com/2023/08/rustship-a-new-rust-podcast/">RustShip</a> episodes.</p> <p>But we felt that there is a gap in the Rust podcast landscape: We wanted to hear more about how companies use Rust in production.</p> <p>So we decided to sit down and create the content we wanted to listen to. We interviewed people from companies that use Rust in production and asked them the tough questions that you want to hear answered but never get the chance to ask:</p> <ul> <li>Why did they choose Rust?</li> <li>What are the real challenges of using Rust in production?</li> <li>How did your team get up to speed with Rust?</li> <li>Did you notice any performance improvements?</li> </ul> <p>These and other questions are top of mind for developers and decision makers who are considering Rust for their next project. We want to help them understand the benefits and challenges of using Rust in production before they head down that path.</p> <p>And we’re starting with a bang: In the first episode we will talk to Paul Dix, founder and CTO of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.influxdata.com/">InfluxData</a>, about how the company rewrote the core of their time series database in Rust. Stay tuned! We will release the first episode on Thursday, December 14th and then biweekly episodes every Thursday.</p> Mon, 04 Dec 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/paradigms/ https://corrode.dev/blog/paradigms/ <p>Rust is a multi-paradigm programming language, accommodating imperative, object-oriented, and functional programming styles. The choice of style often depends on a developer’s background and the specific problem they’re addressing.</p> <p>With Rust attracting developers from varied backgrounds such as C++, Java, Python, and Haskell, it has shaped its own <em>unique</em> set of styles and idioms. This diversity is a strength, but it also leads to uncertainty about which style to use in various scenarios.</p> <p>As the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch17-00-oop.html">Rust Book explains</a>:</p> <blockquote> <p>Many competing definitions describe what Object-Oriented Programming is, and by some of these definitions Rust is object-oriented.</p> </blockquote> <p>However, it <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/book/ch13-00-functional-features.html">also states</a>:</p> <blockquote> <p>Rust’s design has taken inspiration from many existing languages and techniques, and one significant influence is functional programming.</p> </blockquote> <p>These statements are not contradictory, but they do leave a lot of room for interpretation and personal preference.</p> <h2 id="guiding-principles-for-choosing-the-right-paradigm"><a class="zola-anchor" href="#guiding-principles-for-choosing-the-right-paradigm" aria-label="Anchor link for: guiding-principles-for-choosing-the-right-paradigm">Guiding Principles For Choosing The Right Paradigm</a></h2> <p>Rust is certainly influenced by object-oriented programming concepts. One factor that sets it apart from other object-oriented languages is its composition-based nature, as opposed to being inheritance-based. Its trait system is a core component of this object-oriented design, a concept absent in languages like C++ and Java.</p> <p>Similarly, Rust’s design encourages patterns that align closely with functional programming principles: immutability, iterator patterns, algebraic data types, and pattern matching.</p> <p>Just as Rust adopts certain object-oriented principles without being a purely object-oriented language, it similarly embraces functional programming concepts without being a purely functional language. It allows side effects everywhere and does not strictly enforce <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Referential_transparency">referential transparency</a> — the ability to replace an expression with its value without changing the program’s behavior.</p> <p>In conclusion, providing some guidance on using different paradigms in Rust might be helpful, especially for developers transitioning from other languages. This article explores my personal decision-making process when choosing between different paradigms in Rust, a process that has by now become almost second nature.</p> <h2 id="a-small-example"><a class="zola-anchor" href="#a-small-example" aria-label="Anchor link for: a-small-example">A Small Example</a></h2> <p>There is nothing wrong with simple <code>for</code> loops in Rust.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> sum</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 0</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">for</span><span> i</span><span style="color: #FF79C6;"> in</span><span style="color: #BD93F9;"> 0</span><span style="color: #FF79C6;">..</span><span style="color: #BD93F9;">10</span><span> {</span></span> <span class="giallo-l"><span> sum</span><span style="color: #FF79C6;"> +=</span><span> i;</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>But even in such a short example, we can see a discrepancy between the problem we’re trying to solve and the code we’re writing: The intermediate values of <code>sum</code> are irrelevant! We only care about the final result.</p> <p>Compare that to a more functional version:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> sum</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u32</span><span style="color: #FF79C6;"> =</span><span> (</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;">..</span><span style="color: #BD93F9;">10</span><span>)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sum</span><span>();</span></span></code></pre> <p>In small examples like this, it might not matter much, but when we start working with nested loops, we see that in the imperative approach, more lines are dedicated to bookkeeping than to the actual problem. This causes the code’s accidental complexity (the unnecessary complexity we introduce ourselves) to increase. Complexity, no matter how small, costs attention.</p> <h2 id="a-slightly-bigger-example-nested-loops"><a class="zola-anchor" href="#a-slightly-bigger-example-nested-loops" aria-label="Anchor link for: a-slightly-bigger-example-nested-loops">A Slightly Bigger Example: Nested Loops</a></h2> <p>Let’s consider a slightly bigger example. Imagine we had a list of programming languages, their supported paradigms, and the number of production users for each language. The task is to find the top five languages that support functional programming and have the most users.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// All data is made up for the sake of this example! We love you, Haskell.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> languages</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Rust&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>, Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ObjectOriented</span><span>],</span><span style="color: #BD93F9;"> 100_000</span><span>),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Go&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ObjectOriented</span><span>],</span><span style="color: #BD93F9;"> 200_000</span><span>),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Haskell&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>],</span><span style="color: #BD93F9;"> 5_000</span><span>),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Java&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ObjectOriented</span><span>],</span><span style="color: #BD93F9;"> 1_000_000</span><span>),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;C++&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ObjectOriented</span><span>],</span><span style="color: #BD93F9;"> 1_000_000</span><span>),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Language</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;Python&quot;</span><span>,</span><span style="color: #50FA7B;"> vec!</span><span>[Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ObjectOriented</span><span>, Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>],</span><span style="color: #BD93F9;"> 1_000_000</span><span>),</span></span> <span class="giallo-l"><span>];</span></span></code></pre> <p>Here is a <em>painfully</em> explicit solution using nested <code>for</code> loops:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Filter languages to keep only the functional ones</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> functional_languages</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[];</span></span> <span class="giallo-l"><span style="color: #FF79C6;">for</span><span> language</span><span style="color: #FF79C6;"> in</span><span> languages {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> language</span><span style="color: #FF79C6;">.</span><span>paradigms</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>) {</span></span> <span class="giallo-l"><span> functional_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(language);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Sort the functional languages by the number of users in descending order</span></span> <span class="giallo-l"><span style="color: #FF79C6;">for</span><span> i</span><span style="color: #FF79C6;"> in</span><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;">..</span><span>functional_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> j</span><span style="color: #FF79C6;"> =</span><span> i;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> while</span><span> j</span><span style="color: #FF79C6;"> &gt;</span><span style="color: #BD93F9;"> 0</span><span style="color: #FF79C6;"> &amp;&amp;</span><span> functional_languages[j]</span><span style="color: #FF79C6;">.</span><span>users</span><span style="color: #FF79C6;"> &gt;</span><span> functional_languages[j</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>]</span><span style="color: #FF79C6;">.</span><span>users {</span></span> <span class="giallo-l"><span> functional_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">swap</span><span>(j, j</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>);</span></span> <span class="giallo-l"><span> j</span><span style="color: #FF79C6;"> -=</span><span style="color: #BD93F9;"> 1</span><span>;</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Keep only the top 5 languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;">while</span><span> functional_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt;</span><span style="color: #BD93F9;"> 5</span><span> {</span></span> <span class="giallo-l"><span> functional_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">pop</span><span>();</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=f9b28b96acde1f9d11e8dd5957539826">Rust Playground</a>)</p> <p>This is a <em>very verbose</em>, imperative solution. We mutate the vector in-place and destroy the intermediate results in the process. While it’s not incorrect, I would argue that it’s not the most idiomatic Rust code either.</p> <p>In practice, you would probably reach for a few more helper methods from the standard library:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> top_languages</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[];</span></span> <span class="giallo-l"><span style="color: #FF79C6;">for</span><span> language</span><span style="color: #FF79C6;"> in</span><span> languages {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> language</span><span style="color: #FF79C6;">.</span><span>paradigms</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>) {</span></span> <span class="giallo-l"><span> top_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(language);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">// Sort our languages in descending order of popularity.</span></span> <span class="giallo-l"><span style="color: #6272A4;">// This line is already somewhat functional in nature.</span></span> <span class="giallo-l"><span>top_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sort_by_key</span><span>(</span><span style="color: #FF79C6;">|</span><span>lang</span><span style="color: #FF79C6;">|</span><span> std</span><span style="color: #FF79C6;">::</span><span>cmp</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">Reverse</span><span>(lang</span><span style="color: #FF79C6;">.</span><span>users));</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>top_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">truncate</span><span>(</span><span style="color: #BD93F9;">5</span><span>);</span></span></code></pre> <p>Since we’re consuming <code>languages</code> anyway, we might as well be a little more concise when filtering:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> top_languages</span><span style="color: #FF79C6;"> =</span><span> languages;</span></span> <span class="giallo-l"><span>top_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">retain</span><span>(</span><span style="color: #FF79C6;">|</span><span>language</span><span style="color: #FF79C6;">|</span><span> language</span><span style="color: #FF79C6;">.</span><span>paradigms</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>));</span></span></code></pre> <p>We still use a mutable variable, but now the code looks more succinct. <code>retain</code> is a higher-order method that takes a closure as an argument, so the code naturally became a little more functional. Let’s continue down this path and see where it takes us next.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let mut</span><span> top_languages</span><span style="color: #FF79C6;"> =</span><span> languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">clone</span><span>();</span></span> <span class="giallo-l"><span>top_languages</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sort</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> top_languages</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Language</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span> top_languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">into_iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Only keep functional languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>language</span><span style="color: #FF79C6;">|</span><span> language</span><span style="color: #FF79C6;">.</span><span>paradigms</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>))</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Keep only the top 5 languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">take</span><span>(</span><span style="color: #BD93F9;">5</span><span>)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Collect the results into a vector</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span></code></pre> <p>Or, if external crates are an option, we could use <code>sorted_by_key</code> from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/itertools/latest/itertools/trait.Itertools.html#method.sorted_by_key"><code>itertools</code></a> to chain all intermediate operations:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> top_languages</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Language</span><span>&gt;</span><span style="color: #FF79C6;"> =</span><span> languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Only keep functional languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>language</span><span style="color: #FF79C6;">|</span><span> language</span><span style="color: #FF79C6;">.</span><span>paradigms</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">contains</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>Paradigm</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Functional</span><span>))</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Sort our languages in descending order of popularity.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">sorted_by_key</span><span>(</span><span style="color: #FF79C6;">|</span><span>lang</span><span style="color: #FF79C6;">|</span><span style="color: #50FA7B;"> Reverse</span><span>(lang</span><span style="color: #FF79C6;">.</span><span>users))</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Keep only the top 5 languages</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">take</span><span>(</span><span style="color: #BD93F9;">5</span><span>)</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Collect the results into a new vector</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=8c1d45de856b6a7980ea48ebeaf43290">Rust Playground</a>)</p> <p>Sorting the entire list (even if it’s filtered) to extract just the top 5 elements seems somewhat inefficient. This highlights a limitation in Rust compared to C++, which offers a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.cppreference.com/w/cpp/algorithm/partial_sort">partial_sort</a> function in its standard library. While Rust doesn’t have an equivalent in std, there are third-party crates. Alternatively, a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/collections/struct.BinaryHeap.html">BinaryHeap</a> can be used.</p> <p>To me, this solution is easier to reason about. The operations are neatly aligned below each other, and the code reads like a description of what we’re trying to achieve. I do admit, however, that it takes some getting used to, especially if you’re not familiar with functional programming patterns.</p> <p>One could say that I hand-picked a problem that is well-suited for functional programming, and that is certainly the case. The truth is, that this way of method chaining just feels natural after a while — especially for ad-hoc transformations on immutable data structures.</p> <p>There are a few reasons for this:</p> <ul> <li><strong>Readability</strong>: The steps are easy to follow.</li> <li><strong>Library Support</strong>: The Rust standard library and external crates provide many helpful combinators for iterators, which play nicely with immutable data structures.</li> <li><strong>Efficiency</strong>: Under the hood, methods like <code>map</code> and <code>filter</code> create new iterators that operate on the previous iterator and do not incur any allocations. The actual computations (like adding 1 or filtering even numbers) are only executed when the final iterator is consumed, in this case by the <code>collect</code> method. The <code>collect</code> method makes a single allocation to store the results in a new vector. Our higher-level abstractions incur no runtime overhead.</li> <li><strong>Parallelism</strong>: The functional approach lends itself to parallel computation. Each chain of operations is independent of the others, allowing them to be executed simultaneously on modern hardware.</li> </ul> <p>The result is clean, readable, and efficient code, which is why you’ll see this pattern a lot.</p> <blockquote> <p>No matter what language you work in, programming in a functional style provides benefits. You should do it whenever it is convenient, and you should think hard about the decision when it isn’t convenient. — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://web.archive.org/web/20120427212006/www.altdevblogaday.com/2012/04/26/functional-programming-in-c/">John Carmack</a></p> </blockquote> <p>Carmack talks about <em>convenience</em> here. What is the tipping point where functional programming becomes inconvenient? Let’s explore that with a more realistic example.</p> <h2 id="real-world-example-filtering-a-list-of-files"><a class="zola-anchor" href="#real-world-example-filtering-a-list-of-files" aria-label="Anchor link for: real-world-example-filtering-a-list-of-files">Real-World Example: Filtering a List of Files</a></h2> <p>Here is a little Rust exercise: how would you list all XML files in a directory? Before you continue, feel free to try this yourself. See which style you would naturally lean towards. Why not try different approaches and see which one you prefer?</p> <h3 id="imperative-style"><a class="zola-anchor" href="#imperative-style" aria-label="Anchor link for: imperative-style">Imperative Style</a></h3> <p>Here is my imperative solution:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> xml_files</span><span>(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> files</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> f</span><span style="color: #FF79C6;"> in</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This line is necessary, because the file could have</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // been deleted since the call to `read_dir`.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> f</span><span style="color: #FF79C6;"> =</span><span> f</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> ==</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">OsStr</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;xml&quot;</span><span>)) {</span></span> <span class="giallo-l"><span> files</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(files)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=f3314816d1584ea372e8cdf6bdccd426">Rust Playground</a>)</p> <p>Not great, not terrible.</p> <p>We have to do some bookkeeping, and there are some minor paper cuts like <code>let f = f?;</code> and the bit about <code>OsStr::to_str</code>, but overall it’s fine. The paper cuts are due to the <em>inherent</em> complexity of the problem: dealing with the possibility of errors and the fact that the file extension might not be valid UTF-8 on all platforms.</p> <p>As the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/ffi/struct.OsString.html">documentation for <code>OsStr</code></a> explains:</p> <ul> <li>On Unix systems, strings are often arbitrary sequences of non-zero bytes, in many cases interpreted as UTF-8.</li> <li>On Windows, strings are often arbitrary sequences of non-zero 16-bit values, interpreted as UTF-16 when it is valid to do so.</li> </ul> <p>The astute reader might have noticed that we don’t check if the path is actually a file before we check the extension. This is done in the interest of brevity.</p> <h3 id="functional-style"><a class="zola-anchor" href="#functional-style" aria-label="Anchor link for: functional-style">Functional Style</a></h3> <p>Let’s see how we can solve this problem in a more functional style:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> xml_files</span><span>(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> entries</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(Result</span><span style="color: #FF79C6;">::</span><span>ok)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>entry</span><span style="color: #FF79C6;">|</span><span> entry</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">|</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> ==</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(OsStr</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;xml&quot;</span><span>)))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(entries)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=448b6246dd4da2d1cd9b8cf1f4e1f09e">Rust Playground</a>)</p> <p>This implementation is arguably more streamlined. It maps directory entries to paths, filters out non-XML files, and collects the results, all without needing mutable variables or conditional branching.</p> <p>That said, the solution also has its drawbacks. Most importantly, it is not equivalent to the imperative version. That is because <code>filter_map(Result::ok)</code> filters out all errors.</p> <div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>What is the difference between <code>filter</code> and <code>filter_map</code>?</p> </h4> </div> <p>In Rust, <code>filter</code> takes a closure that returns a <code>bool</code> to decide whether to include an element in the resulting iterator, whereas <code>filter_map</code> takes a closure that returns an <code>Option&lt;T&gt;</code>.</p> <p>For <code>filter_map</code>, if the closure returns <code>Some(value)</code>, that value is included in the new iterator; if it returns <code>None</code>, the element is excluded. Essentially, <code>filter_map</code> allows filtering and mapping in a single step.</p> </div> <p>Whether we want to ignore errors depends on the use case; it is a tradeoff between correctness and ergonomics. In production code, we should at least log all errors, though. We can use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.inspect"><code>inspect</code></a> to do that:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> xml_files</span><span>(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> entries</span><span style="color: #FF79C6;"> =</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Logs each element of the iterator to stderr for debugging, then passes the value on.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">inspect</span><span>(</span><span style="color: #FF79C6;">|</span><span>entry</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if let</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(e)</span><span style="color: #FF79C6;"> =</span><span> entry {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> eprintln!</span><span>(</span><span style="color: #F1FA8C;">&quot;Error: {}&quot;</span><span>, e);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(Result</span><span style="color: #FF79C6;">::</span><span>ok)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>entry</span><span style="color: #FF79C6;">|</span><span> entry</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">|</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> ==</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(OsStr</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;xml&quot;</span><span>)))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(entries)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=f3bd287c8c82ff661b9ec9616b5514a9">Rust Playground</a>)</p> <p>So far, I would still lean towards the functional version, but let’s see how both approaches hold up as we add more complexity.</p> <h3 id="making-filtering-more-generic"><a class="zola-anchor" href="#making-filtering-more-generic" aria-label="Anchor link for: making-filtering-more-generic">Making Filtering More Generic</a></h3> <p>What if we wanted to filter by arbitrary file attributes? For instance, we might want to find all files with a given prefix or extension.</p> <p>We could introduce a new parameter, <code>valid</code>, which would be a function that takes a <code>Path</code> and returns a <code>bool</code>. (This is also known as a <em>predicate</em> in functional programming.)</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> filter_files</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>&gt;(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>, valid</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> F</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(Result</span><span style="color: #FF79C6;">::</span><span>ok)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>entry</span><span style="color: #FF79C6;">|</span><span> entry</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">|</span><span style="color: #50FA7B;"> valid</span><span>(path))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This is a generic function that can be used for many different use cases. Higher-order functions like this are a typical pattern in functional programming and are also available in Rust.</p> <p>The imperative version, while concise, now incorporates a higher-order function, demonstrating that the line between functional and imperative programming is often blurry:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> filter_files</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>&gt;(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>, valid</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt; </span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> F</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> files</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> f</span><span style="color: #FF79C6;"> in</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> f</span><span style="color: #FF79C6;"> =</span><span> f</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span style="color: #50FA7B;"> valid</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>()) {</span></span> <span class="giallo-l"><span> files</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(files)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=d89eb67e614ad324de56b7d94204dc7f">Rust Playground</a>)</p> <h3 id="recursively-filtering-directories-for-files"><a class="zola-anchor" href="#recursively-filtering-directories-for-files" aria-label="Anchor link for: recursively-filtering-directories-for-files">Recursively Filtering Directories For Files</a></h3> <p>Let’s go one more step further.</p> <p>So far, our solution only works for a single directory. What if we wanted to <em>recursively</em> filter a directory and all its subdirectories for files?</p> <p>First, the (mostly) imperative version with mutable state:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> filter_files</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>&gt;(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>, valid</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> F</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> files</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> for</span><span> f</span><span style="color: #FF79C6;"> in</span><span> fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> f</span><span style="color: #FF79C6;"> =</span><span> f</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_dir</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Recursively filter the directory</span></span> <span class="giallo-l"><span> files</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extend</span><span>(</span><span style="color: #50FA7B;">filter_files</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>(), valid)</span><span style="color: #FF79C6;">?</span><span>);</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else if</span><span style="color: #50FA7B;"> valid</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>()) {</span></span> <span class="giallo-l"><span> files</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(f</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(files)</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=e55738f928e70d9f42e2408e10166e1e">Rust Playground</a>)</p> <p>While we have one more level of nesting, the imperative version holds up reasonably well.</p> <p>Next, the functional version:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> filter_files</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>&gt;(p</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>, valid</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">F</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;&gt;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">where</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> F</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>{</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(fs</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">read_dir</span><span>(p)</span><span style="color: #FF79C6;">?</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">filter_map</span><span>(Result</span><span style="color: #FF79C6;">::</span><span>ok)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>entry</span><span style="color: #FF79C6;">|</span><span> entry</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">path</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">flat_map</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">| match</span><span> path {</span></span> <span class="giallo-l"><span> p</span><span style="color: #FF79C6;"> if</span><span> p</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_dir</span><span>()</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> filter_files</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>p, valid)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">unwrap_or_default</span><span>(),</span></span> <span class="giallo-l"><span> p</span><span style="color: #FF79C6;"> if</span><span style="color: #50FA7B;"> valid</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>p)</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> vec!</span><span>[p],</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #50FA7B;"> vec!</span><span>[],</span></span> <span class="giallo-l"><span> })</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">collect</span><span>())</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We’re dealing with an iterator of iterators here, so we need to flatten it to get a single iterator of paths with the help of <code>flat_map</code>. However, this also means that we need to return a vector of paths in all cases, even if it’s empty. The <code>unwrap_or_default</code> is a symptom of this.</p> <p>I will let you be the judge of which version you prefer.</p> <p>Either way, this is where I feel the flow of logic is in need of improvement. What I want is better encapsulation and modularity to keep the complexity in check. Rust allows us to seamlessly transition to an object-oriented style to do just that.</p> <h3 id="transitioning-to-object-oriented-rust"><a class="zola-anchor" href="#transitioning-to-object-oriented-rust" aria-label="Anchor link for: transitioning-to-object-oriented-rust">Transitioning to Object-Oriented Rust</a></h3> <p>In contrast to the functional and imperative examples discussed earlier, let’s introduce a new struct, <code>FileFilter</code>, which encapsulates the logic for filtering files and file iteration.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> FileFilter</span><span> {</span></span> <span class="giallo-l"><span> predicates</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Box</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Predicate</span><span>&gt;&gt;,</span></span> <span class="giallo-l"><span> start</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;,</span></span> <span class="giallo-l"><span> stack</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;fs</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">ReadDir</span><span>&gt;,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Each <code>FileFilter</code> object carries its state: a collection of predicates for filtering, a starting path, and a stack of directories for iteration.</p> <p>A predicate is defined like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">type</span><span style="color: #8BE9FD;font-style: italic;"> Predicate</span><span style="color: #FF79C6;"> = dyn</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>;</span></span></code></pre> <p>You might be surprised to see a <code>dyn</code> here. In Rust, no two closures, even if identical, have the same type!</p> <blockquote> <p>A closure expression produces a closure value with a unique, anonymous type that cannot be written out. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/types/closure.html">The Rust Reference</a></p> </blockquote> <p>To accommodate this in a collection like a Vec, we use a trait object with <em>dynamic dispatch</em>. By ‘boxing’ these closures, we create a <code>Box&lt;Predicate&gt;</code> (essentially <code>Box&lt;dyn Fn(&amp;Path) -&gt; bool&gt;</code>), which allows us to store different predicate closures in the same <code>Vec</code> despite their unique types.</p> <h4 id="adding-filters"><a class="zola-anchor" href="#adding-filters" aria-label="Anchor link for: adding-filters">Adding Filters</a></h4> <p>In functional programming, we leveraged the power of iterators and closures to filter files. In the imperative style, we directly manipulated vectors with loops and conditions. The FileFilter, however, abstracts these details away.</p> <p>Consider the <code>add_filter</code> method:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> add_filter</span><span>(</span><span style="color: #FF79C6;">mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, predicate</span><span style="color: #FF79C6;">: impl</span><span style="color: #50FA7B;"> Fn</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">Path</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span style="color: #FF79C6;"> +</span><span> &#39;</span><span style="color: #8BE9FD;font-style: italic;">static</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>predicates</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(Box</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(predicate));</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This allows us to easily add multiple filters by chaining calls — something that was previously closely coupled with the iteration logic.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> filter</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> FileFilter</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">add_filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">|</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // check if path begins with &quot;foo&quot;</span></span> <span class="giallo-l"><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">file_name</span><span>()</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">and_then</span><span>(OsStr</span><span style="color: #FF79C6;">::</span><span>to_str)</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>name</span><span style="color: #FF79C6;">|</span><span> name</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">starts_with</span><span>(</span><span style="color: #F1FA8C;">&quot;foo&quot;</span><span>))</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">unwrap_or</span><span>(</span><span style="color: #BD93F9;">false</span><span>)</span></span> <span class="giallo-l"><span> }) </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">add_filter</span><span>(</span><span style="color: #FF79C6;">|</span><span>path</span><span style="color: #FF79C6;">|</span><span> path</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">extension</span><span>()</span><span style="color: #FF79C6;"> ==</span><span style="color: #8BE9FD;font-style: italic;"> Some</span><span>(OsStr</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;xml&quot;</span><span>)));</span></span></code></pre><h4 id="iterator-implementation"><a class="zola-anchor" href="#iterator-implementation" aria-label="Anchor link for: iterator-implementation">Iterator Implementation</a></h4> <p>What truly showcases the OOP approach in Rust is the implementation of the <code>Iterator</code> trait for <code>FileFilter</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Iterator</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> FileFilter</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">PathBuf</span><span>&gt;;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> next</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Option</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Iteration logic to filter entries.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This is outside the scope of this article</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Check out the full implementation on GitHub</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // or on the Rust Playground</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>In doing so, <code>FileFilter</code> becomes a building block that neatly integrates with Rust’s powerful iterator ecosystem and can be used in all the same places as any other iterator. This design allows for complex iteration logic to be encapsulated <em>within</em> the object, abstracting away the details from the user.</p> <p>You can find the full implementation of <code>FileFilter</code> <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/corrode/filefilter">on GitHub</a> or <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=d0b5ce70c858b39151ca46cf9dc07369">on the Rust Playground</a>. The code was closely modeled after the excellent <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/BurntSushi/walkdir">Walkdir</a> crate, which I recommend for production use.</p> <h4 id="encapsulation-and-reusability"><a class="zola-anchor" href="#encapsulation-and-reusability" aria-label="Anchor link for: encapsulation-and-reusability">Encapsulation and Reusability</a></h4> <p>The <code>FileFilter</code> example illustrates how OOP in Rust can lead to solid encapsulation and modularity. Unlike the earlier examples where the logic for filtering files was tightly coupled with iteration, we now separate the <em>what</em> (the predicates) from the <em>how</em> (the iteration and filtering logic). The trait system allows us to easily integrate our custom iterator with the rest of the ecosystem. Having these tools at our disposal makes the code more composable and reusable.</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <p>Mixing different styles is not only possible, but encouraged in Rust! This can also be seen by taking a look at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/influences.html">Rust’s key influences on its language design</a>. Influences as diverse as C++, Haskell, OCaml, and Erlang have shaped Rust’s design.</p> <p>In the beginning, Rust was more functional in nature, but it has since evolved into a more balanced language, supporting a variety of styles. The question is where to draw the line between different programming paradigms.</p> <p>I found that I often use a functional core with an imperative shell. The core consists of small, composable functions that transform data, while the shell provides the necessary control flow. I often use object-oriented constructs to organize larger parts of my application, encapsulating related data and functions.</p> <p>Here are my personal rules of thumb:</p> <ul> <li> <p><strong>Embrace object-oriented patterns for organization.</strong> For organizing larger parts of your application, consider object-oriented constructs. Using structs or enums can encapsulate related data and functions, providing a clear structure without worrying about the details.</p> </li> <li> <p><strong>Leverage functional patterns for data transformations.</strong> Especially within smaller scopes like functions and closures, functional methods such as mapping, filtering, or reducing can make your code both concise and clear. Use functional programming when you can phrase your problem as a series of transformations over some data.</p> </li> <li> <p><strong>Use imperative style for granular control.</strong> In scenarios where you’re working close to the hardware, or when you need explicit step-by-step execution, the imperative style is often a necessity. It allows for precise control over operations, especially with mutable data. This style can be particularly useful in performance-critical sections or when interfacing with external systems where exact sequencing matters. However, always weigh its performance gains against potential readability trade-offs. If possible, encapsulate imperative code within a limited scope.</p> </li> <li> <p><strong>Prioritize readability and maintainability.</strong> Regardless of your chosen paradigm, always write code that’s straightforward and easy to maintain. It benefits not only your future self, but also your colleagues who might work on the same codebase.</p> </li> <li> <p><strong>Avoid premature optimization.</strong> Don’t prematurely optimize for performance at the cost of readability. The real bottleneck might be elsewhere. Measure first, then optimize. Elegant solutions can be turned into fast ones, but the reverse is not always true.</p> </li> </ul> <p>Lastly, avoid bias towards any particular paradigm. You can write better code if you test your assumptions every now and then.</p> Thu, 21 Sep 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/immutability/ https://corrode.dev/blog/immutability/ <p>Some Rustaceans go to great lengths to avoid copying data — even once.</p> <p>This is typically noticeable among those with a background in systems programming, who are deeply conscious of performance and memory usage, sometimes to the detriment of code readability. They make heavy use of <code>mut</code> to mutate data in place and frequently try to sidestep <code>.clone()</code> calls at every turn in an attempt to (prematurely) optimize their code.</p> <p>I believe this approach is misguided. Immutability — which means once something is created, it can’t be changed — results in code that is easier to understand, refactor and parallelize and it doesn’t have to be slow either.</p> <p>Immutability is an incredible complexity killer.</p> <blockquote> <p>Mutable objects are the new spaghetti code. And by that, I mean that you, eventually, with mutable objects, create an intractable mess. And encapsulation does not get rid of that. Encapsulation just means: well, I am in charge of this mess. But the real mess comes from this network that you create of objects that can change, and your inability to look at the state of a system and understand how it got there, how to get it there to test it next time. So it is hard to understand a program where things can change out from underneath you. — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/matthiasn/talk-transcripts/blob/master/Hickey_Rich/ClojureConcurrency.md">Rick Hickey</a></p> </blockquote> <p>The <code>mut</code> keyword should be used sparingly; preferably only in tight scopes.</p> <p>This article aims to convince you that <strong>embracing immutability is central to writing idiomatic Rust</strong>.</p> <h2 id="immutability-and-state"><a class="zola-anchor" href="#immutability-and-state" aria-label="Anchor link for: immutability-and-state">Immutability and State</a></h2> <p>As programmers, we think a lot about state.</p> <p>The problem is, that humans are pretty bad at keeping track of state transitions and multiple moving parts. (That is, unless you’re a chess grandmaster or the parent of a toddler, of course.)</p> <blockquote> <p>A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in.<br /> — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://www.sevangelatos.com/john-carmack-on/">John Carmack</a></p> </blockquote> <p>Immutability can help us reduce the cognitive load of keeping track of state. Instead of having to keep track of all the ways in which a variable can change, we know that it can’t change at all.</p> <p>This brings us to Rust, a language that has chosen to prioritize immutability.</p> <h2 id="why-did-rust-choose-immutability-by-default"><a class="zola-anchor" href="#why-did-rust-choose-immutability-by-default" aria-label="Anchor link for: why-did-rust-choose-immutability-by-default">Why Did Rust Choose Immutability By Default?</a></h2> <p>In Rust, variables are immutable by default, which means that once a variable is bound to a value, it cannot be changed (unless you <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.com/a/54242058/270334">try excruciatingly hard to shoot yourself in the foot</a>).</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span>x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 23</span><span>;</span><span style="color: #6272A4;"> // error: re-assignment of immutable variable `x`</span></span></code></pre> <p>Especially C and C++ programmers <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/is-immutability-by-default-worth-the-hassle/83668">tend to be surprised by that design decision</a> and their first Rust programs typically contain a lot of <code>mut</code> keywords.</p> <p>In my opinion, choosing immutability was a good decision, because it helps reduce mental overhead. It is a nod to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/influences.html">Rust’s functional roots</a> and a consequence of its focus on safety.</p> <p>If the default was mutability, you’d have to check every function to see if it changes the value of a variable.</p> <p>Instead, Rust is very explicit about mutability. It makes you write it out every time you create or pass a mutable variable.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> black_box</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span> x);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> println!</span><span>(</span><span style="color: #F1FA8C;">&quot;{}&quot;</span><span>, x);</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> black_box</span><span>(x</span><span style="color: #FF79C6;">: &amp;mut</span><span style="color: #8BE9FD;font-style: italic;"> i32</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> *</span><span>x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 23</span><span>;</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Oh, how awfully, painfully explicit!</p> <p>Warning signs all over the place, which indicate that we are leaking state changes to the outside world.</p> <p>Compare that to C++:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="cpp"><span class="giallo-l"><span style="color: #FF79C6;">#include</span><span style="color: #E9F284;"> &lt;</span><span style="color: #F1FA8C;">iostream</span><span style="color: #E9F284;">&gt;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">void</span><span style="color: #50FA7B;"> black_box</span><span>(</span><span style="color: #FF79C6;">int*</span><span style="color: #FFB86C;font-style: italic;"> x</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> *</span><span>x </span><span style="color: #FF79C6;">=</span><span style="color: #BD93F9;"> 23</span><span>;</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">int</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> int</span><span> x </span><span style="color: #FF79C6;">=</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> black_box</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span>x);</span></span> <span class="giallo-l"><span> std</span><span style="color: #FF79C6;">::</span><span>cout </span><span style="color: #FF79C6;">&lt;&lt;</span><span> x </span><span style="color: #FF79C6;">&lt;&lt;</span><span> std</span><span style="color: #FF79C6;">::</span><span>endl;</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Here we have to read the function body to see if it modifies our variable. We need to use the <code>const</code> keyword in C++ to indicate that a pointer shouldn’t modify the data it points to.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="cpp"><span class="giallo-l"><span style="color: #FF79C6;">void</span><span style="color: #50FA7B;"> black_box</span><span>(</span><span style="color: #FF79C6;">const int*</span><span style="color: #FFB86C;font-style: italic;"> x</span><span>) {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This would be an error</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // *x = 23;</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This is somewhat analogous to Rust’s immutability, <em>but it is opt-in in C++</em>, meaning you have to remember to use it.</p> <p>In Rust, explicit mutability is part of the function signature, which makes it easier to understand the implications of that function call at a glance. It even warns you if something is mutable, but needn’t be!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> black_box</span><span>(x);</span></span> <span class="giallo-l"><span>}</span></span></code></pre><pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>warning</span><span style="color: #FF79C6;">:</span><span> variable does not need to be mutable</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> --&gt;</span><span> src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">4</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">9</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #BD93F9;">4</span><span style="color: #FF79C6;"> | let mut</span><span> x</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 42</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ----^</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | |</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span><span> help</span><span style="color: #FF79C6;">:</span><span> remove this `</span><span style="color: #FF79C6;">mut</span><span>`</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> =</span><span> note</span><span style="color: #FF79C6;">:</span><span> `#[warn(unused_mut)]` on by default</span></span></code></pre> <p>Rust’s immutability-by-default is not just a syntactic choice; it’s a deliberate decision to promote code clarity and safety. By requiring explicit mutability, Rust ensures developers are acutely aware of its implications. Especially in concurrent programming, where mutable states can introduce complexity, this can be a lifesaver.</p> <p>Mutability means state: a thing can be in one of many states. Immutability means no state: the thing won’t change. That’s why immutability is a good default: most of the time you don’t need all that state in the first place.</p> <p>The real-world implications of immutability can be less straightforward. Let’s explore a concrete example to illustrate how an immutable approach can impact our design decisions for the better.</p> <h2 id="side-note-function-signatures"><a class="zola-anchor" href="#side-note-function-signatures" aria-label="Anchor link for: side-note-function-signatures">Side Note: Function Signatures</a></h2> <p>In Rust, function signatures are very explicit about what a function does. For instance, what is the difference between these two function signatures?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> my_function1</span><span>(a</span><span style="color: #FF79C6;">: &amp;mut</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>) {</span><span style="color: #FF79C6;"> ...</span><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> my_function2</span><span>(</span><span style="color: #FF79C6;">mut</span><span> a</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>) {</span><span style="color: #FF79C6;"> ...</span><span> }</span></span></code></pre> <p>The first function takes an immutable reference to a mutable value. This means that the value being pointed to can be modified through the reference, but the reference itself cannot be reassigned.</p> <p>The second function takes a mutable binding to an immutable reference. This means that the binding <code>a</code> can be reassigned to point to different values, but cannot modify any value it points to.</p> <p>The difference is subtle, but it goes to show how Rust makes you think about mutability in a very explicit way.</p> <p>You would typically use the first form (<code>a: &amp;mut T</code>) when you need to modify the original value in place, like updating a struct’s fields or modifying an element in a data structure. The second form (<code>mut a: &amp;T</code>) is less common and is used when you need to temporarily point to different values within a function, like when comparing multiple values or iterating through a collection of references.</p> <h2 id="controlling-mutability"><a class="zola-anchor" href="#controlling-mutability" aria-label="Anchor link for: controlling-mutability">Controlling Mutability</a></h2> <p>Consider the following (problematic) implementation of a <code>Mailbox</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The emails in the mailbox</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Obviously, don&#39;t represent emails as strings in real code!</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Use higher-level abstractions instead.</span></span> <span class="giallo-l"><span> emails</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The total number of words in all emails</span></span> <span class="giallo-l"><span> total_word_count</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span> emails</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(),</span></span> <span class="giallo-l"><span> total_word_count</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 0</span><span>,</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> add_email</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, email</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>) {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>emails</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(email</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Misguided optimization: Track the total word count</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> word_count</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span style="color: #FF79C6;"> =</span><span> email</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">split_whitespace</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">count</span><span>();</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>total_word_count </span><span style="color: #FF79C6;">+=</span><span> word_count;</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> get_word_count</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>total_word_count</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // ... other methods ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre><div class="info"> <div class="info-header"> <span class="icon icon-info"></span> <h4><p>Note</p> </h4> </div> <p>This is a contrived example and not idiomatic Rust code! In a real-world scenario, we should use better abstractions, such as a <code>Message</code> struct of some sort, which encapsulates the email’s content and metadata, but bear with me for the sake of the argument.</p> </div> <p>Note how <code>add_email</code> takes a <code>&amp;mut self</code>, changing both the <code>emails</code> and <code>total_word_count</code> fields.</p> <p>The idea here was to optimize for performance by keeping track of the total word count on insertion, so that we don’t have to iterate over all emails every time we want to get the word count later. In what may have been a well-intentioned effort to optimize, <code>emails</code> and <code>total_word_count</code> have now become tightly coupled. We might refactor the code and forget to update the <code>total_word_count</code> field, causing bugs!</p> <h2 id="immutability-in-purely-functional-programming"><a class="zola-anchor" href="#immutability-in-purely-functional-programming" aria-label="Anchor link for: immutability-in-purely-functional-programming">Immutability In Purely Functional Programming</a></h2> <p>Issues with mutable state are less prevalent in purely functional programming languages. For example, Haskell <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://wiki.haskell.org/Mutable_variable">doesn’t even have mutable variables except when using the state monad</a>. Therefore, our naive <code>Mailbox</code> type might look like this in Haskell:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="haskell"><span class="giallo-l"><span style="color: #FF79C6;">newtype</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> Mailbox</span><span> [</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>]</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #50FA7B;">addEmail</span><span style="color: #FF79C6;"> ::</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span></span> <span class="giallo-l"><span>addEmail (</span><span style="color: #BD93F9;">Mailbox</span><span> emails) email </span><span style="color: #FF79C6;">=</span><span style="color: #BD93F9;"> Mailbox</span><span> (email </span><span style="color: #FF79C6;">:</span><span> emails)</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #50FA7B;">getWordCount</span><span style="color: #FF79C6;"> ::</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Int</span></span> <span class="giallo-l"><span>getWordCount (</span><span style="color: #BD93F9;">Mailbox</span><span> emails)</span><span style="color: #FF79C6;"> =</span><span> sum </span><span style="color: #FF79C6;">$</span><span> map (length </span><span style="color: #FF79C6;">.</span><span> words) emails</span></span></code></pre> <p>This returns a new <code>Mailbox</code> every time we add a message.</p> <p>To the keen-eyed systems programmer, this might sound appalling: “A fresh Mailbox for each email? Really?” But before entirely dismissing that idea, remember that in purely functional languages like Haskell, such practices are quite common because they are quite efficient:</p> <ul> <li>In the <code>addEmail</code> function, you’re prepending an email to the list with the <code>:</code> operator. Prepending to a linked list in Haskell is an <code>O(1)</code> operation, so it’s quite performant.</li> <li>While we’re returning a new <code>Mailbox</code>, Haskell’s lazy evaluation and the way it handles memory can mitigate some of the potential inefficiencies. For instance, unchanged parts of a data structure might be shared between the old and new versions.</li> <li><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/haskell/comments/w25rj7/how_does_haskell_internally_represent_lists/igpurex/">Linked lists in Haskell are similar to “streams” in other languages</a>, which helps put the performance expectations into perspective.</li> </ul> <p>The functional approach pushed us towards a better design, because it made it obvious that we don’t need the <code>totalWordCount</code> field at all: It was much easier to write a version which calculates the sum on the fly instead of mutating state.</p> <p>The code is a lot easier to reason about and it might not even be slower. While lazy evaluation has many advantages, its main drawback is that <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://wiki.haskell.org/Lazy_evaluation">memory usage becomes hard to predict</a>.</p> <p>Which brings us back to Rust.</p> <h2 id="rust-s-pragmatic-approach-to-mutability"><a class="zola-anchor" href="#rust-s-pragmatic-approach-to-mutability" aria-label="Anchor link for: rust-s-pragmatic-approach-to-mutability">Rust’s Pragmatic Approach To Mutability</a></h2> <p>Rust does not have lazy evaluation, in part due to its focus on predictable runtime behavior and its commitment to zero-cost abstractions. Thus, we can’t rely on the same optimizations as in languages that support lazy evaluation.</p> <p>Instead, many Rust developers would probably opt for a middle ground:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span> emails</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>&gt;,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Mailbox</span><span> {</span></span> <span class="giallo-l"><span> emails</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> add_email</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, email</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>) {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>emails</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">push</span><span>(email</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> get_word_count</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>emails</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">iter</span><span>()</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // In real code, `email` might have a `body` field with a</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // `word_count()` method instead</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>email</span><span style="color: #FF79C6;">|</span><span> email</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">split_whitespace</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">count</span><span>())</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> .</span><span style="color: #50FA7B;">sum</span><span>()</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // ... other methods ...</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We mutate the original <code>Mailbox</code>, while now avoiding the <code>total_word_count</code> field from the original code. We don’t carry the extra state around, and we calculate the word count on the fly when needed.</p> <p>The compiler prevents multiple mutable references to the same data, making this approach safe.</p> <p>Our Haskell example wasn’t a mere detour; it highlighted how an immutable mindset can often lead to stronger application design, even outside purely functional contexts. We should strive to embrace immutability in Rust as well.</p> <h2 id="a-word-on-performance"><a class="zola-anchor" href="#a-word-on-performance" aria-label="Anchor link for: a-word-on-performance">A Word On Performance</a></h2> <p>In case counting the words becomes expensive, an alternative would be to refactor the the code such that <code>add_email</code> takes a <code>Mail</code> struct, which contains the metadata:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Mail</span><span> {</span></span> <span class="giallo-l"><span> body</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Cache word count for faster access</span></span> <span class="giallo-l"><span> word_count</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Mail</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(body</span><span style="color: #FF79C6;">: &amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Mail</span><span> {</span></span> <span class="giallo-l"><span> body</span><span style="color: #FF79C6;">:</span><span> body</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(),</span></span> <span class="giallo-l"><span> word_count</span><span style="color: #FF79C6;">:</span><span> body</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">split_whitespace</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">count</span><span>(),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> word_count</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>word_count</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Then our <code>get_word_count</code> method could look like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> get_word_count</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>emails</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">iter</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">map</span><span>(</span><span style="color: #FF79C6;">|</span><span>email</span><span style="color: #FF79C6;">|</span><span> email</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">word_count</span><span>())</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">sum</span><span>()</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Even in this case, we don’t need any mutable state to implement the global word count. Our intuition should be finding better abstractions, not mutating state.</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary">Summary</a></h2> <h3 id="move-instead-of-mut"><a class="zola-anchor" href="#move-instead-of-mut" aria-label="Anchor link for: move-instead-of-mut">Move instead of <code>mut</code></a></h3> <p>Lean into Rust’s ownership model to avoid mutable state.</p> <p>It is safe to move variables into functions and structs, so use that to your advantage. This way you can avoid <code>mut</code> in many cases and avoid copies, which is especially important for large data structures.</p> <h2 id="don-t-be-afraid-of-copying-data"><a class="zola-anchor" href="#don-t-be-afraid-of-copying-data" aria-label="Anchor link for: don-t-be-afraid-of-copying-data">Don’t Be Afraid Of Copying Data.</a></h2> <p>If you have the choice between a lot of <code>mut</code> and a few <code>.clone()</code> calls, copying data is not as expensive as you might think.</p> <p>As computers get more cores and memory becomes cheaper, the benefits of immutability outweigh the costs: especially in distributed systems, synchronization and coordination of mutable data structures is hard and has a runtime cost. Immutability can help you avoid a lot of headaches.</p> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://xion.io/post/code/rust-borrowchk-tricks.html">Don’t worry about a few <code>.clone()</code> calls here and there.</a> Instead, write code that is easy to understand and maintain.</p> <p>The alternative is often to use locks and these have a runtime cost, too. On top of that, they are a common source of deadlocks.</p> <h2 id="immutability-is-a-great-default"><a class="zola-anchor" href="#immutability-is-a-great-default" aria-label="Anchor link for: immutability-is-a-great-default">Immutability Is A Great Default</a></h2> <p>Immutable code is easier to test, parallelize, and reason about. It’s also easier to refactor, because you don’t have to worry about side effects.</p> <p>Where <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://stackoverflow.com/a/29682542/270334">C/C++ requires you to explicitly declare things as immutable</a>, Rust requires you to explicitly declare things as mutable, making everything else immutable by default.</p> <p>Rust pushes you towards immutability and offers <code>mut</code> as an opt-in escape hatch for hot paths and tight loops. Many (perhaps most) other languages do the exact opposite: they use mutability as the default and require you to consciously choose immutability.</p> <h2 id="limit-mutability-to-tight-scopes"><a class="zola-anchor" href="#limit-mutability-to-tight-scopes" aria-label="Anchor link for: limit-mutability-to-tight-scopes">Limit Mutability To Tight Scopes</a></h2> <p>Good code keeps mutable state short-lived, making it easier to reason about. The use of <code>mut</code> should be the exception, not the rule.</p> Sun, 27 Aug 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/compile-time-invariants/ https://corrode.dev/blog/compile-time-invariants/ <p>Working on something completely unrelated, I stumbled across this comment in a Rust project:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// TODO: Make sure this has at least one element</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> kafka_brokers</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #F1FA8C;">&quot;kafka:9092&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;kafka2:9092&quot;</span><span>];</span></span></code></pre> <p>The intent here was to make sure that there is at least one Kafka broker (server) to connect to.</p> <p>Right now, the program would happily compile with an empty vector. We’d have to add a runtime check to make sure that the vector is not empty:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> connect_to_kafka</span><span>(brokers</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #FF79C6;">&amp;</span><span style="color: #8BE9FD;font-style: italic;">str</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">KafkaClient</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span>&gt;&gt; { </span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> brokers</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;At least one Kafka broker is required&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Connect to brokers</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>That’s not great, because we have to remember to validate the vector before we use it. During refactoring, the check could be accidentally removed, which would lead to a runtime error.</p> <h2 id="wait-there-s-a-crate-for-that"><a class="zola-anchor" href="#wait-there-s-a-crate-for-that" aria-label="Anchor link for: wait-there-s-a-crate-for-that">Wait, there’s a crate for that!</a></h2> <p>Maybe you know about the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rustonaut/vec1"><code>vec1</code></a> crate, which provides a <code>Vec1</code> type that can <strong>only</strong> be constructed with <strong>at least</strong> one element.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> kafka_brokers</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[</span><span style="color: #F1FA8C;">&quot;kafka:9092&quot;</span><span>];</span><span style="color: #6272A4;"> // works</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> kafka_brokers</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[];</span><span style="color: #6272A4;"> // compile error</span></span></code></pre> <p>Now the program would not compile if we tried to use <code>vec1!</code> with zero elements, which is exactly what we want!</p> <h2 id="type-driven-development"><a class="zola-anchor" href="#type-driven-development" aria-label="Anchor link for: type-driven-development">Type-driven development</a></h2> <p>There’s a deeper lesson here, which applies to idiomatic Rust code in general:<br /> <strong>If in doubt, lean into the type system to enforce invariants at compile-time.</strong></p> <p>An invariant is a condition that must always hold true. You want to enforce these invariants as early as possible.</p> <p>I recently learned about the term <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/">type-driven development</a>, a practice that emphasizes the use of types to ensure program correctness.</p> <p>To see how it works, let’s try to implement a basic version of <code>vec1</code> ourselves.</p> <h2 id="the-vec1-macro"><a class="zola-anchor" href="#the-vec1-macro" aria-label="Anchor link for: the-vec1-macro">The <code>vec1</code> macro</a></h2> <p>Let’s create a macro that behaves like <code>vec!</code>, but doesn’t allow an empty vector.</p> <p>The macro handles two cases:</p> <ul> <li>The first case matches a single element, followed by zero or more elements.</li> <li>The second case matches an empty vector and will panic at compile-time.</li> </ul> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[macro_export]</span></span> <span class="giallo-l"><span style="color: #50FA7B;">macro_rules! vec1</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The first element is mandatory, </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // while additional elements are optional (denoted by the `*`).</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Just like `vec!`, we also allow a trailing comma (denoted by the `?`).</span></span> <span class="giallo-l"><span> [</span><span style="color: #FF79C6;">$</span><span>x</span><span style="color: #FF79C6;">:</span><span>expr</span><span style="color: #FF79C6;"> $</span><span>(,</span><span style="color: #FF79C6;"> $</span><span>xs</span><span style="color: #FF79C6;">:</span><span>expr)</span><span style="color: #FF79C6;">* $</span><span>(,)</span><span style="color: #FF79C6;">?</span><span>]</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Just create an ordinary `Vec`</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #FF79C6;">$</span><span>x,</span><span style="color: #FF79C6;"> $</span><span>(</span><span style="color: #FF79C6;">$</span><span>xs),</span><span style="color: #FF79C6;">*</span><span>]</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span> []</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> compile_error!</span><span>(</span><span style="color: #F1FA8C;">&quot;vec1! requires at least one element&quot;</span><span>)</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This works</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[</span><span style="color: #F1FA8C;">&quot;Hello&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;World&quot;</span><span>];</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // This will fail to compile, which is what we want.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[];</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=6449703583b75ea1a76a763be9a0ba5f">Rust Playground</a>)</p> <p>We use <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/macro.compile_error.html"><code>compile_error!</code></a>, from the standard library, which will always fail to compile with the given error message.</p> <p>This does indeed look like it solves our problem!<br /> However, it only does so superficially. There’s a nifty bug hiding in disguise.</p> <p>Since we return an ordinary <code>Vec</code>, the information that there must be at least one element is not a part of the type and the invariant will <em>not</em> be enforced by the type system later on. We only handle the case where we construct the vector, but not when we use it.</p> <p>Nothing keeps us from passing an empty vector to a function that requires at least one element. As a result, we would still need our <code>brokers.is_empty()</code> runtime check from above. Dolorous.</p> <p>All of the hard work was for naught.</p> <p>But, can we do better?</p> <h2 id="second-try-implementing-a-vec1-type"><a class="zola-anchor" href="#second-try-implementing-a-vec1-type" aria-label="Anchor link for: second-try-implementing-a-vec1-type">Second Try: Implementing a <code>Vec1</code> type</a></h2> <p>The trick is to create a new type, <code>Vec1</code>, that behaves like an ordinary <code>Vec</code>, but encapsulates the knowledge we just gained about our input.</p> <p>We do this by using two fields internally, <code>first</code> and <code>rest</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">// Note: Fields are not public, so we can enforce </span></span> <span class="giallo-l"><span style="color: #6272A4;">// invariants during construction</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Vec1</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The first element is mandatory</span></span> <span class="giallo-l"><span> first</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The rest is optional</span></span> <span class="giallo-l"><span> rest</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Let’s update our macro to return a <code>Vec1</code> instead of a <code>Vec</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[macro_export]</span></span> <span class="giallo-l"><span style="color: #50FA7B;">macro_rules! vec1</span><span> {</span></span> <span class="giallo-l"><span> [</span><span style="color: #FF79C6;">$</span><span>x</span><span style="color: #FF79C6;">:</span><span>expr</span><span style="color: #FF79C6;"> $</span><span>(,</span><span style="color: #FF79C6;"> $</span><span>xs</span><span style="color: #FF79C6;">:</span><span>expr)</span><span style="color: #FF79C6;">* $</span><span>(,)</span><span style="color: #FF79C6;">?</span><span>]</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Vec1</span><span> {</span></span> <span class="giallo-l"><span> first</span><span style="color: #FF79C6;">: $</span><span>x,</span></span> <span class="giallo-l"><span> rest</span><span style="color: #FF79C6;">:</span><span style="color: #50FA7B;"> vec!</span><span>[</span><span style="color: #FF79C6;">$</span><span>(</span><span style="color: #FF79C6;">$</span><span>xs),</span><span style="color: #FF79C6;">*</span><span>],</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span> []</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> compile_error!</span><span>(</span><span style="color: #F1FA8C;">&quot;vec1! requires at least one element&quot;</span><span>);</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>To make our <code>Vec1</code> behave like any ordinary <code>Vec</code>, we can implement the same traits.</p> <p>For example, we probably want to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/iter/trait.IntoIterator.html">iterate</a> over the elements:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> IntoIterator</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Vec1</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Item</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> IntoIter</span><span style="color: #FF79C6;"> =</span><span> iter</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Chain</span><span>&lt;iter</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Once</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;, vec</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">IntoIter</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Item</span><span>&gt;&gt;;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> into_iter</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">IntoIter</span><span> {</span></span> <span class="giallo-l"><span> iter</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">once</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span>first)</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chain</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span>rest)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The associated <code>IntoIter</code> type is a bit tricky, but it’s just a way to chain together the first element and the rest of the elements without additional allocations.</p> <p>We also want to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/ops/trait.Index.html">index</a> into our <code>Vec1</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Index</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">usize</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Vec1</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Output</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> index</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, index</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>)</span><span style="color: #FF79C6;"> -&gt; &amp;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Output</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span> index {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 0</span><span style="color: #FF79C6;"> =&gt; &amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span>first,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // We can use `index - 1` because we know that</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // `index` is at least 1.</span></span> <span class="giallo-l"><span> i</span><span style="color: #FF79C6;"> =&gt; &amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;">.</span><span>rest[i</span><span style="color: #FF79C6;"> -</span><span style="color: #BD93F9;"> 1</span><span>],</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>To behave <em>exactly</em> like a <code>Vec</code>, we would need to implement <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/vec/struct.Vec.html#trait-implementations">a lot more traits</a>, but remember that the goal here is to learn about the general pattern of using types to enforce invariants.</p> <p>Note that we cannot simply implement <code>Deref</code> and <code>DerefMut</code> to delegate to the underlying <code>Vec</code>, because that would allow us to mutate the vector in a way that violates our invariant. Furthermore, we would need a custom implementation of <code>remove</code> and <code>pop</code> to make sure that the vector is never empty.</p> <p>On the other hand, your own types are probably very specific to your use-case, so you might not need to implement as many traits.</p> <p>With that, let’s write some tests:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[cfg(test)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> tests {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span style="color: #BD93F9;font-style: italic;"> super</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_single_element</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> v</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[</span><span style="color: #F1FA8C;">&quot;Hello&quot;</span><span>];</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(v[</span><span style="color: #BD93F9;">0</span><span>],</span><span style="color: #F1FA8C;"> &quot;Hello&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_multiple_elements</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> v</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[</span><span style="color: #F1FA8C;">&quot;Hello&quot;</span><span>,</span><span style="color: #F1FA8C;"> &quot;World&quot;</span><span>];</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(v[</span><span style="color: #BD93F9;">0</span><span>],</span><span style="color: #F1FA8C;"> &quot;Hello&quot;</span><span>);</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(v[</span><span style="color: #BD93F9;">1</span><span>],</span><span style="color: #F1FA8C;"> &quot;World&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_other_type</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> _v</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec1!</span><span>[</span><span style="color: #BD93F9;">1</span><span>,</span><span style="color: #BD93F9;">2</span><span>,</span><span style="color: #BD93F9;">3</span><span>,</span><span style="color: #BD93F9;">4</span><span>];</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // This won&#39;t compile, which is what we want to enforce the invariant.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Uncommenting the next line will break the compilation.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // #[test]</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // fn test_zero_elements() {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // let v = vec1![];</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We now have a vector with at least one element. If you want to play around with the code, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=316d933bfa7bf97eac0f4c8f152d5d61">here’s a link to the Rust playground</a>.</p> <p>In any real-world scenario, you would probably want to use the <code>vec1</code> crate instead of rolling your own implementation. And yes, the <code>vec1</code> crate implements all the necessary traits to make <code>Vec1</code> behave like a <code>Vec</code> in a similar fashion to what we did above.</p> <h2 id="using-a-fixed-size-array"><a class="zola-anchor" href="#using-a-fixed-size-array" aria-label="Anchor link for: using-a-fixed-size-array">Using a fixed-size array</a></h2> <p>If we assume that the list of Kafka brokers doesn’t change at runtime (a reasonable assumption, given that it’s a configuration setting) we could also use a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/std/primitive.array.html">fixed-size array</a>.</p> <p>By using an array, we can statically allocate the whole collection, which is more efficient than using a <code>Vec</code> (a dynamically allocated datatype on the heap).</p> <p>Here is the same code as above, but using an array instead of a <code>Vec</code>.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Array1</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #FF79C6;"> const</span><span style="color: #BD93F9;"> N</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>&gt; {</span></span> <span class="giallo-l"><span> first</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> T</span><span>,</span></span> <span class="giallo-l"><span> rest</span><span style="color: #FF79C6;">:</span><span> [</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>;</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>],</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[macro_export]</span></span> <span class="giallo-l"><span style="color: #50FA7B;">macro_rules! array1</span><span> {</span></span> <span class="giallo-l"><span> [</span><span style="color: #FF79C6;">$</span><span>x</span><span style="color: #FF79C6;">:</span><span>expr</span><span style="color: #FF79C6;"> $</span><span>(,</span><span style="color: #FF79C6;"> $</span><span>xs</span><span style="color: #FF79C6;">:</span><span>expr)</span><span style="color: #FF79C6;">* $</span><span>(,)</span><span style="color: #FF79C6;">?</span><span>]</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Array1</span><span> {</span></span> <span class="giallo-l"><span> first</span><span style="color: #FF79C6;">: $</span><span>x,</span></span> <span class="giallo-l"><span> rest</span><span style="color: #FF79C6;">:</span><span> [</span><span style="color: #FF79C6;">$</span><span>(</span><span style="color: #FF79C6;">$</span><span>xs),</span><span style="color: #FF79C6;">*</span><span>],</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span> []</span><span style="color: #FF79C6;"> =&gt;</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> compile_error!</span><span>(</span><span style="color: #F1FA8C;">&quot;array1! requires at least one element&quot;</span><span>)</span></span> <span class="giallo-l"><span> };</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Note that the compiler will infer <code>N</code> (the number of elements in <code>rest</code>) as well as <code>T</code> (the type of elements).</p> <p>Our trait implementations now expect a <code>const</code> parameter, e.g.:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #FF79C6;"> const</span><span style="color: #BD93F9;"> N</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> usize</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Index</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">usize</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Array1</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">T</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> N</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // contents unchanged</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The unit tests are the same as before. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=88011ae90e333502c352e7a50d21c632">Here’s the entire code</a>.</p> <p>I like the fact that this avoids any runtime overhead, which can be helpful in memory-constrained environments or in situations where dynamic allocation is not possible.</p> <p>It depends on your use-case to decide whether this is a better approach than using a <code>vec1</code>. It’s fun how all of the guarantees can be enforced without any runtime overhead, though!</p> <h2 id="further-improvements"><a class="zola-anchor" href="#further-improvements" aria-label="Anchor link for: further-improvements">Further Improvements</a></h2> <p>One could think of a few ways to add more checks. For example, since we know that Kafka brokers get represented as URLs, we could also enforce that invariant at compile-time.</p> <p>Which additional checks you want to add depends on your use-case. For instance, if Kafka brokers are a central part of your application, you might want to create your own <code>KafkaBroker</code> type that enforce additional invariants.</p> <p>Here’s a nice general rule of thumb:</p> <blockquote> <p>Model your data using the most precise data structure you reasonably can.<br /> — <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lexi-lambda.github.io/about.html">Alexis King</a> in <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/">Parse, don’t validate</a></p> </blockquote> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Rust has great support for type-driven design, which can guide you towards robust and idiomatic code to enforce invariants at compile-time.</p> <p>Always be on the lookout for ways to let the type-system guide you towards stronger abstractions.</p> <p>If you liked this, you might also be interested in my previous post on <a href="/blog/illegal-state">making illegal states unrepresentable in Rust</a>.</p> Tue, 08 Aug 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/enums/ https://corrode.dev/blog/enums/ <p>Many Rust beginners with a background in systems programming tend to use <code>bool</code> (or even <code>u8</code> – an 8-bit unsigned integer type) to represent <em>“state”</em>.</p> <p>For example, how about a <code>bool</code> to indicate whether a user is active or not?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> active</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Initially, this might seem fine, but as your codebase grows, you’ll find that “active” is not a binary state. There are many different states that a user can be in. For example, a user might be suspended or deleted. However, extending the user struct can get problematic, because other parts of the code might rely on the fact that <code>active</code> is a <code>bool</code>.</p> <p>Another problem is that <code>bool</code> is not self-documenting. What does <code>active = false</code> mean? Is the user inactive? Or is the user deleted? Or is the user suspended? We don’t know!</p> <p>Alternatively, you could use an unsigned integer to represent state:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This is <em>slightly</em> better, because we can now use different values to represent more states:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> ACTIVE</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 0</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> INACTIVE</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 1</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> SUSPENDED</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 2</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> DELETED</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 3</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> ACTIVE</span><span>,</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>A common use-case for <code>u8</code> is when you interface with C code. In that case, using <code>u8</code> might seemingly be the only option. However, we could still wrap that <code>u8</code> in a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/rust-by-example/generics/new_types.html">newtype</a>!</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> ACTIVE</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> UserStatus</span><span>(</span><span style="color: #BD93F9;">0</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> INACTIVE</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> UserStatus</span><span>(</span><span style="color: #BD93F9;">1</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> SUSPENDED</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> UserStatus</span><span>(</span><span style="color: #BD93F9;">2</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;">const</span><span style="color: #BD93F9;"> DELETED</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> UserStatus</span><span>(</span><span style="color: #BD93F9;">3</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> ACTIVE</span><span>,</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>This way, we can still use <code>u8</code> to represent state, but we can now also put the type system to work (a common pattern in idiomatic Rust). For example, we can define methods on <code>UserStatus</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> is_active</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;"> ==</span><span style="color: #BD93F9;"> ACTIVE</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>And we can even define a constructor that validates the input:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> new</span><span>(status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span> status {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> ACTIVE</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;">ACTIVE</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> INACTIVE</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;">INACTIVE</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> SUSPENDED</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;">SUSPENDED</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> DELETED</span><span style="color: #FF79C6;">.</span><span style="color: #BD93F9;">0</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;">DELETED</span><span>),</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Invalid status&quot;</span><span>),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>It’s still not ideal, however! Not even if you interface with C code, as we will see in a bit. But first, let’s look at a common way to represent state in Rust.</p> <h2 id="use-enums-instead"><a class="zola-anchor" href="#use-enums-instead" aria-label="Anchor link for: use-enums-instead">Use Enums Instead!</a></h2> <p><strong>Enums are a great way to model state inside your domain.</strong> They allow you to express your intent in a very concise way.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub enum</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The user is active and has full access</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// to their account and any associated features.</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Active</span><span>,</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The user&#39;s account is inactive.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// This state can be reverted to active by</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// the user or an administrator.</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span>,</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The user&#39;s account has been temporarily suspended, </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// possibly due to suspicious activity or policy violations.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// During this state, the user cannot access their account,</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// and an administrator&#39;s intervention might</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// be required to restore the account.</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span>,</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// The user&#39;s account has been permanently </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// deleted and cannot be restored.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// All associated data with the account might be </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// removed, and the user would need to create a new account</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// to use the service again.</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We can plug this enum into our <code>User</code> struct:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>But that’s not all; in Rust, enums are much more powerful than in many other languages. For example, we can add data to our enum variants:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub enum</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Active</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span> { until</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt; },</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span> { deleted_at</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt; },</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We can then model our <strong>state transitions</strong>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> chrono</span><span style="color: #FF79C6;">::</span><span>{</span><span style="color: #8BE9FD;font-style: italic;">DateTime</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> Utc</span><span>};</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub enum</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Active</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span> { until</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt; },</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span> { deleted_at</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt; },</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Suspend the user until the given date.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> suspend</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>, until</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt;) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span style="color: #FF79C6;"> =&gt; *</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span> { until },</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // For all non-active states, do nothing.</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span> {}</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Activate the user.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> activate</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;(),</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // A deleted user can&#39;t be activated!</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span> {</span><span style="color: #FF79C6;"> ..</span><span> }</span><span style="color: #FF79C6;"> =&gt; return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;can&#39;t activate a deleted user&quot;</span><span>),</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt; *</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Delete the user. This is a permanent action!</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> delete</span><span>(</span><span style="color: #FF79C6;">&amp;mut</span><span style="color: #BD93F9;font-style: italic;"> self</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if let</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span> {</span><span style="color: #FF79C6;"> ..</span><span> }</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Already deleted. Don&#39;t set the deleted_at field again.</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span>;</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span> {</span></span> <span class="giallo-l"><span> deleted_at</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Utc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">now</span><span>(),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> is_active</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> matches!</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> is_suspended</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> matches!</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span> {</span><span style="color: #FF79C6;"> ..</span><span> })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> is_deleted</span><span>(</span><span style="color: #FF79C6;">&amp;</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> bool</span><span> {</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> matches!</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span> {</span><span style="color: #FF79C6;"> ..</span><span> })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[cfg(test)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> tests {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span style="color: #BD93F9;font-style: italic;"> super</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_user_status</span><span>()</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;(),</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt;{</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> status</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_active</span><span>());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Suspend until tomorrow</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">suspend</span><span>(Utc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">now</span><span>()</span><span style="color: #FF79C6;"> +</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">1</span><span>));</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_suspended</span><span>());</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">activate</span><span>()</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_active</span><span>());</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">delete</span><span>();</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_deleted</span><span>());</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(())</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_user_status_transition</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let mut</span><span> status</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>;</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_active</span><span>());</span></span> <span class="giallo-l"><span> status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">delete</span><span>();</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_deleted</span><span>());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Can&#39;t activate a deleted user</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(status</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">activate</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_err</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We can extend the application with confidence, knowing that we can’t attempt to delete a user twice (which might have unwanted side effects like, say, triggering an expensive cleanup job twice) or re-activate a deleted user.</p> <p>Out of the box, enums don’t prevent us from making invalid state transitions. We can still write code that transitions from <code>Active</code> to <code>Suspended</code> without checking if the user is already suspended. A simple fix is to return a <code>Result</code> from the transition methods (as we did above) to indicate if the transition was successful. This way, we can handle errors gracefully at compile-time without too much ceremony. It’s a simple and effective way towards <a href="/blog/illegal-state/">making illegal states unrepresentable</a>.</p> <p>Another often mentioned drawback is that you need pattern matching to handle state transitions.</p> <p>For example, we wrote this code to suspend a user:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">match</span><span style="color: #BD93F9;font-style: italic;"> self</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span style="color: #FF79C6;"> =&gt; *</span><span style="color: #BD93F9;font-style: italic;">self</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span> { until },</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // For all non-active states, do nothing.</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span> {}</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This can become a bit verbose, especially if you have many state transitions. In practice, I rarely found this to be a problem, though. Pattern matching is very ergonomic in Rust, and it’s often the most readable way to describe state transitions. On top of that, the compiler will error if you forget to handle a state transition, which is a strong safety net.</p> <p>Enums offer another key benefit: efficiency. The compiler optimizes them well, often matching the performance of direct integer use. This makes enums ideal for state machines and performance-critical code. In our example, the UserStatus enum’s size equals that of its largest variant (plus a small tag) <sup class="footnote-reference" id="fr-1-1"><a href="#fn-1">1</a></sup></p> <p>Overall, while not perfect, the simplicity, readability, and memory efficiency of enums often outweigh their drawback in practice.</p> <h2 id="using-enums-to-interact-with-c-code"><a class="zola-anchor" href="#using-enums-to-interact-with-c-code" aria-label="Anchor link for: using-enums-to-interact-with-c-code">Using Enums to Interact with C Code</a></h2> <p>Actually, there’s one more advantage! Earlier, I promised that you can still use enums, even if you have to interact with C code.</p> <p>Suppose you have a C library with a user status type (I’ve omitted the other fields for brevity).</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="c"><span class="giallo-l"><span style="color: #FF79C6;">typedef struct</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> uint8_t</span><span> status;</span></span> <span class="giallo-l"><span>} User;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>User </span><span style="color: #FF79C6;">*</span><span style="color: #50FA7B;">create_user</span><span>(</span><span style="color: #FF79C6;">uint8_t</span><span style="color: #FFB86C;font-style: italic;"> status</span><span>);</span></span></code></pre> <p>You can write a Rust enum to represent the status:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span>#[repr(</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>)]</span></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">Debug</span><span>,</span><span style="color: #8BE9FD;font-style: italic;"> PartialEq</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">pub enum</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Active</span><span style="color: #FF79C6;"> =</span><span style="color: #BD93F9;"> 0</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> TryFrom</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span style="color: #FF79C6;"> =</span><span> ();</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> try_from</span><span>(value</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> match</span><span> value {</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 0</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 1</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Inactive</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 2</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span>),</span></span> <span class="giallo-l"><span style="color: #BD93F9;"> 3</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">UserStatus</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span>),</span></span> <span class="giallo-l"><span> _</span><span style="color: #FF79C6;"> =&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(()),</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Noticed that <code>#[repr(u8)]</code> attribute? It tells the compiler to represent this enum as an unsigned 8-bit integer. This is crucial for compatibility with C code.</p> <p>Now, let’s wrap that C function in a safe Rust wrapper:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">extern</span><span style="color: #F1FA8C;"> &quot;C&quot;</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> create_user</span><span>(status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>)</span><span style="color: #FF79C6;"> -&gt; *mut</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>;</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">pub fn</span><span style="color: #50FA7B;"> create_user_wrapper</span><span>(status</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserStatus</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">User</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> = unsafe</span><span> {</span><span style="color: #50FA7B;"> create_user</span><span>(status</span><span style="color: #FF79C6;"> as</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span>) };</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> user</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_null</span><span>() {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Failed to create user&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span><span style="color: #FF79C6;"> else</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #FF79C6;">unsafe</span><span> {</span><span style="color: #FF79C6;"> *</span><span style="color: #8BE9FD;font-style: italic;">Box</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_raw</span><span>(user) })</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>The Rust code now communicates with the C code using a rich enum type, which is both expressive and type-safe.</p> <p>If you want, you can play around with the code on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=8973e5e655c92c725f0b2b00f7830385">Rust playground</a>.</p> <p>To make these conversions easier, there are crates like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/num_enum"><code>num_enum</code></a>, which provides great ergonomics to convert enums to and from primitive types.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> num_enum</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">IntoPrimitive</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[derive(</span><span style="color: #8BE9FD;font-style: italic;">IntoPrimitive</span><span>)]</span></span> <span class="giallo-l"><span>#[repr(</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">enum</span><span style="color: #8BE9FD;font-style: italic;"> Number</span><span> {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Zero</span><span>,</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> One</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> zero</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u8</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Number</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Zero</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into</span><span>();</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert_eq!</span><span>(zero,</span><span style="color: #BD93F9;"> 0</span><span style="color: #8BE9FD;font-style: italic;">u8</span><span>);</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Here, the <code>IntoPrimitive</code> derive macro generates a <code>From</code> implementation for <code>Number</code> to <code>u8</code>. This makes converting between the enum and the primitive type as simple as calling <code>into()</code>.</p> <h2 id="the-typestate-pattern"><a class="zola-anchor" href="#the-typestate-pattern" aria-label="Anchor link for: the-typestate-pattern">The Typestate Pattern</a></h2> <p>At this point, many experienced Rust developers would mention another way to safely handle state transitions: the typestate pattern. The idea is pretty neat – encode the state of an object in its type as a generic parameter. The current state becomes <em>part</em> of your type.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #6272A4;">/// Our trait for user states</span></span> <span class="giallo-l"><span style="color: #FF79C6;">trait</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span> {}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// Each state is a separate struct</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// Implement the trait for each state</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> {}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span> {}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span> {}</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span> {}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// The User struct is generic over the state</span></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">S</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Generic over the state</span></span> <span class="giallo-l"><span> id</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> u64</span><span>,</span></span> <span class="giallo-l"><span> name</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // The state is encoded in the type</span></span> <span class="giallo-l"><span> state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> S</span><span>,</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// Implement methods for each state separately</span></span> <span class="giallo-l"><span style="color: #6272A4;">/// Note how the return type changes based on the state.</span></span> <span class="giallo-l"><span style="color: #6272A4;">/// That&#39;s the trick!</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> suspend</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>, until</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> DateTime</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span>&gt;)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>id, name</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>name, state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> deactivate</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Inactive</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>id, name</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>name, state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Inactive</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> activate</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>id, name</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>name, state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Suspended</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> activate</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Active</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>id, name</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>name, state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;">/// Deleted users can&#39;t be reactivated or suspended</span></span> <span class="giallo-l"><span style="color: #6272A4;">/// Once we reach this state, the user is gone for good.</span></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">S</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">S</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> delete</span><span>(</span><span style="color: #BD93F9;font-style: italic;">self</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Deleted</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>id, name</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;font-style: italic;"> self</span><span style="color: #FF79C6;">.</span><span>name, state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Deleted</span><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>This pattern provides even stronger guarantees than enums, as it makes illegal state transitions impossible at compile-time. For instance, you can’t deactivate a suspended user or reactivate a deleted user even if you wanted to: there simply isn’t a method for that.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">fn</span><span style="color: #50FA7B;"> main</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 1</span><span>, name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;Alice&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(), state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> };</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> user</span><span style="color: #FF79C6;"> =</span><span> user</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">suspend</span><span>(Utc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">now</span><span>()</span><span style="color: #FF79C6;"> +</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">1</span><span>));</span></span> <span class="giallo-l"><span> </span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Error: no method named `deactivate` found for type `User&lt;Suspended&gt;`</span></span> <span class="giallo-l"><span> user</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">deactivate</span><span>(); </span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>(You can play around with this code on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=ded18a44c5f32d488eb5ea387ddd1eb8">Rust playground</a>)</p> <p>However, it’s worth noting that there’s some pushback against overusing the typestate pattern.</p> <ul> <li>The additional generic parameter can make the code more complex and harder to understand, especially for developers who aren’t familiar with the pattern.</li> <li>The documentation and error messages can also be less clear, as the compiler will often mention the generic type parameter and that can distract from the main logic.</li> <li>When you need to work with collections of items that could be in different states, the typestate pattern could be harder to work with.</li> </ul> <p>The last point is often overlooked, so let’s dive into it a bit more. Say you have a list of users, each in a different state, then you’d need to use a trait object to store them:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> users</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Vec</span><span>&lt;</span><span style="color: #8BE9FD;font-style: italic;">Box</span><span>&lt;</span><span style="color: #FF79C6;">dyn</span><span style="color: #8BE9FD;font-style: italic;"> UserState</span><span>&gt;&gt;</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> vec!</span><span>[</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Box</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 1</span><span>, name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;Alice&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(), state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Active</span><span> }),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Box</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 2</span><span>, name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;Bob&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(), state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Inactive</span><span> }),</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Box</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">User</span><span> { id</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;"> 3</span><span>, name</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;Charlie&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>(), state</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Suspended</span><span> }),</span></span> <span class="giallo-l"><span>];</span></span></code></pre> <p>This triggers a heap allocation and dynamic dispatch (the correct method to call is determined at runtime), which is less efficient than the same code using enums, but more importantly, by using trait objects, you’re losing the ability to statically know which specific state each user is in. This means you can’t directly call state-specific methods on the users in the collection without first downcasting again or by using dynamic dispatch.</p> <p>It can be tempting to verify everything at compile-time, but sometimes the trade-offs aren’t worth it. I’d recommend using the typestate pattern only when you need the strongest possible compile-time guarantees at the cost of worse developer experience. For simpler scenarios, enums get you 80% of the way at very little cost.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>State management in Rust is more nuanced than in most other languages.</p> <p>Here’s a quick summary of the different state management approaches in Rust:</p> <ol> <li><strong>Simple bool/integer</strong>: Easy to understand but prone to errors and not self-documenting.</li> <li><strong>Enums</strong>: Provide type-safety and self-documentation, suitable for most cases. They even work well with C code.</li> <li><strong>Typestate Pattern</strong>: Offers the strongest compile-time guarantees, ideal for critical systems but can be more verbose.</li> </ol> <p>Remember, the goal is to write code that is not only correct but also maintainable and understandable by your team.</p> <p>My recommendation is to use enums whenever you need to represent a set of possible values, like when representing the state of an object. For even stronger guarantees, consider the typestate pattern, especially in safety-critical applications.</p> <section class="footnotes"> <ol class="footnotes-list"> <li id="fn-1"> <p>In our case, this means that the <code>UserStatus</code> enum is as large as a <code>DateTime&lt;Utc&gt;</code>. <a href="#fr-1-1">↩</a></p> </li> </ol> </section> Sun, 06 Aug 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/illegal-state/ https://corrode.dev/blog/illegal-state/ <p>If you’ve worked with Rust for a while, you’ve probably heard the phrase “making illegal states unrepresentable”. It’s a phrase that’s often used when people praise Rust’s type system. But what exactly does it mean? And how can you apply it to your own code?</p> <h2 id="what-is-illegal-state"><a class="zola-anchor" href="#what-is-illegal-state" aria-label="Anchor link for: what-is-illegal-state">What is illegal state?</a></h2> <p>Imagine we’re writing an application that manages a list of users.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>,</span></span> <span class="giallo-l"><span> birthdate</span><span style="color: #FF79C6;">:</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NaiveDate</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Looks simple enough, but is it correct?</p> <p>What happens if we create a user with an empty username?</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(),</span></span> <span class="giallo-l"><span> birthdate</span><span style="color: #FF79C6;">:</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NaiveDate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_ymd</span><span>(</span><span style="color: #BD93F9;">1990</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>),</span></span> <span class="giallo-l"><span>};</span></span></code></pre> <p>Intuitively, we know that this is <strong>not</strong> what we want, but the compiler can’t help us. We did not give it enough information about usernames. Already, with this simple example, we managed to introduce illegal state.</p> <p>Now, how can we fix this?</p> <h2 id="the-type-system-is-your-friend"><a class="zola-anchor" href="#the-type-system-is-your-friend" aria-label="Anchor link for: the-type-system-is-your-friend">The Type System Is Your Friend</a></h2> <p>Consider the <code>String</code> type. It’s a type that represents an arbitrary sequence of unicode characters. In our case, we need much stricter constraints. For a start, we want to make sure that the username is <em>not empty</em>.</p> <p>One powerful way to model these constraints is through <a href="/blog/enums/">enums</a>, which allow you to represent a set of possible values in a type-safe way.</p> <p>Whenever you’re uncertain how to model something in Rust, start by defining your basic types — your domain. That takes some practice, but your code will be much better for it.</p> <p>In our case, we want to define a type that represents a username.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> new</span><span>(username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> username</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_empty</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Username cannot be empty&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>(username))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>Note how the constructor now returns a <code>Result</code>.<br /> Also note, that wrapping the <code>String</code> in a struct is a zero-cost abstraction. The compiler will optimize it away, so there’s no performance penalty!</p> <p>We can now use this type in our <code>User</code> struct.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>,</span></span> <span class="giallo-l"><span> birthdate</span><span style="color: #FF79C6;">:</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NaiveDate</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>See how the compiler now guides us towards idiomatic Rust code? It’s subtle, but <code>username</code> is now of type <code>Username</code> instead of <code>String</code>. This means we have much stronger guarantees around our own type as we can’t accidentally create a user with an empty username. The username has to be constructed before:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> username</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;johndoe&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> birthdate</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> NaiveDate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_ymd</span><span>(</span><span style="color: #BD93F9;">1990</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> { username, birthdate };</span></span></code></pre><h2 id="side-note-how-do-we-get-rid-of-username-new"><a class="zola-anchor" href="#side-note-how-do-we-get-rid-of-username-new" aria-label="Anchor link for: side-note-how-do-we-get-rid-of-username-new">Side Note: How do we get rid of <code>Username::new</code>?</a></h2> <p>You could implement <code>TryFrom</code>:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> std</span><span style="color: #FF79C6;">::</span><span>convert</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">TryFrom</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span>&lt;&#39;</span><span style="color: #8BE9FD;font-style: italic;">a</span><span>&gt;</span><span style="color: #8BE9FD;font-style: italic;"> TryFrom</span><span>&lt;</span><span style="color: #FF79C6;">&amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>&gt;</span><span style="color: #FF79C6;"> for</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> type</span><span style="color: #8BE9FD;font-style: italic;"> Error</span><span style="color: #FF79C6;"> = &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> try_from</span><span>(value</span><span style="color: #FF79C6;">: &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">a str</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Error</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #BD93F9;font-style: italic;"> Self</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(value</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">into</span><span>())</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">let</span><span> user</span><span style="color: #FF79C6;"> =</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #F1FA8C;"> &quot;johndoe123&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">try_into</span><span>()</span><span style="color: #FF79C6;">?</span><span>,</span></span> <span class="giallo-l"><span> birthdate</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> NaiveDate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">from_ymd</span><span>(</span><span style="color: #BD93F9;">1990</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>,</span><span style="color: #BD93F9;"> 1</span><span>),</span></span> <span class="giallo-l"><span>};</span></span></code></pre><h2 id="what-about-the-birthdate"><a class="zola-anchor" href="#what-about-the-birthdate" aria-label="Anchor link for: what-about-the-birthdate">What About the Birthdate?</a></h2> <p>A new user that is 1000 years old is probably not a valid user. Let’s add some constraints.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">use</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Datelike</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Birthdate</span><span>(chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NaiveDate</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Birthdate</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> new</span><span>(birthdate</span><span style="color: #FF79C6;">:</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">NaiveDate</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> today</span><span style="color: #FF79C6;"> =</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">today</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">naive_utc</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> birthdate</span><span style="color: #FF79C6;"> &gt;</span><span> today {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Birthdate cannot be in the future&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #6272A4;"> // Note, this age calculation is not 100% accurate, but you get the</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // idea. Here&#39;s a more robust implementation:</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // https://gist.github.com/mre/ee7a59491e2aee46d767bd3b5372c5c2</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> age</span><span style="color: #FF79C6;"> =</span><span> today</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">year</span><span>()</span><span style="color: #FF79C6;"> -</span><span> birthdate</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">year</span><span>();</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> age</span><span style="color: #FF79C6;"> &lt;</span><span style="color: #BD93F9;"> 12</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;Not old enough to register&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> age</span><span style="color: #FF79C6;"> &gt;=</span><span style="color: #BD93F9;"> 150</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;How are you not dead yet?&quot;</span><span>)</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>(birthdate))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>#[cfg(test)]</span></span> <span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> tests {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span style="color: #BD93F9;font-style: italic;"> super</span><span style="color: #FF79C6;">::*</span><span>;</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> use</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Duration</span><span>;</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span> #[test]</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> test_birthdate</span><span>() {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> let</span><span> today</span><span style="color: #FF79C6;"> =</span><span> chrono</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Utc</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">today</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">naive_utc</span><span>();</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Birthdate cannot be in the future</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Birthdate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(today</span><span style="color: #FF79C6;"> +</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">1</span><span>))</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_err</span><span>());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Excuse me, how old are you?</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Birthdate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(today</span><span style="color: #FF79C6;"> -</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">365</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 150</span><span>))</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_err</span><span>());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Not old enough</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Birthdate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(today</span><span style="color: #FF79C6;"> -</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">365</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 11</span><span>))</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_err</span><span>());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Ok</span></span> <span class="giallo-l"><span style="color: #50FA7B;"> assert!</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">Birthdate</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(today</span><span style="color: #FF79C6;"> -</span><span> Duration</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">days</span><span>(</span><span style="color: #BD93F9;">365</span><span style="color: #FF79C6;"> *</span><span style="color: #BD93F9;"> 15</span><span>))</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_ok</span><span>());</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>No mocking, no complicated setup, testing becomes a breeze.</p> <p>Our <code>User</code> struct now looks like this:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> User</span><span> {</span></span> <span class="giallo-l"><span> username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>,</span></span> <span class="giallo-l"><span> birthdate</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> Birthdate</span><span>,</span></span> <span class="giallo-l"><span>}</span></span></code></pre><h2 id="adding-more-constraints"><a class="zola-anchor" href="#adding-more-constraints" aria-label="Anchor link for: adding-more-constraints">Adding More Constraints</a></h2> <p>It might sound simple, trivial even, but this is a very powerful technique. What’s important is that you’re handling errors at the lowest possible level. In this case, when you create the <code>Username</code> object — and not when you insert it into your database for example.</p> <p>This will make your code much more robust and easier to reason about, and it’s quick to add more constraints as you go along. For example, we might want to make sure that the username is not shorter than 3 characters, not longer than 256 characters, and that it contains only alphanumeric characters or dashes and underscores:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;">impl</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Represents a user&#39;s login name.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// # Errors</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// Returns an error if</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// - the username is shorter than 3 characters</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// - the username is longer than 256 characters</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// - the username contains characters other than </span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// alphanumeric characters, dashes, or underscores</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// # Examples</span></span> <span class="giallo-l"><span style="color: #6272A4;"> ///</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// ```rust</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// # use yourcrate::username::Username;</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// assert!(Username::new(&quot;1&quot;.into()).is_err());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// assert!(Username::new(&quot;&quot;.into()).is_err());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// assert!(Username::new(&quot;user_name-123&quot;.into()).is_ok());</span></span> <span class="giallo-l"><span style="color: #6272A4;"> /// ```</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> fn</span><span style="color: #50FA7B;"> new</span><span>(username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> username</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &lt;</span><span style="color: #BD93F9;"> 3</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;username must be at least 3 characters long&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> username</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">len</span><span>() &gt;</span><span style="color: #BD93F9;"> 256</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;username must not be longer than 256 characters&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // Note: we use `is_ascii_alphanumeric` instead of `is_alphanumeric`</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // because we want to restrict usernames to ASCII characters only</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // and exclude e.g. Chinese ideograms and Arabic-Indic digits.</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // See https://doc.rust-lang.org/std/primitive.char.html#method.is_alphanumeric</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> if</span><span> username</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">chars</span><span>()</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">any</span><span>(</span><span style="color: #FF79C6;">|</span><span>c</span><span style="color: #FF79C6;">| !</span><span>c</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">is_ascii_alphanumeric</span><span>()</span><span style="color: #FF79C6;"> &amp;&amp;</span><span> c</span><span style="color: #FF79C6;"> !=</span><span style="color: #F1FA8C;"> &#39;-&#39;</span><span style="color: #FF79C6;"> &amp;&amp;</span><span> c</span><span style="color: #FF79C6;"> !=</span><span style="color: #F1FA8C;"> &#39;_&#39;</span><span>) {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> return</span><span style="color: #8BE9FD;font-style: italic;"> Err</span><span>(</span><span style="color: #F1FA8C;">&quot;username must only contain alphanumeric characters, dashes, and underscores&quot;</span><span>);</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span style="color: #8BE9FD;font-style: italic;"> Ok</span><span>(</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>(username))</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>I’ve added some usage examples, which will be shown in the documentation of the <code>Username</code> struct. This is a great way to document your constraints and to show how to use your types! As an added bonus, you can run these examples as tests with <code>cargo test --doc</code>.</p> <p>Here’s a link to the code on the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2021&amp;gist=2a896bbfa9a25e76ceed2e15159643a8">Rust Playground</a>.</p> <h2 id="does-this-really-prevent-illegal-states"><a class="zola-anchor" href="#does-this-really-prevent-illegal-states" aria-label="Anchor link for: does-this-really-prevent-illegal-states">Does This Really Prevent Illegal States?</a></h2> <p>The keen reader might have noticed that we could still create invalid objects manually:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> username</span><span style="color: #FF79C6;"> =</span><span style="color: #50FA7B;"> Username</span><span>(</span><span style="color: #F1FA8C;">&quot;&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span><span style="color: #6272A4;"> // uh oh</span></span></code></pre> <p>In any real-world scenario, we would probably encapsulate our logic in a module and only expose a constructor function to the outside world:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">mod</span><span> user {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span style="color: #FF79C6;"> impl</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> pub fn</span><span style="color: #50FA7B;"> new</span><span>(username</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span><span>)</span><span style="color: #FF79C6;"> -&gt;</span><span style="color: #8BE9FD;font-style: italic;"> Result</span><span>&lt;</span><span style="color: #BD93F9;font-style: italic;">Self</span><span>,</span><span style="color: #FF79C6;"> &amp;</span><span>&#39;</span><span style="color: #8BE9FD;font-style: italic;">static str</span><span>&gt; {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // ...</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span> }</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>If we now tried to create a <code>Username</code> object from the outside, we’d get a compiler error:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> username</span><span style="color: #FF79C6;"> =</span><span> user</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">Username</span><span>(</span><span style="color: #F1FA8C;">&quot;&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>());</span></span> <span class="giallo-l"></span> <span class="giallo-l"><span>error[</span><span style="color: #8BE9FD;font-style: italic;">E0603</span><span>]</span><span style="color: #FF79C6;">:</span><span> tuple</span><span style="color: #FF79C6;"> struct</span><span> constructor `</span><span style="color: #8BE9FD;font-style: italic;">Username</span><span>` is private</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> --&gt;</span><span> src</span><span style="color: #FF79C6;">/</span><span>main</span><span style="color: #FF79C6;">.</span><span>rs</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">45</span><span style="color: #FF79C6;">:</span><span style="color: #BD93F9;">26</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> |</span></span> <span class="giallo-l"><span style="color: #BD93F9;">2</span><span style="color: #FF79C6;"> | pub struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span>(</span><span style="color: #8BE9FD;font-style: italic;">String</span><span>);</span></span> <span class="giallo-l"><span style="color: #FF79C6;"> | ------</span><span> a constructor is private</span><span style="color: #FF79C6;"> if</span><span> any of the fields is private</span></span></code></pre> <p>With that, the only way to create a <code>Username</code> object is by using our <code>new</code> function:</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">let</span><span> username</span><span style="color: #FF79C6;"> =</span><span> user</span><span style="color: #FF79C6;">::</span><span style="color: #8BE9FD;font-style: italic;">Username</span><span style="color: #FF79C6;">::</span><span style="color: #50FA7B;">new</span><span>(</span><span style="color: #F1FA8C;">&quot;mre&quot;</span><span style="color: #FF79C6;">.</span><span style="color: #50FA7B;">to_string</span><span>())</span><span style="color: #FF79C6;">?</span><span>;</span></span></code></pre> <p><strong>This means, illegal states are avoided for users of our module.<br /> In a way, we only made them “unconstructable”, though.</strong></p> <p>If we really wanted, we could model our struct to avoid illegal states at compile time, but it would be rather tedious to work with.</p> <pre class="giallo" style="color: #F8F8F2; background-color: #282A36;"><code data-lang="rust"><span class="giallo-l"><span style="color: #FF79C6;">struct</span><span style="color: #8BE9FD;font-style: italic;"> Username</span><span> {</span></span> <span class="giallo-l"><span style="color: #6272A4;"> // At least 3 characters required</span></span> <span class="giallo-l"><span> prefix</span><span style="color: #FF79C6;">:</span><span> [</span><span style="color: #8BE9FD;font-style: italic;">char</span><span>;</span><span style="color: #BD93F9;"> 3</span><span>]</span></span> <span class="giallo-l"><span> rest</span><span style="color: #FF79C6;">:</span><span style="color: #8BE9FD;font-style: italic;"> String</span></span> <span class="giallo-l"><span>}</span></span></code></pre> <p>We get the benefit of compile-time safety, but at the cost of ergonomics. However, this pattern can be useful in other cases, as we will see in an <a href="/blog/compile-time-invariants/">article about compile-time invariants</a>.</p> <h2 id="library-support"><a class="zola-anchor" href="#library-support" aria-label="Anchor link for: library-support">Library Support</a></h2> <p>I personally prefer to write validation functions as shown above, but you could consider using a validation library like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://crates.io/crates/validator">validator</a> instead.</p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>If possible, use self-contained, custom types to model your domain. It will improve your system design, making it easier to test and reason about. Handle errors at the lowest possible level (as early as possible).</p> Tue, 01 Aug 2023 00:00:00 +0000 Matthias Endler https://corrode.dev/blog/why-rust/ https://corrode.dev/blog/why-rust/ <p>Interest in Rust has surged in recent years, with tech leaders such as Microsoft, Google, and Amazon coming forward to share their experiences of leveraging Rust for critical systems.</p> <p>Much of the dialogue about Rust, however, is still driven by those who have not leveraged Rust in a significant production capacity or have only done so for non-critical systems. This results in a skewed understanding of Rust’s application in production settings, especially for small and medium-sized businesses, where discussions tend to highlight performance benefits and gloss over other crucial aspects.</p> <p>In my role as a Rust consultant, <a href="/podcast">I have had the opportunity to engage with many companies, large and small</a>. I found that companies value Rust’s stability, and long-term maintainability on par with its performance benefits.</p> <p>This overview distills key insights, offering a resource for businesses to assess whether Rust is the right tool for their use-case or not.</p> <p>The intent is to provide an honest look at Rust’s practicality for production to help decision-makers understand its benefits and challenges.</p> <div class="info"> <div class="info-header"> <span class="icon icon-radio"></span> <h4><p>Streamline Your Decision-Making with Our Compact Audio Guide on Rust</p> </h4> </div> <p>Considering Rust for your production needs?<br /> You might also want to listen to <a href="/podcast/s01e07-season-finale/">this podcast episode of Rust in Production</a>.</p> <p>Key Highlights:</p> <ul> <li>Insights into <a href="/blog/hiring-rust-engineers/">hiring Rust engineers</a>.</li> <li>Tips to <a href="/blog/flattening-rusts-learning-curve/">flatten the learning curve</a>.</li> <li>Effective strategies for <a href="/blog/successful-rust-business-adoption-checklist/">Rust adoption</a>.</li> <li>The significant impact of Rust’s performance on user experience.</li> <li>And much more.</li> </ul> <p>This episode offers a balanced perspective on the advantages and challenges of implementing Rust, supported by real-life experiences and insights from CTOs and lead engineers who have navigated this transition.</p> </div> <h2>Table of Contents</h2> <details class="toc"> <summary> Click here to expand the table of contents. </summary> <ul> <li><a href="https://corrode.dev/blog/why-rust/#reasons-for-using-rust-in-production">Reasons For Using Rust In Production</a> <ul> <li><a href="https://corrode.dev/blog/why-rust/#reliability-and-stability">Reliability and Stability</a></li> <li><a href="https://corrode.dev/blog/why-rust/#maintainability">Maintainability</a></li> <li><a href="https://corrode.dev/blog/why-rust/#predictable-runtime-behavior">Predictable Runtime Behavior</a></li> <li><a href="https://corrode.dev/blog/why-rust/#cost-savings">Cost Savings</a></li> <li><a href="https://corrode.dev/blog/why-rust/#ergonomics">Ergonomics</a></li> <li><a href="https://corrode.dev/blog/why-rust/#focus-on-long-term-sustainability">Focus on Long-Term Sustainability</a></li> <li><a href="https://corrode.dev/blog/why-rust/#productivity-and-developer-happiness">Productivity And Developer Happiness</a></li> <li><a href="https://corrode.dev/blog/why-rust/#performance-and-energy-efficiency">Performance And Energy Efficiency</a></li> <li><a href="https://corrode.dev/blog/why-rust/#gradual-adoption-and-ffi">Gradual Adoption and FFI</a></li> <li><a href="https://corrode.dev/blog/why-rust/#support-for-a-wide-range-of-environments">Support for a Wide Range of Environments</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/why-rust/#reasons-against-using-rust-in-production">Reasons Against Using Rust In Production</a> <ul> <li><a href="https://corrode.dev/blog/why-rust/#immature-ecosystem">Immature ecosystem</a></li> <li><a href="https://corrode.dev/blog/why-rust/#lack-of-developers">Lack Of Developers</a></li> <li><a href="https://corrode.dev/blog/why-rust/#tooling">Tooling</a></li> <li><a href="https://corrode.dev/blog/why-rust/#learning-curve">Learning Curve</a></li> <li><a href="https://corrode.dev/blog/why-rust/#compile-times">Compile Times</a></li> </ul> </li> <li><a href="https://corrode.dev/blog/why-rust/#conclusion">Conclusion</a></li> <li><a href="https://corrode.dev/blog/why-rust/#talks">Talks</a></li> <li><a href="https://corrode.dev/blog/why-rust/#next-steps">Next Steps</a></li> </ul> </details> <h2 id="reasons-for-using-rust-in-production"><a class="zola-anchor" href="#reasons-for-using-rust-in-production" aria-label="Anchor link for: reasons-for-using-rust-in-production">Reasons For Using Rust In Production</a></h2> <h3 id="reliability-and-stability"><a class="zola-anchor" href="#reliability-and-stability" aria-label="Anchor link for: reliability-and-stability">Reliability and Stability</a></h3> <p>From experience, the majority of companies care less about uncompromising performance and more about <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://talks.osfc.io/osfc2021/talk/JTWYEH/">reliability and stability</a> of their services.</p> <p>This is backed by the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cloud.google.com/devops/state-of-devops/"><em>State of DevOps Report 2023</em></a> by Google Cloud, which states:</p> <blockquote> <p><strong>Reliability unlocks performance.</strong> […] Strong reliability practices predict better operational performance, team performance, and organizational performance. […] Being able to operate the machine effectively allows teams to achieve more, which allows organizations to thrive. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://cloud.google.com/devops/state-of-devops/"><em>State of DevOps Report 2023</em></a></p> </blockquote> <p>More predictable and stable services are easier to maintain and cheaper to operate. Less time is spent on debugging and on-call, and more time on building new features. Scaling services is also easier when you know how systems behave under load.</p> <blockquote> <p>Given our small team size, infrastructure reliability is crucial, otherwise, maintenance starves innovation. Rust provides us with confidence that any code modification or refactor is likely to produce working programs that will run for months with minimal supervision. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://x.ai/">xAI (formerly Twitter)</a></p> </blockquote> <p>As another example, the npm registry migrated to Rust in 2019. (See their whitepaper <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.rust-lang.org/static/pdfs/Rust-npm-Whitepaper.pdf">here</a>.) As the largest software registry in the world, it sees upwards of 1.3 billion package downloads… <em>per day</em>. Npm is critical infrastructure for the JavaScript ecosystem, and the stability of its services is paramount. This focus on stability directly impacts the effectiveness and reliability of the entire JavaScript ecosystem.</p> <blockquote> <p>My biggest compliment to Rust is that it’s boring, and this is an amazing compliment. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.linkedin.com/in/christophersdickinson/">Chris Dickinson</a>, former Engineer at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.npmjs.com/about">npm, Inc</a></p> </blockquote> <p><a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://deepsource.com/blog/exponential-cost-of-fixing-bugs">Bugs cost more to fix the later they are found.</a> Below is the relative cost of fixing bugs at various stages of the development lifecycle. Bugs found in production are significantly more expensive to fix than bugs found during development. (Source: NIST <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.nist.gov/system/files/documents/director/planning/report02-3.pdf">Costs of Software Defects</a>)</p> <img src="bug-costs.svg" class="invert" alt="Cost of fixing bugs over time"> <p>In a survey, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://msrc.microsoft.com/blog/2019/07/a-proactive-approach-to-more-secure-code/">Microsoft found that 70% of their bugs are due to memory safety issues</a>. In 2018, the number of CVEs (Common Vulnerabilities and Exposures) at Microsoft was 468. Each CVE costs an average of $150,000 to fix, which, as Microsoft points out, is a very conservative estimate. (Source: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=NQBVUjdkLAA&amp;t=1s">Ryan Levick - Rust at Microsoft</a>). Rust couldn’t have prevented all of these bugs, but it would have drastically reduced the total amount.</p> <p>Rust’s strong type system and its borrow checker allow you to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://kerkour.com/bugs-rust-compiler-helps-prevent">catch bugs earlier in the development lifecycle, typically at compile-time</a> (instead of runtime as in languages with less stringent type systems or static analysis capabilities). This results in real cost savings for companies.</p> <blockquote> <p>We always talk about the performance gains […] when using Rust but honestly I much more look for the stability gains. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=KTJIsicwW5s">Stefan Baumgartner, Senior Product Architect at Dynatrace</a></p> </blockquote> <p>As requirements grow, Rust is a great language for building larger applications that are maintained by a bigger team over a long period of time. This is due to its strong type system, its focus on memory safety, its powerful tooling (cargo, rustfmt, clippy, etc.) and its stability guarantees (backwards compatibility) due to its edition system. All of that makes large-scale refactoring easier.</p> <blockquote> <p>What I usually hear is that [efficiency is] what people are first excited about but the reason that they keep using [Rust] is because actually it’s better for building more reliable systems. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=oGN62EEHyn8">Nicholas Matsakis, Senior Principal Engineer at AWS and lead of the Rust language design team.</a></p> </blockquote> <p>In a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html">Google survey</a>, developers were asked about their confidence in Rust code compared to other languages. The results were overwhelmingly positive: <strong>85% of respondents were more confident in their team’s Rust code in comparison to other languages.</strong></p> <img src="rust_code_confidence.svg" class="invert" alt="Google Survey: confidence in Rust code is very high compared to other languages"> <h3 id="maintainability"><a class="zola-anchor" href="#maintainability" aria-label="Anchor link for: maintainability">Maintainability</a></h3> <p>Rust’s design principles significantly contribute to software maintainability.</p> <blockquote> <p>We find that when we build things in Rust, they are pretty easy to maintain. They just don’t break. Our requirements can change; we may need to modify them, but it’s pretty reliable - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=1faOd6KH-w4&amp;t=740s">Edward Wright, Staff Engineer at Vortexa</a></p> </blockquote> <p>This ease of maintainability means that Rust applications require less effort to adapt and evolve over time, reducing overall technical debt and freeing up developer resources for new features rather than maintenance.</p> <p>Emphasizing Rust’s impact on development efficiency and time-to-market, Wright continues</p> <blockquote> <p>We’re probably spending our time more focused on actually adding value for our customers and changing things when the requirements change — work that we should be doing rather than busy work. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=1faOd6KH-w4&amp;t=761s">Edward Wright, Staff Engineer at Vortexa</a></p> </blockquote> <h3 id="predictable-runtime-behavior"><a class="zola-anchor" href="#predictable-runtime-behavior" aria-label="Anchor link for: predictable-runtime-behavior">Predictable Runtime Behavior</a></h3> <p>Predictable runtime behavior is closely related to reliability and stability. It means that services run smoothly without any hiccups. This is especially important for latency-sensitive services like games, chat applications, or services that need to act on real-time data.</p> <p>Smooth operation is of uppermost importance for organizations as it is a significant cost factor and can impact customer satisfaction. According to a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.techrepublic.com/article/on-call-cloud-operations-cost-organizations-an-average-of-2-5-million-per-year/">recent study</a>, organizations are spending an average of $2.5 million per year on on-call operations. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.pragmaticengineer.com/oncall-compensation/">Compensation for on-call engineers</a> is a big part of that cost.</p> <blockquote> <p>People just didn’t like getting paged in the middle of the night, and Rust was helping avoid that - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=oGN62EEHyn8">Nicholas Matsakis</a> (in the context of npm migrating to Rust)</p> </blockquote> <p>Discord has a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://discord.com/blog/why-discord-is-switching-from-go-to-rust">great article</a> about why they switched from Go to Rust. They mention that Go’s garbage collector was a source of unpredictable latency spikes. After switching to Rust, they were able to fully get rid of garbage collection and have a more predictable runtime behavior.</p> <blockquote> <p>When we started load testing, we were instantly pleased with the results. The latency of the Rust version was just as good as Go’s and had no latency spikes!</p> </blockquote> <p>Here is a diagram from the above article by Discord. Notice how the latency spikes in the Go version (purple) are gone in the Rust version (blue) and how that impacts the 95th percentile response time, making it much more predictable and smooth.</p> <img src="discord.png" alt="Discord Go (purple) vs Rust (blue)"> <p>Another example is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.cloudflare.com/big-pineapple-intro/">Cloudflare</a>, which uses Rust to power their DNS service, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://1.1.1.1/">1.1.1.1</a>. They mention that Rust’s predictable runtime behavior is a big reason for using it:</p> <blockquote> <p>One of the things we’ve learned with the previous implementations is that, for a service open to the public, a peak performance of the I/O matters less than the ability to pace clients fairly.</p> </blockquote> <p>Furthermore, Rust shows excellent runtime behavior when handling network requests. In a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://medium.com/star-gazers/benchmarking-low-level-i-o-c-c-rust-golang-java-python-9a0d505f85f7">benchmark by Eugene Retunsky</a>, Rust had the lowest tail latency and maximum throughput next to C and C++.</p> <p>Here is the diagram from the benchmark, showing the p99.9 latency for each language under test. As the requests per second increase, the latency for Rust stays low and stable. Go and Java on the other hand have a higher baseline latency while Python shows latency spikes at a certain point.</p> <img src="runtime.png" alt="Rust Runtime behavior"> <p>The author concludes:</p> <blockquote> <p>In conclusion, Rust has a much lower latency variance than Golang, Python, and especially Java. […] Rust might be a better alternative to Golang, Java, or Python if predictable performance is crucial for your service. Also, before starting to write a new service in C or C++, it’s worth considering Rust. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://medium.com/star-gazers/benchmarking-low-level-i-o-c-c-rust-golang-java-python-9a0d505f85f7">Eugene Retunsky</a></p> </blockquote> <h3 id="cost-savings"><a class="zola-anchor" href="#cost-savings" aria-label="Anchor link for: cost-savings">Cost Savings</a></h3> <p>We touched on cost savings already, but its significance warrants a dedicated section.</p> <p>Rust has a low runtime overhead. This is especially important for services that need to scale to handle a large number of requests. It can save a lot of money on cloud infrastructure costs if the same workload can be handled with fewer resources.</p> <p>For example, AWS has a service called <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/blogs/aws/firecracker-lightweight-virtualization-for-serverless-computing/">Firecracker</a>, which runs virtual machines with very low overhead. It powers AWS Lambda functions and AWS Fargate containers.</p> <blockquote> <p>Firecracker consumes about 5 MiB of memory per microVM. You can run thousands of secure VMs with widely varying vCPU and memory configurations on the same instance.</p> </blockquote> <p>The better hardware utilization translates to lower costs for companies.</p> <p>Firecracker allowed AWS to improve the efficiency of Fargate, which passed on cost savings to customers. As a result, they were able to reduce the price of Fargate by up to 50%. (<a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://shahbhargav.medium.com/firecracker-secure-and-fast-microvms-628e6043b572">Image source</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://aws.amazon.com/blogs/compute/aws-fargate-price-reduction-up-to-50/">AWS announcement</a>)</p> <img src="fargate.png" alt="Firecracker" /> <h3 id="ergonomics"><a class="zola-anchor" href="#ergonomics" aria-label="Anchor link for: ergonomics">Ergonomics</a></h3> <p>Rust has great developer ergonomics. Its expressive type system allows developers to model their domain in a way that lets the compiler help with writing correct code.</p> <p>Furthermore, functional concepts like pattern matching, <a href="/blog/enums/">enums</a>, <code>Result</code> and <a href="/blog/rust-option-handling-best-practices/"><code>Option</code> types</a> allow for concise and expressive code.</p> <p>Rust’s robust error handling story, which requires the programmer to explicitly handle errors, is a big reason for its reliability.</p> <p>All these features make it easier to write correct code, reduce the cognitive load on developers and catch bugs at compile-time instead of runtime.</p> <blockquote> <p>More than its memory safety and thread safety guarantees, the language exposes facilities to library designers for building abstractions that resist misuse. The emergent safe library ecosystem enables “if it compiles, then it’s correct” programming unmatched by other mainstream languages, even garbage collected ones. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://docs.rs/dtolnay/0.0.11/dtolnay/macro._03__soundness_bugs.html">David Tolnay, author of serde</a></p> </blockquote> <p>Rust’s static analysis <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://en.wikipedia.org/wiki/Shift-left_testing">shifts the quality assurance of code to the left</a>:</p> <img src="robustness.svg" class="invert" alt="Bug detection over time"> <blockquote> <p>Rust has been a force multiplier for our team, and betting on Rust was one of the best decisions we made. More than performance, its ergonomics and focus on correctness has helped us tame sync’s complexity. We can encode complex invariants about our system in the type system and have the compiler check them for us. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://dropbox.tech/infrastructure/rewriting-the-heart-of-our-sync-engine">Dropbox</a></p> </blockquote> <p>An often mentioned benefit of Rust is the possibility to refactor code without fear. This should not be underestimated as it allows you to improve your codebase over time and make it more robust. Especially for applications that use multi-threading, this is a big advantage as <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html">typical error scenarios of concurrent programming are detected by the compiler</a>.</p> <h3 id="focus-on-long-term-sustainability"><a class="zola-anchor" href="#focus-on-long-term-sustainability" aria-label="Anchor link for: focus-on-long-term-sustainability">Focus on Long-Term Sustainability</a></h3> <p>Companies rarely rewrite their services in another language. It incurs a lot of costs and risks. Only if a rewrite promises a <em>significant</em> upside, companies will consider it.</p> <p>One well-known company that started to heavily invest in Rust is Microsoft.</p> <blockquote> <p>Microsoft is going big on Rust and spending $10 million to make it 1st class language in our engineering systems + $1 million @rustlang foundation. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/dwizzzleMSFT/status/1720134540822520268">David Weston, Vice President of OS Security and Enterprise at Microsoft</a></p> </blockquote> <p>Microsoft even <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/markrussinovich/status/1656416376125538304">integrated Rust into the Windows kernel</a>. The fact that they take big bets on Rust shows that they are in it for the long run. This is a good sign for the Rust ecosystem, as the backing of a large company can help Rust to become more mainstream and ensure long-term sustainability.</p> <p>Similarly, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.kernel.org/doc/html/next/rust/index.html">the Linux kernel now supports Rust</a> as well. The Kernel incorporating Rust is a major endorsement of the language. Notably, the Linux Kernel maintainers have previously <a class="external-link" rel="noopener noreferrer external" target="_blank" href="http://harmful.cat-v.org/software/c++/linus">refused to integrate C++ in the Kernel</a>.</p> <p>In a landmark development for Rust, the open source <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://ferrous-systems.com/blog/officially-qualified-ferrocene/">Ferrocene toolchain</a> has achieved a significant milestone: Ferrocene, based on Rust 1.68, is now ISO 26262 and IEC 61508 qualified. This certification means that the Rust compiler meets rigorous safety standards, making it fully usable in safety-critical environments like automotive or avionics. Few other languages have achieved this level of certification. It is another strong signal that Rust is here to stay.</p> <p>For another take on this, watch <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=WnIWRks35Fk">“In It for the Long Haul”</a> by <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://twitter.com/carols10cents">Carol Nichols</a>.</p> <h3 id="productivity-and-developer-happiness"><a class="zola-anchor" href="#productivity-and-developer-happiness" aria-label="Anchor link for: productivity-and-developer-happiness">Productivity And Developer Happiness</a></h3> <p>As mentioned in the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.jetbrains.com/lp/devecosystem-2021/rust/#:~:text=Rust%20developers%20are%20generally%20more,senior%20positions%20than%20other%20developers">2021 JetBrains Developer Ecosystem Report</a>, Rust developers are typically more proficient compared to developers in other languages, as many have more experience and often occupy senior roles.</p> <p>Many developers enjoy working with Rust. It has consistently been the most admired language according to the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://survey.stackoverflow.co/2023/#section-admired-and-desired-programming-scripting-and-markup-languages">StackOverflow Developer Survey</a>. More than 80% of developers that use it want to use it again next year.</p> <p>For teams that are looking to hire and retain talent, Rust can be a great choice because <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.microsoft.com/en-us/research/publication/towards-a-theory-of-software-developer-job-satisfaction-and-perceived-productivity/">developer happiness is a big factor in job satisfaction and has a positive impact on productivity</a>.</p> <h3 id="performance-and-energy-efficiency"><a class="zola-anchor" href="#performance-and-energy-efficiency" aria-label="Anchor link for: performance-and-energy-efficiency">Performance And Energy Efficiency</a></h3> <p>As stated earlier, performance often gets mentioned as a main reason for using Rust. On top of that, Rust has great support for multi-threaded workloads. Libraries like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rayon-rs/rayon">rayon</a> and <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://tokio.rs/">Tokio</a> are considered best-in-class for writing high-performance applications.</p> <p>Making efficient use of compute resources has much deeper implications for companies than just raw execution speed.</p> <p>One important aspect is scalability: companies can defer costly performance optimizations and scaling efforts by choosing a language that is efficient by default. This way, they can focus on building features and growing their business before they need to worry about performance bottlenecks.</p> <p>In his talk at FrOSCon 2024, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/kerkmann">Daniél Kerkmann</a>, software engineer at <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opentalk.eu">OpenTalk</a> – a secure video conferencing platform written in Rust – shared that sentiment:</p> <blockquote> <p><strong>The performance of Rust kept us afloat for a long time.</strong></p> <p>Up to a point of 10.000 video participants we didn’t have to refactor thanks to Rust’s performance. We could focus on features instead without worrying about bottlenecks.<br /> — Source: <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://media.ccc.de/v/froscon2024-3105-in_rust_radikal_refactorn#t=1198">FrOSCon 2024 talk by Daniél Kerkmann (German)</a></p> </blockquote> <p>Another aspect of performance is energy efficiency.</p> <p>In the below benchmark, taken from <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://greenlab.di.uminho.pt/wp-content/uploads/2017/10/sleFinal.pdf">“Energy Efficiency across Programming Languages”</a> by Pereira et al., Rust has superior runtime performance on par with C and C++ and faster than Go by a factor of 2-3x as well as Python by a factor of 70x.</p> <table><thead><tr><th>Lang</th><th>Time (Normalized)</th></tr></thead><tbody> <tr><td>C</td><td>1.00</td></tr> <tr><td>Rust</td><td>1.04</td></tr> <tr><td>C++</td><td>1.56</td></tr> <tr><td>Java</td><td>1.89</td></tr> <tr><td>Go</td><td>2.83</td></tr> <tr><td>JavaScript</td><td>6.52</td></tr> <tr><td>PHP</td><td>27.64</td></tr> <tr><td>Ruby</td><td>59.34</td></tr> <tr><td>Python</td><td>71.90</td></tr> </tbody></table> <p>This translates to lower energy consumption as well. Energy is another important cost factor for companies at scale.</p> <img src="energy-consumption.svg" class="invert" alt="Energy Efficiency across Programming Languages" /> <h3 id="gradual-adoption-and-ffi"><a class="zola-anchor" href="#gradual-adoption-and-ffi" aria-label="Anchor link for: gradual-adoption-and-ffi">Gradual Adoption and FFI</a></h3> <p>One often overlooked aspect of Rust is that it can be incrementally integrated into existing codebases. Interoperability is a key concern of Rust, allowing it to <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://users.rust-lang.org/t/tips-and-experiences-integrating-rust-into-other-projects/12091/12">natively interface with other languages like C, C++, or Python</a>.</p> <p>This makes it possible for Rust to take on a supporting role in existing codebases, where it can be used for security- or performance-critical parts while the rest of the codebase remains in the original language. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.youtube.com/watch?v=l--5nx_q0_Y">This greatly reduces risks as big rewrites are avoided.</a></p> <p>In a data science environment dominated by Python, integrating Rust offers significant performance enhancements. By using Rust to process data originally managed with Python libraries such as Pandas and NumPy, data can be strategically copied from Python into Rust structures, and leveraging Rust’s powerful concurrency tools like Rayon for parallel processing.</p> <p>As a case-study, this approach, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://youtu.be/1faOd6KH-w4?si=pdd04RikPpsohiza&amp;t=1111">significantly accelerated a critical data processing task at Vortexa</a>, which wrote a Python extension in Rust to optimize the performance of a hot path in their data processing pipeline. The result was a reduction from 24 hours to 1 hour with 400 lines of Rust code. The rest of the codebase remained intact.</p> <p>It shows Rust’s potential to serve as a <em>surgical tool</em> within other ecosystems, dramatically optimizing performance with minimal intrusion.</p> <p>On top of that, the Rust library code could be reused across projects from embedded programs to cloud services, which streamlines the development process and further reduces maintenance costs.</p> <h3 id="support-for-a-wide-range-of-environments"><a class="zola-anchor" href="#support-for-a-wide-range-of-environments" aria-label="Anchor link for: support-for-a-wide-range-of-environments">Support for a Wide Range of Environments</a></h3> <p>Rust is a versatile language, which can be used in a wide range of applications, from embedded systems to high-performance web services.</p> <table><thead><tr><th>Environment</th><th>Rust</th><th>Kotlin</th><th>Go</th><th>C++</th><th>TypeScript</th><th>Python</th></tr></thead><tbody> <tr><td>Frontend Development</td><td>Yes (via WASM)</td><td>Partial (via Kotlin/JS)</td><td>No</td><td>No</td><td>Yes</td><td>Partial (via frameworks like PyScript)</td></tr> <tr><td>Backend Development</td><td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td></tr> <tr><td>Mobile Development</td><td>Yes</td><td>Yes (Android)</td><td>No</td><td>Partial</td><td>No</td><td>Partial (Kivy, BeeWare)</td></tr> <tr><td>Data Science</td><td>Yes</td><td>Yes</td><td>Partial</td><td>Partial</td><td>No</td><td>Yes</td></tr> <tr><td>Game Development</td><td>Yes</td><td>Partial</td><td>Partial</td><td>Yes</td><td>Partial</td><td>Partial</td></tr> <tr><td>DevOps</td><td>Yes</td><td>Partial</td><td>Yes</td><td>Yes</td><td>Partial</td><td>Yes</td></tr> <tr><td>Systems Programming</td><td>Yes</td><td>No</td><td>Partial</td><td>Yes</td><td>No</td><td>Partial</td></tr> <tr><td>Embedded Systems</td><td>Yes</td><td>Partial</td><td>Partial</td><td>Yes</td><td>No</td><td>Partial (MicroPython)</td></tr> </tbody></table> <p>For companies with diverse product portfolios, it can be beneficial to have a single language that can be used across the entire stack. Clients often mention that the same crates can be used in different contexts, reducing boundaries between teams and making it easier to share code.</p> <h2 id="reasons-against-using-rust-in-production"><a class="zola-anchor" href="#reasons-against-using-rust-in-production" aria-label="Anchor link for: reasons-against-using-rust-in-production">Reasons Against Using Rust In Production</a></h2> <p>Every technology comes with its own set of challenges, and Rust is no exception. The following points highlight some common concerns about using Rust in production. You need to weigh them against the benefits discussed earlier to make an informed decision for your team.</p> <h3 id="immature-ecosystem"><a class="zola-anchor" href="#immature-ecosystem" aria-label="Anchor link for: immature-ecosystem">Immature ecosystem</a></h3> <p>Rust is a relatively young language. Version 1.0 was first released in 2015. This means that the ecosystem is still maturing. Many important libraries <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/11byl6u/why_is_every_crate_pre10/">did not see their 1.0 release yet</a>.</p> <p>This phenomenon has been <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/11byl6u/why_is_every_crate_pre10/ja3auop/">brought up as a reason to be cautious when using Rust in production</a>.</p> <p>In practice, it might be hard to find production-grade libraries for specific needs. Your team might be required to write custom crates or improve existing ones. Furthermore, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/sponsors/explore?ecosystem=RUST">sponsoring open source maintainers</a> to work on critical dependencies is a good way to ensure that the long-term sustainability of the ecosystem.</p> <p>That said, libraries for common tasks like JSON parsing or network handling are very robust and stable and considered best-in-class. Breaking changes are rare and important crates like <code>serde</code> or <code>tokio</code> are already past their 1.0 release.</p> <p>A relatively recent addition to the Rust ecosystem is async/await support, a feature designed to streamline the writing of concurrent applications. This support represents a significant evolution in Rust’s capabilities, but it is still in its early stages. If you’re planning to write network applications in Rust, there is a high chance that you will need to use async/await. As such it’s important to stay on top of its ongoing development and limitations. For a detailed exploration of where async/await in Rust stands today, including its practical implications, we invite you to read our comprehensive post detailing the current <a href="/blog/async/">state of async/await in Rust</a>.</p> <h3 id="lack-of-developers"><a class="zola-anchor" href="#lack-of-developers" aria-label="Anchor link for: lack-of-developers">Lack Of Developers</a></h3> <p>Related to the previous point, the Rust community is still relatively small. It is hard to find developers with professional Rust experience.</p> <p>From talking to companies that use Rust in production, I found that they are mostly training their developers on the job. Moreover, Rust is noted for enabling a smooth onboarding process for engineers already proficient in languages like C++ or Java.</p> <p>On the other hand, Rust developers are generally very passionate about their craft and are actively seeking out jobs that allow them to use Rust, so the market for Rust developers is growing. (Also see the previous section about developer happiness.)</p> <p>For more insights on finding and hiring Rust talent, see our dedicated guide on <a href="/blog/hiring-rust-engineers/">how to hire Rust engineers</a>.</p> <blockquote> <p>Rust has more than tripled the size of its community over the past two years and currently has 3.7M users, of which 0.6M joined in the last six months alone.[…] Furthermore, Rust has built a loyal community of developers who care about memory safety and security. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.developernation.net/resources/reports/state-of-the-developer-nation-24th-edition-q1-2023">State of the Developer Nation 24th Edition - Q1 2023 report</a></p> </blockquote> <a href="https://www.developernation.net/resources/reports/state-of-the-developer-nation-24th-edition-q1-2023" target="_blank"> <img src="communities.svg" class="invert" alt="Programming Language Communities Size"> </a> <h3 id="tooling"><a class="zola-anchor" href="#tooling" aria-label="Anchor link for: tooling">Tooling</a></h3> <p>Cargo, rustfmt, clippy, and rust-analyzer are all great tools that make Rust development a joy. Debugging support is still lacking, but it is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://rustc-dev-guide.rust-lang.org/debugging-support-in-rustc.html">steadily improving</a>. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.jetbrains.com/lp/devecosystem-2021/rust/#Rust_what-profiling-tools-do-you-use-for-rust">The story for profiling support is similar.</a> It should be noted, that Rust integrates well with existing tools like <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.logrocket.com/debugging-rust-apps-with-gdb/">GDB</a> or perf, although <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://github.com/rust-lang/rustup/issues/2838">the experience is not seamless on all platforms yet</a>. For an up-to-date overview, see this list of <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/perf-book/profiling.html">Rust profiling tools</a>.</p> <p>Recently, <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.jetbrains.com/rust/">JetBrains announced RustRover</a>, a new IDE for Rust which is based on IntelliJ. This is a strong signal that JetBrains sees it as a good investment to build tooling for Rust developers and that they expect Rust to become more mainstream.</p> <h3 id="learning-curve"><a class="zola-anchor" href="#learning-curve" aria-label="Anchor link for: learning-curve">Learning Curve</a></h3> <p>Rust has a <a href="/blog/flattening-rusts-learning-curve/">famously steep learning curve</a>. It is a complex language with many advanced features.</p> <p>When asked why they don’t use Rust, participants of the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2023/08/07/Rust-Survey-2023-Results.html#rust-usage">2022 Annual Rust Survey</a> mentioned the learning curve as the main reason:</p> <img src="why-not-rust.svg" class="invert" alt="Why not Rust?"> <p>In the <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2020/12/16/rust-survey-2020.html#improved-learnability">Rust 2020 survey</a>, participants were asked to rate the difficulty of various Rust concepts. Here are the results:</p> <img src="topic-difficulty-ratings.svg" class="invert" alt="Difficulty by topic"> <p>Lifetime annotations, ownership, and borrowing were mentioned as the most difficult topics to grasp. In real-world applications, lifetimes are less of an issue, however, as the compiler can often infer them through <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://doc.rust-lang.org/reference/lifetime-elision.html">lifetime elision</a>. Ownership and borrowing however are crucial concepts in Rust that need to be understood to become proficient.</p> <p>It is important to set clear expectations for your team when adopting Rust: Rust is not a language that you can learn in a few days. It requires practice to internalize the concepts around ownership and borrowing to become productive with it.</p> <p>There is an upfront cost of learning the language and training your team with the expectation that it will pay off in the long run.</p> <p>The time to become productive with Rust varies. Google’s experience suggests:</p> <blockquote> <p>Based on our studies, more than 2/3 of respondents are confident in contributing to a Rust codebase within two months or less when learning Rust. Further, a third of respondents become as productive using Rust as other languages in two months or less. <strong>Within four months, that number increased to over 50%.</strong> - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html">Google</a></p> </blockquote> <p>Microsoft also shared a <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://msrc.microsoft.com/blog/2020/04/the-safety-boat-kubernetes-and-rust/">similar experience</a>:</p> <blockquote> <p><strong>It takes several weeks of hard effort</strong> learning how to code properly in Rust before the learning curve levels out. However, that hard effort up front pays off in dividends due to the aforementioned safety features. We also noticed that once developers are over that initial curve, they are able to contribute to code just as easily as with any other language. Just be aware that there will be some initial pain.</p> </blockquote> <p>Depending on your immediate needs, this might be a deal-breaker for your team. Other languages like Go or Python have a much lower learning curve and are a better fit for rapid prototyping. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://mdwdotla.medium.com/using-rust-at-a-startup-a-cautionary-tale-42ab823d9454">Think twice before adopting it in a fast-paced startup environment</a> , particularly if your team doesn’t include seasoned Rust developers.</p> <blockquote> <p>Assuming you’re building a product in the right domain for Rust […], even then the answer is not clear-cut. […] Development velocity and being able to make rapid iterations is so important for an early stage startup that it outweighs a lot of the benefits that Rust brings to the table. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.shuttle.rs/blog/2021/10/08/building-a-startup-with-rust">Christos Hadjiaslanis - Founder of Shuttle</a></p> </blockquote> <h3 id="compile-times"><a class="zola-anchor" href="#compile-times" aria-label="Anchor link for: compile-times">Compile Times</a></h3> <p>Rust has a reputation for having long compile times. This is especially true for large projects with many dependencies.</p> <blockquote> <p>Slow build speeds were by far the #1 reported challenge that developers have when using Rust, with only a little more than 40% of respondents finding the speed acceptable. - <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html">Google</a></p> </blockquote> <p>Rapid iteration is important for developers. Long compile times can be a productivity killer. This is most noticeable for developers that are used to languages like Go or Python, where the feedback loop is much faster.</p> <p>Compile times are a known issue and the Rust team is <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://nnethercote.github.io/2023/03/24/how-to-speed-up-the-rust-compiler-in-march-2023.html">continously working on improving them</a>. And these incremental improvements are paying off. The Rust compiler is getting faster over time. For example, the Rust compiler is twice as fast than it was in 2018 for <code>cargo check</code> (which is the most common command to quickly check for errors):</p> <img src="compile-times.svg" class="invert" alt="Rust Compile Times Over Time"> <p>Very recently, the Rust compiler frontend also gained support for <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2023/11/09/parallel-rustc.html">parallel compilation</a>, which could drastically reduce compile times for large projects. The feature is currently in <em>nightly</em> only and highly experimental, but it promises speedups of up to 50%. Details on how to test it can be found in the announcement <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://blog.rust-lang.org/2023/11/09/parallel-rustc.html">blog post</a>.</p> <p>For more advice on how to improve compile times, see <a href="/blog/tips-for-faster-rust-compile-times/">my article on this topic</a> with many practical tips. For medium-sized projects, compile times are less of an issue. <a class="external-link" rel="noopener noreferrer external" target="_blank" href="https://www.reddit.com/r/rust/comments/qgi421/doing_m1_macbook_pro_m1_max_64gb_compile/">Modern hardware can also mitigate the issue to some extent.</a></p> <h2 id="conclusion"><a class="zola-anchor" href="#conclusion" aria-label="Anchor link for: conclusion">Conclusion</a></h2> <p>Rust is a great language for building large-scale, reliable, and stable applications. It is a good fit for companies that value productivity and developer happiness and see it as a long-term investment.</p> <p>On the other side, Rust is still a young language and the ecosystem is still maturing. It has a steep learning curve and long compile times.</p> <p>These challenges are not insurmountable, however. They require a commitment to Rust and a willingness to invest in training and tooling.</p> <p>Navigating the decision to integrate Rust into your technology stack is pivotal and requires thoughtful consideration. Should you find yourself weighing its benefits against your specific requirements, professional guidance can prove invaluable. Equally, if you are ready to embrace Rust and are seeking expertise in training or consulting to ensure a smooth transition, specialized support is essential.</p> <p><a href="/services/">Get in touch</a> to explore if Rust is the right choice for your organization and how it can contribute to your long-term success.</p> <div class="info"> <div class="info-header"> <span class="icon icon-radio"></span> <h4><p>Rust in Production Podcast</p> </h4> </div> <p>Real-world experiences are the best way to learn about the benefits and challenges of a technology. That’s why we started <a href="/podcast">Rust in Production</a>, a podcast about companies that bet big on Rust.</p> <p>Listen to the first-hand accounts from decision-makers about why they chose Rust and how it impacted their business. Each episode is a deep dive into the motivations, challenges, and lessons learned from adopting Rust in production by companies that shape the future of infrastructure.</p> <p><a href="/podcast">More information here</a>.</p> </div> <h2 id="talks"><a class="zola-anchor" href="#talks" aria-label="Anchor link for: talks">Talks</a></h2> <ul> <li><a href="https://www.youtube.com/watch?v=DnT-LUQgc7s" target="_blank">Considering Rust — Jon Gjengset, 2020</a></li> <li><a href="https://www.youtube.com/watch?v=GCsxYAxw3JQ" target="_blank">How I Convinced the World’s Largest Package Manager to Use Rust, and So Can You! — Ashley Williams, 2017</a></li> <li><a href="https://www.youtube.com/watch?v=QrrH2lcl9ew" target="_blank">Beyond Safety and Speed: How Rust Fuels Team Productivity — Lars Bergstrom, 2024</a></li> </ul> <h2 id="next-steps"><a class="zola-anchor" href="#next-steps" aria-label="Anchor link for: next-steps">Next Steps</a></h2> <ul> <li><a href="/services/">Reach Out for Rust Training and Consulting</a></li> </ul>