Blog — Page 3 of 53
Browsing page 3 of 53 — 634 articles and counting.
How RabbitMQ Works Internally: AMQP Protocol, Exchange Routing, and Quorum Queues From Connection to Consumer
A deep dive into RabbitMQ internals covering the AMQP 0-9-1 connection and channel model, binary frame structure, exchange types with binding-based routing, queue storage with Erlang process internals and persistence mechanics, credit-based flow control, consumer acknowledgment and prefetch semantics, the evolution from classic mirrored queues to Raft-based quorum queues, virtual hosts for multi-tenancy, and a tradeoffs comparison table across RabbitMQ, Kafka, NATS, Apache Pulsar, and Redpanda.
How Apache Airflow Works Internally: DAG Parsing, Task Scheduling, and the Executor Architecture Behind Production Workflow Orchestration
A deep dive into Apache Airflow's internals covering DAG file parsing and serialization, the scheduler tight loop, executor architectures, the metastore schema, the triggerer component for async deferrals, and production tuning guidance for teams running Airflow at scale.
How HAProxy Works Internally: Multi-Threaded Event Model, Connection Routing, and the Load Balancing Engine Behind High-Availability Infrastructure
A deep dive into how HAProxy works internally: its evolution from single-process to multi-threaded event-driven model, frontend/backend/server configuration flow, connection multiplexing with HTTP/2, health checking subsystems, stick tables for session persistence and rate limiting, ACL-based content switching, and production tuning for high-throughput deployments.
How Deno Works Internally: The V8 Sandbox, Rust Runtime, and the Permission Model That Rethinks Server-Side JavaScript
A deep dive into Deno's internals covering the V8 integration through rusty_v8, the Tokio-based async runtime, the capability-based permission system, URL-native module resolution, swc-based TypeScript transpilation, the FFI layer, Deno KV, and production considerations for memory management and cold-start optimization.
How Nginx Works Internally: Event Loop, Master-Worker Architecture, and Request Processing from Accept to Upstream
A deep-dive into how Nginx handles tens of thousands of concurrent connections with a handful of worker processes: the master-worker process model, epoll/kqueue event loop, multi-phase request pipeline, upstream connection pooling, shared memory zones, and production tuning for worker count, buffers, and keepalive.
How Redpanda Works Internally: Thread-Per-Core Architecture, Raft-Based Replication, and the C++ Streaming Engine That Replaces Kafka Without the JVM
A deep dive into how Redpanda works internally: its Seastar thread-per-core execution model, Raft consensus for partition replication, shadow indexing for tiered storage, Wasm-based transforms, and what the absence of the JVM actually means in production.
How Apache Pulsar Works Internally: Tiered Storage, BookKeeper-Backed Persistence, and the Multi-Tenant Messaging Engine That Separates Compute from Storage
A deep dive into Apache Pulsar internals covering the broker-BookKeeper separation that decouples compute from storage, the write path through managed ledgers and journal plus entrylog persistence, the read path with cursor tracking and catch-up versus tailing consumers, topic partitioning and bundle-based load balancing, native multi-tenancy with tenant/namespace/topic hierarchy, tiered storage offloading to S3 or GCS, geo-replication via replication cursors, and a tradeoffs comparison against Kafka, RabbitMQ, NATS, and Redpanda.
How RocksDB Works Internally: LSM-Tree Storage, Compaction Strategies, and the Embedded Engine Behind Modern Distributed Databases
A deep dive into RocksDB internals covering the LSM-tree write path through WAL and MemTable to SST files, the read path with bloom filters and block cache, leveled versus universal versus FIFO compaction and their amplification tradeoffs, column families, write stall mechanics, and production tuning guidance.
How Vitess Works Internally: VTGate Query Routing, VTTablet Management, and the Sharding Middleware That Scales MySQL to Planetary Proportions
A deep dive into how Vitess horizontally scales MySQL through VTGate query routing, VTTablet sidecar management, VSchema, scatter-gather query rewriting, Online DDL, VReplication, and live resharding workflows.
How Bun Works Internally: The JavaScriptCore Engine, Zig Runtime, and the Architecture Decisions That Make It Fast
A deep dive into Bun's internals covering why it chose JavaScriptCore over V8, how the Zig runtime manages memory and async I/O without libuv, the bundler and transpiler architecture, native SQLite integration, the HTTP server implementation, the test runner, and the real tradeoffs compared to Node.js and Deno.
How MongoDB Works Internally: The WiredTiger Storage Engine, Document Model, and Replication Protocol Behind the Most Popular NoSQL Database
A deep dive into MongoDB internals covering WiredTiger B-tree storage and MVCC, BSON encoding, compound and wildcard indexes, the query planner's trial-period competition, oplog-based replication, Raft-inspired elections, sharding chunk mechanics, and tunable read/write concerns.
How ZooKeeper Works Internally: ZAB Protocol, Znodes, Watches, and the Coordination Engine Behind Distributed Systems
A deep dive into Apache ZooKeeper's internals covering the ZAB atomic broadcast protocol, the znode data model, watch notification semantics, session management, the request processing pipeline, and snapshot-based persistence. Includes a tradeoffs comparison table against etcd, Consul, and Chubby.