Rust interview questions for beginners — Part 2

Published in

Tech Tonic

13 min readMar 16, 2024

In this article series, we’ll go through Rust interview questions for beginners. As a multi-paradigm, general-purpose language, Rust programming language has gained popularity recently by engaging developers with its unique blend of performance, safety, and concurrency. While Rust’s community is growing at an incredible pace, its adoption in the industry is not far behind. Tech giants like Microsoft, Google, and Amazon have recognized Rust’s potential and are actively supporting it. As a result, Rust is increasingly finding its way into real-world applications and products.

This is the second article in this series. Without wasting further time, let’s jump into the questions 11 to 20 for beginner interviews.

The other articles are:

Question 11 — Explain the concept of modules and how they help organize code in Rust.

Modules are a fundamental building block for code organization in Rust. They allow you to group related functionality together, enhancing modularity, readability, and maintainability of the applications.

Benefits of modules

Organization: Modules help you structure your codebase by grouping related definitions (functions, structs, enums, etc.) under a common namespace. This improves code organization and makes it easier to find specific code elements.
Separation of concerns: Modules promote separation of concerns, allowing you to focus on specific functionalities within a module without worrying about conflicts with code in other parts of your program.
Namespace management: Modules act as namespaces, preventing naming conflicts between functions, structs, or other definitions with the same name but residing in different modules.
Code reusability: Well-defined modules with clear functionalities can be reused across different parts of your program or even in other projects, promoting code reusability.

How modules work

Defining modules: You can define modules using the mod keyword followed by the module name. The module body is enclosed in curly braces {}.

mod greetings {
  pub fn hello() {
    println!("Hello, world!");
  }
}

Access within modules: Elements defined within a module can be directly accessed by using their name.

fn main() {
  greetings::hello(); // Calling the hello function from the greetings module
}

Public vs. private visibility: By default, items defined within a module are private and cannot be accessed from outside the module. Use the pub keyword to make specific items publicly accessible.

mod greetings {
  pub fn hello() {
    println!("Hello, world!");
  }

  fn private_greeting() {
    // This function is private and cannot be accessed from outside the module
  }
}

Nested modules: You can create nested module hierarchies to further organize your code by grouping related sub-modules within a parent module.

Module files

Larger modules can be split across multiple files for better organization. Use a mod.rs file in the module directory to centralize module definitions and manage sub-modules. This mod.rs file typically includes statements like mod sub_module; to reference sub-modules and pub use sub_module::Item; to make specific items from sub-modules publicly accessible.

Question 12 — How can you handle user input in a Rust application?

Rust provides mechanisms to interact with the user and obtain inputs. Here’s a breakdown of the common approach.

Using the std::io library

The std::io library offers functionalities for standard input/output operations. You'll primarily be using the following APIs for handling user input:

stdin() function: This function returns a handle to the standard input stream, which is typically the keyboard by default.
read_line() method: This method is called on the standard input handle (stdin()) to read a line of text entered by the user. It takes a mutable string (&mut String) as an argument to store the user's input.

use std::io;

fn main() {
  let mut name = String::new();

  println!("Enter your name: ");
  io::stdin().read_line(&mut name).expect("Failed to read input");

  println!("Hello, {}!", name.trim()); // Remove trailing newline
}

Explanation

use std::io;: Brings the std::io library into scope for use.
let mut name = String::new();: Creates an empty string variable to store the user's input.
println!("Enter your name: ");: Prints a prompt to the user.
io::stdin(): Gets the standard input handle.
.read_line(&mut name): Reads a line of text from standard input and stores it in the name string.
.expect("Failed to read input"): Handles potential errors during reading (e.g., unexpected end-of-file).
println!("Hello, {}!", name.trim());:Prints a greeting message incorporating the user’s name.
name.trim(): Removes any trailing newline character from the input.

Error handling

The expect method used in the example panics the program if an error occurs while reading input. For more robust error handling, consider using options (Option<T>) or the Result<T, E> type to handle potential errors gracefully.

Question 13 — Describe the difference between `panic!` and `Result` for error handling in Rust.

Rust offers two primary approaches for handling errors:

panic! macro

Signals a critical error that the program cannot recover from.
Used for unexpected situations or bugs in your own code.
Causes the program to abruptly terminate.

