Flattening Rust’s learning curve

- Each data object in Rust has exactly one owner. - Ownership can be transferred in ways that preserve the one-owner rule. - If you need multiple ownership, the real owner has to be a reference-counted cell. Those cells can be cloned (duplicated.) - If the owner goes away, so do the things it owns. - You can borrow access to a data object using a reference. - There's a big distinction between owning and referencing. - References can be passed around and stored, but cannot outlive the object. (That would be a "dangling pointer" error). - This is strictly enforced at compile time by the borrow checker.

I usually teach it by translating it to our physical world by way of an object like a book, which I like to think is intuitive.

I have a book. I own it. I can read it, and write into the margin. Tear the pages off if I want. I can destroy it when I am done with it. It is mine.

I can lend this book in read only to you and many others at the same time. No modifications possible. Nobody can write to it, not even me. But we can all read it. And borrower can lend it recursively in read only to anybody else.

Or I can lend this book exclusively to you in read/write. Nobody but you can write on it. Nobody can read it; not even me; while you borrow it. You could shred the pages, but you cannot destroy the book. You can share it exclusively in read/write to anybody else recursively. When they are done, when you are done, it is back in my hands.

I can give you this book. In this case it is yours to do as you please and you can destroy it.

If you think low level enough, even the shared reference analogy describes what happens in a computer. Nothing is truly parallel when accessing a shared resource. We need to take turns reading the pages. The hardware does this quickly by means of cached copies. And if you don't want people tearing off pages, give then a read only book except for the margins.