Interview questions: ownership, borrowing and lifetimes

How to answer

Interviewers want to see that you understand why, not just that you memorised rules. A good structure: one-sentence definition, the reason it exists, a two-line example, and a common mistake. Practise saying answers out loud; explaining clearly is a skill.

Q1. What is ownership?

Model answer: "Ownership is how Rust manages memory without a garbage collector. Each value has one owner; there is one owner at a time; when the owner goes out of scope the value is dropped. The compiler checks this, so double frees and leaks from forgotten frees are prevented at compile time."

Q2. Move, Copy and Clone: what is the difference?

Model answer: "Assigning a heap-owning value like String moves it: only the pointer, length and capacity are copied and the old variable becomes invalid, to avoid a double free. Small stack-only types that implement Copy, such as integers and bool, are copied and both stay valid. clone() is an explicit deep copy that duplicates the heap data and costs time and memory."

Q3. What are the borrowing rules, and why?

Model answer: "At any time you can have either any number of shared references or exactly one mutable reference, and references must always be valid. This prevents data races and bugs like modifying a collection while iterating it. The checks happen at compile time, so there is no run-time cost."

Q4. String versus &str?

Model answer: "String owns growable UTF-8 text on the heap. &str is a borrowed view of some UTF-8 text: it can point into a String, a literal or another slice. I take &str as a function parameter because it accepts both, and return String when the function creates new text."

Q5. What is a lifetime? When do you write one?

Model answer: "A lifetime is the region of code where a reference is valid. The compiler infers most of them through elision rules. I write them when the compiler cannot tell how an output reference relates to the inputs, for example a function taking two &str and returning one of them, or a struct that holds a reference. Annotations describe relationships; they never extend how long anything lives."

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}

Q6. Why can a function not return a reference to a local variable?

Model answer: "The local is dropped when the function returns, so the reference would dangle. The compiler rejects it (E0106 or E0515). The fix is to return an owned value, like String, so ownership moves to the caller."

Q7. What are non-lexical lifetimes?

Model answer: "Since Rust 2018, a borrow lasts until its last use, not until the end of its block. So you can take a shared reference, use it, and then take a mutable one in the same block."

Q8. What does 'static mean?

Model answer: "As a lifetime on a reference, &'static T means the data lives for the entire program, like string literals. As a bound, T: 'static means the type holds no non-static references, which is why thread::spawn requires it: the thread might outlive any borrowed data."

Common interview mistakes

• Saying "Rust has no memory management". It has automatic, deterministic memory management through ownership.
• Saying a lifetime annotation "makes a value live longer". It does not.
• Saying clone is always bad. It is fine when data is small or a copy is truly needed; just know its cost.
• Long, rambling answers. Define, explain why, show a tiny example, stop.