learning rust lang

1. Introduction

I have been trying to learn Rust for a while now, as I always ended up in it. Like: Github projects and repositories that interest me, trying to understand how to build scalable and reliable systems, low level controls for example on inferences runtime or good hardware and GPU integrations. So, I decided it was better to understand it early or at least start rather than wait till much later.

Around the time I was starting to learn rust, my roommate left for Chicago for easter break, before leaving he asked me what I was doing for break, Since we are in DSA class together. I told him I have been learning to build some projects in Rust, and also currently strengthening my concepts and understanding. I talked about memory efficiency, performancy and how the language forces you to thing more carefully as we write, and even said I might like it more than python. He said, ‘bro they are all the same.’ I said, ‘no, she is different ’. Cringey, lol.

Anyway, I kept building projects in Rust over the next few days, applying what I had learned and reinforcing my concepts. I’d already spent time with Python and JavaScript, and just enough C++ to understand that memory management is handled very differently in each language. Python abstracts it entirely and JavaScript gives you flexibility with almost no constraints. C++ on the other hand gives you full manual control with no guardrails, and Rust sits in its own category. We get the performance of C++ without undefined behavior, because the compiler enforces memory safety. It felt bit challenging at first, but over time I came to prefer it as I actually like the fact that everyone in the community tends to follow the same standards for code for Rust, which is a really nice thing.

2. Setup

I set up Rust using rustup for toolchain management. I used VS Code as my editor, with the rust-analyzer extension for autocomplete, inline error messages, and type hints. The project structure was one Cargo project per concept, so it could be well managed and accessible and connected to GitHub so I could save my progress.

Figure: One folder per concept. Each has its own Cargo.toml and main.rs.

Cargo is the Rust build and package manager. Running cargo new creates a project and cargo run compiles and executes it. Dependencies, tests, and builds all go through this one tool, which keeps things simple. One thing though, add **/target/ to your .gitignore before your first push. That folder can get huge, hundreds of megabytes, and once it’s tracked you’ll have to go back and untrack it manually so it would be way easier to just ignore it from the start.

I used the rust-analyzer extension to get inline error messages, type hints, and faster feedback*. It underlines errors as you type and explains them inline, which makes the feedback loop much faster than the usual write-compile-debug cycle.*

3. Concepts Covered

3.1 Variables and Mutability

In Rust, every variable is immutable by default. Once you set a value, it stays that value. To allow a variable to change, you mark it explicitly with mut. This is the opposite of Python, where any variable can be reassigned at any time without declaration.

let name = "Sandesh"; // immutable - cannot be changed
let mut age = 20;     // mutable - can be changed
age = 21;             // fine because of mut
// name = "someone"; // compile error - name is immutable

What this is used for

Immutability by default prevents accidental changes to data. In a large codebase, knowing a variable cannot change unless it is explicitly marked mut makes the code easier to reason about. When you see mut, it signals intent: this variable is supposed to change. Without it, you can be confident it will not.

3.2 Functions

Functions in Rust use the fn keyword. Unlike Python’s def, you have to declare the type of every argument and the return type. The return type comes after an arrow. There is no return keyword. The last expression without a semicolon is returned automatically.

Figure: Function signatures in Rust include explicit parameter types and return type.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}
fn add(a: i32, b: i32) -> i32 {
    a + b  // no semicolon: this value is returned
    // a + b; with a semicolon returns nothing
}

That semicolon rule took the most getting used to. Adding one changes a return expression into a void statement. The compiler error is clear: “mismatched types: expected i32, found ()”. Declaring types up front also makes functions self-documenting. You can read a signature and know exactly what it expects and gives back, without reading through the implementation.

3.3 Ownership and Borrowing

Ownership is what makes Rust fundamentally different from every other mainstream language. Every value has exactly one owner at any time. When you assign a value to another variable, ownership moves to the new one and the original is no longer valid.

let name = String::from("Sandesh");
let name2 = name;       // ownership moves to name2
println!("{}", name2);  // works
// println!("{}", name); // compile error - name was moved

// To keep both, use clone:
let name3 = name2.clone();

// Or borrow - lend without moving:
fn print_name(n: &String) { println!("{}", n); }
print_name(&name2);     // lend temporarily
println!("{}", name2);  // original still alive

This eliminates use-after-free and double-free errors, which are common in C and C++ and cause crashes and security vulnerabilities. In Rust these cannot happen because the compiler enforces ownership rules at build time. You get memory safety without a garbage collector, which is why Rust is used in operating systems, game engines, and embedded systems.

3.4 Structs

Structs group related data together under a single name. They are similar to classes in Python but without inheritance. Rust does not support class-based inheritance. Methods are added separately through impl blocks.

struct Person {
    name: String,
    age: u32,
    email: String,
}
let mut person = Person {
    name: String::from("Sandesh"),
    age: 20,
    email: String::from("sandesh@example.com"),
};
person.age = 22; // works because person is mut

Structs are the primary way to model data in Rust. A network packet, a database record, a user account, a game entity: all of these get represented as structs.

3.5 Enums

An enum defines a type that can only be one of a fixed set of variants. In Python you might use strings to represent states, but nothing prevents an invalid value. In Rust the options are defined at the type level and the compiler enforces them.

enum Direction { Up, Down, Left, Right }
let dir = Direction::Down;
match dir {
    Direction::Up    => println!("Going up"),
    Direction::Down  => println!("Going down"),
    Direction::Left  => println!("Going left"),
    Direction::Right => println!("Going right"),
}

