Ownership clicked for me — here's the mental model that worked_

A useful mental model: the borrow checker is a compile-time read-write lock. Many &T borrows = many readers (fine). One &mut T borrow = exclusive writer (no readers allowed). This is exactly why Rust can guarantee no data races without a runtime.

Every value has exactly one owner. When the owner goes out of scope, the value is dropped (freed). There is no GC, no manual free — the compiler inserts the drop at the right place. Ownership transfer (move) is the default for heap types. Copy types (integers, bools) are implicitly copied instead.

When the compiler cannot infer how long a reference lives, you annotate with a lifetime: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. The 'a just means 'the output lives at least as long as both inputs'. Lifetimes express constraints, they do not create them.

You can lend a value without transferring ownership by taking a reference. Shared references (&T) allow many readers simultaneously. Exclusive references (&mut T) allow one writer and no readers. The borrow checker enforces this statically. This is what makes data races a compile error.