Rust Async Programming with Tokio: Getting Started
Learn async Rust with Tokio from scratch. Covers async/await syntax, spawning tasks, channels, TCP servers, and common pitfalls with working examples.
·8 min read · #rust#async#tokio
#rust
53 posts · page 1 of 2
Rust Concurrency: Channels, Mutex, and Arc Patterns
Learn Rust concurrency with channels, Mutex, Arc, and thread-safe patterns. Covers mpsc, shared state, thread pools, and real-world examples.
·9 min read · #rust#concurrency#channels
Rust Error Handling with anyhow and thiserror
Master Rust error handling with anyhow for applications and thiserror for libraries. Practical patterns, conversions, and context-rich error reporting.
·8 min read · #rust#error-handling#anyhow
Rust Iterators and Closures: Functional Programming
Master Rust iterators and closures for functional-style programming. Covers map, filter, fold, chaining, custom iterators, and Fn trait family.
·10 min read · #rust#iterators#closures
Rust Lifetimes Explained Simply with Examples
Learn Rust lifetimes from scratch with clear visual examples, common patterns, and practical rules that make lifetime annotations easy to understand.
·9 min read · #rust#lifetimes#borrowing
Rust macro_rules!: Write Your Own Macros
Learn to write Rust declarative macros with macro_rules!. Covers syntax, fragment specifiers, repetitions, hygiene, and practical macro patterns.
·9 min read · #rust#macros#macro-rules
Rust Pattern Matching: Advanced Techniques and Guards
Go beyond basic match with pattern guards, bindings, nested patterns, or-patterns, and real-world refactoring strategies in Rust.
·10 min read · #rust#pattern-matching#enums
Understanding Rust Smart Pointers: Box, Rc, and Arc
A hands-on guide to Rust smart pointers covering heap allocation with Box, shared ownership with Rc, and thread-safe sharing with Arc.
·7 min read · #rust#smart-pointers#box
Trait Objects vs Generics in Rust: A Decision Guide
Understand the trade-offs between dynamic dispatch with trait objects and static dispatch with generics in Rust through real-world examples.
·7 min read · #rust#traits#generics
Tokio vs async-std: Choosing a Rust Async Runtime
A practical comparison of Tokio and async-std covering performance, ecosystem, API design, and migration considerations for async Rust projects.
·6 min read · #rust#async#tokio
Rust Async Runtime Internals: How It Works Under the Hood
Explore how Rust async runtimes work internally, including futures, wakers, executors, and the reactor pattern that powers async I/O.
·7 min read · #rust#async#runtime
Rust Closures and Fn Traits Explained
Master Rust closures, understand Fn, FnMut, and FnOnce traits, learn how closures capture variables, and use closures effectively in your code.
·7 min read · #rust#closures#fn-traits
Rust Error Handling with thiserror and anyhow
Learn practical Rust error handling using thiserror for library errors and anyhow for application errors, with real-world patterns and examples.
·6 min read · #rust#error-handling#thiserror
Rust Interior Mutability: Cell and RefCell
Understand Rust's interior mutability pattern using Cell and RefCell, when to use each, and how they let you mutate data behind shared references.
·6 min read · #rust#interior-mutability#cell
Rust macro_rules! Practical Guide
Master Rust's macro_rules! with practical examples covering syntax matching, repetition, common patterns, and debugging tips for declarative macros.
·6 min read · #rust#macros#metaprogramming
Rust Pin and Unpin Explained: Why They Exist
Understand Pin, Unpin, and self-referential types in Rust. Learn why Pin exists, when you need it, and how to work with pinned data safely.
·6 min read · #rust#pin#async
Rust Serde Serialization and Deserialization Guide
Master Serde in Rust with practical patterns for JSON, custom serialization, field renaming, enums, and error handling in real-world projects.
·5 min read · #rust#serde#serialization
Rust Smart Pointers: Box, Rc, and Arc Compared
Learn when and how to use Box, Rc, and Arc smart pointers in Rust with practical examples covering heap allocation, shared ownership, and thread safety.
·6 min read · #rust#smart-pointers#memory-management
Rust Unsafe Code Guidelines: When and How to Use unsafe
Learn when unsafe Rust is justified, what the five unsafe superpowers are, and how to write unsafe code that maintains Rust's safety guarantees.
·6 min read · #rust#unsafe#ffi
Async/Await in Rust
Learn async Rust — futures, async/await syntax, the tokio runtime, spawning tasks, channels, and common async patterns.
·4 min read · #rust#async#advanced
Error Handling with Result and Option in Rust
Handle errors idiomatically in Rust — Result, Option, the ? operator, custom error types, and the thiserror/anyhow ecosystem.
·4 min read · #rust#error-handling#intermediate
Rust Ownership and Borrowing Explained
Understand Rust's ownership model — move semantics, borrowing, references, lifetimes, and why the borrow checker exists.
·5 min read · #rust#ownership#beginners
Pattern Matching in Rust
Master Rust's pattern matching — match expressions, if let, while let, destructuring, guards, and patterns in function parameters.
·4 min read · #rust#patterns#intermediate
Traits and Generics in Rust
Master Rust traits and generics — defining traits, trait bounds, default methods, trait objects, and generic data structures.
·4 min read · #rust#traits#intermediate
Rust Actix vs Axum Comparison
A side-by-side comparison of Actix Web and Axum, covering architecture, ergonomics, performance, ecosystem, and how to pick the right one for your project.
·4 min read · #rust#actix#axum
Rust async/await and Futures Explained
How Rust's async/await desugars into a state machine, what a Future actually is, and the runtime model that makes it efficient on real workloads.
·4 min read · #rust#async#futures
Rust Axum Web Framework Tutorial
A practical introduction to building HTTP services in Rust using the Axum web framework, with routing, extractors, state, and JSON handling.
·4 min read · #rust#axum#web
Rust Builder Pattern Explained
Learn the builder pattern in Rust, why it fits the language so well, and how to use it for ergonomic, type-safe configuration of complex structs.
·4 min read · #rust#builder#design-patterns
Rust Cargo Workspaces Tutorial
Organize multi-crate Rust projects with Cargo workspaces: shared dependencies, internal crates, build performance tips, and publishing workflows.
·4 min read · #rust#cargo#workspaces
Rust Channels and mpsc Tutorial
A practical tour of Rust's std::sync::mpsc channels: senders, receivers, backpressure, and patterns for safe message passing between threads.
·4 min read · #rust#concurrency#mpsc
Rust Deref and AsRef Explained
Demystify Rust's Deref, DerefMut, and AsRef traits with clear examples showing how smart pointers, coercions, and flexible APIs really work.
·5 min read · #rust#traits#deref
Rust Clippy and Fmt Tutorial
How to use Clippy and rustfmt effectively in Rust projects, including configuration, CI integration, and tips to make linting friction-free.
·4 min read · #rust#clippy#rustfmt
Rust Error Conversion With From
How Rust's From trait powers the question-mark operator and lets you compose error types cleanly across libraries, applications, and async code.
·4 min read · #rust#errors#from
Rust Error Handling with Result
How idiomatic Rust handles errors with Result and the ? operator: propagation, conversion, custom error types, and when to use anyhow or thiserror.
·5 min read · #rust#result#error-handling
Rust Lifetimes Deep Dive
Lifetimes are how Rust tracks how long references live. This deep dive covers annotations, elision rules, generic lifetimes, and the common error patterns.
·6 min read · #rust#lifetimes#references
Rust Iterators and Adapters
Master Rust's iterator trait, lazy adapters like map and filter, and consumers like collect and fold for fast, expressive data processing.
·3 min read · #rust#iterators#adapters
Rust Modules and Visibility Explained
Understand how Rust organizes code with modules, files, and the pub keyword, plus the visibility rules that keep crates clean and maintainable.
·5 min read · #rust#modules#visibility
Rust Ownership and Borrowing Explained
A practical introduction to Rust's ownership and borrowing rules: moves, references, mutability, and the mental model that makes the borrow checker stop fighting you.
·6 min read · #rust#ownership#borrowing
Rust Macros: Declarative vs Procedural
A practical comparison of declarative macro_rules! and procedural macros in Rust, including derive, function-like, and attribute macros with examples.
·4 min read · #rust#macros#metaprogramming
Rust Pattern Matching Tutorial
Use Rust's match expression, if-let, while-let, and pattern syntax to destructure data safely with exhaustive compile-time checking.
·4 min read · #rust#pattern-matching#match
Rust Serde Tutorial
A complete guide to Serde, Rust's de facto serialization framework, covering derive macros, attributes, custom types, and common JSON patterns.
·4 min read · #rust#serde#json
Rust Tokio Runtime Explained
How Tokio schedules tasks, manages workers, and integrates with the OS to power asynchronous Rust programs efficiently across cores.
·4 min read · #rust#tokio#async
Rust Traits vs Interfaces
Rust traits look like interfaces from other languages, but the differences matter: associated types, blanket impls, coherence, and dynamic dispatch all behave their own way.
·5 min read · #rust#traits#polymorphism
Cargo Basics: Building, Testing, and Publishing Rust Code
A practical tour of Cargo — creating projects, managing dependencies and features, running tests, building release binaries, and using workspaces.
·6 min read · #rust#cargo#intermediate
Rust Collections: Vec, HashMap, and HashSet
A hands-on tour of Rust's core collections — Vec, HashMap, and HashSet — with common operations, iteration patterns, and ownership gotchas.
·6 min read · #rust#collections#intermediate
Rust Error Handling with Result and the ? Operator
A practical guide to error handling in Rust covering Result, the ? operator, unwrap and expect, custom error types, and the thiserror and anyhow crates.
·5 min read · #rust#error-handling#intermediate
Rust Structs and Enums: Modeling Data Safely
Learn how to model domain data in Rust with structs and enums, use pattern matching exhaustively, and lean on Option and Result for safety.
·5 min read · #rust#structs-enums#intermediate
Rust Traits: Shared Behavior Without Inheritance
Understand how Rust traits define shared behavior, with default methods, trait bounds, derive, and a clear take on dyn Trait versus impl Trait.
·6 min read · #rust#traits#intermediate