Rust From Scratch on Atharva Pandey

Lesson 25: Where to Go from Here — Your Rust learning path

Thu, 18 Apr 2024 18:00:00 +0000

You’ve made it through 24 lessons. You understand ownership, borrowing, structs, enums, traits, generics, error handling, closures, iterators, and file I/O. That’s not nothing — that’s the foundation of every Rust program ever written. But foundations are for building on. Here’s where to go from here.

What You Know Now

Take a second to appreciate what you’ve learned. You can:

Set up a Rust project with Cargo
Write functions with proper ownership and borrowing
Model data with structs and enums
Handle errors with Result and the ? operator
Use collections: Vec, HashMap, HashSet
Write generic code with trait bounds
Process data with iterators and closures
Test your code with #[test]
Read and write files

That’s a real skill set. You can build useful things right now. Before diving into advanced topics, I strongly recommend you build something. Nothing fancy — a command-line tool, a file processor, a simple data structure. The gap between “I understand the concepts” and “I can write a program” is only bridged by practice.

Lesson 24: Reading and Writing Files — Real I/O in Rust

Tue, 16 Apr 2024 13:45:00 +0000

Every tutorial teaches you to manipulate data in memory, but real programs read from files and write to files. Rust’s file I/O is built on the same ownership and error handling principles you’ve been learning — and once you see how Result, iterators, and traits come together, the entire language design starts to feel cohesive.

Reading a File — The Quick Way

use std::fs;

fn main() {
 match fs::read_to_string("hello.txt") {
 Ok(content) => println!("File contents:\n{content}"),
 Err(e) => eprintln!("Error reading file: {e}"),
 }
}

fs::read_to_string reads the entire file into a String. It returns Result<String, io::Error> — because file operations can fail (file doesn’t exist, permission denied, disk error, etc.).

Lesson 23: Writing Your First Tests — #[test] and assert!

Sun, 14 Apr 2024 11:00:00 +0000

I have a rule: I won’t merge code without tests. Not because I’m a purist — because I’ve been burned too many times. Rust makes testing so frictionless that there’s no excuse to skip it. Tests live in the same file as your code. They run with one command. The tooling just works.

Your First Test

fn add(a: i32, b: i32) -> i32 {
 a + b
}

#[cfg(test)]
mod tests {
 use super::*;

 #[test]
 fn test_add() {
 assert_eq!(add(2, 3), 5);
 }

 #[test]
 fn test_add_negative() {
 assert_eq!(add(-1, 1), 0);
 }

 #[test]
 fn test_add_zero() {
 assert_eq!(add(0, 0), 0);
 }
}

Run with cargo test:

Lesson 22: Iterators — Lazy, composable data processing

Fri, 12 Apr 2024 09:30:00 +0000

I once profiled a Go service and found it was spending 40% of CPU time allocating intermediate slices in a data pipeline. Each transformation created a new slice, copied data, processed it, then created another. In Rust, iterator chains do the same transformation with zero intermediate allocations. The data flows through the pipeline element by element, transformed in place. That’s not just elegant — it’s measurably faster.

The Iterator Trait

At its core, an iterator is any type that implements the Iterator trait:

Lesson 21: Closures — Functions that capture

Wed, 10 Apr 2024 12:15:00 +0000

Closures are where Rust stops feeling like a systems language and starts feeling like a functional one. You’ve already been using them — every time you passed |x| x * 2 to .map() or |a, b| a.cmp(b) to .sort_by(), that was a closure. Time to understand what’s actually happening under the hood.

What Is a Closure?

A closure is an anonymous function that can capture variables from its surrounding scope:

Lesson 20: Generics — Writing code that works for any type

Mon, 08 Apr 2024 20:00:00 +0000

I used to think generics were fancy academic stuff that you’d rarely need in practice. Then I wrote my third function that was identical to a previous one except it operated on f64 instead of i32. Generics aren’t luxury features — they’re how you stop writing the same function five times for five different types.

The Problem Generics Solve

Without generics, you write duplicate code:

fn largest_i32(list: &[i32]) -> &i32 {
 let mut largest = &list[0];
 for item in list {
 if item > largest {
 largest = item;
 }
 }
 largest
}

fn largest_f64(list: &[f64]) -> &f64 {
 let mut largest = &list[0];
 for item in list {
 if item > largest {
 largest = item;
 }
 }
 largest
}

