Blog — Page 8 of 53
Browsing page 8 of 53 — 634 articles and counting.
How WebSockets Work: The Upgrade Handshake, Frame Protocol, and Bidirectional Communication From HTTP to Persistent Connection
A deep dive into the WebSocket protocol internals: the HTTP upgrade handshake with Sec-WebSocket-Key/Accept computation, the binary frame format, control frames, permessage-deflate compression, and production considerations for horizontal scaling, backpressure, and reconnection.
How Kubernetes Works: Pods, Scheduling, and the Reconciliation Loop
A deep dive into Kubernetes internals covering the control plane architecture, etcd watch mechanics, the scheduler's filter and score phases, controller manager reconciliation loops, kubelet pod assignment, the CRI and CNI plugin models, and production considerations for resource requests, pod disruption budgets, and cluster autoscaler behavior.
How PostgreSQL Works: MVCC, the Query Planner, and the Storage Engine Behind the World's Most Advanced Open-Source Database
A deep technical guide to PostgreSQL internals: the process model, heap storage with 8KB pages and TOAST, MVCC via xmin/xmax snapshot isolation, the write-ahead log, the cost-based query planner, index types from B-tree to GIN and BRIN, the buffer manager, vacuum, and production tuning for shared_buffers, work_mem, and connection pooling.
How React Works Internally: The Fiber Architecture, Reconciliation Algorithm, and Concurrent Rendering from setState to DOM Update
A deep dive into React's internal architecture covering the Fiber tree data structure, the O(n) reconciliation algorithm, hook storage as linked lists, concurrent rendering with lanes and priority scheduling, and the complete lifecycle of a state update from setState through to DOM commit.
How Docker Works: Namespaces, Cgroups, Union Filesystems, and the Container Runtime from Build to Execution
A deep dive into Docker internals covering Linux namespace isolation, cgroup resource constraints, OverlayFS copy-on-write layer mechanics, Dockerfile build cache invalidation rules, the containerd and runc OCI runtime stack, and production considerations for image hardening and startup latency.
How Elasticsearch Works: Inverted Indexes, Segment Merges, and Distributed Search From Query to Hit
A deep dive into Elasticsearch internals covering the Lucene foundation, immutable segment storage, distributed search execution, BM25 relevance scoring, near-real-time search mechanics, and cluster scaling patterns.
How Kafka Works: Partitions, Replication, Consumer Groups, and the Commit Log
A deep dive into Kafka internals covering the append-only commit log, partition-level ordering, leader-follower replication with ISR mechanics, consumer group rebalancing, exactly-once semantics, and production sizing considerations.
How SQLite Works: B-Tree Storage, WAL Mode, and the Single-File Architecture That Powers Edge Computing
A deep dive into SQLite internals covering the page-based single-file layout, B-tree storage engine, VDBE bytecode execution, WAL mode vs rollback journal, transaction locking states, query planning, and why SQLite has become the default database at the edge.
How Nginx Works: Event-Driven Architecture, Request Processing, and Reverse Proxy Mechanics
A deep dive into Nginx internals for senior engineers. Covers the master-worker process model, epoll/kqueue event loops, the request processing pipeline, reverse proxy upstream management with keepalive pools, load balancing algorithms, SSL termination, sendfile for static assets, and connection draining during graceful reload. Includes a tradeoffs table comparing Nginx, Caddy, HAProxy, and Envoy.
How Redis Works: Single-Threaded Execution, Data Structures, and Persistence Mechanics From Command to Disk
A deep dive into Redis internals covering the single-threaded event loop, core data structure implementations (SDS, skip lists, radix trees), RDB and AOF persistence, replication, pub/sub, and memory eviction policies with TypeScript client examples.
How React Server Components Work: The Compilation Pipeline, RSC Protocol, and Architecture Behind Zero-Bundle Server Rendering
A deep technical look at how React Server Components split the module graph at use client boundaries, serialize the component tree over the Flight wire protocol, and reconstruct it on the client without shipping server code to the browser.
How the Browser Renders a Web Page: Parsing, Layout, Paint, and Compositing from URL to Pixels
A deep dive into the browser's critical rendering path: HTML and CSS parsing, render tree assembly, layout computation, paint operations, and GPU compositing. With TypeScript examples for measuring and optimizing each phase.