Complete archive

Archive

3,240 articles, newest first · page 46 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.

2023
Dec 11, 2023 Activation Outlier Channels and Mixed-Precision Decomposition Why a few hidden-state channels carry magnitudes far above the rest, how splitting those channels out of the integer path preserves accuracy, and what the split costs per token. inference systems · intermediate
Dec 11, 2023 Deadline Misses: Detection, Recovery, and Watchdog Design How a kernel learns that a deadline was missed, what recovery actions are safe after a miss, and how a watchdog is configured so that a stuck task resets cleanly. embedded systems · advanced
Dec 11, 2023 MutationObserver Records, Batching, and Microtask Delivery Observers accumulate a record per mutation and deliver them once per microtask checkpoint, which coalesces bursts into a single callback and makes delivery timing a question about the event loop. web platform · intermediate
Dec 11, 2023 Quorum Intersection and the Arithmetic of Stale Reads Why R + W > N guarantees a read sees the latest acknowledged write, what that inequality does not guarantee, and how sloppy quorums and read-your-writes routing break it. distributed systems · intermediate
Dec 10, 2023 Dead Tuples, Bloat, and What VACUUM Actually Reclaims How update-in-place storage produces dead row versions, what a vacuum pass removes from pages, and why the table file does not shrink when it finishes. databases · foundational
Dec 8, 2023 Height Bounds and the Cost of a Degenerate Search Tree Why the worst-case depth of a binary search tree, not its average depth, sets lookup cost, and what a balance invariant has to constrain to fix it. data structures · foundational
Dec 7, 2023 Connection Pool Checkout and the Exhaustion Cliff What a checkout actually costs, why exhaustion degrades a service sharply rather than gradually, and how wait queues, validation, and recycling interact under load. backend systems · intermediate
Dec 7, 2023 Weight-Balanced Trees and the Ratio That Bounds Depth Why subtree size is a usable balance weight, how the size ratio is chosen, and why size balance makes join and split the natural primitives. data structures · intermediate
Dec 6, 2023 Deserialization as Re-entry Across the Trust Boundary Why parsing untrusted bytes into objects is the most exposed operation a runtime performs, how format-directed object construction grants authority, and which design choices contain the damage. language runtimes · intermediate
Dec 6, 2023 Random Hyperplane LSH and the Arithmetic of Banding How one random plane per bit turns cosine similarity into collision probability, and how band and row counts convert that probability into a practical recall curve with a sharp threshold. information retrieval · foundational
Dec 6, 2023 The Frame Check Sequence: CRC-32 and the Errors It Misses How the four-byte Ethernet trailer is computed, why CRC-32 catches every burst up to 32 bits, and which corruption patterns pass it undetected. networking · foundational
Dec 4, 2023 Shape Identity, Interning, and Structural Equality Why two layouts with the same property names and offsets may still need to be distinct, when an engine may safely merge them, and how the identity comparison in a guard depends on that decision. language runtimes · advanced
November
Nov 28, 2023 Transposed Convolution and the Checkerboard Artifact How the backward pass of a convolution defines an upsampling operator, why unequal kernel overlap produces a fixed grid pattern, and how to avoid it entirely. deep learning · intermediate
Nov 28, 2023 Unwinding Across an FFI Boundary Why an exception cannot safely propagate through a C frame, how table-based unwinding locates a handler, and what a boundary must do instead of throwing through it. language runtimes · intermediate
Nov 27, 2023 Dominator Trees and the Cooper-Harvey-Kennedy Iterative Method What it means for one vertex to dominate another, why the immediate dominator relation forms a tree, and how reverse post-order makes the iterative fixpoint converge quickly. algorithms · advanced
Nov 27, 2023 Multisample Coverage and What the Resolve Step Actually Does How one shading result is shared across several coverage samples, why resolve averages coverage rather than colour, and where alpha-to-coverage and centroid sampling fit. gpu computing · intermediate
Nov 27, 2023 What a System Call Actually Costs Where the cycles go between the trap instruction and the return, which costs are fixed and which scale with the argument, and why mitigations changed the baseline. operating systems · intermediate
Nov 26, 2023 Compare-and-Swap Retry Loops Under Contention Why a lock-free read-modify-write loop that is faster than a mutex with two threads is slower with twenty, and how to bound, batch, or replace the retry. performance engineering · advanced
Nov 26, 2023 Software Breakpoints: Replacing an Instruction with a Trap Byte How a debugger turns a source line into a one-byte code patch, why the program counter has to be rewound, and what the patch cannot do in shared or generated code. developer tools · foundational
Nov 25, 2023 Why fork and exec Are Separate Calls The two-step process creation model, what fork copies and what copy-on-write defers, and why the split survives despite its cost in a program that only wants to exec. computing history · foundational
Nov 24, 2023 Gap Locks and Next-Key Locking in an Index-Ordered Store How a locking engine prevents phantoms by locking the space between index entries, why the locks are taken on index records rather than rows, and what the resulting deadlocks look like. databases · advanced
Nov 24, 2023 Separator Keys and Search Routing in Internal Nodes How internal B-tree pages choose the keys that route a search, what happens when a separator is too short to be unique, and how duplicate keys are ordered. databases · foundational
Nov 23, 2023 Checkpoint Regions and Tail Recovery in an Append-Only Log How a log-structured filesystem bounds what a crash can lose, and how it reconstructs the segment summaries written after the last durable checkpoint by scanning forward instead of backward. filesystems · foundational
Nov 23, 2023 Early Depth Testing and the Order of Per-Fragment Operations Which per-fragment operations happen before the fragment shader and which after, why stencil and depth tests can be hoisted only when the shader permits it, and what that costs on overdraw. gpu computing · intermediate
Nov 23, 2023 Precision and Recall at a Cutoff: Why the Cutoff Changes the Metric How a rank cutoff turns set-based measures into per-prefix measures, why precision at small k is unstable across topics, and what R-precision fixes. information retrieval · foundational
Nov 22, 2023 Coarse-Grained Locking by Design: What a Chubby Cell Optimizes For Why a lock service built for locks held for hours makes different choices than one built for request-path coordination, and where those choices stop paying. distributed systems · advanced
Nov 21, 2023 Severity Tiers, Escalation Timers, and the Cost of a Page Separating impact from urgency so a tier is decidable in minutes, converting tiers into acknowledgment and update timers, and the attention economics that decide when paging is the wrong response. software engineering · intermediate
Nov 20, 2023 Memory-Level Parallelism and Latency Tolerance How many independent memory requests a kernel keeps in flight determines whether it can saturate bandwidth, and how unrolling and load reordering raise that count without adding warps. gpu computing · intermediate
Nov 16, 2023 Lockfile Determinism, Diffs, and Merge Conflicts Why two resolutions of the same inputs should produce identical bytes, which writer choices break that, and why merging lockfiles textually is unsound even when it usually appears to work. developer tools · advanced
Nov 15, 2023 Feedback Latency as Compounding Interest A slow test suite charges every change a fixed toll and inflates batch size, which makes each failure harder to diagnose. The queueing mechanics behind that second effect. software architecture · intermediate
Nov 15, 2023 LambdaMART and Metric-Driven Gradient Boosting How lambda gradients weight document pairs by their effect on NDCG, why the resulting tree ensemble is trained on pseudo-residuals, and where the heuristic gradient fails. information retrieval · advanced
Nov 13, 2023 Migrating Guests Whose Memory the Hypervisor Cannot Read Confidential computing encrypts guest memory under keys the hypervisor does not hold, which removes compression, zero-page detection, and inspection from the migration path and adds an attestation step at the destination. virtualization · advanced
Nov 13, 2023 Wear Leveling and the Erase-Cycle Budget of a Flash Device How erase counts are tracked, what dynamic and static leveling each accomplish, and why the endurance rating is a property of the worst block rather than the average. filesystems · intermediate
Nov 11, 2023 Coordinating Multiple Language Servers Across Workspace Folders What happens when one buffer is claimed by several servers and one workspace has several roots: document selectors, folder change notifications, per-scope configuration, and watched-file events. developer tools · advanced
Nov 11, 2023 The Accept Loop: From listen() to an Accepted Connection What the kernel does between the TCP handshake and a readable socket, why listen() takes a backlog argument, and how accept wakeups distribute work across processes. backend systems · foundational
Nov 10, 2023 Conflict Serializability and the Precedence Graph Test How read-write conflicts between concurrent transactions form a directed graph, why a cycle means no equivalent serial order exists, and where the test stops being useful. databases · foundational
Nov 9, 2023 Tickless Idle and Timer Reprogramming How a kernel suppresses the periodic tick while the system is idle, which timer it programs instead, and what the reprogramming costs in latency and in lost timekeeping. embedded systems · intermediate
Nov 8, 2023 The Equivalence Relation That Refactoring Depends On Refactoring is defined as behavior-preserving change, which first requires deciding what counts as behavior. That decision is the whole discipline. software engineering · foundational
Nov 7, 2023 Beta Reduction and the Consequences of Evaluation Order How the single rewrite rule of the lambda calculus produces drastically different programs depending on where it is applied, and why normal order finds a value whenever one exists. computation theory · foundational
Nov 7, 2023 Peer Requirements and the Problem of Straddling Two Majors Why some dependencies must be singletons supplied by the consumer, what happens when a package is asked to support two incompatible majors at once, and how the constraint is expressed. software engineering · intermediate
Nov 6, 2023 The Reparameterization Trick and Gradient Flow Through Sampling Why a sampling operation blocks backpropagation, how the score-function estimator works around it, and what the reparameterized estimator changes about gradient variance. deep learning · foundational
Nov 5, 2023 Buffering Modes and Why Pipeline Output Appears Out of Order How the C library decides between line and block buffering, why redirection changes the interleaving of standard output and standard error, and what flushing actually guarantees. developer tools · intermediate
Nov 4, 2023 Punched-Card Encoding in Hollerith Tabulating Equipment How a pinned card completes a circuit into a mercury cup, what the hole pattern encodes, and why sorting a deck became the way to answer arbitrary questions about census data. computing history · foundational
Nov 4, 2023 Translational Weight Sharing and Feature Map Aliasing How a kernel applied at every position implements a translation-equivariant prior, what the stride lattice does to that guarantee, and where shift invariance actually breaks. deep learning · foundational
October
Oct 28, 2023 Retry Classification When the Failure Arrives as a Timeout A timeout is the absence of an answer, not a statement that the request failed, and the decision to retry depends on whether the server can tell a duplicate from a first attempt. mobile computing · intermediate
Oct 27, 2023 Data Races, Memory Models, and Where Parallel Algorithms Lose Determinism How relaxed memory ordering breaks the intuitive interleaving model, what the C and C++ memory model guarantees, and why race-free parallel code can still be non-deterministic. algorithms · advanced
Oct 27, 2023 The Curb-Cut Effect and the Marginal Cost of Building a Constraint In Why constraints that are cheap at design time are expensive as retrofits, how the benefit of a widened constraint spreads beyond its original justification, and where the reuse argument stops being true. accessibility · foundational
Oct 26, 2023 Attributing Energy to Code with a State Machine Model How to assign charge to firmware paths by tracking state transitions, why instruction counts are a poor proxy, and where the attribution model is structurally wrong. embedded systems · advanced
Oct 26, 2023 Scheduling a Job Graph Around Its Critical Path The longest path through the dependency graph bounds pipeline latency regardless of machine count, and the cost of fan-out decides whether widening the graph helps at all. devops · intermediate
Oct 24, 2023 Package Encapsulation and the Leak of Internal Types How languages draw the visibility line around a package, which constructs quietly widen it, and why an exported type in a public signature defeats the boundary it was meant to protect. software architecture · intermediate
Oct 23, 2023 Live-Range Splitting at Region Boundaries Why a value that is live in two distant regions is better allocated as two values, how splitting interacts with spilling, and what the extra moves cost at the join. compilers · advanced
Oct 21, 2023 Inside the NIC Receive Path: Descriptors, Rings, and NAPI A frame arriving at a network interface moves through a DMA ring, a descriptor, an interrupt, and a poll loop; where each step can drop it. networking · advanced
Oct 21, 2023 Parsing SQL: Clause Structure and Expression Precedence How a statement becomes a parse tree, where the SQL grammar is genuinely ambiguous, and which decisions the parser deliberately leaves to later stages. databases · foundational
Oct 20, 2023 Deriving a Changelog from Commit Messages How a structured commit header turns release notes into a mechanical transformation, which parts of the convention are load-bearing, and where the encoder and the reader disagree. devops · foundational
Oct 19, 2023 Deriving k Bloom Filter Probes from Two Hash Words Why the h1 + i·h2 construction preserves the false-positive bound, where the independence assumption breaks, and what enhanced double hashing repairs. data structures · intermediate
Oct 19, 2023 The Order of Sources in Accessible Name Computation How an accessible name is assembled from aria-labelledby, aria-label, host-language labels, and content, and where the recursion stops. accessibility · foundational
Oct 19, 2023 Treaps: Priorities, Expected Depth, and Rotation-Only Updates How assigning a random priority per key turns a binary search tree into a heap-ordered structure with a probabilistic height bound, and what deletion by rotation costs. data structures · intermediate
Oct 18, 2023 Global History and the Gshare Index Hashing recent branch outcomes into the predictor index lets one branch learn from another; the mechanism, the XOR that spreads history across sets, and the interference it creates. computer architecture · intermediate
Oct 18, 2023 Quarantine and Replay: What Happens to Records That Fail Validation Rejecting a record is a write to a second table, and replaying it later is a second write path; both need a schema, an ordering rule, and a bound on how long they stay open. data engineering · advanced
Oct 18, 2023 Signing Key Rotation and the Proof-of-Rotation Lineage How a new signing key proves continuity with the old one, why the lineage is a linked list of cross-signed certificates, and what a device that has never seen the old key must be told. mobile computing · intermediate

2023

November

October