#domain/software 13

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.
Seedling 7 months ago

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

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

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

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.
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.