fn main() {
 let ints = vec![34, 50, 25, 100, 65];
 let floats = vec![3.4, 5.0, 2.5, 10.0, 6.5];

 println!("Largest int: {}", largest_i32(&ints));
 println!("Largest float: {}", largest_f64(&floats));
}

These functions are identical except for the type. Generics let you write it once:

Lesson 19: Traits — Your first abstraction

Sun, 07 Apr 2024 15:45:00 +0000

Traits are the mechanism I miss most when I leave Rust. They’re interfaces without inheritance, type classes without the math, and the foundation of every abstraction in the language. If structs define what data is, traits define what data does.

What Is a Trait?

A trait defines a set of methods that a type can implement:

trait Greet {
 fn hello(&self) -> String;
}

struct Person {
 name: String,
}

struct Robot {
 id: u32,
}

impl Greet for Person {
 fn hello(&self) -> String {
 format!("Hi, I'm {}!", self.name)
 }
}

impl Greet for Robot {
 fn hello(&self) -> String {
 format!("UNIT-{} OPERATIONAL", self.id)
 }
}

fn main() {
 let person = Person { name: String::from("Alice") };
 let robot = Robot { id: 42 };

 println!("{}", person.hello());
 println!("{}", robot.hello());
}

The trait Greet declares that any implementing type must have a hello method. Person and Robot each provide their own implementation. Different types, same interface.

Lesson 18: Crates, Cargo.toml, and Dependencies — The Rust ecosystem

Fri, 05 Apr 2024 10:30:00 +0000

The first time I added a dependency in Rust, I was shocked. Add one line to Cargo.toml, run cargo build, and it downloads, compiles, and links everything automatically. Coming from C++ where dependency management is a special circle of hell, Cargo felt like cheating.

What Is a Crate?

A crate is a compilation unit in Rust — the smallest amount of code the compiler considers at a time. There are two kinds:

Lesson 17: Modules — Organizing your code

Wed, 03 Apr 2024 14:00:00 +0000

Rust’s module system confused me for longer than I’d like to admit. I came from Go, where packages map directly to directories. Rust’s module system is more flexible — and more confusing as a result. But once you understand the mental model, it’s actually quite elegant. The key insight: the file system doesn’t define the module tree. You do.

Modules in a Single File

The simplest case — modules defined inline:

Lesson 16: Result and the ? Operator — Errors as values

Mon, 01 Apr 2024 08:45:00 +0000

Exception-based error handling has a fundamental flaw: you can’t tell by looking at a function signature whether it might throw. Go fixed this by returning (value, error) tuples, but then you’re back to forgetting to check the error. Rust’s Result type gets it right — errors are values, and the type system makes them impossible to ignore.

The Result Type

// Built into the language:
// enum Result<T, E> {
// Ok(T),
// Err(E),
// }

Result<T, E> is either Ok(T) (success with a value) or Err(E) (failure with an error). You’ve seen Option<T> — Result is similar but carries error information when something goes wrong.

Lesson 15: Vec, HashMap, and HashSet — The collections you'll use daily

Sat, 30 Mar 2024 11:15:00 +0000

In my experience, about 80% of all data structures in real programs are either lists or key-value maps. Rust nails both of them. Vec and HashMap are fast, safe, and ergonomic — and once you know these two plus HashSet, you can build almost anything.

Vec — The Dynamic Array

Vec<T> is Rust’s growable array. It stores elements contiguously on the heap, like ArrayList in Java or std::vector in C++.

Lesson 14: Methods and Associated Functions — impl blocks explained

Thu, 28 Mar 2024 17:30:00 +0000

In most object-oriented languages, data and behavior are bundled together inside classes. Rust separates them — you define data with struct (or enum) and attach behavior with impl blocks. This separation is cleaner than it sounds. You can add methods to a type from anywhere, not just its original definition. And there’s no inheritance tax.

Your First impl Block

#[derive(Debug)]
struct Rectangle {
 width: f64,
 height: f64,
}

impl Rectangle {
 fn area(&self) -> f64 {
 self.width * self.height
 }

 fn perimeter(&self) -> f64 {
 2.0 * (self.width + self.height)
 }

 fn is_square(&self) -> bool {
 (self.width - self.height).abs() < f64::EPSILON
 }
}

fn main() {
 let rect = Rectangle { width: 10.0, height: 5.0 };

 println!("Area: {}", rect.area());
 println!("Perimeter: {}", rect.perimeter());
 println!("Is square: {}", rect.is_square());
}

