Most of what we call “systems programming” has nothing to do with kernels. It is a set of habits about how software fails. Those habits transfer to every program you will ever write.

Measure before you optimize #

The fastest code is the code that never runs, and the second fastest is the code you stopped calling after you looked at a profile. Guesses about performance are wrong in both directions, expensively.

Make failure modes explicit #

When a function returns Result, the caller cannot forget the failure case — the program will not compile until they choose. That single design decision removes an entire class of silently-swallowed errors from the codebase.

Prefer boring determinism #

Deterministic builds, sorted iteration, no hidden timestamps: none of these are glamorous, and all of them make debugging a first-class activity. If the same input produces different output, you cannot diff reality against expectations.

rust
let mut paths: Vec<PathBuf> = read_dir("content")?.collect();
paths.sort(); // deterministic output, reproducible tests

Bound the blast radius #

Small modules with clear inputs are not an aesthetic preference. They decide how far a bug can travel. A renderer that receives an event stream and returns HTML cannot corrupt your configuration loader — there is simply no path.

Checklists are systems programming #

Run the same checks every time: format, lint, test, build, verify, deploy. A pipeline that skips silently is worse than no pipeline, because it manufactures false confidence. CI that only passes is a feature, not a bureaucracy.

These habits are why this blog is generated by a program instead of assembled by hand: the pipeline enforces the checks, so the writing stays the fun part.