Design Philosophies

Rust, like most modern programming languages, does not exist in a void. Much of the reasoning behind Rust’s design decisions comes from decades of lessons learned through an ever-evolving technological landscape. This section explores what makes Rust familiar and the unique characteristics that set it apart from other programming languages.

Language Classification

People often call Rust a “systems programming language”, but it turns out that defining what makes a systems language is nuanced. With room for heavy caveat it’s generally safe to characterize a systems language by its ability to provide granular control over low-level elements like memory and hardware. These kinds of controls enable developers to write highly optimized code. Unlike higher-level languages that may favor more abstraction for usability or portability, systems languages tend to prioritize the ability to directly interact with underlying hardware and machine instructions.

From an execution standpoint Rust is an ahead-of-time compiled language meaning that the code is compiled to architecture-specific machine code. This allows compiled binaries to run natively on target systems. Unlike languages that rely on a traditional runtime or interpreter (such as Python or Java), Rust does not require such a layer. This capability also allows Rust to operate in environments where fine-grained control over hardware and memory is crucial, such as in bootstrapping an operating system before more complex interpreters or virtual machines are initialized.

Rust also provides low-level capabilities in the standard library. For example, Rust ships with tools to manually manage memory, implement custom data structures (such as a classical array), and even allows you to inline assembly with the asm! macro. This kind of low-level access makes system languages like Rust indispensable for performance-critical or specialized domains such as operating systems, device drivers, embedded systems, and compilers.

What sets Rust apart from other systems languages is the way it balances the control and performance of traditional systems languages with modern tooling, a carefully considered feature set, and memory safe ergonomics. Rust includes deliberate design choices to provide both fundamental constructs and abstractions that allow you to write code that is both easy to read and performs as efficiently as hand-optimized low-level code. This is referred to as “zero cost abstraction” and includes both general features like closures and generics, as well as Rust-specific concepts like traits which are similar to interfaces in other languages. These features cannot really be coded any faster using verbose, “low-level” styles so there is no real penalty to using these convenient and helpful abstractions. The result is that you can eliminate extra “boilerplate” code that makes what is unique about a statement or block easier to identify. For example, for loop constructs actually de-sugar into more fundamental while loops over iterators, meaning that there is no execution penalty for using the more compact and ergonomic for construct. Rust also features true generics (without the complexity of C++ templates), and through a process called monomorphization, the compiler generates highly specialized machine code for specific types at compile time, enabling better compiler optimization.

Hardware has changed since the proliferation of traditional systems languages and Rust was consciously designed with concurrency and/or parallelism in mind, enabling the language to take full advantage of modern multi-core CPUs. This is in large part due to the language’s memory model and ownership system which make it safe to write concurrent programs without fear of data races, deadlocks, data corruption, or undefined behavior. Rust also has excellent interoperability with C, making it a perfect choice for writing safer “drop-in” replacements for existing C and C++ codebases.

Balancing control and safety is a delicate act and there is no such thing as free lunch. Rust’s focus on safety, performance, and predictability often comes at the expense of complexity and compile times. Rust is often criticized for its cryptic syntax, complex lifetime management semantics, difficult metaprogramming, and extensive type knowledge required to reliably comply with compile-time safety and ownership rules. These issues present a steep learning curve which can pose a significant barrier for entry to new and experienced programmers. Learning Rust can be quite an investment and it’s common for people to describe “fighting the borrow checker” and the language’s strong opinions while learning. The good thing is that Rust rarely re-invents the wheel, and many of the concepts that Rust forces you to understand and deal with up front translate well across other languages. Rust makes it possible to implement your own unsafe structures and operations while encouraging you to know why you shouldn’t through brow-beating and convenient alternatives.

Design Paradigms

Rust does not adhere to a single language paradigm. Instead Rust includes features that provide flexibility in stylistic approach. At its roots Rust is fundamentally more procedural, but does contain functional features that encourage developers to write declarative compositions.

Imperative (Procedural)

Rust contains syntax for loops and conditionals where state management and side effects are the focus. This should be very familiar to developers coming from the C family of languages and languages like Ruby, Limbo, and Mesa. At its most basic Rust places focus on how a program operates.

Object-Oriented

Rust uses a handful of object-oriented programming (OOP) design principals that classify it loosely as an OOP language. For example, you can use structs and enums to define custom types that contain structured data and may have implementation blocks that provide methods for those types. They may not be called objects in Rust, but they provide similar functionality. Rust also allows for encapsulation with public identifiers that hide implementation details for private members. You can use traits to define common elements and methods for code reuse similar to an interface in other languages. Instead of a direct polymorphism characteristic Rust uses generics to abstract over different possible types and trait bounds. This is used to impose constraints on what those types must provide. This idea is sometimes called bounded parametric polymorphism. Lastly, and to the relief of some, Rust does not support inheritance. There is no way to write a struct with an implementation that inherits a parent struct’s fields or methods.

Functional

Rust is heavily influenced by functional programming. For example, all data is immutable by default in Rust. Rust also encourages more abstract declarative compositions which is a big part of why Rust code can look so foreign to many programmers more familiar with imperative composition styles frequently present in the C family. To achieve this, Rust supports functions as first-class citizens and higher-order functions. Support for functions as first-class citizens means you can use functions like any other variable. You can bind functions to variables, pass them to/from other functions, and even store them in data structures. Rust also supports higher-order functions, defined as functions that take functions as arguments or return functions as values. Closures, or anonymous functions, are essentially lambda functions that capture their environment and embody this dual approach to supporting higher-order functions and treating functions as first-class citizens. Rust’s approach to functions and heavy use of closures allows developers to chain statements and functions into declarative (functional) compositions. Other functional principals include the heavy use of algebraic data types (including “product” and “sum” types) and pattern matching. One truly unique aspect to Rust is its ownership and borrowing mechanisms which expands on some functional design philosophies but does not really have any language analogs. Closures, product and sum types, pattern matching, and ownership are such a large parts of Rust that they get their own dedicated sections in this language module.

Freedom Of Expression

Rust’s mutli-paradigm approach provides quite a bit of runway to express code that best suits the problem domain. Consider the following code snippet that illustrates the same algorithm written in functional style and imperative style. Each of the algorithms creates a collection of values from 1-30, doubles each number in the collection, and only keeps the doubled values that are divisible by three. The last three lines compare the expected results with each of the algorithm outputs proving that they produce the same result.

#[test]
fn style_illustration() {

    // Functional approach
    let functional: Vec<i32> = (1..=30)
        .map(|x| x * 2)
        .filter(|&x| x % 3 == 0)
        .collect();

    // Imperative approach
    let mut imperative = Vec::new();
    for x in 1..=30 {
        let doubled = x * 2;
        if doubled % 3 == 0 {
            imperative.push(doubled);
        }
    }

    let expected: Vec<i32> = vec![6, 12, 18, 24, 30, 36, 42, 48, 54, 60];
    assert_eq!(functional, expected);
    assert_eq!(imperative, expected);
}