Blog — Page 9 of 53
Browsing page 9 of 53 — 634 articles and counting.
How Vite Works: ES Modules, Dependency Pre-Bundling, and the Architecture Behind the Fastest Dev Server
A deep-dive into Vite's architecture covering native ES module serving, esbuild dependency pre-bundling, HMR propagation, the plugin pipeline, and production Rollup builds for senior engineers.
How DNS Works: Resolution, Caching, and Traffic Routing From Query to Response
A deep dive into DNS resolution covering the full recursive chain, record types and their production uses, TTL mechanics and negative caching, DNS-based traffic management strategies, DNSSEC, and practical guidance for startup engineering teams.
How gRPC Works: Protocol Buffers, HTTP/2 Streaming, and Production Patterns in TypeScript
A deep dive into how gRPC actually works: Protocol Buffer encoding and schema evolution, the four RPC communication patterns, HTTP/2 multiplexing mechanics, interceptors, deadline propagation, load balancing with gRPC, the health checking protocol, and when to reach for gRPC over REST or GraphQL. TypeScript examples using @grpc/grpc-js and connect-es.
How the V8 JavaScript Engine Works: Parsing, Compilation, Garbage Collection, and Why Your Node.js Server Pauses
A deep dive into V8's internal architecture for senior Node.js engineers: the parsing pipeline, Ignition bytecode interpreter, TurboFan optimizing compiler, speculative optimization and deoptimization, hidden classes, inline caches, and the generational garbage collector behind every GC pause.
How LLM Tokenizers Work: BPE, Vocabulary Construction, and Why Token Economics Matter for Production AI
A deep dive into how BPE tokenization works, how tiktoken and SentencePiece build vocabularies, why tokens don't map 1:1 to words, and what token economics mean for cost, RAG chunk sizing, and multilingual efficiency in production.
How TLS Works: Certificates, Handshakes, and the Trust Chain Behind Every Secure Connection
A deep dive into TLS 1.3: certificate chain validation, ECDHE key exchange, session resumption with PSK and 0-RTT, certificate transparency, and production considerations for rotation, pinning, and mTLS.
How HTTP/2 and HTTP/3 Work: Multiplexing, QUIC, and the Protocol Upgrades Behind Modern Web Performance
A deep dive into the protocol evolution from HTTP/1.1 to HTTP/2 to HTTP/3. Covers binary framing, multiplexed streams, HPACK compression, QUIC over UDP, 0-RTT handshakes, connection migration, and production deployment patterns for CDN and edge delivery.
How Containers Actually Work: Namespaces, Cgroups, and the Linux Primitives Behind Docker
A deep dive into the Linux kernel primitives that make containers possible: PID, network, and mount namespaces for isolation, cgroups v2 for resource enforcement, union filesystems for layered images, and how to debug resource limit failures in Kubernetes production workloads.
How Git Works Internally: Objects, References, and the DAG Behind Every Commit
A deep dive into Git's content-addressable object store, how branches are just files, how the DAG enables branching and merging, three-way merge and rebase mechanics, packfile delta compression, and what all of this means for reflog, garbage collection, and recovering lost work.
How Kubernetes Works Internally: The Control Loop, API Server, and Scheduler Behind Container Orchestration
Most engineers use Kubernetes daily without knowing what actually happens between kubectl apply and a running pod. This article covers the internals: how the API server processes requests, how etcd stores cluster state, how the scheduler assigns pods, and how controllers and the kubelet drive actual state toward desired state.
Designing a Database-as-a-Service Platform: Tenant Provisioning, Compute-Storage Separation, and Connection Routing at Scale
A deep technical walkthrough of how modern DBaaS platforms work under the hood: tenant provisioning and lifecycle management, compute-storage separation as the foundation for serverless databases, connection routing and pooling across thousands of tenants, backup orchestration with point-in-time recovery, noisy neighbor prevention, and the tradeoffs between shared-nothing, shared-compute, and serverless deployment models.
How a Database Executes a Query: Parsing, Planning, and Optimization from SQL String to Result Set
A deep technical walkthrough of how PostgreSQL transforms a SQL string into result rows, covering lexing, parsing, semantic analysis, cost-based optimization, join algorithm selection, scan type decisions, and the Volcano execution model.