Complete archive

Archive

3,240 articles, newest first · page 10 of 54. For subject-based browsing use topics; for keyword lookup try search. Dates shown are assigned archive dates that order the library; they are not historical publication records.

2026
Jun 7, 2026 Flash Translation Layers: Mapping Tables, Garbage Collection, and Write Cost How a controller maps logical blocks onto pages that can never be overwritten, why the mapping table does not fit in SRAM, and how the choice of victim block sets write amplification. hardware engineering · intermediate
Jun 7, 2026 Fold Fusion and the Elimination of Intermediate Lists How the foldr/build rule removes intermediate lists at compile time, what deforestation generalized it to, and why strictness and sharing break the rewrite. programming languages · intermediate
Jun 7, 2026 Overlay Endpoint Resolution and Its Caches How a host maps an inner destination to the tunnel endpoint that hosts it, what the per-flow and per-prefix caches hold, and why a stale mapping is worse than a missing one. networking · intermediate
Jun 7, 2026 Value Objects and Entities: Deciding What Has Identity Why some domain types are defined by their attributes and others by a lifecycle, and how equality, mutation, and identifier choice all follow from that one decision. software architecture · foundational
Jun 6, 2026 Histogram Split Finding and the Weighted Quantile Sketch Binning a feature into a few hundred buckets turns repeated per-node sorts into linear passes, and choosing the boundaries by weighted quantiles keeps the buckets where the data actually is. machine learning · advanced
Jun 6, 2026 Insertion Sort and the Inversion Count That Predicts Its Runtime How the shift loop makes insertion sort cost exactly n plus the number of inversions, why that adaptivity matters more than the quadratic worst case, and what binary insertion does not fix. algorithms · foundational
Jun 6, 2026 Power Sequencing, Reset Order, and the First Power-On Why rails must rise in a defined order, what happens to a device whose I/O is driven before its supply, and how boundary scan turns a dead board into a locatable fault. hardware engineering · advanced
Jun 5, 2026 Erasing From the Middle: Compaction and the Order It Destroys Why removal from a contiguous array costs a shift, when swap-and-pop is the right substitute, and how tombstone markers defer the cost without hiding it. data structures · advanced
Jun 5, 2026 Fast-Forward, Merge Commits, and What First-Parent History Hides When a ref move is enough to integrate a branch, when a merge commit is required, and how first-parent traversal changes the history a reader sees. software engineering · foundational
Jun 5, 2026 Provisioning Lag and the Reaction Time of a Fleet How the delay between a load increase and usable capacity determines the headroom a plan needs, why boot time and image pull dominate the loop, and how the lag compounds with forecast error. performance engineering · intermediate
Jun 5, 2026 What an Allreduce Actually Moves: Trees, Rings, and the Cost Model Why the obvious gather-reduce-scatter is the wrong shape, how ring and recursive-doubling algorithms trade latency for bandwidth, and where the two cross over. scientific computing · foundational
Jun 4, 2026 Hit Ratio Arithmetic and How to Size a Cache Tier How to convert a hit ratio into source load and latency, why the miss-rate curve flattens before the working set is covered, and which measurement choices make a cache look better than it is. backend systems · advanced
Jun 4, 2026 Seeds, Generator State, and Reproducible Random Streams Why a seed is not enough to reproduce a stochastic result, how generator state advances, and how parallel workers avoid splitting one stream into correlated pieces. scientific computing · intermediate
Jun 4, 2026 Unambiguous Message Framing in Cryptographic Protocols Why a byte string must decode to exactly one message structure, how length prefixes and canonical encodings achieve it, and where parsing ambiguities become key-recovery attacks. cryptography · foundational
Jun 3, 2026 Cancellation and Drop at Suspension Points Stopping a task means unwinding or abandoning whatever state it holds at the moment it was suspended. Why cancellation is safe only at suspension points, and what a partially completed operation leaves behind. language runtimes · advanced
Jun 3, 2026 Collecting Declarations Before Resolving Any Body How a hoisting pass makes forward and mutual references resolvable, what it must record about ordering and initialization, and which language rules it cannot express. compilers · intermediate
Jun 3, 2026 Coordinating Tabs with Locks, BroadcastChannel, and Storage Events How Web Locks give same-origin tabs a queue per name, what BroadcastChannel does and does not deliver, and why the storage event cannot serve as a mutex. web platform · advanced
Jun 3, 2026 DWARF Debug Information: Abbreviation Tables and the Line Number State Machine How debug sections compress a typed tree of entries into a byte stream, why attribute forms matter, and how a line table is reconstructed by running a small virtual machine over its opcodes. systems programming · intermediate
Jun 3, 2026 Equivalence Checking: Proving a Netlist Matches Its RTL How combinational equivalence is reduced to a miter of two circuits and a satisfiability question, why sequential transformations break that reduction, and where the proof stops being cheap. hardware engineering · advanced
Jun 3, 2026 Exactly-Once Delivery Across System Boundaries The dual-write problem, the outbox that removes it, and the narrow sense in which a message can be applied exactly once when the database and the broker are separate systems. backend systems · advanced
Jun 3, 2026 Monotone Dataflow: Lattices, Transfer Functions, and Fixpoints The worklist formulation behind liveness, reaching definitions, and constant propagation, why monotonicity guarantees termination, and where the abstraction loses precision. developer tools · intermediate
Jun 3, 2026 Syscall Filtering and the Process as a Security Boundary How seccomp filters restrict a process to a fixed set of system calls, why argument inspection is limited by the kernel interface, and where the remaining escape routes lie. language runtimes · foundational
Jun 2, 2026 DMARC Alignment Between Header and Envelope Domains How DMARC combines two independent authentication results into one verdict, why alignment is stricter than either check, and what the policy record actually authorizes. internet protocols · advanced
Jun 2, 2026 Interleaving Pages Across Nodes for Aggregate Bandwidth Why spreading a range round-robin over every node raises streaming throughput and raises pointer-chasing latency, how the interleave sequence is kept, and when the policy is worth its cost. memory systems · intermediate
Jun 2, 2026 Phi Accrual Detectors: Turning Inter-Arrival Samples into a Continuous Suspicion Level How a detector fits a distribution to observed heartbeat gaps, converts the current gap into a probability that the peer is dead, and why the exponential form of that probability is what makes a threshold portable. distributed systems · intermediate
Jun 2, 2026 Routing Requests Between Old and New with a Strangler Facade How a routing layer in front of a legacy application lets capabilities move to a replacement one slice at a time, what the routing key must capture, and why session and data ownership decide the order. software architecture · intermediate
Jun 2, 2026 System Call ABIs and the Register Argument Convention How arguments and return values cross the privilege boundary, why there are at most six of them, and why two ABIs on one machine can disagree about the layout of a struct. operating systems · foundational
Jun 2, 2026 The Merkle-Damgård Construction and the Padding That Binds It How a fixed-width compression function is iterated into a variable-length hash, why the padding encodes the message length, and which attacks the iteration rule leaves open. cryptography · foundational
Jun 1, 2026 Designing a C ABI That Survives Version Changes Which parts of an interface are frozen by binary compatibility, how struct sizing and symbol versioning let a library grow, and what a versioned entry point must promise. language runtimes · advanced
Jun 1, 2026 XOR Linked Lists: One Link Field for Both Directions Storing the difference of the two neighbour addresses halves link storage and forces traversal to carry two cursors, which breaks under debugging tools and section boundaries. data structures · intermediate
May
May 31, 2026 Pattern Matching and the Exhaustiveness Check How a match expression is compiled into a decision tree, why exhaustiveness is decidable for constructors but not for guards, and what an unreachable arm costs. programming languages · intermediate
May 31, 2026 Yield Models That Turn Defect Density into Die Cost The Poisson and negative binomial yield formulas, why clustering makes the Poisson model pessimistic, and how die area, redundancy, and wafer size set the cost of a working part. hardware engineering · intermediate
May 30, 2026 Deadline-Aware Batching and Tenant Fairness When a batch is full, admission becomes an arbitration problem. Deadline slack, tenant shares, and starvation bounds each answer a different question about who gets the next slot. inference systems · intermediate
May 30, 2026 Decommissioning a Source System: Proving Quiescence Why an idle-looking system is not an unused one, how to measure the absence of traffic, and the sequence that ends with a restore test rather than a shutdown. cloud infrastructure · advanced
May 29, 2026 Content-Addressed Build Cache Keys: What Must Go Into the Hash A cache hit is only sound if the key covers every input that can change the output. The compiler binary, its flags, the header contents, and the transitive environment all belong in it; the clock and the path usually do not. compilers · intermediate
May 28, 2026 Expected Cost, Amortized Cost, and Where the Average Comes From Three kinds of average appear in algorithm analysis. They average over different things, hold under different adversary models, and cannot be substituted for one another. algorithms · intermediate
May 28, 2026 From Duty Cycle to Average Current and Battery Life How charge accounting turns an active and sleep schedule into an average current, and where the resulting battery-life estimate stops being trustworthy. embedded systems · foundational
May 28, 2026 Time-Triggered Buses, Global Time, and Bus Guardians How a static TDMA schedule removes arbitration from the communication path, how nodes agree on a global time, and why a bus guardian is needed to enforce slot ownership. embedded systems · advanced
May 27, 2026 Content Security Policy: Source Lists, Nonces, and Trust Propagation How CSP directives fall back to default-src, why host allowlists leak through JSONP and open redirects, and how nonces plus strict-dynamic move script trust to runtime provenance. web platform · intermediate
May 27, 2026 Head-Based Sampling: Where the Decision Belongs and What It Costs How probabilistic and rate-limiting samplers make the keep-or-drop call at trace start, why the decision must be consistent across the trace, and how the sampled flag makes it authoritative downstream. observability · intermediate
May 27, 2026 Key Ordering and Cursor Semantics in IndexedDB How IndexedDB compares keys of different types, why compound keys sort lexicographically, and how cursor direction and ranges decide which records a traversal visits. web platform · intermediate
May 27, 2026 Reaching Definitions and the Monotone Dataflow Framework How a compiler computes which assignments can reach each program point, why the answer is a least fixpoint over a lattice, and where the bitvector approximation stops being exact. compilers · foundational
May 27, 2026 Splitting a Partition While Writes Continue The in-place split protocol: freeze, cut, publish, then let readers discover the new boundary. Why the split point is a durable record and why the parent must keep serving. distributed systems · advanced
May 26, 2026 Cache API Match Semantics and Opaque Responses How a Cache decides whether a stored entry answers a request, what Vary does to lookup, and why opaque cross-origin responses cost quota without being readable. web platform · intermediate
May 26, 2026 Rate-Monotonic Priority Assignment and Its Utilisation Bound Why assigning priorities by period is optimal among fixed-priority schemes, what the 69 percent bound actually guarantees, and where the harmonic case recovers full utilisation. embedded systems · intermediate
May 26, 2026 Reconciliation Loops: Why Level-Triggered Control Beats Event Handling A platform that compares desired state to observed state on every pass recovers from missed events and partial failures. The mechanism, its cost in API traffic, and the edge cases where a loop oscillates. virtualization · foundational
May 26, 2026 Two-Phase Commit Across Shards: The Coordinator, the Veto, and the In-Doubt Window How prepare and commit phases make a cross-shard transaction atomic, why a coordinator failure leaves participants unable to decide, and what presumed abort changes. databases · advanced
May 25, 2026 Blockwise 8-Bit Optimizer State Without Losing the Second Moment Quantising Adam moments to eight bits cuts state memory by four, but small second-moment values quantise to zero. Blockwise scaling and dynamic exponent sharing fix that. deep learning · advanced
May 25, 2026 Checksum Blind Spots: Misdirected Writes and Lost Updates The fault classes that survive a correct checksum, from acknowledged writes that never landed to corruption introduced above the filesystem, and the ordering machinery each one needs. filesystems · advanced
May 25, 2026 Replicating the Commit Decision So the Coordinator Can Die Why a single durable decision record is a single point of failure, how consensus turns commit into a replicated log entry, and what the extra round trip buys in recovery time. distributed systems · advanced
May 25, 2026 Size-Class Segregation and Fit Policy in the Heap Why bucketing free blocks by size turns an unbounded search into a bounded one, how rounding requests up to a class wastes memory, and how fit policy interacts with fragmentation. memory systems · foundational
May 25, 2026 Zero-Copy Paths: What sendfile, splice, and mmap Remove Which memory copies each zero-copy interface eliminates, which ones remain, and the page-cache, alignment, and lifetime constraints that decide whether the saving is real. performance engineering · intermediate
May 23, 2026 Signature Verification and Where the Root Key Lives How a constrained bootloader verifies an image signature, which algorithms fit in its budget, and why storing the public key in flash defeats the purpose. embedded systems · advanced
May 22, 2026 Aggregating Task Estimates: Why Summed Ranges Come Out Too Narrow Why adding per-task ranges produces an interval that is too tight for the whole job, how skew and correlation break the diversification argument, and what to compute instead. software engineering · foundational
May 22, 2026 Mutation Testing as a Measure of Assertion Strength How generated mutants expose tests that execute code without checking it, which mutation operators matter, why equivalent mutants cap the score, and what the technique costs. software engineering · advanced
May 22, 2026 Warp Granularity: Why Thirty-Two Threads Share One Program Counter How a block of threads is carved into warps, why the hardware tracks one instruction stream per group of thirty-two lanes, and what that granularity costs at the edges. gpu computing · foundational
May 21, 2026 Persistent Connections, Pipelining, and Connection Reuse Why HTTP/1.1 keeps the connection open, what pipelining actually requires of a server, and how idle timeouts and half-closed sockets break reuse. internet protocols · intermediate
May 21, 2026 Utilization Targets and the Knee of the Latency Curve Why latency stays flat until utilization approaches one and then rises sharply, how arrival variability moves the knee, and how to locate the operating point from measurements rather than doctrine. performance engineering · foundational
May 21, 2026 Why Scaled Dot-Product Attention Divides by the Square Root of the Key Dimension Where the 1/sqrt(d_k) factor comes from, what quantity it holds constant as width changes, and how a saturated softmax destroys the gradient reaching queries and keys. deep learning · foundational
May 21, 2026 Window Assignment and Trigger Semantics How an event is mapped to windows, why sliding windows multiply state, and how triggers separate when a result is emitted from what it contains. data engineering · foundational

2026

May