The match statement forces you to handle every variant. If you add a new one later, the compiler gives you an error until you handle it. This is the feature, not a bug.

3.6 Error Handling

Rust has no exceptions and no try/except. Every function that can fail returns a Result type, either Ok with a value or Err with an error. For values that might not exist, Rust uses Option. The compiler warns you if you ignore either.

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 { Err("cannot divide by zero".into()) }
    else { Ok(a / b) }
}
match divide(10.0, 0.0) {
    Ok(result) => println!("Result: {}", result),
    Err(e)     => println!("Error: {}", e),
}

Failure is part of the function signature, not a hidden possibility. Anyone reading the code knows immediately whether a function can fail and must decide what to do about it.

3.7 Collections

The two main collection types in Rust are Vec and HashMap. Vec is a growable list, equivalent to a Python list. HashMap is a key-value store, equivalent to a Python dictionary. HashMap does not preserve insertion order because it is optimized for fast lookup, not ordering.

let mut numbers = Vec::new();
numbers.push(1); numbers.push(2); numbers.push(3);
println!("First: {}", numbers[0]);

use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert("Sandesh", 95);
scores.insert("Alice", 87);
println!("{}", scores["Sandesh"]);

3.8 Iterators

Rust iterators let you transform and filter collections by chaining operations. Call iter() on a collection, chain map and filter, then call collect() to get the result back as a Vec. Iterators are lazy, meaning no work happens until collect() is called.

let numbers = vec![1, 2, 3, 4, 5];

let doubled: Vec<i32> = numbers.iter()
    .map(|x| x * 2).collect();

let evens: Vec<&i32> = numbers.iter()
    .filter(|x| *x % 2 == 0).collect();

let result: Vec<i32> = numbers.iter()
    .filter(|x| *x % 2 == 0)
    .map(|x| x * 2).collect(); // [4, 8]

Lazy evaluation means you can chain many operations without creating intermediate collections in memory, which matters for performance with large datasets.

3.9 Threads

Threads let you run multiple pieces of code at the same time. The output order between threads is not predictable, and that is expected, not a bug.

Figure: Rust threads run in true parallel. Ownership prevents data races at compile time.

use std::thread;
use std::time::Duration;

let handle = thread::spawn(|| {
    for i in 1..5 {
        println!("thread: count {}", i);
        thread::sleep(Duration::from_millis(1));
    }
});
for i in 1..5 {
    println!("main: count {}", i);
    thread::sleep(Duration::from_millis(1));
}
handle.join().unwrap();

In Python, the Global Interpreter Lock prevents multiple threads from running Python code in parallel on CPU-intensive tasks. Rust has no such restriction. The ownership system guarantees that two threads cannot accidentally modify the same data at the same time.

3.10 Async and Await

Async is about waiting efficiently, not running in parallel. Threads run things simultaneously on different CPU cores. Async runs tasks on the same thread but switches between them while they wait for I/O.

Figure: Tokio runtime for async tasks. Task 2 finishes first because it waits less.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    // Both tasks start at the same time
    let t1 = tokio::spawn(async {
        sleep(Duration::from_millis(100)).await;
        println!("Task 1 done"); // prints second
    });
    let t2 = tokio::spawn(async {
        sleep(Duration::from_millis(50)).await;
        println!("Task 2 done"); // prints first
    });
    t1.await.unwrap();
    t2.await.unwrap();
}

Rust needs a runtime to execute async code. The most widely used one is Tokio. Async is the standard approach for high-performance network services in Rust: web servers, database drivers, message queue consumers, and gRPC services all use it because most of their time is spent waiting on I/O rather than doing CPU work.

4. Rust vs Python: Key Differences

Coming from Python, these were the concepts that required the most adjustment.

Figure: Key differences between Python and Rust.

5. Development Process and Mistakes

5.1 Git Setup and the target Folder Problem

The first issue was that Rust’s build folder, called target, got committed to GitHub on the first push. The target folder contains all compiled output and can be hundreds of megabytes. It should never be tracked.

# .gitignore - ignore target/ at any depth
**/target/

# Remove already-committed files:
git rm -r --cached 01_variables/target
git add .
git commit -m "chore: remove tracked build files"

5.2 Mistakes Along the Way

Figure: Four common Rust mistakes and how to fix them: semicolons on return expressions, moved values, non-exhaustive match, and the borrow checker on HashMap.

6. Takeaways

The compiler changed how I think about code. Coming from JavaScript where you find out something is wrong when it throws at runtime in the browser, or Python where it crashes mid-execution, having a compiler stop you before anything runs and then explain itself precisely is a different experience. And yes we have AI now, Copilot predicts half of what we are about to type, but that is different, that is autocomplete. The compiler actually understands what your code means and tells you why it is wrong. The errors are not vague and they tell you what broke, which line, why the rule exists, and sometimes exactly what to change.

The ownership model was the hardest shift and the most lasting one. A value belongs to exactly one thing at a time and moving it transfers that ownership completely, the original is just gone. It can feel like hassle at first, but that constraint is intentional and helpful. Rust makes memory ownership visible in a way nothing else.

If you are starting out the official Rust book is genuinely the best place to begin, it is free, well written, and takes you through everything properly. You can find it at doc.rust-lang.org/book.

Source code: github.com/sandesh-8622/my-rust-progress

Sandesh Bhandari, 2026