Rust Systems Programming - Ownership, Lifetimes & Concurrency

1. Each value in Rust has an owner variable.
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value is automatically dropped.

Types without Copy transfer ownership on assignment or function call (move), invalidating the original variable. Types implementing Copy (like i32, bool, f64) duplicate via bitwise copy, leaving the original valid.

At any given point in execution, data can have either:

They can never coexist in the same scope to eliminate data races at compile time.

The Rust borrow checker feature where a reference's lifetime ends at its last point of use, rather than at the end of its enclosing scope block.

Explicit parameters declared in function or struct signatures that describe relationships between reference lifetimes to help the borrow checker validate memory safety. They do not alter runtime lifetimes.

Compiler heuristics that automatically assign lifetimes without explicit syntax:
1. Each input reference parameter gets its own lifetime.
2. If there is exactly one input lifetime, it is assigned to all output lifetimes.
3. If one input is &self or &mut self, its lifetime is assigned to all output lifetimes.

Indicates that references can live for the entire duration of the program execution (e.g., hardcoded string literals &'static str) or that a type contains no non-static references.

Rust's standard type for handling optional values without null pointers:

enum Option<T> {
    Some(T),
    None,
}