Tutorials

Rust + Axum Async Microservice Guide: Job Queue, Retries, and Graceful Shutdown

Build a production-ready async microservice with Rust and Axum: job queue, background workers, exponential backoff retries, and graceful shutdown. Includes full project structure and Docker example.

Complete implementation and best practices for Rust Axum graceful shutdown

Rust Axum Graceful Shutdown, The Ultimate Guide: Fix the pitfall 99% of engineers hit

Master graceful shutdown for Rust Axum services: listen for SIGINT/SIGTERM, refuse new connections with with_graceful_shutdown, stop background tasks via CancellationToken, set timeouts, and integrate with Docker/Kubernetes termination — protect data integrity and user experience.

Build a high‑performance Web server with Rust and Axum

Rust + Axum, from zero to hero: build a high‑performance Web server the LEGO way

A step‑by‑step Axum guide to build a modern high‑performance Web service: routing, path and query parameters, JSON, shared state, and middleware (tracing, CORS) with complete code samples and best practices.

Rust unsafe isn’t a toy — it’s a blood oath: 6 YOLO mistakes that will blow up your code

Don’t treat unsafe like a get-out-of-jail-free card. With practical examples, this article dissects 6 common unsafe pitfalls: silencing the compiler with duct tape, dereferencing random raw pointers, violating borrow rules inside unsafe, reinventing wheels, abusing unsafe impl, and skipping Safety comments — helping you build the right risk mindset and usage patterns.

The difference between Tokio tasks and OS threads

Stop treating tokio::spawn as a thread! I launched 1000 tasks in 2 seconds and the system stayed calm

tokio::spawn is not a thread but a lightweight task. Under Tokio’s scheduler you build highly concurrent services with sleep, timeout and select — 1000 tasks in 2 seconds with negligible overhead.

Rust async is compiled into a state machine and driven by Future, poll, and Waker

Rust Async State Machine, Unmasked: How Future, poll, and Waker Really Work

A practical deep dive into Rust async: why calling an async function doesn’t run it, how the compiler turns async into a state machine, and how executors drive tasks forward with poll and Waker. Understand the real mechanics behind async/await.

Rust 1.89: Intel Mac demotion and compiler improvements

Rust 1.89: Intel Macs demoted to Tier 2, clearer lifetimes, and new x86 intrinsics

Rust 1.89 demotes x86_64-apple-darwin (Intel Mac) from Tier 1 to Tier 2, adds the mismatched_lifetime_syntaxes lint, constant generics ‘_’ inference, and a wave of new x86 intrinsics.

Rust Cluster Commands: Managing Distributed Systems Like Conducting an Orchestra

Learn how to implement cluster-level control commands in Rust distributed actor systems, making node management as elegant as conducting a symphony

When Your Actor Cluster Grows Up, It Needs Sharding

How do you manage 100,000 Actors across 10 machines? Let’s talk about consistent hashing

Why Rust Makes C++ Programmers Lose Sleep at Night: Lessons from My Migration Journey

A C++ developer with 5 years of experience shares real insights from switching to Rust. From memory safety to concurrency, these 10 features completely changed my perspective on systems programming