#Infrastructure
446 posts
Does fork Really Copy Memory? — Copy-on-Write in Practice
Why fork duplicates an entire process yet finishes in milliseconds: copy-on-write at the page-table level. The copy-only-when-written mechanism, why fork+exec is nearly free, real cases like Redis snapshots and pre-fork servers, and why memory accounting and overcommit get confusing.
EFS vs EBS vs S3: Choosing AWS Storage
A working standard for choosing among the three AWS storage services: the access-model difference between block, file, and object storage, unit prices that spread from $0.023 to $0.30 per GB and the provisioned-versus-usage billing split behind them, hidden costs like EFS throughput charges, the common overengineering of using EFS without a sharing requirement, and a selection order driven by access patterns.
Processes vs. Threads — Everything Follows from Shared Memory
The process/thread difference unpacked from one criterion: whether memory is shared. The isolation-versus-sharing tradeoff, context switch costs, crash blast radius, and what nginx, browsers, Java, and Python (GIL) each chose — in practical terms.
SQS vs SNS vs EventBridge: Choosing a Messaging Service
A working standard for choosing among the three AWS messaging services: the model difference between a queue, pub/sub, and an event bus, where retention and retries exist and where they do not, pricing that spreads from $0.40 to $1.00 per million with 64KB-chunk billing, combination patterns like SNS-to-SQS fan-out, and the traps of EventBridge latency and FIFO throughput limits.
ALB vs NLB: Choosing a Load Balancer
A working standard for choosing between ALB and NLB: the layer difference between L7 routing and L4 forwarding, the things only NLB can do (static IPs, source IP preservation, PrivateLink), how bills diverge in LCU math even though the hourly rate is identical, hidden costs like cross-zone load balancing, and the chained NLB-to-ALB setup for when you need both.
How Linux Came to Dominate Servers — Cost, Architecture, Ecosystem
How Linux became the default server OS, from both the technical and ecosystem sides: the zero-license, open-source starting point, the structural traits that fit server duty (headless, remote-managed, long-running), the lock-in effects of the cloud and container eras, and the territories Linux never took.
Choosing a GPU Cloud: Hyperscaler vs Specialist GPU Cloud vs Serverless Inference
A working standard for where to rent GPUs for AI workloads: why H100 hourly rates run 2〜5x apart between hyperscalers (AWS) and specialist GPU clouds (Lambda, RunPod), what you accept when spot drops below half, where serverless inference removes GPU management with per-token billing, and the integration, network, and regulatory requirements that flip the price difference.
The Core of Incident Handling — What Matters Most When Things Break
Making incident response run on procedure instead of heroics: recovery before root cause, separating command, communications, and operations, severity levels and declaration criteria, writing blameless postmortems that still name causes, and the conditions that keep on-call sustainable.
Error Budgets — The Concept and Math of a Failure Allowance
The error budget that falls out of any SLO: converting budget size into time and request counts, why burn-rate alerts beat threshold alerts, the policy that fires when the budget runs dry, and running the speed-versus-stability conflict by rule instead of by meeting.
LLM Quantization Compared: FP16, INT8, INT4 and GGUF, AWQ, GPTQ
A working standard for choosing an LLM quantization method: how precision (FP16, INT8, INT4) halves VRAM, the math that takes a 70B model from 140GB to 35GB, where the three formats (GGUF, AWQ, GPTQ) diverge by use (local, GPU serving, accuracy), where INT4 degrades quality on reasoning and code tasks, and how to match the format to the serving framework.
SLI, SLO, SLA — From Metric to Objective to Contract
Sorting out the easily confused trio in working order: choosing good SLIs (the good-events-ratio method), setting SLO numbers realistically, why an SLA must be looser than the SLO, a feel for the nines, and the common mistakes.
vLLM vs Ollama vs SGLang: Choosing an LLM Serving Framework
A working standard for choosing an LLM serving framework when self-hosting: where local execution (Ollama) and production throughput (vLLM, SGLang) diverge, why PagedAttention and continuous batching open a 3〜4x throughput gap, the 2026 shift with TGI entering maintenance mode, differences in quantization and structured-output support, and a selection order by team size.