Forem: Ann Maina

🚀 Mastering Vectors in Rust

Ann Maina — Thu, 26 Jun 2025 18:23:02 +0000

In Session 6 of the Polkadot Kisumu Bootcamp, we dived deep into one of the most practical and powerful data structures in Rust: Vectors.

If you’ve ever needed to store a list of items that can change size, vectors are your best friend in Rust.

What Is a Vector?

A vector is a resizable array that stores values on the heap. It's useful when you don’t know the size of your data at compile time.

fn main() {
    let mut numbers = Vec::new();
    numbers.push(10);
    numbers.push(20);
    println!("{:?}", numbers); // Output: [10, 20]
}

🔄 Using .push() and .pop()

These are the basic ways to grow or shrink a vector.

fn main() {
    let mut fruits = vec!["apple", "banana"];
    fruits.push("mango");  // Add item
    fruits.pop();          // Remove last item
    println!("{:?}", fruits); // Output: ["apple", "banana"]
}

✂️ Slices – Borrowing Part of a Vector

Slices let you access a section of the vector without taking ownership.

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let slice = &data[1..4];
    println!("{:?}", slice); // Output: [2, 3, 4]
}

This is memory-efficient and avoids unnecessary copying.

🧬 Generics – Writing Flexible Code

Generics in Rust let you write functions or types that work with any data type, as long as the type meets certain conditions.

Instead of writing duplicate code for each type (i32, String, etc.), you can use a generic type parameter like T.

fn print_all<T: std::fmt::Debug>(items: Vec<T>) {
    for item in items {
        println!("{:?}", item);
    }
}

What's Happening:

T is a placeholder for any type.

T: std::fmt::Debug means the type T must implement the Debug trait so it can be printed.

You can now call print_all() with Vec, Vec<&str>, Vec, etc.

fn main() {
    let numbers = vec![1, 2, 3];
    let names = vec!["Ann", "Ben", "Chris"];

    print_all(numbers);
    print_all(names);
}

