In the previous tutorial, we learned modules and project organization. Now we learn testing – one of Rust’s best features. Rust has testing built into the language and toolchain. You do not need to install a separate testing framework. Write #[test], run cargo test, and you are done. The compiler and test runner handle everything. Good tests give you confidence to refactor code, add features, and fix bugs without breaking existing functionality. ...
In the previous tutorial, we learned Rust collections. As projects grow, putting everything in one file becomes unmanageable. In this tutorial, we learn modules – Rust’s system for organizing code into logical units. Good project structure makes code easier to read, test, and maintain. Rust’s module system is simple once you understand the rules. Let us learn them step by step. What is a Module? A module is a named container for functions, structs, enums, and other items. Modules control: ...
In the previous tutorial, we learned threads, channels, and Mutex for concurrency. Now we learn async/await – a different way to handle concurrent work. Threads are good when you have CPU-heavy tasks. But many programs spend most of their time waiting – for network responses, file reads, or database queries. Creating one thread per request wastes memory. Async programming solves this problem. It lets one thread handle thousands of waiting tasks. ...
In the previous tutorial, we learned async programming with Tokio. Now we dive deeper into channels — the primary way async tasks communicate with each other. Channels let tasks send and receive messages without sharing memory directly. This is the “message passing” model of concurrency. Instead of locking shared data with a Mutex, you send data through a channel. The task that receives it owns it completely. Tokio provides four channel types. Each one solves a different problem. By the end of this tutorial, you will know when to use each one. ...
In the previous tutorial, we learned smart pointers. Now we learn concurrency — running code on multiple threads at the same time. Concurrency is hard in most languages. Data races, deadlocks, and race conditions cause bugs that only show up in production. Rust prevents most of these bugs at compile time. The ownership system guarantees that you cannot share data unsafely between threads. This is called fearless concurrency. The compiler catches mistakes before your code runs. ...
In the previous tutorial, we learned closures and iterators. Now we learn smart pointers — types that act like pointers but have extra capabilities. In Rust, the most common pointer is a reference (&T). References borrow data but do not own it. Smart pointers own the data they point to. They also add features like heap allocation, reference counting, and interior mutability. What Is a Smart Pointer? A smart pointer is a struct that: ...
In the previous tutorial, we learned async programming with Tokio. Now we take a deep dive into Rust collections – HashMap, BTreeMap, HashSet, BTreeSet, VecDeque, and BinaryHeap. You already know Vec and basic HashMap. This tutorial covers the advanced features: the entry API, custom keys, range queries, set operations, sliding windows, and priority queues. HashMap – The Entry API The entry API is the most important HashMap feature to learn. It lets you insert or update values without looking up the key twice. ...
In the previous tutorial, we learned lifetimes. Now we learn two features that make Rust code clean and expressive: closures and iterators. Closures are anonymous functions you can store in variables and pass to other functions. Iterators let you process collections step by step. Together, they replace most loops with short, readable code. What Is a Closure? A closure is a function without a name. It can capture variables from its environment: ...
In the previous tutorial, we learned generics. Now we learn lifetimes — the last piece of Rust’s ownership system. Lifetimes answer one question: “How long does this reference live?” The Rust compiler uses lifetimes to make sure every reference is always valid. No dangling pointers. No use-after-free bugs. No segfaults. If you have struggled with lifetime errors, this tutorial will help. Most of the time, lifetimes are invisible — the compiler figures them out for you. But sometimes you need to tell the compiler what you mean. ...
In the previous tutorial, we learned traits — how to define shared behavior. Now we learn generics — how to write code that works with many types without repeating yourself. You already use generics every day in Rust. Vec<T>, Option<T>, Result<T, E> — these are all generic types. The T is a placeholder for any type. In this tutorial, you learn to write your own. Why Generics? Without generics, you would write separate functions for each type: ...