Scrolls
5 min read
On this page

Why Rust

Rust occupies a unique position in the programming landscape. It delivers the performance of C and C++ with the safety guarantees that previously required a garbage collector. That combination is not marketing — it is a fundamental design achievement backed by a type system and ownership model that catches entire categories of bugs at compile time.

Performance Without Garbage Collection

Rust has no runtime and no garbage collector. Memory is allocated and freed deterministically through ownership rules enforced at compile time. This means:

  • No GC pauses disrupting latency-sensitive workloads
  • No background threads scanning the heap
  • Predictable memory usage that you control explicitly
  • Performance on par with hand-tuned C
fn process_data(data: Vec<u8>) -> Vec<u8> {
    // When this function returns, `data` is dropped automatically.
    // No GC involved. The compiler inserts the deallocation.
    let mut result = Vec::with_capacity(data.len());
    for byte in &data {
        result.push(byte.wrapping_add(1));
    }
    result
    // `data` is freed here. `result` is moved to the caller.
}

In Go or Java, you would rely on the garbage collector to eventually reclaim data. In Rust, the compiler knows exactly when it is no longer needed.

Memory Safety Without Runtime Cost

Buffer overflows, use-after-free, double-free, null pointer dereferences — Rust eliminates all of these at compile time. Not by adding runtime checks (though bounds checking exists for slices), but by making invalid states unrepresentable in the type system.

fn main() {
    let name = String::from("Rust");
    let greeting = name; // `name` is moved, not copied

    // This would fail to compile:
    // println!("{}", name); // error: value used after move

    println!("{}", greeting);
}

The compiler refuses to let you use a value after it has been moved. This is not a runtime check — it is a compile-time guarantee.

Fearless Concurrency

Data races require three ingredients: shared mutable state, multiple threads, and no synchronization. Rust's type system makes it impossible to have the first two without the third.

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

Result: 10

Try removing the Mutex and the compiler will stop you. Try sharing a non-Arc reference across threads and the compiler will stop you. The type system encodes thread safety.

Where Rust Shines

Systems programming. Operating systems, device drivers, embedded firmware. Rust is the first new language accepted into the Linux kernel in decades. That says something.

Web backends. Frameworks like Axum and Actix-web deliver throughput that competes with C++ while being pleasant to write. If your service needs to handle tens of thousands of concurrent connections with minimal memory, Rust is a strong choice.

CLI tools. Ripgrep, fd, bat, exa — some of the best command-line tools of the last decade are written in Rust. The language compiles to a single binary with no runtime dependencies, which makes distribution trivial.

WebAssembly. Rust has first-class WASM support. The lack of a runtime means small binary sizes. Tools like wasm-pack make it straightforward to ship Rust code to the browser.

Networking & infrastructure. DNS servers, proxies, load balancers, database engines. Anywhere you need control over every byte and every microsecond, Rust delivers.

Where Rust Does Not Shine

Quick prototypes. If you need to validate an idea in an afternoon, Rust's compile-time checks will slow you down. Python or JavaScript will get you to a working prototype faster. You can always rewrite the hot path in Rust later.

Data science & machine learning. The ecosystem is not there yet. Python has NumPy, pandas, scikit-learn, PyTorch, and decades of tooling. Rust has promising libraries like polars and burn, but the ergonomics and breadth cannot compete today.

Scripting & glue code. Bash, Python, or Ruby are better for quick automation scripts. Rust's compile step and strict typing add friction for throwaway code.

Teams unfamiliar with systems concepts. If your team has never thought about stack vs heap, ownership will feel alien. The investment pays off, but it is an investment.

The Learning Curve Is Real

Rust has a reputation for a steep learning curve, and it is earned. The borrow checker will reject code that looks correct. Lifetimes will confuse you. Trait bounds will produce error messages that feel like a wall of text.

But here is the thing: the compiler is almost always right. When it rejects your code, it is catching a bug that would have been a segfault in C or a race condition in Go. Every fight with the borrow checker teaches you something about how memory and concurrency actually work.

The curve flattens. After a few weeks of real Rust, you will start writing code that compiles on the first try. After a few months, you will miss the borrow checker when you go back to other languages.

// This will not compile, and the error message tells you exactly why:
fn dangling_reference() -> &str {
    let s = String::from("hello");
    &s // error: `s` does not live long enough
}

// The fix is to return the owned value:
fn no_dangle() -> String {
    let s = String::from("hello");
    s // ownership transferred to caller
}

Common Pitfalls

  • Fighting the borrow checker instead of learning from it. When the compiler says no, pause and think about why. It is usually protecting you from a real bug.
  • Reaching for unsafe too early. Almost anything you need can be done in safe Rust. If you think you need unsafe, you probably need a different approach.
  • Comparing Rust to garbage-collected languages on developer speed. The comparison is unfair in both directions. Rust is slower to write but produces code that rarely breaks in production.
  • Ignoring the ecosystem. Crates like serde, tokio, clap, and rayon solve common problems better than you will on your own. Use them.
  • Expecting OOP patterns to transfer directly. Rust is not object-oriented. Traits and enums replace inheritance. Composition over inheritance is not advice in Rust — it is the only option.

Key Takeaways

  • Rust gives you C-level performance with compile-time memory safety and thread safety.
  • The ownership model eliminates garbage collection pauses and entire categories of bugs.
  • Rust is excellent for systems programming, web backends, CLI tools, and WebAssembly.
  • It is not ideal for quick prototypes, data science, or scripting.
  • The learning curve is real but finite. The compiler is teaching you, not punishing you.
  • If you need performance and correctness, Rust is the best tool available today.