A collection of notable Rust blog posts

all-the-rust-blogs.md

• Introduction
  • Understanding Over Guesswork
  • An Alternative Introduction to Rust
  • Rust and CSV Parsing
• 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
• Concurrency
  • 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 Parallism 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
• Traits
  • Abstraction Without Overhead
  • Going Down the Rabbit Hole with Rust Traits
  • Huon's Trait Object Quadrilogy
    • Peeking Inside Trait Objects
    • The Sized Trait
    • Object Safety
    • Where Self meets Sized: Revisiting Object Safety
  • Rust's Built-in Traits, the When, How & Why
  • Rust Traits for Developer Friendly Libraries
• 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
• The Rust Language
  • Finding Closure in Rust
  • Mixing Matching, Mutations and Moves
  • Reading Rust Function Signatures
  • Myths and Legends About Integer Overflow in Rust
  • Effectively Using Iterators in Rust
  • A Journey Into Iterators
• 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
• Rust in Practice
  • The Many Kinds of Code Reuse in Rust
  • 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
  • Rust + Nix = Easier Unix Systems Programming
  • ripgrep code review
  • Elegant Library APIs in Rust
  • gnome-class: Integrating Rust and the GNOME object system
  • Making Terminal Applications in Rust with Termion
  • Exploring Rust's standard library: system calls and errors
  • Starting a New Rust Project Right, with error-chain
• 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
• 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
• 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
• Internals
  • Optimizing Rust Struct Size: A 6-month Compiler Development Project
  • Rust Tidbits: What Is a Lang Item?
  • Reflections on Rusting Trust
• Culture
  • Stability as a Deliverable
  • The Not Rocket Science Rule of Software Engineering
  • RIIR
    • Rewrite Everything In Rust
    • Have You Considered Rewriting it In Rust?
  • Making Your Open Source Project Newcomer Friendly
  • Rust Discovery, or: How I Figure Things Out
  • 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
• Cheat Sheets
  • Periodic Table of Rust Types
  • Rust String Conversions Cheat Sheet
  • Rust Iterator Cheat Sheet
  • Rust Container Cheet Sheet
• Additional Reading
  • The Book
  • The Nomicon
  • Rust By Example
  • Writing an OS in Rust
  • Rust 101
  • rustlings
  • The Little Book of Rust Macros
  • The Rust FFI Omnibus
• Uncategorized Chapters
  • Why Is A Rust Executable Large?
  • Where Are You From::from?
  • Type-level Shenanigans
    • Type-level Shenanigans
    • More Type-level Shenanigans
  • Rustic Bits
  • Mapping Over Arrays
  • Rust for Functional Programmers
  • From &str to Cow
  • Graydon's Lists
    • Five Lists of Six Things About Rust
    • Things Rust Shipped Without
  • for loops in Rust
  • Convenient and Idiomatic Conversions in Rust
  • Using and_then and map combinators on the Rust Result Type
  • I used to use pointers. Now what?
  • Let’s Stop Ascribing Meaning to Code Points
    • Let’s Stop Ascribing Meaning to Code Points
    • Breaking Our Latin-1 Assumptions
  • What are Sum, Product, and Pi types?
  • Rust your ARM microcontroller!
  • It's Time for a Memory Safety Intervention
  • Bugs You'll Probably Only Have in Rust
  • Four Years With Rust
  • My Experience Writing Enjarify in Rust
  • Rust's Type System is Turing-Complete
  • Rust Makes Invariants Explicit
  • Rust: A Scala Engineer's Perspective