The Garden 19

Every note, filterable by growth stage and topic. Some are still unwritten.

Tools and practices 5

Welcome to the Garden

What this digital garden is and how to wander it.
Seedling

Spaced Repetition

Reviewing material at increasing intervals to fight forgetting.
Seedling

System calls: the border crossing

Your program cannot touch the disk, the network, or another process on its own - only the kernel can. A system call is the one controlled crossing into kernel space, and every crossing has a toll.
Seedling

Memory models: the rules behind happens-before

Single-threaded code runs in the order you wrote it. Put a second thread on the same memory and that stops being true - a memory model is the contract for which writes a thread is guaranteed to see, and when.
Budding

Garbage collection: the pause you didn't schedule

Automatic memory management removes a class of bugs by deciding for you when memory is safe to reclaim. You pay for that convenience in a currency that only shows up under load - pauses, CPU, and headroom.
Seedling

The cost of async

Async is sold as strictly faster. It is really a trade - cheap concurrency for work that waits, paid for with allocation, scheduling, and lost locality that CPU-bound code gets nothing back for.
Seedling

Async/await: syntax over a state machine

The keyword does not make code fast or parallel. It rewrites a function into something that can pause and resume, so one thread can be partway through thousands of waits at once.
Budding

The Go scheduler: G, M, and P

How Go runs hundreds of thousands of goroutines on a handful of OS threads - the G-M-P model, local run queues, work-stealing, and the syscall handoff.
Budding

Threads vs coroutines: who decides to yield

Both let a program do many things at once. The real difference is who is in control - the kernel that preempts a thread, or the coroutine that yields itself - and what each "thing" costs.
Budding

CPU-bound vs IO-bound

Whether your program spends its time computing or waiting decides your concurrency model - and quietly picks the language that will feel effortless.
Evergreen

Rate limiting as an invariant

A rate limit reads like a restriction from outside and like a promise from inside - the invariant that keeps a system in a regime where it still works.
Evergreen

Queues Are Everywhere

A queue decouples a producer from a consumer so they need not move at the same speed. Most of the queues in a system are the ones nobody drew on the diagram.
Seedling

Retries and idempotency

Retries are only safe when the operation is idempotent - otherwise you get duplicate records or double charges.
Seedling

Why APIs break

Breaking changes usually trace back to versioning, contracts, and team coordination - not just code.
Evergreen

Caching Isn't Cheating

Caching gets dismissed as a hack, but it is one of the oldest principled moves in computing - spending space, and a little staleness, to buy time.
Evergreen

Tail latency: the number the average hides

The average request looks fine while the slowest one percent decides your reputation. Why tails happen, and how to defend them.
Evergreen

Latency vs Throughput vs IOPS: why your fast API still fails at scale

Three performance numbers people blur together - and how the workload decides which one you should be optimizing.
Budding Map of Content

How Programs Actually Run MOC

A map of the runtime notes - how a program is scheduled onto threads and cores, how it shares memory without corrupting it, and what it costs to leave your own process.
Budding Map of Content

Performance & Latency MOC

A map of the performance notes - how to measure speed, the mechanisms that create it, and how to keep it under load.