Rust ownership and borrowing in outline

What it is

The Rust book states three rules: each value has an owner, there can only be one owner at a time, and when the owner goes out of scope the value is dropped. Assigning or passing a heap-owning value such as a String moves it; using the old binding afterwards is a compile error, not a runtime surprise. Types that live entirely on the stack (integers, bool, char, tuples of them) implement Copy and are duplicated instead, and .clone() makes an explicit deep copy. A reference (&T or &mut T) borrows a value without taking ownership; the book gives two rules for references: at any given time either one mutable reference or any number of immutable references, and references must always be valid. The compiler's borrow checker rejects a reference that would outlive its value (a dangling reference) and a mutation while a shared reference is alive. The book contrasts this with languages that have a garbage collector, where the collector tracks memory that is no longer used.

Why it matters

In Python or JavaScript every object is shared by reference and freed by the collector; aliasing plus mutation is normal and occasionally a bug. Rust's rules turn that bug class, along with iterator invalidation and data races, into compile errors. The cost is that patterns that were free before (two structures holding the same object, a method returning a reference into a temporary) require a deliberate choice.

How to apply

• Default to passing references: &T for reads and &mut T for in-place changes; pass ownership only when the callee needs to keep the value.
• Return owned values from constructors and parsers; return references only when the result borrows from an argument, and let the compiler ask for a lifetime annotation when it cannot infer the link.
• Use Rc<T> (single-threaded) or Arc<T> (shared across threads) when several owners are genuinely needed, and RefCell or Mutex when shared data must also be mutated.
• When the checker complains, restructure first (shorten the borrow, clone a small value, split a struct into independently borrowed parts) before reaching for unsafe.

Pitfalls

Holding a & into a Vec while pushing to it. Iterating a collection by value (for x in v) moves it; iterate &v to keep it. Storing references in a struct makes the struct generic over a lifetime. Calling clone() on large data to silence the checker hides the design problem instead of fixing it.