The impl Rectangle block defines methods for the Rectangle type. Inside the block, &self is a reference to the instance the method is called on. It’s equivalent to self: &Self, where Self is an alias for Rectangle.

Lesson 13: Pattern Matching — The match superpower

Tue, 26 Mar 2024 09:45:00 +0000

Pattern matching ruined switch statements for me. After using match in Rust for a few months, going back to C-style switch/case feels like using a butter knife to do surgery. The compiler checks that you’ve covered every case. It destructures data inline. It does not fall through. It is, hands down, the most elegant control flow construct I’ve ever used.

Basic match

fn main() {
 let x = 3;

 match x {
 1 => println!("one"),
 2 => println!("two"),
 3 => println!("three"),
 _ => println!("something else"),
 }
}

_ is the catch-all pattern — it matches anything. Think of it as the default case in a switch statement, except it’s mandatory when the other arms don’t cover all possibilities.

Lesson 12: Enums and Option — Null safety by design

Mon, 25 Mar 2024 12:00:00 +0000

Tony Hoare called null his “billion-dollar mistake.” He invented it in 1965 and has publicly apologized for it multiple times since. Rust took him seriously. There is no null in Rust — and the replacement is so much better that going back to languages with null feels like giving up a superpower.

Basic Enums

At their simplest, enums define a type that can be one of several variants:

#[derive(Debug)]
enum Direction {
 North,
 South,
 East,
 West,
}

fn describe(dir: &Direction) -> &str {
 match dir {
 Direction::North => "heading north",
 Direction::South => "heading south",
 Direction::East => "heading east",
 Direction::West => "heading west",
 }
}

fn main() {
 let d = Direction::North;
 println!("{:?}: {}", d, describe(&d));
}

If this is all enums did, they’d be equivalent to C enums. Mildly useful. Not exciting.

Lesson 11: Structs — Modeling your domain

Sat, 23 Mar 2024 20:15:00 +0000

I worked on a Go codebase once where someone had passed around a map[string]interface{} for user data. It was fine until someone misspelled “email” as “emial” and we spent half a day tracking down why emails weren’t sending. Structs are how you prevent this entire category of mistake — named fields with typed data, checked at compile time.

Defining a Struct

struct User {
 name: String,
 email: String,
 age: u32,
 active: bool,
}

fn main() {
 let user = User {
 name: String::from("Alice"),
 email: String::from("alice@example.com"),
 age: 30,
 active: true,
 };

 println!("{} ({}) - age {}", user.name, user.email, user.age);
}

Struct names are PascalCase. Field names are snake_case. These aren’t suggestions — the compiler warns you if you deviate.

Lesson 10: Strings — String vs &str and why it matters

Fri, 22 Mar 2024 15:30:00 +0000

Strings are the #1 source of confusion for Rust beginners. I see the same questions every week: “Why are there two string types?” “Why can’t I index a string?” “Why is this so much harder than in Python?” It’s not harder — it’s more honest. Other languages hide the complexity of text. Rust makes you deal with it.

The Two String Types

Rust has two main string types:

String — owned, heap-allocated, growable, mutable
&str — borrowed, a slice/view into string data, immutable (usually)

fn main() {
 let owned: String = String::from("hello"); // heap-allocated, you own it
 let borrowed: &str = "hello"; // string literal, embedded in binary

 println!("{owned} {borrowed}");
}

The relationship between String and &str is exactly like Vec<u8> and &[u8]. A String is a buffer you own. A &str is a view into someone else’s string data (or a literal baked into your binary).

Lesson 9: Slices — Views into data

Wed, 20 Mar 2024 10:45:00 +0000

Slices clicked for me when I stopped thinking of them as a language feature and started thinking of them as a design pattern: “here’s a window into someone else’s data.” They’re one of Rust’s most elegant ideas, and you’ll use them everywhere.

What Is a Slice?

A slice is a reference to a contiguous sequence of elements in a collection. It doesn’t own the data — it’s a view into data owned by something else.

Lesson 8: Borrowing and References — Sharing without giving

Mon, 18 Mar 2024 13:00:00 +0000

After the last lesson, you might be thinking “so every function I call takes my data and I never see it again?” That would be terrible. Borrowing is the answer — it lets you share data without transferring ownership, and it’s where Rust’s safety guarantees really shine.

References with &

A reference lets you refer to a value without owning it:

