learning rust lang

1. Introduction

I have been trying to learn Rust for a while now because I kept running into it. Many of the GitHub projects and repositories that interested me were written in Rust, especially those focused on building scalable and reliable systems, inference runtimes, low-level control, and hardware or GPU integrations. Eventually, I realized it made more sense to start learning it early rather than keep putting it off.

Over the next few weeks, I spent my time building small projects in Rust, applying what I learned and reinforcing the language’s core concepts. Having already worked with Python and JavaScript, and with enough C++ to understand manual memory management, I quickly noticed how differently each language approaches memory.

Python abstracts memory management almost entirely, while JavaScript gives developers a great deal of flexibility with very few constraints. C++, on the other hand, provides complete manual control but also places the responsibility for correctness entirely on the programmer. Rust sits in its own category. It delivers performance comparable to C++ while preventing entire classes of memory bugs through compile-time ownership, borrowing, and lifetime checks. Instead of relying on a garbage collector or trusting the programmer to manage memory correctly, the compiler enforces memory safety before the code can even run.

The learning curve was definitely steeper than I expected, and at times it felt frustrating. But over time, I began to appreciate the language’s design philosophy. Rather than fighting the compiler, I found myself thinking more carefully about ownership, data flow, and correctness before writing code. That shift in mindset ultimately made me a better programmer.

One thing I especially came to appreciate was the Rust community’s emphasis on consistency. The ecosystem encourages common patterns, strong tooling, and shared coding standards, making it easier to read, understand, and contribute to other people’s code. As I built more projects, I found myself enjoying Rust more and more, not just because of its performance, but because of the way it encourages writing reliable, maintainable software from the beginning.

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.

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"

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