#Infrastructure
380 posts
MCP (Model Context Protocol) Explained: The Standard for AI Tool Use
A single-post summary of MCP, the protocol that keeps appearing in agent articles: how a standard interface turns the N-by-M tool-integration problem into N-plus-M, its relationship to function calling, hosts, clients, servers and the tools/resources/prompts primitives, adoption status and foundation governance as of 2026, security cautions from third-party server trust to prompt injection, and when adopting it is worth it — and when it is not.
What a Database Index Actually Does — B-trees, Lookup Cost, and the Price of Writes
How indexes make lookups fast, from the B-tree up: the cost gap versus full scans, composite indexes and column order, why indexes are not free (write cost, storage), and the working rules for what to index and what to leave alone.
RAG vs Fine-Tuning vs Long Context: Getting Knowledge Into an LLM
A working standard for the three ways to get your data into an LLM: the structural difference between retrieving and injecting (RAG), modifying weights (fine-tuning), and stuffing everything in with caching (long context), the boundary that fine-tuning teaches behavior rather than knowledge, a selection order driven by knowledge size and update frequency, and the practical setup that combines all three.
When a REST API Is Slow — the Order for Finding the Bottleneck
Finding API bottlenecks by procedure instead of instinct: instrumenting to split the request into segments, the four usual suspects (database, serialization, external calls, N+1), the priority order of fixes like caching and pagination, and why p99 matters more than p50.
RI vs Savings Plans: Choosing an AWS Commitment Discount
A working standard for choosing between Reserved Instances and Savings Plans: the structural difference between matching instance attributes and committing to an hourly spend, the flexibility split behind the identical 72% maximum discount, the services Savings Plans cannot cover (RDS and friends), capacity reservation as a separate problem, and how to size a commitment against the stable floor of your bill.
What Load Average Actually Is — and How It Differs from CPU Usage
Reading the most misread metric in Linux correctly: the definition (running + runnable + disk-wait D-state tasks), judging against core count, the four classic ways it diverges from CPU usage, and reading the 1/5/15-minute triple as a trend.
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.