master-list.md

Rust Anthology Master List

This is a collection of substantial blog posts about Rust.

It additionally collects other notable sources of material that might be useful to a Rust learner: cheat sheets, examples and exercises, and additional long-form reading. In content it has significant overlap with rust-learning, but with a different focus.

Note: As of February 2020, I am only adding "unevaluated links" to the bottom of this page. Someday I will get around to re-organizing this list.

Anthology 1 candidates

• Introduction
  • Understanding Over Guesswork
  • An Alternative Introduction to Rust
  • Learning Rust
    • Rust Basics
    • Rust: Beyond the Basics
    • Rust: The Tough Part
  • Rust and CSV Parsing
  • Rust for Functional Programmers
  • Graydon's Lists
    • Five Lists of Six Things About Rust
    • Things Rust Shipped Without
• Experience Reports
  • My Experience Writing Enjarify in Rust
  • Rust: A Scala Engineer's Perspective
  • Giving up on wlroots-rs
• Ownership
  • Where Rust Really Shines
  • Rust Means Never Having to Close a Socket
  • The Problem with Single-threaded Shared Mutability
  • Rust Ownership the Hard Way
  • Strategies for Solving "cannot move out of" Borrowing Errors
  • Interior Mutability In Rust
    • Interior mutability in Rust: what, why, how?
    • Interior mutability in Rust, part 2: thread safety
    • Interior mutability in Rust, part 3: behind the curtain
  • & vs. ref in Patterns
  • Holy std::borrow::Cow
    • Holy std::borrow::Cow!
    • Holy std::borrow::Cow Redux!
  • Graphical Depiction of Ownership and Borrowing in Rust
  • Wrapper Types in Rust: Choosing Your Guarantees
• Traits
  • Abstraction Without Overhead
  • Going Down the Rabbit Hole with Rust Traits
  • Huon's Trait Object Quadrilogy (All About Trait Objects)
    • Peeking Inside Trait Objects
    • The Sized Trait
    • Object Safety
    • Where Self meets Sized: Revisiting Object Safety
  • Rust Traits for Developer Friendly Libraries
• The Rust Language
  • The Many Kinds of Code Reuse in Rust
  • Mixing Matching, Mutations and Moves
  • What are Sum, Product, and Pi types?
  • Reading Rust Function Signatures
  • Finding Closure in Rust
  • Rust's Built-in Traits, the When, How & Why
  • Myths and Legends About Integer Overflow in Rust
• Iterators
  • Effectively Using Iterators in Rust
  • A Journey Into Iterators
  • for loops in Rust
  • Little tour of multiple iterators implementation in Rust
• Concurrency and Parallelism
  • Fearless Concurrency with Rust
  • How Rust Achieves Thread Safety
  • Defaulting to Thread-safety: Closures and Concurrency
  • Some Notes on Send and Sync
  • Niko's Rayon Quadrilogy
    • Rayon: Data Parallelism in Rust
    • Parallel Iterators in Rust Part 1: Foundations
    • Parallel Iterators in Rust Part 2: Producers
    • Parallel Iterators in Rust Part 3: Consumers
  • Parallelizing Enjarify in Go and Rust
  • Lock-freedom Without Garbage Collection
  • A Rusty Tale of Shared Memories and Passed Messages
    • Part 1
    • Part 2
  • Must Be This Tall to Write Multithreaded Code
• Rust in Practice
  • Rust Error Handling
  • Why your first FizzBuzz implementation may not work
  • Herman Radtke's String Trilogy
    • String vs. &str in Rust Functions
    • Creating a Rust Function That Accepts String or &str
    • Creating a Rust Function That Returns String or &str
  • Gankro's Collections Trilogy
    • Rust, Lifetimes, and Collections
    • Rust, Generics, and Collections
    • Rust Collections Case Study: BTreeMap
  • Learning Rust with Entirely Too Many Linked Lists
  • Working With C Unions in Rust FFI
  • Quick tip: the #[cfg_attr] attribute
  • Using the Option Type Effectively
    • Part 1
    • Part 2
  • ripgrep code review
  • gnome-class: Integrating Rust and the GNOME object system
  • Exploring Rust's standard library: system calls and errors
  • I used to use pointers. Now what?
  • Starting a New Rust Project Right, with error-chain
  • Bugs You'll Probably Only Have in Rust
  • Using and_then and map combinators on the Rust Result Type
  • Mapping Over Arrays
  • From &str to Cow