fn print_length(s: &String) {
 println!("Length of '{}': {}", s, s.len());
}

fn main() {
 let s = String::from("hello");
 print_length(&s); // lend s to the function
 println!("I still own: {s}"); // s is still valid
}

The & creates a reference. &s doesn’t move s — it creates a pointer to s that the function can use. When the function returns, the reference goes away but s remains untouched.

Lesson 7: Ownership — The rule that changes everything

Sat, 16 Mar 2024 08:30:00 +0000

I spent three hours fighting the borrow checker on my first real Rust project. I was furious. Then I realized every single error the compiler flagged was a genuine bug — a use-after-free, a data race, a dangling reference. The compiler wasn’t being difficult. It was saving me from myself.

Why Ownership Exists

In C, you allocate memory and free it manually. Forget to free? Memory leak. Free twice? Undefined behavior. Use after free? Crash (if you’re lucky) or silent corruption (if you’re not).

Lesson 6: Control Flow — if, loop, while, for — and why there's no ternary

Thu, 14 Mar 2024 19:10:00 +0000

I once reviewed a pull request that had seven levels of nested if-else. In Go. The author said “the language doesn’t give me better tools.” In Rust, you’ve got match, labeled loops, if let, and blocks-as-expressions — enough to keep your code flat and readable even when the logic is complex.

if / else

fn main() {
 let temperature = 35;

 if temperature > 30 {
 println!("It's hot");
 } else if temperature > 20 {
 println!("It's nice");
 } else {
 println!("It's cold");
 }
}

Standard stuff. No parentheses around the condition — that’s a syntax error in Rust. The braces are mandatory, even for single-line bodies. No arguing about whether to use braces. They’re required. Discussion over.

Lesson 5: Functions, Expressions, and Statements — Everything is an expression

Wed, 13 Mar 2024 10:20:00 +0000

When I first read that “everything in Rust is an expression,” I thought it was marketing fluff. It’s not. It’s a genuine design principle that affects how you write code every single day, and once you internalize it, going back to statement-heavy languages feels clunky.

Defining Functions

fn add(a: i32, b: i32) -> i32 {
 a + b
}

fn main() {
 let result = add(3, 7);
 println!("3 + 7 = {result}");
}

A few things to notice:

Lesson 4: Variables, Mutability, and Primitive Types — Let, let mut, and the type system

Mon, 11 Mar 2024 16:45:00 +0000

Coming from JavaScript, I was stunned the first time Rust refused to compile because I tried to reassign a variable. “What do you mean it’s immutable by default? Who designs a language like that?” Turns out — people who’ve debugged enough mutable state to know better.

Variables with let

fn main() {
 let x = 5;
 println!("x is {x}");
}

let creates a variable binding. It binds a name to a value. By default, that binding is immutable — you can’t change it.

Lesson 3: Hello, World — Anatomy of a Rust program

Sat, 09 Mar 2024 11:00:00 +0000

The first program I ever wrote was in BASIC on a Commodore 64 emulator. Took me twenty minutes to figure out why PRINT didn’t work (I was typing PIRNT). Rust’s version of Hello World looks simple — four lines — but there’s a surprising amount of language design packed into those four lines.

The Program

fn main() {
 println!("Hello, world!");
}

That’s it. Three lines if you’re counting. But each piece tells you something about how Rust thinks.

Lesson 2: Installing Rust — rustup, cargo, and your first build

Thu, 07 Mar 2024 14:30:00 +0000

I’ve installed Rust on maybe fifty machines at this point — Linux servers, Macs, Windows boxes, even a Raspberry Pi. The process has gotten remarkably smooth. Rustup is one of the best toolchain managers in any language ecosystem, and I say that without hesitation.

Installing rustup

Rustup is the official Rust toolchain installer and manager. It handles downloading the compiler, updating it, and switching between versions. One command gets you everything.

Lesson 1: Why Rust Exists — And why you should care

Tue, 05 Mar 2024 09:15:00 +0000

I mass-deleted a production database once because a C program I’d written had a use-after-free bug that corrupted a pointer used for query routing. Took us fourteen hours to recover. That was the week I started learning Rust.

The Problem Rust Solves

Every few years, someone publishes a study on CVEs in major software projects. The numbers are always the same: roughly 70% of critical security vulnerabilities in C and C++ codebases are memory safety issues. Buffer overflows, use-after-free, double-free, null pointer dereferences. The same bugs, decade after decade.