Applying Clean Code Principles in Rust: Reducing Dependencies with Ownership and Borrowing

Introduction

Welcome to the third lesson of the Applying Clean Code Principles in Rust course! In our previous lessons, we explored the significance of the DRY (Don't Repeat Yourself) principle in minimizing redundancy and the KISS (Keep It Simple, Stupid) principle for maintaining simplicity. Today, we'll delve into how Rust's unique ownership and borrowing system can help us reduce dependencies and write cleaner, more modular code. By understanding and applying these concepts, you'll be able to craft efficient and maintainable Rust programs. Let's dive in! 🦀

The Power of Ownership and Borrowing in Clean Code

Rust's ownership and borrowing system is not just about memory safety; it's a powerful tool for designing clean code with clear boundaries and minimal dependencies. By enforcing strict rules around how data is accessed and modified, Rust encourages you to write code that is modular and free from unintended side effects. More specifically: Ownership ensures that each piece of data (i.e., variable) has a single owner responsible for its lifetime, which is the scope during which the data is valid and can be accessed. Borrowing allows you to access data without taking ownership, promoting data immutability and controlled mutation. These concepts help you avoid common pitfalls like dangling pointers and data races, leading to cleaner and safer code.

Problem: Tight Coupling Without Ownership Principles

Let's look at an example where not following ownership and borrowing principles leads to tightly coupled code: Rust struct Logger {level: String,} impl Logger {fn log(&self, message: &str) {// Borrow `self` immutably to access `level` println!("[{}] {}", self.level, message);}} struct Application {logger: Logger, // `Application` owns a `Logger` instance directly} impl Application {fn run(&self) {self.logger.log("Application is running"); // Additional code...}} fn main() {let app = Application {logger: Logger {level: String::from("INFO"),},}; app.run();} struct Logger {level: String,} impl Logger {fn log(&self, message: &str) {// Borrow `self` immutably to access `level` println!("[{}] {}", self.level, message);}} struct Application {logger: Logger, // `Application` owns a `Logger` instance directly} impl Application {fn run(&self) {self.logger.log("Application is running"); // Additional code...}} fn main() {let app = Application {logger: Logger {level: String::from("INFO"),},}; app.run();} What's wrong here? The Application struct owns a Logger instance directly. This tight coupling means Application cannot easily change logging behavior without modifying its own structure. It increases dependencies and reduces flexibility.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rust

struct Logger {
    level: String,
}

impl Logger {
    fn log(&self, message: &str) {
        // Borrow `self` immutably to access `level`
        println!("[{}] {}", self.level, message);
    }
}

struct Application {
    logger: Logger, // `Application` owns a `Logger` instance directly
}

impl Application {
    fn run(&self) {
        self.logger.log("Application is running");
        // Additional code...
    }
}

fn main() {
    let app = Application {
        logger: Logger {
            level: String::from("INFO"),
        },
    };
    app.run();
}

Rust

struct Logger {
    level: String,
}

impl Logger {
    fn log(&self, message: &str) {
        // Borrow `self` immutably to access `level`
        println!("[{}] {}", self.level, message);
    }
}

// The `'a` is a lifetime parameter indicating that `Application` cannot outlive the borrowed `Logger`
struct Application<'a> {
    logger: &'a Logger, // `Application` borrows `Logger` with lifetime `'a`
}

impl<'a> Application<'a> {
    fn run(&self) {
        // Use the borrowed `Logger` to call `log`
        self.logger.log("Application is running");
        // Additional code...
    }
}

fn main() {
    let logger = Logger {
        level: String::from("INFO"),
    };
    let app = Application { logger: &logger }; // Pass a reference to `logger`
    app.run();
}

struct Logger {
    level: String,
}

impl Logger {
    fn log(&self, message: &str) {
        // Borrow `self` immutably to access `level`
        println!("[{}] {}", self.level, message);
    }
}

// The `'a` is a lifetime parameter indicating that `Application` cannot outlive the borrowed `Logger`
struct Application<'a> {
    logger: &'a Logger, // `Application` borrows `Logger` with lifetime `'a`
}

impl<'a> Application<'a> {
    fn run(&self) {
        // Use the borrowed `Logger` to call `log`
        self.logger.log("Application is running");
        // Additional code...
    }
}

fn main() {
    let logger = Logger {
        level: String::from("INFO"),
    };
    let app = Application { logger: &logger }; // Pass a reference to `logger`
    app.run();
}

Rust

fn print_message(message: String) {
    // `message` takes ownership of the passed `String`
    println!("{}", message);
    // `message` is dropped here
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(msg.clone()); // Cloning `msg` to avoid moving ownership
    // `msg` is still valid here, but we unnecessarily cloned it.
}

fn print_message(message: String) {
    // `message` takes ownership of the passed `String`
    println!("{}", message);
    // `message` is dropped here
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(msg.clone()); // Cloning `msg` to avoid moving ownership
    // `msg` is still valid here, but we unnecessarily cloned it.
}

Rust

fn print_message(message: &str) {
    // `message` is borrowed immutably
    println!("{}", message);
    // `message` goes out of scope, but as it's a reference, no ownership is transferred
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(&msg); // Borrow `msg` instead of cloning
    // `msg` is still valid here without cloning.
}

fn print_message(message: &str) {
    // `message` is borrowed immutably
    println!("{}", message);
    // `message` goes out of scope, but as it's a reference, no ownership is transferred
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(&msg); // Borrow `msg` instead of cloning
    // `msg` is still valid here without cloning.
}

Rust

struct Config {
    debug_mode: bool,
}

fn update_config(config: &mut Config) {
    // Mutable borrow allows us to modify `config`
    config.debug_mode = true;
}

fn main() {
    let mut config = Config { debug_mode: false };
    update_config(&mut config); // Pass mutable reference to `config`
    println!("Debug mode: {}", config.debug_mode);
}

struct Config {
    debug_mode: bool,
}

fn update_config(config: &mut Config) {
    // Mutable borrow allows us to modify `config`
    config.debug_mode = true;
}

fn main() {
    let mut config = Config { debug_mode: false };
    update_config(&mut config); // Pass mutable reference to `config`
    println!("Debug mode: {}", config.debug_mode);
}

Rust

struct Config {
    debug_mode: bool,
}

impl Config {
    fn enable_debug(&mut self) {
        // Controlled mutation within the method
        self.debug_mode = true;
    }

    fn is_debug_mode(&self) -> bool {
        // Immutable borrow to read `debug_mode`
        self.debug_mode
    }
}

fn main() {
    let mut config = Config { debug_mode: false };
    config.enable_debug(); // Mutate `config` through method
    println!("Debug mode: {}", config.is_debug_mode());
}

struct Config {
    debug_mode: bool,
}

impl Config {
    fn enable_debug(&mut self) {
        // Controlled mutation within the method
        self.debug_mode = true;
    }

    fn is_debug_mode(&self) -> bool {
        // Immutable borrow to read `debug_mode`
        self.debug_mode
    }
}

fn main() {
    let mut config = Config { debug_mode: false };
    config.enable_debug(); // Mutate `config` through method
    println!("Debug mode: {}", config.is_debug_mode());
}

Rust

use std::fs::File;

fn main() {
    let file = File::open("example.txt").expect("Failed to open file");
    // `file` owns the `File` resource
    // Do something with the file
    // `file` is dropped here, and the file handle is closed automatically
}

use std::fs::File;

fn main() {
    let file = File::open("example.txt").expect("Failed to open file");
    // `file` owns the `File` resource
    // Do something with the file
    // `file` is dropped here, and the file handle is closed automatically
}

Rust

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1; // Unsafe mutable access to global variable
    }
}

fn main() {
    increment();
    unsafe {
        println!("Counter: {}", COUNTER); // Unsafe read of global variable
    }
}

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1; // Unsafe mutable access to global variable
    }
}

fn main() {
    increment();
    unsafe {
        println!("Counter: {}", COUNTER); // Unsafe read of global variable
    }
}

Rust

struct Counter {
    value: i32,
}

impl Counter {
    fn increment(&mut self) {
        // Mutable borrow of `self` to modify `value`
        self.value += 1;
    }

    fn get(&self) -> i32 {
        // Immutable borrow of `self` to read `value`
        self.value
    }
}

fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment(); // Mutate `counter` through method
    println!("Counter: {}", counter.get());
}

struct Counter {
    value: i32,
}

impl Counter {
    fn increment(&mut self) {
        // Mutable borrow of `self` to modify `value`
        self.value += 1;
    }

    fn get(&self) -> i32 {
        // Immutable borrow of `self` to read `value`
        self.value
    }
}

fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment(); // Mutate `counter` through method
    println!("Counter: {}", counter.get());
}

Rust

struct Logger {
    level: String,
}

impl Logger {
    fn log(&self, message: &str) {
        // Borrow `self` immutably to access `level`
        println!("[{}] {}", self.level, message);
    }
}

// The `'a` is a lifetime parameter indicating that `Application` cannot outlive the borrowed `Logger`
struct Application<'a> {
    logger: &'a Logger, // `Application` borrows `Logger` with lifetime `'a`
}

impl<'a> Application<'a> {
    fn run(&self) {
        // Use the borrowed `Logger` to call `log`
        self.logger.log("Application is running");
        // Additional code...
    }
}

fn main() {
    let logger = Logger {
        level: String::from("INFO"),
    };
    let app = Application { logger: &logger }; // Pass a reference to `logger`
    app.run();
}

Rust

fn print_message(message: String) {
    // `message` takes ownership of the passed `String`
    println!("{}", message);
    // `message` is dropped here
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(msg.clone()); // Cloning `msg` to avoid moving ownership
    // `msg` is still valid here, but we unnecessarily cloned it.
}

Rust

fn print_message(message: &str) {
    // `message` is borrowed immutably
    println!("{}", message);
    // `message` goes out of scope, but as it's a reference, no ownership is transferred
}

fn main() {
    let msg = String::from("Hello, Rust!");
    print_message(&msg); // Borrow `msg` instead of cloning
    // `msg` is still valid here without cloning.
}

Rust

struct Config {
    debug_mode: bool,
}

fn update_config(config: &mut Config) {
    // Mutable borrow allows us to modify `config`
    config.debug_mode = true;
}

fn main() {
    let mut config = Config { debug_mode: false };
    update_config(&mut config); // Pass mutable reference to `config`
    println!("Debug mode: {}", config.debug_mode);
}

Rust

struct Config {
    debug_mode: bool,
}

impl Config {
    fn enable_debug(&mut self) {
        // Controlled mutation within the method
        self.debug_mode = true;
    }

    fn is_debug_mode(&self) -> bool {
        // Immutable borrow to read `debug_mode`
        self.debug_mode
    }
}

fn main() {
    let mut config = Config { debug_mode: false };
    config.enable_debug(); // Mutate `config` through method
    println!("Debug mode: {}", config.is_debug_mode());
}

Rust

use std::fs::File;

fn main() {
    let file = File::open("example.txt").expect("Failed to open file");
    // `file` owns the `File` resource
    // Do something with the file
    // `file` is dropped here, and the file handle is closed automatically
}

Rust

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1; // Unsafe mutable access to global variable
    }
}

fn main() {
    increment();
    unsafe {
        println!("Counter: {}", COUNTER); // Unsafe read of global variable
    }
}

Rust

struct Counter {
    value: i32,
}

impl Counter {
    fn increment(&mut self) {
        // Mutable borrow of `self` to modify `value`
        self.value += 1;
    }

    fn get(&self) -> i32 {
        // Immutable borrow of `self` to read `value`
        self.value
    }
}

fn main() {
    let mut counter = Counter { value: 0 };
    counter.increment(); // Mutate `counter` through method
    println!("Counter: {}", counter.get());
}

Introduction

The Power of Ownership and Borrowing in Clean Code

Problem: Tight Coupling Without Ownership Principles

Join the 1M+ learners on CodeSignal

Solution: Reducing Dependencies with Borrowing

Problem: Unnecessary Data Cloning

Solution: Borrowing Instead of Cloning

Problem: Mutable Access Without Control

Solution: Controlled Mutation and Encapsulation

Applying Ownership to Manage Resources

Problem: Extensive Use of Global State

Solution: Use Local State and Pass as Needed

Summary and Next Steps