6.1 The lexicon and the discourse

Part 6 is the third machine: what Rust programmers mean, and how they say it.

This matters more for your stated goal than any single technical topic. You want to discuss Rust credibly. Credibility in a technical discussion is mostly precision — and Rust’s vocabulary is unusually precise, so imprecision is unusually visible.

The metaphors are technical terms

Rust’s core vocabulary is metaphorical, and every metaphor has an exact meaning.

Varies: the gap between the everyday word and the technical term

Word	Everyday sense	Exact Rust meaning
move	relocate something	Transfer ownership; source becomes unusable. Says nothing about bytes being relocated.
borrow	take temporarily, give back	Create a reference. There is no “giving back” — the borrow just ends.
outlive	live longer than	Region containment. `'a: 'b` means the set of program points `'a` contains `'b`.
own	possess	Be responsible for dropping. Exactly one owner at a time.
drop	let fall	Run the destructor and release resources, at a defined point.
implement for	—	Provide a trait’s methods for a specific type. Note for, not on — the preposition is fixed.

Using these loosely is the fastest way to signal that you have read about Rust rather than used it. Using them exactly is the fastest way to signal the opposite.

A note on the prepositions, because English fixes them and they are not guessable:

You implement a trait for a type. (Not on.)
A lifetime outlives another. (Not is longer than.)
A value is moved into a function, out of a struct.
A type is generic over T.
Code is generic over a lifetime, bounded by a trait.
A future is polled to completion.

Things not to say

More useful than a list of jargon. These are the overclaims that make an experienced listener quietly downgrade everything else you say.

“Rust prevents memory leaks.” It does not, and never claimed to. Rc cycles leak. mem::forget is a safe function. Leaking is memory-safe — it is not use-after-free. Say instead: “Rust prevents use-after-free and data races. Leaks are still possible, and Rc cycles are the usual way.”

“If it compiles, it works.” It compiles, so it has no data races, no use-after-free, and no null dereferences. Your logic can still be completely wrong. Say instead: “It eliminates a specific bug class. It doesn’t check that your code does the right thing.”

“Rust is faster than Go/Java.” Sometimes, and less than people assume for typical services. Rust competes with C++ at the top end; against a tuned Go service doing mostly I/O, the difference may be small and the development cost is real. Say instead: “It’s predictable — no GC pauses, and you can reason about allocation. Whether that matters depends on the workload.”

“The borrow checker prevents crashes.” It enforces a structural rule about references (2.1), and rejects some correct programs. Say instead: “It enforces shared-XOR-exclusive. That happens to prevent a class of bugs, and it also rejects some programs that would have been fine.”

“unsafe turns off the borrow checker.” It unlocks five abilities and disables nothing (5.1).

“Rust has no runtime.” It has a small one — panic handling, stack overflow detection, some initialisation. It has no garbage collector and no managed runtime. Say instead: “No GC, and no green-thread runtime unless you bring one.”

Being able to correct these gently is even more valuable than avoiding them. It is exactly the register a tech lead needs: precise without being pedantic.

Phrases that carry a lot

These are compressions. Using one correctly saves a paragraph.

“That’s a borrowck error, not a lifetime error.” — the distinction between overlapping borrows and insufficient regions.
“Make invalid states unrepresentable.” — replace flags and optionals with an enum.
“Zero-cost abstraction.” — compiles to what you would have written by hand.
“That’s not dyn-compatible.” — cannot be a trait object; usually a generic method or a Self return.
“Push the Arc down” / “pull the lock up.” — change where sharing or locking happens in the structure.
“That clone is fine, it’s an Arc.” — a refcount bump, not a deep copy.
“Is that cancellation-safe?” — asked about anything inside a select!.
“What’s the MSRV?” — asked when adding a dependency.
“Clippy will complain about that.” — a soft way to flag non-idiomatic code without making it personal. Genuinely useful in review.

Register: how disagreement sounds

The Rust community has a distinctive discussion style, and matching it makes participation easier — especially useful when English is not your first language, because the patterns are formulaic and learnable.

Hedging is normal and is not weakness. “I might be wrong, but…”, “if I’m reading this right…”, “I’d lean towards…” are standard even from very experienced people. Flat assertions read as more aggressive in this community than in many others.

Questions are preferred to statements when disagreeing. “Why Arc rather than Rc here?” lands better than “this should be Rc” — and it is safer, since the author may have a reason.

Concrete beats abstract. “This allocates per request” is much better received than “this is inefficient”.

When asking for help: show what you tried, paste the actual compiler error rather than paraphrasing, and state what you expected. The community is unusually welcoming, and also unusually insistent on a reproducible example. A Playground link is the gold standard.

Where the conversation happens

This Week in Rust — weekly digest. Twenty minutes a week keeps you current.
users.rust-lang.org — the official forum. Read some threads purely for register.
r/rust — announcements and discussion, more opinionated.
The RFC repository — where language changes are argued. Reading one RFC’s discussion thread teaches you more about how the community reasons than any amount of documentation.
docs.rs and lib.rs — the second ranks crates by real usage and is better for judging whether something is maintained.

Explain it to yourselfwrite it — thinking it does not count

Rewrite each of these to be accurate, in the register described above:

“Rust is memory safe so we won’t have leaks.”
“This is bad, use a channel.”
“The borrow checker is stopping me from doing something that’s obviously fine.”

For the third, write it as you would post it on the forum, asking for help.

The full lexicon

The complete list — around sixty terms, each with a definition and a sentence showing it in real use — is on the Glossary page. It is searchable and tagged.

Use it as a reference rather than something to memorise. The usage sentences are the part that matters: they are what you are trying to be able to produce, not just recognise.

What you should now be able to say

The metaphors — move, borrow, outlive, own — are exact technical terms, and their prepositions are fixed.
The common overclaims and their accurate replacements.
A set of compressed phrases that each save a paragraph.
The community’s register: hedged, question-shaped, concrete, with a Playground link.

Next: 6.2 — Explaining Rust to your team, the last lesson, which is entirely about the conversations you will actually have.