30 articles in applied systems › how things work.
How Flink uses Chandy-Lamport distributed snapshots, barrier alignment, RocksDB state backends, and incremental checkpointing to achieve exactly-once processing in stream jobs.
How S3 achieves 11 nines of durability through erasure coding, partition mapping, request routing, and cross-AZ replication across storage nodes.
How DynamoDB partitions data, handles adaptive capacity, performs consistent reads, and auto-splits hot partitions without downtime.
How Cassandra uses consistent hashing, gossip protocol, SSTables with LSM trees, and tunable consistency to handle millions of writes per second.
How PostgreSQL parses SQL, plans execution with the cost-based optimizer, chooses between sequential and index scans, and manages MVCC for concurrent reads and writes.
How Nginx uses an event-driven architecture with epoll, master-worker process model, and efficient connection handling to serve millions of concurrent connections.
How MongoDB stores documents as BSON, uses WiredTiger's B-tree and LSM engine, replicates via Raft-based elections, and distributes data through chunk-based sharding.
How Lambda manages execution environments with Firecracker microVMs, handles cold starts, routes invocations, and scales from zero to thousands of concurrent executions.
How gRPC uses HTTP/2 multiplexing, Protocol Buffers serialization, bidirectional streaming, and deadline propagation to achieve sub-millisecond inter-service communication.
How Linux containers use namespaces for isolation, cgroups for resource limits, overlay filesystems for layered images, and seccomp for syscall filtering.
How Prometheus uses pull-based scraping, TSDB with time-series compression, PromQL evaluation, and alerting rules to power modern observability stacks.
How Terraform parses HCL, builds a dependency graph, calculates diffs against state, and executes changes through provider plugins via gRPC.
How HashMaps use hash functions, bucket arrays, collision resolution with chaining and open addressing, and dynamic resizing to achieve O(1) average-case lookups.
How browsers parse HTML into a DOM tree, construct the CSSOM, build the render tree, perform layout calculations, and paint pixels through the compositing pipeline.
How garbage collectors use generational collection, mark-and-sweep, concurrent marking, and compaction to manage memory in JVM, V8, and Go runtimes.
How ClickHouse uses columnar storage, vectorized execution, MergeTree engine families, and distributed query processing to scan billions of rows per second.
How Snowflake's multi-cluster shared data architecture uses micro-partitions, virtual warehouses, result caching, and Time Travel to deliver elastic data warehousing.
How Cloudflare Workers use V8 isolates instead of containers, the event-driven execution model, KV storage, Durable Objects, and the global Anycast network to execute code within milliseconds of users.
How eBPF safely injects custom programs into the kernel using a verifier, JIT compiler, and hook points for networking, security, and observability without kernel module risks.
How Envoy uses the xDS discovery protocol with CDS, EDS, LDS, and RDS to dynamically configure clusters, endpoints, listeners, and routes without restarts.
How browsers enforce the same-origin policy, when preflight OPTIONS requests trigger, how Access-Control headers work, and why credentials mode changes everything.
How GraphQL parses queries into an AST, validates against a schema, resolves fields through the resolver tree, and handles N+1 problems with DataLoader batching.
How JIT compilers in the JVM (C1/C2), V8 (TurboFan), and .NET (RyuJIT) profile running code, identify hot paths, and compile bytecode to optimized machine code on the fly.
How OAuth 2.0 authorization code flow, PKCE, refresh tokens, and token introspection work together to secure API access without sharing passwords.
How RocksDB uses LSM tree architecture with memtables, SSTables, write-ahead log, and multiple compaction strategies to optimize write-heavy workloads while maintaining read performance.
How TLS certificates use public key infrastructure, certificate chains, OCSP stapling, and the certificate lifecycle from issuance to revocation to establish trust on the internet.
How video streaming uses adaptive bitrate with HLS/DASH, CDN edge caching, video encoding ladders, and buffer management to deliver smooth playback over unreliable networks.
How WebAssembly compiles high-level languages to a portable binary format, gets validated and compiled by the browser engine, and interoperates with JavaScript through linear memory and import/export tables.
How webhook systems reliably deliver HTTP callbacks using event queues, exponential backoff retries, signature verification, and dead letter queues to handle millions of outbound notifications.
How lossless compression uses Huffman coding, LZ77 dictionary matching, and DEFLATE to reduce data size, and how modern algorithms like Zstd and Brotli improve the speed-ratio tradeoff.