Zero-Cost Abstractions: Memory Safety in Rust

Traditional systems languages such as C and C++ grant developers unchecked authority over memory allocation through raw pointers. However, manual pointer arithmetic frequently introduces fatal vulnerabilities:

1. Use-after-free
2. Double frees
3. Data races in multi-threaded concurrency

Modern garbage-collected languages (Go, Java, Python) eliminate these vulnerabilities at the cost of non-deterministic runtime pauses and increased memory footprint. Rust demonstrates that another paradigm is possible: compile-time memory safety via affine types.

1. The Core Invariant: Ownership

Every value in Rust has an owner represented by a variable binding. The core rules enforced strictly at compile time:

• Each value in Rust has an owner.
• There can only be one owner at a time.
• When the owner goes out of scope, the value is dropped automatically via the Drop trait.

struct Buffer {
    data: Vec<u8>,
    capacity: usize,
}

impl Buffer {
    pub fn new(capacity: usize) -> Self {
        Self {
            data: Vec::with_capacity(capacity),
            capacity,
        }
    }
}

fn process() {
    let buf = Buffer::new(1024); // buf allocated
    // Passing buf transfers ownership (move semantics)
    consume(buf);
    // buf is no longer accessible here — compiler rejects usage!
}

fn consume(b: Buffer) {
    println!("Processing buffer of capacity {}", b.capacity);
} // b dropped here deterministically!

2. The Borrow Checker: Aliasing XOR Mutability

Rust permits references to data without relinquishing ownership. This mechanism is called borrowing.

At any given point in a program's execution, data access must satisfy the fundamental law of safety:

You may have either any number of immutable references (&T), OR exactly one mutable reference (&mut T), but never both simultaneously.

fn main() {
    let mut numbers = vec![1, 2, 3, 4];

    let first = &numbers[0]; // Immutable borrow begins

    // The line below fails at compile time if uncommented!
    // numbers.push(5); // ERROR: cannot borrow `numbers` as mutable

    println!("First element is: {}", first); // Immutable borrow ends here

    numbers.push(5); // Now mutable borrow succeeds cleanly!
}

3. Explicit Lifetimes

When functions accept references and return references, the compiler uses generic lifetime parameters (e.g. 'a) to verify that the output reference never outlives the input data:

/// Returns the longest of two string slices.
/// Both slices must live at least as long as lifetime 'a.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

By verifying lifetimes statically during compilation, Rust achieves memory safety with zero runtime overhead.