The log
Writing
Articles on Rust for Mastering Backend — memory, traits, concurrency and the systems underneath.
- Articles on Mastering Backend
- 30
- Reader likes
- 4300+
- Topics covered
- 7
Index · 31 articles
- Rust From and Into Traits: How Type Conversion Works Rust's From and Into traits are the standard way to convert one type into another. Traits & Types Mastering Backend
- Rust Slices: How to Borrow Part of an Array, Vec, or String A Rust slice is a borrowed view into a run of contiguous memory: a pointer plus a length, and no ownership. MemoryCollections Mastering Backend
- Atomic Primitives in Rust: You don't need a mutex Lock-free shared state with Rust’s atomic primitives, and when you don’t need a mutex at all. Concurrency Mastering Backend
- The Rust Advantage: Building Bulletproof Systems When AI Writes Half Your Code Welcome to the age of AI-assisted development, where the question isn't whether machines can write code (they can), but whether they can write code that won't bite you later. Systems & AI Mastering Backend
- What Is a Weak Pointer in Rust (and Why It Matters)? If you've been wrestling with Rust's ownership system and wondering why sometimes you can't just point things at each other, you're in the right place. Memory Mastering Backend
- Collections in Rust: The Essentials The collections you’ll use most in Rust, and the essentials of using them well. Collections Mastering Backend
- Python Devs Beware: The % Operator Lies in Rust In this article, we’ll explore the differences, why Rust does it the way it does, and the correct way to get a true modulo in Rust while preserving signs. Fundamentals Mastering Backend
- Rust Doesn’t Need a Garbage Collector — Here’s Why If you're coming from a language like Python or JavaScript, you're used to not worrying about memory. Memory Mastering Backend
- Declarative Macros in Rust: Are They Just Elegant Match Arms? Today, we're diving into one of Rust's most powerful and sometimes intimidating features: declarative macros. Macros & Compiler Mastering Backend
- Rust Extension Traits in 5 Minutes Adding methods to types you don’t own with extension traits, and why Rust’s coherence rules make them necessary. Traits & Types Mastering Backend
- Ensuring Trait Constants Are Validated at Compile Time You've probably written trait constants before, but have you ever needed to validate them? Traits & TypesMacros & Compiler Mastering Backend
- Looping Through Enum Variants in Rust Using strum Rust enums are incredibly powerful for modeling data, but newcomers quickly discover a frustrating limitation: you cannot iterate through enum variants natively. Traits & Types Mastering Backend
- Understanding the as Keyword in Rust: Type Casting, Renaming, and Trait Disambiguation The as keyword in Rust serves three critical purposes that every developer should master. FundamentalsTraits & Types Mastering Backend
- How Rust Knows When You're Not Using a Variable: The _ Prefix Trick In Rust, aside from variables and struct fields, you can also bind memory to patterns. FundamentalsMacros & Compiler Mastering Backend
- Sized & ?Sized: A Beginner's Guide Understanding Sized unlocks deeper comprehension of why Rust behaves the way it does with generics, function parameters, and memory management. Traits & TypesMemory Mastering Backend
- Understanding Cow<T>: Clone on Write How Cow<T> works, how to use it in structs and functions, and the trade-offs and pitfalls to avoid. Memory Mastering Backend
- Rust Send and Sync in Simple Terms What Send and Sync actually mean, and how to read the compiler errors that mention them. ConcurrencyTraits & Types Mastering Backend
- How to Use the Default Trait in Rust When working with structs or enums in Rust, we often need a way to create a "standard" or "initial" instance without specifying all the fields every time. Traits & Types Mastering Backend
- Pattern Matching with the matches! Macro Concise boolean checks against a pattern with the matches! macro. Macros & CompilerFundamentals Mastering Backend
- Rust Error Handling: 80 / 20 Guide The small part of Rust’s error-handling system that covers most real-world code. Fundamentals Mastering Backend
- Understanding Lifetime Elision in Rust This topic builds directly on the concept of lifetimes, so if you're not familiar with them, it’s worth reviewing the fundamentals before diving deeper. Memory Mastering Backend
- Why Rust Is the Most Readable Language Ever tried contributing to an open-source project or even worked on a large code base with neck-breaking documentation? Fundamentals Mastering Backend
- Setting Up a Rust Development Environment Getting a Rust toolchain in place with rustup, cargo and clippy. Fundamentals Mastering Backend
- Building a Validator System in Rust In this article, we'll explore how to build a type-safe and flexible validator system in Rust, taking cues from DRF's elegant design. Systems & AITraits & Types Mastering Backend
- Are Async Blocks Dead? Introducing Async Closures (Rust 1.85) Rust 1.85 shipped async closures. What they are, and whether async blocks still earn their place. Concurrency Mastering Backend
- 3 Powerful Features in Rust's Reqwest Library Three powerful features in reqwest: JSON handling, multipart forms and streaming. Systems & AI Mastering Backend
- Building a Simple RAG System Application with Rust Building a chatbot that queries documents on your local machine, using Gemini for embeddings. Systems & AI Mastering Backend
- Asynchronous Recursion in Rust Why recursive async functions are harder in Rust than in Python or JavaScript, and how to write them. Concurrency Mastering Backend
- When to Use Arrays and Vectors in Rust Fixed-size arrays or growable vectors: when to reach for each in Rust. Collections Mastering Backend
- #[cfg]: Conditional Compilation in Rust Targeting each operating system with #[cfg] and conditional compilation. Macros & Compiler Mastering Backend
- Understanding Rust's Ownership Model A practical walkthrough of how Rust's ownership and borrowing work — and why they matter for writing safe, concurrent systems. MemoryFundamentals This site