• Idioms
  • Elegant Library APIs in Rust
  • Where Are You From::from?
  • Rustic Bits
  • Convenient and Idiomatic Conversions in Rust
  • Pretty State Machine Patterns
• Macros
  • A Practical Introduction to Rust Macros
  • Macros In Rust
    • Part 1
    • Part 2
    • Part 3
    • Part 4
  • Creating an enum iterator using Macros 1.1
  • An Overview of Macros in Rust
• Unsafe Rust
  • Unsafe Rust: An Intro and Open Questions
  • What Does Rust's unsafe Mean?
  • Memory Leaks are Memory Safe
  • On Reference Counting and Leaks
  • A Few More Remarks on Reference Counting and Leaks
  • Pre-pooping Your Pants With Rust
  • Niko's Unsafe Abstractions Series
    • Unsafe Abstractions
    • The "Tootsie Pop" Model for Unsafe Code
    • "Tootsie Pop" Followup
    • Thoughts on Trusting Types in Unsafe Code
    • Observational Equivalence and Unsafe Code
    • Assigning Blame to Unsafe Code
    • Unsafe Code and Shared References
  • How MutexGuard was Sync When It Should Not Have Been
  • The Scope of Unsafe
• Async I/O
  • Getting Acquainted with mio
  • My Basic Understanding of mio and Async I/O
  • Creating a Simple Protocol With mio
  • Managing Connection State With mio
  • Zero-cost Futures in Rust
  • Designing Futures for Rust
  • Asynchronous Rust for Fun and Profit
  • Understanding the Tokio Reactor Core
• Web Programming
  • Touring a Fast, Safe, and Complete(ish) Web Service in Rust
  • Making a 100% Statically-Linked, Single-File Web App with React and Rust
• Performance
  • Benchmarking In Rust
  • Profiling Rust Applications on Linux
  • Does Your Code Leave a Trail of Slowness?
  • Rust Faster!
  • Rust Performance: A story featuring perf and flamegraph on Linux
  • Zero-cost abstractions
  • ripgrep is faster than {grep, ag, git grep, ucg, pt, sift}
  • Rust Performance Pitfalls
  • Optimizing Rc Memory Usage in Rust
  • Why Is A Rust Executable Large?
  • Building Tiny Rust Binaries for Embedded Linux
• Systems Programming
  • Making Terminal Applications in Rust with Termion
  • Rust + Nix = Easier Unix Systems Programming
• Embedded Programming
  • Japaric's RTFM Series
    • Rust your ARM Microcontroller!
    • Fearless Concurrency in Your Microcontroller
    • Overhead Analysis of the RTFM Framework
    • The ITM and the Quest for Faster Logging
    • A CPU Monitor for the RTFM Framework
  • Writing A Driver in Rust Using Embedded-Hal Traits for the RN4870 BLE Module
• WASM
  • Making WebAssembly better for Rust and all languages
• The Rust Toolbox
  • Travis on the Train
    • Helping Travis Catch the rustc Train
    • Travis on the Train, Part 2
  • Rust, Travis and GitHub Pages
  • Fuzzing is Magic
  • Rust Code Coverage Guide: kcov + Travis CI + Codecov / Coveralls
• Typesystem Trickery
  • Type-level Shenanigans
    • Type-level Shenanigans
    • More Type-level Shenanigans
  • Rust's Type System is Turing-Complete
• Internals
  • Four Years With Rust
  • Optimizing Rust Struct Size: A 6-month Compiler Development Project
  • Rust Tidbits: What Is a Lang Item?
  • Reflections on Rusting Trust
  • How Rust is tested
