Complete archive
Archive
3,240 articles, newest first · page 2 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
Oct 8, 2026 Reading a Directory as a Stream: readdir and Its Weak Guarantees Directory listing is a cursor over mutable records, not a snapshot; what the offset cookie means, which entries can be missed or repeated, and why sorting requires reading everything first. filesystems · intermediate - Oct 8, 2026 Secondary Indexes Under MVCC: Version Chasing and Index Write Amplification Why every row version needs its own index entries, how a lookup follows pointers through superseded versions, and what a non-covering index costs in a versioned store. databases · advanced
- Oct 8, 2026 Stack Unwinding in the Kernel Without Frame Pointers Walking a call stack whose compiler optimised away the frame pointer, the unwind tables that replace it, and why unwinding from an interrupt frame needs a different entry point. operating systems · intermediate
- Oct 7, 2026 Bidirectional Search and the Problem of Knowing When to Stop Why two frontiers can meet without the answer being final, which stopping rules are provably safe, and how the meeting point is recovered from two label arrays. algorithms · intermediate
- Oct 7, 2026 Conjugate Priors and the Arithmetic of Posterior Updating How a likelihood and a prior combine into a posterior in closed form, what that closure preserves under sequential updating, and where the closed form stops being available. machine learning · foundational
- Oct 7, 2026 Fault Escalation and Reading the Stacked Frame After a Crash Why an imprecise bus fault arrives as a hard fault, which status bits distinguish the causes, and how the stacked frame locates the instruction that failed. embedded systems · advanced
- Oct 7, 2026 Fill-In, Elimination Ordering, and Symbolic Factorization Why eliminating a sparse matrix creates new nonzeros, how ordering heuristics bound the damage, and how the pattern of the factor is predicted before any arithmetic runs. scientific computing · intermediate
- Oct 7, 2026 Linear Blend Skinning and the Candy-Wrapper Collapse Why averaging joint matrices produces volume loss and pinching on twisted limbs, how dual quaternions replace the average, and why dual quaternion skinning is not always the better choice. computer graphics · intermediate
- Oct 7, 2026 OFDMA Scheduling and Multi-User Transmission in Wi-Fi How a 20 MHz channel is split into resource units, how a trigger frame coordinates simultaneous uplinks, and what the scheduling overhead costs. networking · advanced
- Oct 7, 2026 Seek Time, Rotational Latency, and Why the Average Is Not the Middle How a drive decomposes an access into seek, settle, and rotation, why the mean seek is not half the maximum, and how queueing turns latency into a throughput number. hardware engineering · intermediate
- Oct 6, 2026 Exit Status Semantics and the Limits of set -e What the 8-bit exit status encodes, which failures errexit deliberately ignores, and why a pipeline reports only one stage of its work. developer tools · foundational
- Oct 6, 2026 Mapping ARIA Roles onto Platform Accessibility APIs How a role token becomes an MSAA role, an AXRole, or an AT-SPI role, which properties carry states, and where the mappings diverge. accessibility · intermediate
- Oct 6, 2026 Repository-Scale Codemods and the Review Problem A codemod that rewrites ten thousand call sites produces a diff nobody can read. Sharding, mechanization proofs, and a declarative matcher are what make the change reviewable. software engineering · advanced
- Oct 6, 2026 Synonym Expansion at Index Time Versus Query Time Why expanding a thesaurus into the index and expanding it into the query produce the same postings but different costs, and how each choice changes scoring and phrase matching. information retrieval · intermediate
- Oct 6, 2026 Text Metrics and Line Breaking Across Two Font Stacks The same string occupies different space on two platforms because measurement, shaping, and fallback differ. Shared layout must pick one authority for metrics or accept divergence. mobile computing · intermediate
- Oct 5, 2026 Structured Concurrency and the Task Scope Why a spawned task should not outlive its parent, how a scope joins on exit and cancels siblings on failure, and what the nesting rule buys over detached threads. programming languages · intermediate
- Oct 5, 2026 Tail Position, Accumulators, and Continuation-Passing Style Why a call in tail position needs no return frame, how accumulator arguments turn structural recursion into a loop, and what the CPS transformation costs. programming languages · intermediate
- Oct 4, 2026 Non-Transparent Bridges and Multi-Host PCIe Topologies Why two root complexes cannot simply be cabled together, how a non-transparent bridge presents a translated address window to each side, and what the doorbell handshake does not guarantee. hardware engineering · advanced
- Oct 3, 2026 Layer Normalization and the Residual Stream How per-example statistics change the gradient path compared with batch statistics, why the placement of a normalization layer relative to a residual branch alters scale growth with depth, and what the learnable gains do. deep learning · intermediate
- Oct 2, 2026 Bootstrapping a Replica from a Snapshot and a Log Tail Why a running replica cannot simply be copied file by file, how a consistent cut is captured while writes continue, and how the log position inside the snapshot stitches it to the stream. distributed systems · advanced
- Oct 2, 2026 Inter-Operator Parallelism and Stream Scheduling Independent branches of a graph can run concurrently on separate queues, but overlap only helps when the branches use different resources and the dependencies are exact. inference systems · advanced
- Oct 2, 2026 Ordering Stores to Persistent Memory: CLWB, SFENCE, and Failure Atomicity Which instruction makes a store reach the media, why a flush without a fence still allows reordering, and how a persistent heap builds transactions out of a cacheline flush and an undo log. memory systems · advanced
- Oct 2, 2026 Propagation, Cumulativity, and Why Weak Models Need Transitive Visibility Messages that preserve ordering are not enough: a store already observed by one thread must be observed by every thread it reaches, and multi-copy atomicity is the property that says so. computer architecture · advanced
- Oct 2, 2026 Shadow Stacks and Protecting the Return Address Why a parallel copy of the return address catches overflows that canaries miss, how the check is wired into the epilogue, and what the hardware support changes. memory systems · intermediate
- Oct 2, 2026 Stubs, Fakes, and Mocks: What Each Double Actually Verifies The distinction between state verification and interaction verification, why a hand-written fake survives refactoring better than a mock, and what mock assertions couple. software engineering · foundational
-
September
Sep 30, 2026 Coordinated Omission and the Samples a Closed Loop Never Takes How a benchmark that waits for each response before issuing the next one systematically excludes the worst delays from its own histogram, and the interval-based correction that recovers them. performance engineering · foundational - Sep 30, 2026 Error Contracts: Problem Details, Stable Codes, and Retry Semantics How to design an error payload that machines can branch on and humans can act on, and why retryability belongs in the contract rather than in the status code alone. software architecture · intermediate
- Sep 30, 2026 Litmus Tests as Executable Specifications How a five-line concurrency test becomes a machine-checkable claim, what the litmus file format encodes, and how a model checker decides which outcomes are forbidden. memory systems · intermediate
- Sep 30, 2026 Measuring Fragmentation: Free Space That Cannot Be Used How internal and external fragmentation differ, why a heap can be mostly free and still fail a large request, and which ratios turn free space into a number that predicts allocation failure. memory systems · intermediate
- Sep 30, 2026 Migrating Stored Data While Both Formats Are Live A dual-write phase lets code change before data does, but it trades a clean cutover for a consistency problem. Ordering, backfill, and verification decide whether it holds. software engineering · advanced
- Sep 30, 2026 Virtual Cursors and Browse Mode How a screen reader maintains a separate reading cursor over a virtual buffer of the page, distinct from real keyboard focus, and why the two desynchronize. accessibility · intermediate
- Sep 30, 2026 Why RTP Timestamps Do Not Count Seconds RTP timestamps advance at the codec clock rate, which makes arithmetic modular and stream-relative; the rules that follow for wrap, comparison, and cross-stream sync. internet protocols · foundational
- Sep 29, 2026 Failure Domains and the Arithmetic Behind Replication Factor How a copy count becomes a durability estimate, why that estimate collapses when failures correlate, and what placement must do to keep the arithmetic honest. filesystems · foundational
- Sep 29, 2026 Weight-Only Quantization and the Memory-Bandwidth Bound Why 4-bit weights speed up token generation while leaving prefill almost untouched, how the dequantize-on-load kernel works, and where the arithmetic intensity ceiling sits. inference systems · intermediate
- Sep 28, 2026 Resource Requests, Limits, and What the Scheduler Actually Counts Why a request is a scheduling reservation rather than a runtime guarantee, how limits are enforced by cgroups, and why the two numbers produce three quality-of-service classes. virtualization · foundational
- Sep 28, 2026 The Split Between Submission and Relay Ports Why port 587 exists separately from port 25, which policies differ between the two roles, and how a server distinguishes a user from a peer MTA. internet protocols · foundational
- Sep 27, 2026 Linkage, Symbol Visibility, and the Weak Definition What the linker actually does with an external declaration, how internal and external linkage differ, and the resolution order that makes weak and common symbols dangerous. systems programming · intermediate
- Sep 26, 2026 Adjacency Lists, Matrices, and the Cost of Asking Who Is Adjacent How adjacency matrices, per-vertex lists, and compressed sparse row arrays differ in memory, neighbour iteration, and edge lookup, and which graph shapes favour each. algorithms · foundational
- Sep 26, 2026 Fixed and Independent Versioning in a Monorepo How a repository containing many packages decides whether they share one version or several, what the coupling does to upgrades, and how change detection assigns a bump to each package. devops · intermediate
- Sep 26, 2026 Path Building and Validity Checking in X.509 Certificate Chains How a TLS peer turns a list of certificates into a trusted path: name chaining, basic constraints, validity windows, and why path building is search rather than parsing. internet protocols · foundational
- Sep 26, 2026 Suite Economics: Runtime, Feedback Delay, and Test Selection Why the value of a test decays with the time it takes to report, how to partition a suite by feedback latency, and what selective running buys and costs. software engineering · advanced
- Sep 26, 2026 Symbol Interposition and the Global Namespace The search order that decides which definition of a name wins, why a shared library cannot rely on its own globals, and how preloading and interposition actually take effect. compilers · advanced
- Sep 26, 2026 The Shared Kernel Boundary and What Containers Cannot Isolate Why container isolation is a partition of kernel state rather than a hardware boundary, which attack surfaces remain, and how the layers of defence are composed. virtualization · advanced
- Sep 25, 2026 Authenticated Denial of Existence with NSEC and NSEC3 How a signed zone proves that a name or type is absent, why NSEC leaks the zone inventory, and what hashing with NSEC3 costs in queries and opt-out coverage. internet protocols · advanced
- Sep 25, 2026 Cluster Segmentation: Choosing a Blast Radius Instead of Accepting One Control plane failure, node failure, and tenant misbehaviour propagate differently. How to decide what shares a cluster, what must be separated, and what separation costs in operational surface. virtualization · advanced
- Sep 25, 2026 Topological Readiness in Workflow Dependency Graphs How a scheduler decides which task may start, why the dependency edge carries ordering rather than data, and what the critical path bounds. data engineering · foundational
- Sep 24, 2026 32-bit Compatibility System Calls on a 64-bit Kernel How one kernel serves two pointer widths, why the compatibility entry path differs from the native one, and where the translation layer leaks. operating systems · advanced
- Sep 24, 2026 Focus Across Shadow Roots and Frame Boundaries Where document.activeElement points when focus enters a shadow tree or an embedded document, what delegatesFocus changes, and why a custom element that contains a field is not a tab stop by default. accessibility · advanced
- Sep 24, 2026 Incremental Correctness Under Source Mutation Every incremental build assumes the source tree holds still while it runs. What an edit arriving mid-build does to the graph, how tools detect it, and the snapshot technique that removes the assumption. developer tools · advanced
- Sep 24, 2026 Rate-Distortion Theory and the Shape of Lossy Compression Why lossy coding is governed by a curve rather than a single number, how the Gaussian bound is derived, and why vector quantization beats scalar quantization at the same rate. computation theory · advanced
- Sep 24, 2026 Shadow Stacks, Pointer Authentication, and Memory Tagging in Silicon Three hardware answers to memory corruption differ in what they protect and what they cost: a second return stack, signed pointers, and per-allocation tags checked on every access. security · advanced
- Sep 24, 2026 Signals: Delivery, Interruption, and the Async-Signal-Safe Set A signal handler runs on the thread it interrupted, with that thread half-finished, which is why only a small set of functions may be called from one. Delivery, masking, and the self-pipe pattern follow from the handler running on an interrupted thread. systems programming · intermediate
- Sep 23, 2026 Atomic Commits and Snapshot Isolation Between Concurrent Writers What makes a commit atomic when the storage offers only single-object writes, how two writers racing on the same table are serialized, and which conflicts are detected only at commit time. data engineering · foundational
- Sep 23, 2026 Delta Update Patches: Source Identity, Not Just a Diff Why a binary delta is only applicable to the exact bytes it was computed from, how the store identifies those bytes, and why splitting an app bundle changes what a delta can save. mobile computing · intermediate
- Sep 23, 2026 Elaboration: Filling in What the Program Did Not Say How metavariables, unification, and implicit arguments turn surface syntax into a fully explicit core term, and why the process can fail in ways the source does not explain. computation theory · advanced
- Sep 23, 2026 Elias-Fano Encoding for Monotone Sequences How splitting each integer into a high and low part stores a sorted sequence at near-optimal space while keeping random access, and what a select operation costs. information retrieval · advanced
- Sep 23, 2026 How prefers-reduced-motion Reaches an Animation and What It Cannot Stop The media query reports a user setting, so authors must honour it in CSS and in script; which motion triggers vestibular symptoms, and why duration is the wrong knob to turn. accessibility · intermediate
- Sep 23, 2026 HTML Content Model Categories and What They Actually Constrain Flow, phrasing, sectioning, embedded, interactive, and transparent content describe what may nest inside what. Browsers enforce a few of those rules by repairing the tree and ignore the rest. web platform · foundational
- Sep 23, 2026 Unstable Writes, COMMIT, and the Verifier A write may be acknowledged before the server has put the data on stable storage. The reply says how stable it is, and the client decides whether to ask for a commit — a decision that trades latency against the risk of losing an acknowledged write. filesystems · intermediate
- Sep 22, 2026 Leftist and Skew Heaps: Merging in Logarithmic Time How a rank stored per node bounds the right spine, why skew heaps drop the rank and still amortise to logarithmic merge, and what the recursion costs. data structures · intermediate