fn divide(x: i32, y: i32) {
  if y == 0 {
    panic!("Division by zero!"); // Unrecoverable error
  }
  let result = x / y;
  result
}

Result type

Represents the outcome of an operation that might either succeed or encounter an error.
Provides a way to return both successful results (Ok(T)) and error values (Err(E)) from functions.
Allows for handling errors gracefully within the code.

fn divide(x: i32, y: i32) -> Result<i32, String> {
  if y == 0 {
    Err(String::from("Division by zero!")) // Error value
  } else {
    Ok(x / y) // Successful result
  }
}

Choosing the right approach

Use panic! for unexpected situations or internal errors in your code that indicate a bug and require immediate program termination.
Use Result for anticipated errors that can be handled within the program logic. This allows for providing meaningful error messages and potentially recovering from the error or taking alternative actions.

Question 14— What are traits in Rust? How do they promote code reusability?

Traits are fundamental building blocks that define behavior (methods) that various types can implement. They act as contracts, specifying what functionalities a type must provide without dictating how those functionalities are implemented.

Benefits of traits

Code reusability: Traits promote code reusability by allowing you to define functionalities once in a trait and then have different types implement that trait. This avoids code duplication and enables you to write generic code that works with various types as long as they implement the required trait.
Abstraction: Traits provide a layer of abstraction by separating the definition of behavior (what needs to be done) from the implementation details (how it’s done). This allows you to focus on the overall functionality of your code without being concerned with specific implementations for different types.
Polymorphism: Traits enable polymorphism, meaning you can write functions or methods that can operate on different types as long as they implement a common trait. This makes your code more flexible and adaptable.

// Define a trait for shapes that can calculate their area
trait Shape {
  fn area(&self) -> f64;
}

// Implement the Shape trait for a rectangle struct
struct Rectangle {
  width: f64,
  height: f64,
}

impl Shape for Rectangle {
  fn area(&self) -> f64 {
    self.width * self.height
  }
}

// Implement the Shape trait for a circle struct
struct Circle {
  radius: f64,
}

impl Shape for Circle {
  fn area(&self) -> f64 {
    3.14159 * self.radius * self.radius
  }
}

// Function to calculate the area of any Shape
fn calculate_area(shape: &dyn Shape) -> f64 {
  shape.area()
}

fn main() {
  let rect = Rectangle { width: 5.0, height: 3.0 };
  let circle = Circle { radius: 2.0 };

  let rect_area = calculate_area(&rect);
  let circle_area = calculate_area(&circle);

  println!("Rectangle area: {}", rect_area);
  println!("Circle area: {}", circle_area);
}

Explanation

We define a Shape trait with an area method.
Rectangle and Circle structs implement the Shape trait, providing their own implementations for the area method.
The calculate_area function takes a reference to any type that implements the Shape trait (&dyn Shape), demonstrating polymorphism.
This allows us to calculate the area of both Rectangle and Circle using the same function.

Question 15 — What is the role of Cargo in the Rust development process?

Cargo is the official package manager for Rust. It plays a crucial role in streamlining various aspects of the Rust development process, including:

Project setup: When you start a new Rust project, Cargo helps you create the initial project structure with directories for source code, dependencies, and configuration files.
Dependency management: Cargo allows you to declare the external libraries (crates) your project relies on in a Cargo.toml file. It then downloads these dependencies and their dependencies from the Rust registry (crates.io) and manages their versions to ensure compatibility.
Package building: Cargo provides commands for compiling your Rust code and its dependencies into an executable or library. It handles the compilation process, linking with necessary libraries, and generating the final output.
Testing: Cargo helps you integrate testing frameworks into your project and provides commands to run your tests efficiently.
Documentation generation: Cargo can be used to generate documentation for your code in various formats, such as HTML.
Publishing: If you create a reusable library, Cargo provides functionalities to publish your code as a crate on crates.io, allowing others to use it in their projects.

Benefits of using Cargo

Simplified workflow: Cargo automates many tasks involved in building and managing Rust projects, saving you time and effort.
Dependency resolution: Cargo ensures that your project uses compatible versions of all dependencies, avoiding potential conflicts.
Reusability: Cargo facilitates the creation and sharing of reusable libraries (crates) within the Rust community.
Consistent experience: Using Cargo provides a standardized way to manage projects across different development environments.

Cargo commands

Here are some essential Cargo commands to get you started:

cargo new <project_name>: Creates a new Rust project.
cargo build: Compiles your project and its dependencies.
cargo run: Builds and runs your project.
cargo test: Runs the unit tests for your project.

In essence, Cargo acts as a central hub for managing all aspects of a Rust project’s lifecycle, from setup and dependency management to building, testing, and potentially publishing reusable libraries.

Question 16 — Explain the concept of pattern matching in Rust. How can it be used for data validation?

Pattern matching is a powerful control flow mechanism in Rust that allows you to compare a value against various patterns and execute code based on which pattern matches. It provides a concise and expressive way to handle different cases of data.

Patterns can include literals (like numbers or strings), variables, wildcards (_), and more complex constructs like ranges or nested patterns. When a value is matched against a pattern, the variable names in the pattern bind to the corresponding parts of the value if the match is successful.

let number = 5;

match number {
  1 => println!("One"),
  2 => println!("Two"),
  _ => println!("Something else"),
}

The match expression compares the value of number with different patterns.
If the number is 1, the code inside the 1 => ... block is executed.
Similarly, for 2.
The _ (wildcard) pattern matches any value and acts as a catch-all for cases not explicitly handled.

Data validation with pattern matching

Pattern matching excels at data validation by allowing you to check the structure and contents of your data. Here’s how:

Matching against specific values: You can use literals or ranges to ensure data falls within a specific range.

let input = String::from("Hello");

match input.len() {
  5 => println!("The string has 5 characters"),
  _ => println!("The string has a different length"),
}

Destructuring patterns: You can use destructuring patterns to extract specific parts from data structures (structs, enums, tuples) and validate their contents.

let message = (String::from("Error"), 404);

match message {
  (error_type, code) if code >= 400 && code < 500 => println!("Client error: {}", error_type),
  _ => println!("Unexpected message format"),
}

Matching against specific types: You can use type patterns to ensure the data being matched has the expected type.

let value: Option<i32> = Some(10);

match value {
  Some(number) => println!("The value is {}", number),
  None => println!("The value is None"),
}

Benefits of using pattern matching for validation

Readability: Pattern matching makes validation code clear and concise, improving code maintainability.
Exhaustiveness checking: The Rust compiler can verify that your pattern matching is exhaustive, ensuring all possible cases are handled. This helps prevent unexpected behavior due to unhandled data types or structures.
Flexibility: Pattern matching can handle various data types and structures, offering a versatile tool for data validation.

Question 17 — Describe the ownership behavior when passing data to functions in Rust (by value vs. by reference).

Understanding Ownership

Each value in Rust has a single owner. This owner is responsible for ensuring the value’s memory is eventually deallocated (freed) when it’s no longer needed.
Moving ownership: When you assign a value to another variable or pass it to a function by value, ownership is moved. The original variable can no longer be used.

Passing by Value

When you pass data to a function by value, a copy of the data is created on the stack memory.
The function receives ownership of this copy, and any modifications made within the function only affect the copy.
The original variable retains its ownership and value unchanged.

fn increment_by_value(x: i32) -> i32 {
  x + 1 // Here, a copy of x is incremented
}

fn main() {
  let num = 5;
  let new_num = increment_by_value(num);
  println!("Original value: {}", num); // Original value remains 5
  println!("New value (passed by value): {}", new_num); // New value is 6 (copy)
}

Passing by Reference

When you pass data by reference using the & symbol, you pass a reference (memory address) to the original data.
The function can access and modify the original data through this reference.
Ownership remains with the original variable, allowing both the function and the caller to access and potentially modify the same data.

fn increment_by_reference(x: &mut i32) {
  *x += 1; // Dereferencing the reference to modify the original value
}

fn main() {
  let mut num = 5;
  increment_by_reference(&mut num);
  println!("Original value (after modification): {}", num); // Modified value is 6
}

Choosing between passing by value and reference

Use passing by value for small data types like integers or booleans when you don’t need to modify the original data and want a clear copy for the function’s use.
Use passing by reference for larger data structures (like vectors or structs) to avoid unnecessary copying and potentially modify the original data within the function.
Be mindful of mutability (mut) when passing by reference. Use it only when the function needs to modify the original data.

Question 18 — What are closures in Rust? How do they differ from regular functions?

Closures in Rust are anonymous functions that can capture the environment (variables) in which they are defined. This captured environment allows them to access and potentially modify those variables even after the function that created them has returned.