• Culture
  • Stability as a Deliverable
  • The Not Rocket Science Rule of Software Engineering
  • Rust Discovery, or: How I Figure Things Out
  • RIIR
    • Rewrite Everything In Rust
    • Have You Considered Rewriting it In Rust?
    • Why You Should, Actually, Rewrite it in Rust
    • How to Rewrite Your Project in Rust
  • Making Your Open Source Project Newcomer Friendly
  • The Minimally-nice Open Source Software Maintainer
  • Fireflowers
    • Rust is More than Safety
    • Rust is Mostly Safety
    • Safety is Rust's Fireflower
    • Fire Mario, Not Fire Flowers
    • Fire Flowers and Marios
    • Rust is About Productivity
    • Rust is Its Community
    • My Thoughts on Rust in 2017
    • Rust is Software's Salvation
    • Rust is My Magic Whistle
    • Rust is Something Old Made New
    • Rust is Needed Now More than Ever
    • Rust is About Boldness
    • Rust is About Better Citizenship
    • Rust Marketing Pitch
• Uncategorized Chapters
  • Let’s Stop Ascribing Meaning to Code Points
    • Let’s Stop Ascribing Meaning to Code Points
    • Breaking Our Latin-1 Assumptions
  • It's Time for a Memory Safety Intervention
  • Rust Makes Invariants Explicit
  • Why Type Systems Matter
  • Building a Microservice in Rust
  • 100 Days of Rust, or, A Series of Brick Walls
  • Exploring 4 Languages: Integrity and Consistency
  • Cutting Corners vs. Productivity

Cheat Sheets

• Periodic Table of Rust Types
• Rust String Conversions Cheat Sheet
• Rust Iterator Cheat Sheet
• Rust Container Cheet Sheet
• Rust API Guidelines

Examples and Exercises

• Rust By Example
• rustlings
• exercism.io
• Rust Cookbook

Additional Long-Form Reading

• The Little Book of Rust Books
• The Rust Book (2nd Edition)
• The Rust Book (1st Edition)
• The Unstable Book
• The Rustonomicon
• The Rust Reference
• Writing an OS in Rust
• Rust 101
• The Little Book of Rust Macros
• The Rust FFI Omnibus
• Discovery: Discover the World of Microcontrollers Through Rust
• Roguelike Tutorial in Rust + tcod
• Learning Rust
• Unsafe Code Guidelines
• Rust in Easy English

Completely Unevaluated Links

• https://dtolnay.github.io/rust-quiz/18
• https://github.com/dtolnay/semver-trick
• https://medium.com/@edwardpku/being-an-intermediate-rust-programmer-in-one-day-37283bb1b0b0?from=timeline&isappinstalled=0
• https://blog.rust-lang.org/2018/12/21/Procedural-Macros-in-Rust-2018.html
• https://rust-lang-nursery.github.io/api-guidelines/documentation.html#documentation
• https://rust-random.github.io/book/
• https://stjepang.github.io/2019/01/29/lock-free-rust-crossbeam-in-2019.html
• https://limpet.net/mbrubeck/2019/02/07/rust-a-unique-perspective.html
• https://doc.rust-lang.org/nomicon/aliasing.html
• https://manishearth.github.io/blog/2015/05/17/the-problem-with-shared-mutability/
• https://www.rust-lang.org/production
• https://www.reddit.com/r/rust/comments/aohq6u/rust_velocity_and_defect_rates/eg189gu/
• https://rufflewind.com/2017-02-15/rust-move-copy-borrow
• https://blog.adamant-lang.org/2019/rust-lifetime-visualization-ideas/
• http://pling.jondgoodwin.com/post/lifetimes/
• rust-lang-nursery/rust-cookbook#502 (comment)
• https://smallcultfollowing.com/babysteps/blog/2012/11/18/imagine-never-hearing-the-phrase-aliasable/
• https://manishearth.github.io/blog/2017/03/18/inhtpinhtpamaa/
• https://areweasyncyet.rs/ - contains async blog posts
• https://medium.com/@richardanaya/a-journey-through-rust-lifetimes-5a08782c7091
• https://gill.net.in/posts/auth-microservice-rust-actix-web1.0-diesel-complete-tutorial/
• https://medium.com/@ly.lee/hosting-embedded-rust-apps-on-apache-mynewt-with-stm32-blue-pill-c86b119fe5f?sk=f58f4cf6c608fded4b354063e474a93b
• http://thume.ca/2019/04/29/comparing-compilers-in-rust-haskell-c-and-python/
  • https://news.ycombinator.com/item?id=20192645
