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

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.

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.

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.

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.