Rust

In short: A compiled systems programming language focused on memory safety without a garbage collector — prevents many classic C/C++ bugs (e.g. use-after-free) already at compile time.

In more detail: Rust’s “ownership” system checks at compile time who’s allowed to access which memory and when, thereby preventing entire classes of bugs (memory leaks, data races), without the runtime cost of a garbage collector. This gives it similar performance to C/C++, but considerably more safety — popular for systems software, browser engines, and performance-critical tools.

In Depth

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 is now invalid - "moved" to s2
    println!("{}", s2); // works
    // println!("{}", s1); // compiler error: s1 was already "moved"
}

The “ownership” model is Rust’s central innovation: every value in memory has exactly ONE “owner” (a variable), and if this ownership is transferred to another variable (“move”, as in the example), the original variable becomes invalid — the compiler refuses any further access to it. This prevents classic bug classes like double-freeing memory or accessing already-freed memory, checked entirely at compile time, without the runtime overhead of a garbage collector like in Java.

This approach makes the learning curve steeper than most other languages (the “borrow checker” initially often rejects code that seems intuitive, until you’ve internalised the rules), but pays off especially in areas where memory safety AND high performance are critical at the same time: browser engines (parts of Firefox are written in Rust), operating-system components, and performance-critical infrastructure tools.

Origin at Mozilla

Rust was originally started by Graydon Hoare as a personal project and sponsored by Mozilla from 2009, with the concrete goal of developing a safer alternative to C++ for the Firefox browser engine — memory bugs in C/C++ were (and are) one of the most common causes of security vulnerabilities in browsers, since a single mistake in manual memory management can lead to exploitable vulnerabilities. The first stable version appeared in 2015. Mozilla’s Servo project (an experimental browser engine written in Rust) served as a practical stress test for the language in a very complex, performance-critical real-world system.

Error handling without exceptions

Unlike Java or Python, Rust has no classic exceptions for expected errors — instead, a function that can fail explicitly returns a Result type, containing either the success value or an error description. The caller has to explicitly handle this return value (the compiler enforces this), instead of an error invisibly passing control to a distant catch block:

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        return Err(String::from("Division by zero"));
    }
    Ok(a / b)
}

This pattern makes possible sources of error visible in the function signature itself (you can immediately see from the return type declaration that a function can fail) and prevents errors from accidentally slipping through unhandled — a common problem with classic exception systems, where a catch block can easily be forgotten.

Practical adoption

Rust is regularly named one of the most popular programming languages among developers in surveys (e.g. the Stack Overflow Developer Survey), even though its absolute adoption is lower than established languages like JavaScript or Python. Larger projects relying on Rust include parts of the Linux kernel (experimentally allowed for a few years now), Dropbox’s storage backend, and many modern command-line tools (e.g. ripgrep, fd) known for their speed.

See also: C, Go, Garbage Collector