#concept/tradeoffs 10

Notes filed under this topic. All tags

Seedling 6 months ago

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.
Budding 8 months ago

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 9 months ago

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.
Budding 10 months ago

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 10 months ago

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 12 months ago

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 last year

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 2 years ago

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 2 years ago

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

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.