Learning Rust.
Ownership is the whole idea.

Most languages pick one: manual memory (C/C++ — fast, footguns) or a garbage collector (Go/Java — safe, runtime cost). Rust refuses the trade by moving the bookkeeping to compile time.

• No GC, no pauses. Memory is freed at a deterministic, known point — when its owner goes out of scope.
• No use-after-free, no data races. The compiler rejects them — they're not runtime bugs you hunt, they're build errors.
• "Fearless" is literal. The confidence comes from the compiler, not from your discipline or your test coverage.

The cost is real: you learn to think in ownership, and the compiler says "no" a lot at first. This deck is about making those "no"s legible.

The borrow checker is a theorem prover for "no aliasing bug." Pass it, and a whole class of CVEs is simply impossible in safe Rust.

The entire system rests on three rules the compiler enforces. Memorize these; the rest of Rust is consequences of them.

• 1. Each value has one owner — a single variable binding responsible for it.
• 2. One owner at a time — assign or pass it, and ownership moves; the old binding is no longer valid.
• 3. Owner drops → value freed — when the owner leaves scope, the value's Drop runs and its memory is released. Deterministically.

"Borrowing" (next act) is how you let other code use a value without taking ownership — the escape valve that makes rule 2 livable.

Moving everything everywhere would be miserable. References let you lend access. The one rule that makes them safe — and that the borrow checker enforces:

• Any number of shared & references (read-only), OR
• exactly one exclusive &mut reference (read-write) —
• never both at once. Aliasing XOR mutation. That single invariant is what prevents data races and iterator invalidation.

A reference borrows; it never owns. The borrow must end before the owner is moved or dropped — which is what lifetimes (slide 8) track.

A slice (&[T], &str) is a borrowed window — a pointer and a length — into a Vec or String it doesn't own. The borrow checker ties the window's lifetime to the buffer's.

• Hold a slice into a Vec, and you cannot mutate that Vec (e.g. push, which might reallocate) while the slice lives.
• That's the same aliasing-XOR-mutation rule preventing the classic C bug: a pointer left dangling by a realloc.

The bug doesn't need a sanitizer to find at runtime — it doesn't compile.

Rust enums are sum types: each variant can hold its own data. Combined with exhaustive match, you encode "exactly one of these, with its payload" — and the compiler won't let you forget a case.

• A variant can be empty, or carry a tuple/struct of data — model the real shape of your domain.
• match is exhaustive: miss a variant and it's a compile error, not a bug that ships.
• Matching binds the payload, so you handle the data and the case together.

This is how Option and Result are built — they're just enums in the standard library.

There are no exceptions to forget to catch. A function that can fail says so in its return type: Result<T, E> — either Ok(value) or Err(why).

• The signature is honest: you can't ignore a possible failure, because you have to unwrap the Result to get the value.
• ? is the ergonomic glue: "if this is Err, return it from the whole function; otherwise give me the Ok value."
• Errors propagate up the call stack as values, explicitly — no invisible control flow.

panic! exists for truly unrecoverable bugs — but recoverable failure is always a Result.

A trait is a set of methods a type can implement — Rust's answer to interfaces and the basis of generics. NetWatch's DPI layer is one trait, implemented 15 times.

• Define once, implement per type. Each protocol classifier impls the same Classifier trait.
• Static dispatch (<C: Classifier>) — the compiler generates a specialized copy per type. Zero runtime cost.
• Dynamic dispatch (&dyn Classifier) — one vtable, chosen at runtime. For heterogeneous collections.

Bounds like T: Send + Clone say "any type that can do these" — generic code that's still fully type-checked.

Rust has no null. A value that might be missing has type Option<T> — either Some(v) or None — and the compiler forces you to handle the None case before you can touch the value.

• No more accidental null dereferences — the absent case is visible in the type and checked at compile time.
• Rich combinators instead of null checks: map, unwrap_or, and_then, ok_or.
• ? works on Option too — propagate "nothing here" cleanly.

There's no finally, no defer, no garbage-collector finalizer-someday. A value's Drop runs the instant its owner leaves scope — including on early return or panic.

• RAII everywhere. A file closes, a lock unlocks, a socket detaches — because the guard owning it was dropped.
• You rarely write Drop by hand; you compose types that already clean up after themselves.
• Deterministic, not eventual. You know exactly when resources are released — the closing brace.

This is the same mechanism behind MutexGuard unlocking and NetWatch's eBPF handle detaching the kprobe.

cargo is build system, package manager, test runner, and doc generator in one. The cohesion is a feature: every project works the same way, and the ecosystem composes.

• crates.io — one registry; cargo add and a version is wired in, dependencies resolved.
• clippy — 600+ lints that catch real bugs and teach idioms as you go.
• rustfmt — one canonical style; formatting debates simply don't happen.
• rust-analyzer — a world-class language server: types, completions, and the borrow checker's reasoning live in your editor.

Tests and docs are first-class: cargo test runs unit, integration, and even the examples inside your doc comments.

Sometimes you must do what the compiler can't verify — talk to hardware, FFI, or read raw kernel memory. unsafe unlocks exactly five extra powers, and nothing else.

• It lets you dereference raw pointers, call unsafe fns, and a few more — that's the whole list.
• It does not disable the borrow checker, type checking, or ownership for everything else.
• It's a promise: "I've upheld the invariants the compiler can't see." Your job is to wrap it in a sound safe API.

Good Rust isolates unsafe to tiny, audited blocks behind safe interfaces — so the unsafety is contained, not spread.

Rust shines where correctness and control both matter — and the ownership tax pays for itself.

• Systems & infra — networking, databases, OS components, embedded. Predictable performance, no GC pauses.
• Anything concurrent — the compiler eliminates data races, so aggressive parallelism is safe.
• Long-lived, high-stakes code — the type system encodes invariants that survive refactors and new maintainers.
• CLI / TUI tools — fast startup, single static binary, great libraries (exactly NetWatch's niche).

Reach for a GC'd language when iteration speed beats control and a few ms of pause don't matter. Rust is a deliberate trade, not a default.