• http://patshaughnessy.net/2018/3/15/how-rust-implements-tagged-unions
• https://raphaelgomes.dev/blog/articles/2019-07-01-sharing-references-between-python-and-rust.html
• https://dev.to/sendilkumarn/increase-rust-and-webassembly-performance-382h
• https://medium.com/dwelo-r-d/we-rewrote-our-iot-platform-in-rust-and-got-away-with-it-2c8867c61b67
• https://www.ncameron.org/blog/migrating-a-crate-from-futures-0-1-to-0-3/
• https://raphlinus.github.io/rust/2019/08/21/rust-bloat.html
• https://tmandry.gitlab.io/blog/posts/optimizing-await-1/
• https://tmandry.gitlab.io/blog/posts/optimizing-await-2/
• https://aturon.github.io/tech/2018/04/24/async-borrowing/
• https://rust-lang.github.io/async-book/
• https://cheats.rs/
• https://hsivonen.fi/string-length/
• https://github.com/ferrous-systems/elements-of-rust/
• https://arxiv.org/pdf/1902.01906.pdf
• http://blog.pnkfx.org/blog/2019/11/18/rust-bug-minimization-patterns/
• https://docs.rs/dtolnay/*/dtolnay/macro._03__soundness_bugs.html
• https://blog.dbrgn.ch/2019/12/24/testing-for-no-std-compatibility/
• http://cliffle.com/blog/m4vga-in-rust/
• https://stevedonovan.github.io/rustifications/2018/08/18/rust-closures-are-hard.html
• https://stackoverflow.blog/2020/01/20/what-is-rust-and-why-is-it-so-popular/
• https://gregoryszorc.com/blog/2020/01/13/mercurial%27s-journey-to-and-reflections-on-python-3/
• http://cliffle.com/p/dangerust/
• http://dtrace.org/blogs/bmc/2018/09/28/the-relative-performance-of-c-and-rust/
• https://pitdicker.github.io/Interior-mutability-patterns/
• https://medium.com/tadaweb/security-by-design-a-brief-introduction-to-rust-378060e45038
• https://jitter.company/blog/2020/01/28/measuring-space-time-behaviours-of-piano-keys-with-rust/
• https://blog.discordapp.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f
• https://matklad.github.io/2020/02/14/why-rust-is-loved.html
• https://fasterthanli.me/blog/2020/i-want-off-mr-golangs-wild-ride/
• https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/
• https://lucumr.pocoo.org/2020/1/1/async-pressure/
• https://www.pietroalbini.org/blog/shipping-a-compiler-every-six-weeks/
• https://oribenshir.github.io/afternoon_rusting/blog/copy-on-write
• https://os.phil-opp.com/async-await/
• https://jason-williams.co.uk/a-possible-new-backend-for-rust
• https://blog.logrocket.com/how-to-write-crap-rust-code/
• https://ferrous-systems.com/blog/zero-sized-references/
• https://msrc-blog.microsoft.com/2020/04/29/the-safety-boat-kubernetes-and-rust/
• https://richardanaya.github.io/tour_of_rust/
• https://fnordig.de/2020/05/02/rust-in-an-instant/
• https://ferrous-systems.com/blog/stable-async-on-embedded/
• http://kvark.github.io/web/gpu/native/2020/05/03/point-of-webgpu-native.html
• https://nikic.github.io/2020/05/10/Make-LLVM-fast-again.html
• https://medium.com/@polyglot_factotum/rust-concurrency-the-single-writer-principle-applied-aada2cdc6fb0
• https://github.com/pretzelhammer/rust-blog/blob/master/posts/learning-rust-in-2020.md
• https://nickwilcox.github.io/blog/autovec/
• https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md
• http://dtrace.org/blogs/bmc/2020/10/11/rust-after-the-honeymoon/
• https://blog.darklang.com/why-dark-didnt-choose-rust/
• https://foundation.rust-lang.org/posts/2021-02-08-hello-world/
• https://manishearth.github.io/blog/2021/02/22/integrating-rust-and-c-plus-plus-in-firefox/
• https://cacm.acm.org/magazines/2021/4/251364-safe-systems-programming-in-rust/fulltext
• Rust verification tools 2021
• Using unwrap() in Rust is okay
• A Guide to Error Handling in Rust
• Accidentally Quadratic: Rust hash iteration+reinsertion