Archive
1290 posts · Page 105 of 108. ← Blog
Strip a company down to its essence and what remains isn't the product, the code, or the strategy — it's the people who create all of those. An organization is its people, which makes attracting, developing, and keeping good people arguably the highest-leverage thing any company does. Yet engineers and technical leaders often treat "people stuff" as someone else's job (HR's), missing that hiring and developing a team is a core skill that shapes everything they can achieve. Understanding people — how to hire, grow, and keep them — is understanding how organizations actually succeed.
Strip a company down to its essence and what remains isn't the product or the code — it's the people who create all of those. An organization is its people, which makes attracting, developing, and keeping good people arguably the highest-leverage thing any company does. Yet engineers often treat 'people stuff' as HR's job, missing that building a team is a core skill.
Rust's central promise — the one that runs through this entire curriculum — is that you don't have to choose between safety and speed. The abstractions that make Rust pleasant to write (iterators, closures, traits, generics) compile down to code as fast as hand-written low-level equivalents. This closing post steps back to that promise, to what "idiomatic Rust" really means, and to where you go after the fundamentals. It's the capstone of Rust from the Ground Up — a look at the whole, and the road ahead.
Rust's central promise — the one that runs through this whole curriculum — is that you don't have to choose between safety and speed. This closing post steps back to that promise, to what 'idiomatic Rust' really means, and to where you go after the fundamentals. The capstone of Rust from the Ground Up.
A language is more than its syntax — it's the ecosystem and tooling around it, and this is one of Rust's quiet triumphs. The same Cargo you met on day one is the gateway to a vast registry of reusable libraries, a linter that teaches you idiomatic Rust, a formatter that ends style debates, and first-class documentation tooling. Rust's tooling is famously good, and knowing it turns you from someone who writes Rust into someone who's productive and idiomatic in the Rust ecosystem.
A language is more than its syntax — it's the ecosystem and tooling around it, and this is one of Rust's quiet triumphs. The same Cargo you met on day one is the gateway to a vast registry of libraries, a linter that teaches idiomatic Rust, a formatter that ends style debates, and first-class documentation tooling.
Everything so far has been pieces — ownership, traits, error handling, modules. Now we put them together into the kind of thing you'd actually ship: a small command-line application. Building a real program reveals how Rust's features combine in practice — structuring the code, parsing arguments, handling errors gracefully with `Result` and `?`, separating logic from `main` for testability, and returning proper exit codes. It's where the language stops being a set of concepts and becomes a tool for building software.
Everything so far has been pieces — ownership, traits, error handling, modules. Now we put them together into the kind of thing you'd actually ship: a small command-line application. Building a real program reveals how Rust's features combine in practice, where the language becomes a tool for building software.
Module 2 introduced closures as anonymous functions that capture their environment. But once you start passing functions around as values — storing callbacks, building higher-order APIs, returning behavior from functions — a few subtleties surface: functions and closures aren't quite the same type, returning a closure requires a boxing trick, and the `Fn` trait family has a precise structure worth knowing. These details show up constantly in real Rust APIs, and mastering them makes you fluent in Rust's functional side.
Module 2 introduced closures. But once you start passing functions around as values — callbacks, higher-order APIs, returning behavior — subtleties surface: functions and closures aren't quite the same type, returning a closure requires a boxing trick, and the Fn trait family has a precise structure worth knowing.
No language is an island. Decades of critical software — operating systems, libraries, codecs, crypto — is written in C, and any systems language that couldn't talk to it would be dead on arrival. Rust's foreign function interface lets it call C code (and be called from C), which is essential for interoperating with the existing world and for adopting Rust incrementally into C/C++ codebases. Crossing that boundary means leaving Rust's safety guarantees behind, so FFI is inherently unsafe — but it's a controlled, well-defined kind of unsafe.
No language is an island. Decades of critical software is written in C, and any systems language that couldn't talk to it would be dead on arrival. Rust's foreign function interface lets it call C (and be called from C) — essential for interoperating with the existing world and adopting Rust incrementally.
There is a keyword in Rust that feels almost heretical given everything the language stands for: `unsafe`. It exists because Rust's safety guarantees, powerful as they are, are necessarily conservative — the compiler rejects some things that are actually fine, and some low-level operations (talking to hardware, calling C, building certain data structures) genuinely require capabilities the safe subset forbids. `unsafe` is the escape hatch, and understanding it — what it does, what it doesn't, and how to use it responsibly — completes the picture of how Rust achieves safety.
There is a keyword in Rust that feels almost heretical: `unsafe`. It exists because Rust's safety guarantees are necessarily conservative, and some low-level operations genuinely require capabilities the safe subset forbids. Understanding it — what it does and doesn't do — completes the picture of how Rust achieves safety.
Rust's type system has a few corners that don't come up in beginner code but explain things you've quietly wondered about — why some functions "return" a type that isn't really a type, why `str` behaves differently from other types, and how to give a complicated type a readable name. These advanced type features are small individually but together deepen your understanding of how Rust's type system actually works, which pays off when reading real code and library internals.
Rust's type system has a few corners that don't come up in beginner code but explain things you've quietly wondered about — why some functions 'return' a type that isn't really a type, why `str` behaves differently, and how to give a complicated type a readable name.
Traits are Rust's core abstraction mechanism, and Module 2 covered the essentials — but the trait system has more depth that shows up constantly in real code and library APIs: associated types that make traits cleaner than generics, operator overloading, traits that build on other traits, and a pattern that lets you work around Rust's coherence rules. This module goes beyond the foundations into the advanced features you'll meet in serious Rust, starting with the corners of the trait system.
Traits are Rust's core abstraction, and Module 2 covered the essentials — but the trait system has more depth that shows up constantly in real code: associated types that make traits cleaner than generics, operator overloading, traits that build on other traits, and a pattern for working around Rust's coherence rules.
Passkeys are FIDO2; FIDO2 is the spec; Ed25519 is the signature algorithm. The full registration + assertion flow in 200 lines of stdlib Go.
Services need identity too, not just users. SPIFFE issues SVIDs (verifiable identity documents) to workloads; SPIRE is the reference issuer. The shape and the first deploy.
Two signals do most of the work for detecting compromised sessions: impossible travel between consecutive logins, and credential-stuffing density across an IP range. The Go implementation.