Rust Systems Programming - Ownership, Lifetimes & Borrowing Flashcards

Question 1

Three Fundamental Rules of Ownership

Accepted Answer

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

Question 2

Move Semantics vs. Copy Semantics

Accepted Answer

Types implementing the `Copy` trait perform bitwise duplication on assignment. Types without `Copy` (e.g., `String`, `Vec`) transfer ownership via a **move**, rendering the original variable uninitialized and unusable.

Question 3

The Borrow Checker

Accepted Answer

A static analysis tool within the Rust compiler that enforces borrowing rules, preventing memory safety bugs such as dangling pointers, double frees, and data races at compile time.

Question 4

Aliasing XOR Mutability Rule

Accepted Answer

At any given point in a scope, you can have either:
- **Any number of immutable references** (`&T`), OR
- **Exactly one mutable reference** (`&mut T`).

You can never have both simultaneously.

Question 5

Non-Lexical Lifetimes (NLL)

Accepted Answer

A compiler feature that determines reference lifetimes based on actual **usage** in the control flow graph, rather than strict lexical block scopes (`{}`), making borrowing more flexible.

Question 6

Lifetime Annotations (`'a`)

Accepted Answer

Explicit syntax (e.g., `fn foo<'a>(x: &'a str) -> &'a str`) used to tell the compiler how the lifetimes of different references relate to each other, ensuring return references remain valid.

Question 7

Lifetime Elision Rules

Accepted Answer

Three deterministic heuristics compiler rules that allow developers to omit explicit lifetime annotations in common function signature patterns:
1. Each elided input parameter gets its own lifetime.
2. If there is one input lifetime, it is assigned to all output lifetimes.
3. If `&self` or `&mut self` is an input, its lifetime is assigned to all output lifetimes.

Question 8

The Static Lifetime (`'static`)

Accepted Answer

A special lifetime indicating that data lives for the entire execution of the program (e.g., string literals `&'static str`), or a trait bound specifying a type contains no non-static references.

Question 9

Smart Pointer: `Box<T>`

Accepted Answer

A heap-allocation pointer with single ownership. Used for allocating data on the heap when size is unknown at compile time (e.g., recursive types) or for transferring large data without copying.

Question 10

Smart Pointer: `Rc<T>`

Accepted Answer

**Reference Counted** smart pointer for shared, immutable single-threaded ownership on the heap. Memory is deallocated when the reference count drops to zero. *Not thread-safe.*

Question 11

Smart Pointer: `Arc<T>`

Accepted Answer

**Atomic Reference Counted** smart pointer that enables shared ownership across multiple threads using atomic operations for reference counter modifications.

Question 12

Interior Mutability & `RefCell<T>`

Accepted Answer

A design pattern allowing value modification through an immutable reference. `RefCell<T>` enforces Rust's borrowing rules at **runtime** instead of compile time, panicking on rule violations.

Question 13

Concurrency Primitives: `Mutex` vs. `RwLock`

Accepted Answer

- `Mutex` provides dynamic interior mutability across threads by allowing only **one thread** access at a time. - `RwLock` allows **multiple concurrent readers** OR **one single writer** across threads.

Question 14

Enum Pattern Matching (`match`)

Accepted Answer

A control flow operator that matches a value against patterns. In Rust, `match` statements are **exhaustive**; every possible enum variant must be handled.

Question 15

Handling Nullable Values: `Option<T>`

Accepted Answer

An enum representing either presence (`Some(T)`) or absence (`None`) of a value. Eliminates null pointer errors by requiring explicit handling via pattern matching or helper methods like `unwrap_or()`.

Question 16

Error Handling: `Result<T, E>` and `?` Operator

Accepted Answer

An enum for recoverable errors (`Ok(T)` or `Err(E)`). The `?` operator unwraps the `Ok` value or early-returns the `Err` variant from the enclosing function.

Question 17

The `Send` Marker Trait

Accepted Answer

An auto-trait indicating that ownership of a type can be safely transferred across thread boundaries. Most types are `Send`; non-`Send` types include raw pointers and `Rc<T>`.

Question 18

The `Sync` Marker Trait

Accepted Answer

An auto-trait indicating that references to a type (`&T`) can be safely shared across multiple threads. A type `T` is `Sync` if and only if `&T` is `Send`.

Question 19

Trait Bounds (`where` clause / `T: Trait`)

Accepted Answer

Constraints on generic parameters restricting them to types that implement specified behavior. Example:
```rust
fn print_item<T: std::fmt::Display>(item: T) {
    println!("{}", item);
}
```

Question 20

RAII and the `Drop` Trait

Accepted Answer

Resource Acquisition Is Initialization: resources (memory, file handles, sockets) are automatically cleaned up when an owner goes out of scope by calling its `Drop` trait implementation.

Rust Systems Programming - Ownership, Lifetimes & Borrowing

Card Preview

Related Flashcard Sets

SQL Indexing, B-Trees & Query Optimization

Organic Chemistry - Nucleophilic Substitution & Elimination Mechanisms

MIT 8.01 - Classical Mechanics & Newtonian Dynamics

French A1/A2 - Essential Daily Vocabulary & Grammar Foundations