September 2026
78 articles.
-
Cgroups v2 Resource Control for Containers
How cgroups v2 hierarchies account for and limit CPU time, memory, and process creation inside containers.
-
Rust Monomorphization and Static Dispatch
How Rust generates type-specific code for generics, and why that improves call performance while increasing build time and binary size.
-
Linux epoll: Interest Lists, Ready Lists, and Triggers
How epoll tracks watched descriptors, reports readiness, and lets one thread handle many connections with level- or edge-triggered events.
-
Semiconductor Photoresist and EUV Chemical Amplification
How EUV photons create acid, change resist solubility during bake, and produce a printable pattern during development.
-
V8 Hidden Classes and Inline Caches
How V8 tracks JavaScript object shapes, specializes property access, and deoptimizes code when those assumptions stop being true.
-
TCP Slow Start and Congestion Window Growth
How TCP uses acknowledgements to grow its sending window, then reacts to loss or ECN congestion signals.
-
Property-Based Testing Shrinkers
How a property-based test turns a complex generated failure into a smaller counterexample while checking that each reduction still fails.
-
Linux User Namespaces and UID/GID Mapping
How Linux maps container UIDs and GIDs so root inside a user namespace is an unprivileged identity on the host.
-
Transformer KV Cache During Text Generation
How transformers store attention keys and values to avoid recomputing prior tokens, and why longer contexts consume more inference memory.
-
Static Single-Assignment Form and Phi Nodes
SSA gives each intermediate value one definition, while φ-nodes merge values from different control-flow paths for simpler data-flow optimization.
-
How Raft Leader Elections Work
Raft uses numbered terms, randomized timeouts, majority votes, and log checks to elect one safe leader and recover from split votes.
-
Python Descriptors and Method Binding
How Python routes attribute reads and writes through descriptors, and how the same mechanism implements properties, bound methods, and class methods.
-
Linux Page-Cache Readahead
How Linux detects sequential file access, reads pages early, and limits wasted I/O when access becomes sparse or random.
-
Rust Pin and Unpin for Self-Referential Futures
How Rust’s Pin and Unpin types keep asynchronous state machines at stable addresses when futures contain references to their own data.
-
Amazon SQS Visibility Timeout and Message Processing
Understand how SQS hides received messages, why crashes cause redelivery, and how workers safely extend processing time.
-
AEAD Nonces and the Cost of Reuse
How AEAD nonces protect encryption, why each must be unique per key, and how reuse can expose plaintext and enable forgeries.
-
CPU Branch Predictors and Speculative Execution
How CPUs record branch history, execute past unresolved decisions, and discard pipeline work when a prediction is wrong.
-
Idempotency Keys and Safe Request Retries
How servers store an idempotency key with a request result so clients can retry safely without repeating the operation.
-
Bloom Filters and Probabilistic Set Membership
Learn how Bloom filters use a bit array and multiple hashes to save memory while allowing false positives but not false negatives.
-
Linux Dirty Pages, Writeback, and fsync
How Linux caches file writes in RAM, writes them back in the background, and uses fsync to establish a durability boundary.
-
AWS STS AssumeRole and Temporary Credentials
Understand how AWS STS validates a caller, issues role credentials, separates trust from permissions, and refreshes expiring sessions.
-
Chemical-Mechanical Planarization of Semiconductor Wafers
How slurry, polishing pads, dishing, and erosion turn uneven wafer layers into flat surfaces for multilayer chip fabrication.
-
Memory Barriers and Concurrent Memory Ordering
Memory barriers constrain compiler and CPU reordering so one thread can observe another’s updates in order, without making a whole operation atomic.
-
Git Commit-Graph Files and Generation Numbers
How Git records commit relationships and generation data to answer ancestry, merge-base, and reachability queries with fewer object walks.
-
MVCC Snapshots and SQL Row Visibility
How SQL transactions choose visible row versions so readers can use a consistent view while writers update the same data.
-
Linux Copy-on-Write Across forked Processes
How Linux shares forked processes’ pages, changes their page tables, and copies memory only when a write triggers a page fault.
-
DNS Negative Caching and Record Recovery
How resolvers cache NXDOMAIN and NODATA responses, and why a newly created DNS record may remain invisible until a negative TTL expires.
-
Go Interface Values: Dynamic Types, Values, and Nil Pointers
Go interfaces pair a dynamic type with a value, enabling method dispatch while making typed nil pointers different from nil interfaces.
-
AWS Lambda Execution Environment Lifecycle
How Lambda initializes, reuses, freezes, and thaws environments—and why global state changes cold-start and warm-invocation performance.
-
SQL NULL and Three-Valued Logic
Understand SQL NULL, UNKNOWN predicate results, and why WHERE, JOIN, and CHECK constraints handle them differently.
-
How Linkers Resolve Symbols and Relocations
How linkers turn object files into runnable code by matching symbols, fixing addresses, and coordinating position-independent code with shared libraries.
-
Semiconductor Lithography Alignment and Overlay Budgets
How lithography uses wafer and reticle marks to register circuit layers, measure overlay error, and keep placement errors within a manufacturing budget.
-
TLB Shootdowns and Deferred Invalidation
How CPUs keep page-table changes safe, why TLB shootdowns interrupt other cores, and how batching reduces their performance cost.
-
QUIC Connection IDs and Connection Migration
How QUIC connection IDs let a connection survive address changes, NAT rebinding, and network switches without starting a new transport connection.
-
Go’s Garbage-Collector Pacer and Mutator Assists
How Go’s GC pacer budgets marking CPU and makes allocating goroutines help when concurrent collection falls behind.
-
Browser Microtasks and the Render Queue
How promise callbacks enter the browser’s microtask queue, run to completion, and affect rendering, input, and event-loop responsiveness.
-
Mixture-of-Experts Routing and Load Balancing
How MoE routers send tokens to a few expert networks while capacity limits and balancing losses prevent overloaded experts.
-
Linux Seccomp-BPF System Call Filters
How Linux seccomp-BPF examines system calls and lets a process allow, reject, trap, or kill them.
-
Linux Futexes and User-Space Mutex Waiting
A futex lets a mutex use atomic user-space operations normally and enter the kernel only when a contending thread must sleep or be woken.
-
DynamoDB Adaptive Capacity and Hot Partition Keys
DynamoDB adaptive capacity shifts unused throughput toward hot partition keys while keeping the table’s provisioned capacity unchanged.
-
Windows Job Objects for Process Control
Windows job objects group processes so services can account for descendants, enforce resource limits, receive events, and terminate a whole workload.
-
How Tail-Based Trace Sampling Works
Tail-based sampling waits for a trace’s outcome, then keeps or discards every span using evidence from the complete trace.
-
Amazon S3 Multipart Uploads
How S3 uploads large objects as verified parts, assembles them atomically, and why incomplete uploads must be aborted or expired.
-
Go’s G-M-P Scheduler
How Go’s goroutines, OS threads, processors, run queues, and work stealing determine concurrency, latency, and throughput.
-
NIC Interrupt Coalescing and Packet-Batching Tradeoffs
How NICs batch packet notifications to reduce CPU overhead, and how coalescing thresholds trade that efficiency against network latency.
-
Compiler Escape Analysis and Stack Versus Heap
Escape analysis predicts whether a value can outlive its function, guiding stack or heap placement and influencing allocation and garbage-collection costs.
-
Consistent Hashing on a Ring
How consistent hashing assigns keys around a ring, uses virtual nodes to balance load, and limits key movement during membership changes.
-
AWS IAM Policy Evaluation
How IAM combines identity, resource, boundary, and session policies—and why any applicable explicit deny wins.
-
CPU Cache-Line False Sharing
Learn why independent writes can invalidate each other’s cache lines, and how padding and data layout prevent coherence-driven slowdowns.
-
Git Reflogs and Recovering Lost Commits
Learn how Git reflogs track reference movements, expire old entries, and keep deleted or reset commits recoverable for a time.
-
Linux epoll Readiness Notification
How epoll tracks monitored file descriptors, reports readiness, and changes event-loop I/O with level-triggered and edge-triggered modes.
-
The Tool-Calling Loop in AI Agents
How an AI model requests a tool, how the runtime validates and runs it, and how the result becomes the next model input.
-
Python Descriptors and Attribute Access
Understand how Python descriptors power properties, bound methods, and ORM fields by intercepting reads, writes, and deletion.
-
HTTP/2 Multiplexing, Streams, and Flow Control
How HTTP/2 interleaves independent streams in frames over one TCP connection and limits data with per-stream and connection-level windows.
-
Speculative Decoding with Draft and Target Models
How a small model proposes token sequences for a large model to verify, reducing generation latency while preserving the large model’s distribution.
-
TypeScript Structural Assignability and Excess Properties
How TypeScript compares object shapes, and why fresh literals trigger excess-property errors that variables usually avoid.
-
SQL Selectivity Estimates and Query Plans
How database planners use histograms to estimate matching rows, and how bad estimates lead to unexpectedly slow scans, joins, and indexes.
-
Ion Implantation and Electrical Regions in Silicon
How implant energy and dose place dopants in a wafer, and how annealing turns that damaged profile into a working electrical region.
-
Inside Python’s asyncio Event Loop
How await suspends a Task, how I/O and timers wake it, and how the event loop chooses callbacks from its ready queue.
-
Database B-Tree Page Splits and Separator Keys
How B-tree pages split at capacity, propagate separator keys, and preserve fast, logarithmic index lookups.
-
Property-Based Testing and Shrinking Counterexamples
Learn how property-based testing generates varied inputs, detects invariant violations, and shrinks failures into small reproducible counterexamples.
-
LLM Key-Value Caches During Autoregressive Generation
How cached attention keys and values eliminate repeated prefix work during generation, and why the speedup consumes substantial memory.
-
Copy-Up in Container Overlay Filesystems
How Linux overlay filesystems combine read-only image layers with a writable container layer and copy files up when a write requires them.
-
Database Write-Ahead Logging and Crash Recovery
How databases use durable log records to preserve committed transactions and remove incomplete changes after a crash.
-
Photon Shot Noise in EUV Lithography
How random EUV photon counts create missing or malformed wafer features, and how fabs measure and reduce those stochastic defects.
-
Windows I/O Completion Ports and Worker Scheduling
How Windows turns completed overlapped I/O into queued packets and limits runnable workers instead of assigning a thread to every operation.
-
Git Packfiles and Pack Indexes
How Git stores objects in compact packfiles and uses sorted hash indexes to locate them without scanning every packed object.
-
TCP Slow Start and Congestion Avoidance
How TCP grows its congestion window from acknowledgements, then slows growth when packet loss signals that the network is overloaded.
-
Static Single Assignment Form and Phi Nodes
How SSA gives every assignment a distinct version and uses phi nodes to merge values when control-flow paths meet.
-
Linux PID Namespaces and the Responsibilities of PID 1
Understand how Linux PID namespaces provide isolated process IDs and why their PID 1 must handle signals and reap orphaned children.
-
Flip-Flop Metastability and Synchronizer Chains
How setup and hold violations create metastability, and how synchronizer stages make failures extraordinarily unlikely without making them impossible.
-
Rust Pin, Unpin, and Safe Projection
Understand how Rust keeps futures and self-referential values at stable addresses, and how Pin, Unpin, and projection preserve that guarantee safely.
-
DNS Negative Caching for NXDOMAIN and NODATA
How DNS caches absent names and record types, uses TTLs to avoid repeated queries, and can hide newly created hostnames until entries expire.
-
Chemical-Mechanical Polishing in Semiconductor Fabrication
How CMP uses a chemical slurry and rotating pad to flatten wafers for reliable alignment and focus in later lithography.
-
AEAD Nonce Reuse and Its Security Consequences
Why reusing an AEAD nonce exposes plaintext relationships and can enable forgeries—and why protocols must prevent it.
-
Linux TLB Shootdowns and Their Performance Cost
How Linux keeps per-core address-translation caches consistent when page-table entries change, and why that coordination can slow workloads.
-
CPython’s Global Interpreter Lock
How CPython’s GIL protects interpreter state, coordinates thread execution, and lets native extensions run parallel or blocking work safely.
-
Browser Microtasks and the Render Queue
How promise callbacks and mutation observers run between browser tasks, and why long microtask chains can delay rendering and starve the event loop.