Key characteristics of closures:

Anonymous: Closures don’t have a formal name like regular functions.
Environment capture: They can capture variables from their surrounding scope, creating a closure over those variables.
Moves or borrows ownership: The captured variables can be either moved by value into the closure (ownership is transferred) or borrowed by reference (& or &mut).

let mut count = 0;

let increment = || {
  count += 1; // Captures the `count` variable by reference
  println!("Count: {}", count);
};

increment(); // Calls the closure
increment(); // Still has access to the captured `count`

Benefits of Closures

Flexibility: Closures allow you to create functions on the fly without needing a formal definition, enhancing code conciseness and adaptability.
Data Encapsulation: By capturing variables, closures can create a self-contained unit of functionality with access to specific data, improving code organization.
Event Handling: Closures are often used in event-driven programming, where functions are passed as arguments to be executed when certain events occur.

Question 19 — How can you test your Rust programs effectively?

Rust offers a robust testing ecosystem with various tools and methodologies to ensure your code functions as expected. Here are some key approaches:

Unit Testing

Focuses on testing individual units of code (functions, modules) in isolation.
Uses libraries like unit_test to define test functions marked with the #[test] attribute.
Tests specific functionalities of your code and verifies outputs for various inputs.

#[test]
fn test_add() {
  assert_eq!(add(2, 3), 5);
}

Integration Testing

Tests how different components (modules, libraries) interact with each other.
Simulates how your program interacts with external dependencies like databases or APIs.
Ensures that all parts of your system work together seamlessly.

End-to-End Testing (Acceptance Testing)

Tests the overall behavior of your program from the user’s perspective.
Simulates user interactions and verifies expected system outputs.
Often involves tools for browser automation or API testing frameworks.

Property-Based Testing

Uses libraries like prop to generate random test cases based on defined properties.
Verifies that your code behaves correctly for a wide range of possible inputs.
Helps identify edge cases and unexpected behaviors.

Testing Tools and Frameworks

cargo test: The built-in Cargo command for running your tests.
unit_test: A popular library for writing unit tests.
test-runner: An alternative test runner with additional features like parallel test execution.
prop: A library for property-based testing.
mockito: A library for mocking external dependencies in tests.

Question 20 — What are some common mistakes beginners make when using Rust? How can they be avoided?

Unnecessary Indirection

Mistake: Beginners might use references (&) or smart pointers (Rc, Arc) even when a simple value by copy would suffice.
How to avoid: Consider if the data needs to be shared or modified by multiple parts of your code. If not, using the data by value can be more efficient and avoid potential overhead associated with references or smart pointers.

Incorrect Borrowing

Mistake: Misusing references (&, &mut) or forgetting to borrow when accessing data can lead to compilation errors or unexpected behavior.
How to avoid: Understand the Rust ownership system and borrowing rules thoroughly. Use tools like the borrow checker to identify borrowing issues and ensure your code adheres to Rust’s memory safety guarantees.

Excessive Cloning

Mistake: Cloning data (e.g., copying strings) unnecessarily can impact performance, especially for large data structures.
How to avoid: Consider using slices (&[T]) or iterators to access parts of data structures without copying the entire thing. Utilize methods like iter() or as_ref() for efficient data access.

Inefficient String Concatenation

Mistake: Repeated string concatenation using the + operator can be inefficient.
How to avoid: Use methods like String::from or format! for creating strings from multiple parts. These methods handle memory management more efficiently.

Early Returns

Mistake: Trying to return from a function without using the return keyword can lead to unexpected behavior and dangling code.
How to avoid: Always use the return keyword explicitly when returning a value from a function.

Incorrect Mutability

Mistake: Using mut keyword excessively or forgetting to use it when necessary can lead to ownership issues or runtime errors.
How to avoid: Understand when data needs to be modified and use mut only when necessary. Consider using functions that take ownership and modify the data internally if appropriate.

Ignoring Compiler Warnings

Mistake: Overlooking compiler warnings can lead to potential bugs or unexpected behavior.
How to avoid: Pay attention to compiler warnings and address them appropriately. Rust’s compiler often provides helpful hints and suggestions for improving your code.

That’s all about questions 11 to 20. The other articles in this series are:

Thanks for reading! I hope this will be helpful for your next Rust interview.