🧠 Generics = less repetition + more flexibility.
This is the Rust way to write clean, DRY (Don't Repeat Yourself), scalable code.

🔁 Iteration Methods – Understanding Ownership in Loops

.iter() – Immutable Borrow

You borrow each item without modifying or taking ownership.

let nums = vec![1, 2, 3];
for n in nums.iter() {
    println!("{}", n); // Can read, but not modify
}
// nums is still usable here

Use this when you just want to read from the vector.

.iter_mut() – Mutable Borrow

You borrow each item mutably, which means you can change the values.

let mut nums = vec![1, 2, 3];
for n in nums.iter_mut() {
    *n *= 2; // Modify in-place
}
println!("{:?}", nums); // Output: [2, 4, 6]

Use this when you need to edit values in the vector.

.into_iter() – Take Ownership

You move each item out of the vector — meaning the original vector is no longer usable after the loop.

let nums = vec![1, 2, 3];
for n in nums.into_iter() {
    println!("{}", n);
}
// nums is now invalid — ownership moved

✅ Use this when you're done with the vector and want to consume it completely.

Why This Matters

Understanding generics and iteration methods gives you real power in Rust:

You write once, reuse everywhere (generics).
You control how memory is accessed, modified, or moved (iterators).
It ties directly back to ownership and borrowing, which are core to writing safe, high-performance Rust.

This builds on earlier sessions like ownership and borrowing making your code more safe, clean, and production-ready.

🦀 Understanding Lifetimes, Traits, Enums, and Pattern Matching in Rust

Ann Maina — Mon, 23 Jun 2025 18:42:20 +0000

Rust is known for being safe and fast but to get there, you need to understand some core concepts. Let’s break down lifetimes, traits, enums, and pattern matching with clear examples.

🔗 Lifetimes – Keeping References Safe

Rust makes sure you don’t use data that’s already gone. Lifetimes are how Rust tracks how long references are valid.
🧠 Example:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

This function returns the longer of two string slices. The <'a> tells Rust:

"The result reference will live as long as both x and y."

✅ Without this, Rust won’t know how long the returned reference lives and could reject your code to keep things safe.

🧰 Traits – Defining Shared Behavior

Traits define what methods a type must implement. Think of them like "skills" a type can have.


trait Speak {
    fn speak(&self);
}

struct Dog;

impl Speak for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

Now any type that implements Speak must have a speak() method. You can call it like:


let d = Dog;
d.speak(); // Outputs: Woof!

✅ Traits help you write reusable and generic code.

🎭 Enums – One Type, Many Forms

Enums allow a value to be one of several predefined options and each can hold different data.
🧠 Example:

enum Status {
    Success,
    Error(String),
    Loading,
}

This enum can represent three app states. You can use it like this:

let response = Status::Error(String::from("Something went wrong"));

🧩 Pattern Matching – Handling Enums Safely

With enums, you use match to handle each possible value.
🧠 Example:

match response {
    Status::Success => println!("All good!"),
    Status::Error(msg) => println!("Error: {}", msg),
    Status::Loading => println!("Loading..."),
}

✅ This forces you to handle every case, making your code safer and easier to understand.
🧠 Wrap Up

Here’s what you’ve learned:

Lifetimes: Help Rust ensure references don’t outlive the data they point to.
Traits: Let you define shared behavior that different types can implement.
Enums: Represent values that can take different forms.
Pattern matching: Makes handling all possible values safe and clear.

Rust might seem strict at first, but that’s what makes your programs fast and bug-free.
Keep practicing, and these concepts will become second nature.

🦀 Understanding Ownership in Rust: A Dev's Guide to Safe Memory Management

Ann Maina — Wed, 18 Jun 2025 07:29:18 +0000

Rust is known for its blazing-fast performance without a garbage collector and at the heart of that magic lies ownership. For devs coming from languages like Python, JavaScript, or even C++, Rust’s ownership model might feel a little strict at first. But once you get the hang of it, it becomes your best ally in writing safe, concurrent code without worrying about memory leaks or race conditions.

Let’s break it down with real-world analogies and simple concepts.

1. Ownership: One Value, One Boss

In Rust, every value has a single owner—a variable that holds responsibility for it. When you assign that value to another variable, the ownership moves. The original variable is no longer valid.


`let book = String::from("Rust Book");
let borrowed = book; // book is moved here
// println!("{}", book); ❌ Error: book no longer owns the value`

Analogy: Think of it like handing over a physical book. Once you give it away, you can't read it anymore unless it's given back.

2. Move Semantics: Handing Over Ownership

Rust uses move semantics by default for types like String or Vec. When you assign or pass these values around, ownership is transferred—not copied.


`fn print_book(title: String) {
    println!("{}", title);
}

let title = String::from("Rust Ownership");
print_book(title); // title is moved here
// println!("{}", title); ❌ Won't compile`

This ensures that there's only one owner at any given time—no double frees, no use-after-free bugs.

📖 3. Immutable Borrowing: Sharing Without Risk

Sometimes, you want to let others look at your data without changing it. Rust allows this with immutable references:

`
let title = String::from("Borrow Me");
let ref1 = &title;
let ref2 = &title; // ✅ multiple reads allowed
println!("{}, {}", ref1, ref2);`

Analogy: Like sharing your notes in class you’re letting others read, but they can’t mark or edit them.

✏️ 4. Mutable Borrowing: One Writer Only

If you want to allow edits, Rust ensures only one mutable reference exists at a time. This prevents conflicts and keeps your data consistent.

`let mut title = String::from("Update Me");
let ref_mut = &mut title;
ref_mut.push_str(" Now!");
// let ref_mut2 = &mut title; ❌ Only one mutable ref at a time`

Why this matters: It avoids data races, where multiple threads (or code paths) might try to change the same data simultaneously.

5. Scope & Auto Memory Management

Rust doesn't need a garbage collector. Instead, when a value goes out of scope, Rust automatically drops it freeing the memory.

{
    let title = String::from("Temp Book");
} // title is dropped here 🧹`

No more free() calls, no memory leaks Rust handles it all, compile-time.

Final Thoughts: Ownership Makes You Think Differently

Rust’s ownership model forces you to be explicit and intentional about how you use memory. It may slow you down at first, but it pays back in:

Fewer bugs
Safer concurrency
Zero-cost abstractions

And the best part? Once it compiles, it usually just works.