Rust Interview Preparation

# CHAPTER 28

Rust Interview Preparation #

1. Chapter Introduction #

2. The Big Three: Ownership, Borrowing, and Lifetimes #

Q1: Explain Rust's Ownership rules. How do they replace Garbage Collection? *Answer:*

1. 1. Every value has an owner.

1. 2. There can only be one owner at a time.

1. 3. When the owner goes out of scope, the value is dropped.

Q2: What is the difference between a Move and a Copy? *Answer:* Types with a known size on the Stack (like i32, bool) implement the Copy trait; let y = x copies the data. Types on the Heap (like String, Vec) do not. let y = x *Moves* ownership to y, invalidating x to prevent double-free errors.

Q3: State the rules of the Borrow Checker. *Answer:* At any given time, you can have either one mutable reference (&mut T) OR any number of immutable references (&T). You can never have both simultaneously. This strictly prevents Data Races.

Q4: What is a Lifetime Annotation ('a) and why is it needed? *Answer:* A lifetime annotation does not change how long a variable lives. It describes the relationship between the lifetimes of multiple references so the compiler can guarantee that a returned reference will not outlive the data it points to.

3. Concurrency and Async #

Q5: What is a Data Race, and how does Rust prevent it? *Answer:* A data race occurs when two threads access the same memory concurrently, and at least one is writing to it. Rust prevents this using the Borrow Checker's rule: you cannot have aliasing (multiple references) AND mutation at the same time.

Q6: Differentiate between Rc<T> and Arc<T>. When would you use a Mutex? *Answer:* Rc is for single-threaded multiple ownership. Arc is Atomic and thread-safe. You use an Arc<Mutex<T>> when multiple threads need to safely mutate shared state. The Mutex ensures only one thread modifies the data at a time.

Q7: Why doesn't Rust's standard library include an Async runtime? *Answer:* To keep the core language lean and suitable for embedded systems (no_std). It allows the community to build specialized runtimes (like Tokio for heavy I/O networking, or embassy for microcontrollers).

4. Traits and Data Modeling #

Q8: How does Rust achieve Polymorphism without Inheritance? *Answer:* Through Traits (defining shared behavior) and Generics. A function can accept any type <T> as long as it has a Trait Bound (<T: Summary>).

Q9: What is the purpose of the Option Enum? *Answer:* It replaces null. It forces developers to explicitly handle the None case at compile-time via match or if let, making Null Pointer Exceptions mathematically impossible.

Q10: What is the Result Enum? *Answer:* It handles recoverable errors (Ok(T) and Err(E)). Combined with the ? operator, it allows for clean, explicit error propagation up the call stack instead of unpredictable try/catch exceptions.

5. Coding Challenges #

Challenge 1: Find the first word in a string (Without taking ownership) *Solution:*

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

Challenge 2: Process a Vector using Iterators *Prompt:* Given a Vec<i32>, return a new vector containing only the even numbers, multiplied by 10. *Solution:*

fn process_numbers(nums: Vec<i32>) -> Vec<i32> {
    nums.into_iter()
        .filter(|x| x % 2 == 0)
        .map(|x| x * 10)
        .collect()
}

6. Common Pitfalls to Avoid in Interviews #

• Overusing .clone(): If an interviewer sees you throwing .clone() everywhere to satisfy the compiler, they will assume you don't understand references. Try to use & borrows first.

• Overusing unwrap(): In coding challenges, use the ? operator or match to handle errors. Writing .unwrap() shows a disregard for production safety.

7. Exercises #

1. 1. Practice writing the firstword function from memory.

9. Summary #

10. Next Chapter Recommendation #