Introductory Rust books open with an explanation of ownership. But most people are made to read the definition before they have felt any need for it, and drop out. What we recommend is understanding it after the compiler has told you off.

Days 1-2: get told off about moves, repeatedly

rust
let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1); // error[E0382]: borrow of moved value: `s1`

Produce this error ten times. The rule that a value always has exactly one owner enters your body faster than any explanation could put it there.

Days 3-4: get around it by borrowing

When you do not want to hand over ownership, pass a reference instead. Experiencing that it compiles as soon as you add an & is what makes borrowing land as "lending without giving away ownership".

rust
fn show(s: &String) { println!("{}", s); }

let s = String::from("hello");
show(&s);
println!("{}", s); // still usable

Day 5: run into the restrictions on mutable borrows

Any number of immutable borrows, only one mutable borrow, and never both at once. This rule exists to kill data races at compile time. Once you start writing concurrent code, you will feel grateful for it.

Days 6-7: lifetimes can wait until last

You barely write a lifetime annotation until you put a reference inside a struct. At this stage, calling clone() and moving on teaches you more than memorising what 'a means.

Give yourself permission to clone early on. As your understanding of ownership grows, the clones disappear on their own.