Complete archive
Archive
3,240 articles, newest first · page 52 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.
-
2022
Dec 8, 2022 TLB Tagging and Nested Invalidation: Keeping Translations Alive Across a VM Boundary Why guest translations must survive an exit, how address-space identifiers make that possible, and why invalidating the second level is coarser and more expensive than the first. virtualization · advanced - Dec 8, 2022 When Inclusive Constraints Conflict: Partial Orders and Documented Exceptions How to resolve collisions between accessibility constraints using a stated priority order, why an unordered checklist produces inconsistent decisions, and how to record exceptions so they stay auditable. accessibility · advanced
- Dec 6, 2022 Adaptive Execution: Runtime Filters and Mid-Query Replanning How a running plan uses observed cardinalities to change join strategy, and how bloom filters and partition pruning eliminate work before it happens. databases · advanced
- Dec 5, 2022 Row Identity and Why Deduplication Needs a Key, Not a Comparison Deciding that two records describe the same entity requires a declared key; comparing whole rows fails on late-arriving corrections, and windowed dedup only moves the ambiguity. data engineering · foundational
-
November
Nov 30, 2022 Failure Atomicity and Cleanup on the Error Path How partial construction is made safe: commit-or-rollback discipline, errdefer-style compensation, and the invariants a constructor must restore before returning an error. systems programming · foundational - Nov 26, 2022 What a Build Cache Key Must Cover Under-keying produces wrong artifacts that look valid; over-keying destroys the hit rate. How to enumerate the true inputs of a build action, and where the environment leaks in. devops · foundational
- Nov 19, 2022 CAN Error Counters and the State Machine That Silences a Faulty Node Transmit and receive error counters move by different amounts for different faults, and the three-state model that follows from them decides when a node stops talking. embedded systems · intermediate
- Nov 18, 2022 Pairing Heaps and the Two-Pass Merge How a self-adjusting heap replaces rank bookkeeping with a left-to-right then right-to-left merge, why melding is constant time, and what the amortised bounds actually are. data structures · intermediate
- Nov 17, 2022 Colossus and the Counting Attack on Lorenz Wheel Settings How a hypothesised wheel pattern is compared against ciphertext character by character, how valve counters accumulate the statistic, and why the machine was built for one search. computing history · intermediate
- Nov 16, 2022 GLR Parsing and the Graph-Structured Stack How a generalized LR parser follows every viable parse at once by replacing the stack with a DAG, how ambiguity is packaged into a shared forest, and what the merging costs. compilers · advanced
- Nov 15, 2022 Characteristic Impedance from Stackup Geometry How trace width, dielectric height, and copper thickness combine into a characteristic impedance, why the equations are approximations, and what happens to impedance when a net changes layer. hardware engineering · foundational
- Nov 12, 2022 Reducing Failing Inputs to a Minimal Counterexample How property-based testers search for smaller inputs that still fail, why shrinking needs deterministic failures and per-type reduction rules, and what delta debugging assumes. developer tools · advanced
- Nov 11, 2022 The Cost of Generality: Why Fixed-Function Logic Wins What a programmable core spends on instruction issue and operand fetch, how Amdahl bounds the payoff of offloading work, and where a fixed-function unit actually beats a CPU. computer architecture · foundational
- Nov 10, 2022 Model-Based Testing with Explicit State Machines How a reference model plus a generator of valid operation sequences tests stateful systems, why the model must be simpler than the code, and how traces localize a divergence. software engineering · intermediate
- Nov 9, 2022 Egress Boundaries and Which Bytes Are Billed Where traffic is metered in a cloud network, why the same byte can be free or charged twice depending on the path it takes, and how NAT and private endpoints move the boundary. cloud infrastructure · foundational
- Nov 8, 2022 Envelope and Header Addresses in SMTP Delivery Why a message carries two independent sets of addresses, which one routing and bounces actually consult, and what breaks when a gateway rewrites one but not the other. internet protocols · foundational
- Nov 7, 2022 Deriving Test Inputs from Equivalence Partitions and Boundaries How partition analysis narrows an enormous input space to a small set of cases, why defects concentrate at the lines between classes, and where the technique stops paying. software engineering · foundational
- Nov 5, 2022 Protecting Key Material in Memory and at Rest What page locking, guard pages, and zeroization actually prevent, why memory safety languages change the calculus, and where stored keys leak. cryptography · intermediate
- Nov 4, 2022 Input Splits Determine Task Granularity in Batch Jobs How a batch framework derives splits from filesystem blocks, why split size sets the task count, and what happens when files are small or compression is not splittable. data engineering · foundational
- Nov 2, 2022 Render-Blocking CSS and Parser-Blocking Scripts on the Critical Path Why a stylesheet stops the first paint and why a script stops the parser, which dependencies the preload scanner can find on its own, and what defer and async actually order. web platform · foundational
-
October
Oct 31, 2022 Least-Outstanding Routing When Request Costs Vary Round robin assumes equal service cost and equal replica capacity. Token generation breaks both assumptions, so routers score replicas by work in flight instead of counting requests. inference systems · intermediate - Oct 26, 2022 Open Connections When the Device Changes Its Address A handover replaces the address under a live socket; why TCP cannot follow it, how QUIC connection identifiers and path validation allow migration, and what a rebinding costs. mobile computing · advanced
- Oct 20, 2022 Unprivileged User Namespaces and the Attack Surface They Open Why allowing any process to create a user namespace turns privileged kernel code paths into reachable ones, which subsystems are most exposed, and how the trade is bounded in practice. virtualization · advanced
- Oct 18, 2022 Admission Control and the Memory Watermark Reserving headroom so that growth does not become preemption: how watermarks, reservation bounds, and head-of-line blocking interact in a cache pool. inference systems · intermediate
- Oct 14, 2022 Refs, Symbolic HEAD, and the Reflog as an Append-Only Log How branch names are stored as text files and packed lists, how HEAD follows indirection, and what the reflog records that refs do not. developer tools · foundational
- Oct 13, 2022 Fault Isolation Between Tenants in One Address Space How software-based isolation keeps untrusted modules in a shared heap using reservations, per-tenant heaps, and checks, and why the hardware offers no help with cross-tenant reads. language runtimes · advanced
- Oct 12, 2022 EDNS(0) and the Truncation Boundary How the OPT pseudo-record extends the header, how the advertised UDP payload size interacts with the 512-byte default, and why truncation is not a partial answer. internet protocols · intermediate
- Oct 10, 2022 Record Semantics: CNAME Exclusivity and RRset Atomicity Why a CNAME cannot coexist with other data at the same name, how RRsets are ordered and cached as units, and what an alias does to the query type. internet protocols · intermediate
- Oct 10, 2022 Sync Ordering and Pruning in a Git-Driven Control Loop A reconciler that applies a directory of manifests has to decide what order to apply in and what to delete. Both decisions have failure modes that a diff never shows. devops · advanced
- Oct 5, 2022 Randomized Quicksort and the Expected Comparison Count How choosing the pivot uniformly at random makes the 2n ln n comparison bound hold for every input, and where the expectation stops describing a single run. algorithms · foundational
- Oct 4, 2022 Action Precedence When Seccomp Filters Stack How the kernel combines verdicts from multiple attached filters, why the winning action is chosen by a documented ranking rather than by numeric order, and how thread synchronization decides which filters exist at all. virtualization · foundational
-
September
Sep 29, 2022 Homogeneous Clipping and Why Rasterizers Use a Guard Band How triangles are clipped against the view volume in clip space before the perspective divide, why clipping only the near plane is usually enough, and what the guard band buys. gpu computing · foundational - Sep 28, 2022 Rolling Updates, Surge, and the Arithmetic of Availability How a rolling update walks a replica set down and up without dropping below a floor, why maxSurge and maxUnavailable interact with readiness rather than with process start, and where the arithmetic breaks. virtualization · intermediate
- Sep 26, 2022 Cut Elimination and the Subformula Property Why removing the cut rule from a derivation bounds proof search to subformulas of the goal, what the elimination procedure costs, and where the bound fails to be useful. computation theory · intermediate
- Sep 26, 2022 How a Migration Runner Records and Orders Applied Versions The ledger table, version ordering, checksums, and locking that make a migration run reproducible, and what happens when two runners start at the same time. databases · foundational
- Sep 26, 2022 Why Textual Renaming Fails and Syntax Trees Do Not A search-and-replace rename breaks on shadowed names, comments, string literals, and macro bodies. A rename that walks a syntax tree knows which occurrences bind. software engineering · foundational
- Sep 24, 2022 Incremental Backup Chains and Restore Depth How changed-block tracking works, why deduplicated storage makes deletion expensive, and why restore time grows with the number of links in the chain. devops · intermediate
- Sep 19, 2022 Grid Track Sizing and the fr Unit How the grid algorithm sizes tracks from intrinsic contributions, why 1fr has an automatic minimum, and how auto-placement fills the implicit grid. web platform · intermediate
- Sep 15, 2022 Native Callbacks Into Managed Code How a C library invokes a function pointer that lands in a garbage-collected runtime, why the trampoline cannot simply be the managed function, and what keeps the target alive. language runtimes · intermediate
- Sep 13, 2022 Subsurface Scattering and the Diffusion Approximation How multiple scattering inside a translucent medium turns a BRDF into a spatial integral, what the reduced scattering coefficient measures, and where the dipole solution stops applying. computer graphics · advanced
- Sep 13, 2022 Suffix Automata and Counting Distinct Substrings Online How a suffix automaton stores every substring of a text in linear states, why cloning a state preserves end-position sets, and how the state graph yields the distinct-substring count. algorithms · intermediate
- Sep 12, 2022 Escape Analysis and Scalar Replacement in Compiled Code How a JIT proves an allocation never leaves its method, why replacing an object with its fields is only safe while guards hold, and what makes the proof fail in practice. language runtimes · advanced
- Sep 12, 2022 Implicit Roles and How Role Conflicts Resolve How browsers derive a role from element and attributes, what happens when an explicit role token disagrees with the host language, and why some overrides are rejected. accessibility · foundational
- Sep 11, 2022 Module Linking, Live Bindings, and the Order of Evaluation ECMAScript modules resolve and instantiate the whole graph before running a single statement, which is what makes imports live and cycles behave unlike CommonJS. web platform · intermediate
- Sep 9, 2022 Provenance Attestations and the Digest They Must Bind An attestation is a signed claim about a build. Its value depends on a subject digest that names the exact artifact, a predicate that names the process, and a verifier policy. security · intermediate
- Sep 9, 2022 Termination Topologies and the Reflection They Absorb Series, parallel, Thevenin, and active termination compared by what they do to the incident wave, what they cost in DC current, and where each one fails on a multi-drop bus. hardware engineering · intermediate
- Sep 5, 2022 Repeat Suppression and Template Fingerprints How collapsing identical messages into a count preserves signal, why a fingerprint must be computed over the template rather than the text, and where collapsing loses information. observability · intermediate
- Sep 1, 2022 Encoding Accessibility Constraints in a Design System Token Layer Why constraints enforced by review decay while constraints encoded in tokens and components persist, which properties belong in the token layer, and what the approach cannot express. accessibility · intermediate
-
August
Aug 30, 2022 Inverse-Transform Sampling and the Generalized Inverse of the CDF Why mapping a uniform variate through the quantile function produces the right distribution, what the discrete case changes, and where floating-point resolution destroys the tails. scientific computing · foundational - Aug 29, 2022 Dynamic Tracing by Rewriting Instructions: ftrace and kprobes How a function is instrumented without recompiling it, what a five-byte jump patch implies for concurrent execution, and why probing an instruction needs a copy of it somewhere else. operating systems · intermediate
- Aug 17, 2022 Aggregating Percentiles Across a Fleet Without Losing the Tail Why per-host percentiles cannot be combined directly, how cumulative bucketed histograms make merging exact, and what temporal aggregation does to the tail that spatial aggregation does not. performance engineering · intermediate
- Aug 17, 2022 Counting Round Trips Before the First Payload Byte A cold request on a phone crosses radio setup, name resolution, a transport handshake, and a TLS handshake before any application data moves, and each layer can be shortened. mobile computing · foundational
- Aug 15, 2022 Diagnosing a Wakeup That Never Arrived A method for distinguishing a scheduler that declined from a request that was never made, using the platform logs and the app own durable records as two independent witnesses. mobile computing · advanced
- Aug 7, 2022 Hot Keys, Skew, and Load Imbalance in Hash Partitioning Why a partitioner that distributes keys evenly can still produce one task with sixty times the average work, and the static and sampled fixes that spread that load. data engineering · intermediate
- Aug 4, 2022 Measuring Debt Without Inventing Numbers Complexity, size, churn, and coupling each measure something different, and none of them measures interest. How to build a debt inventory whose numbers change a decision. software architecture · intermediate
- Aug 4, 2022 Range Calibration: Trading Clipping Error Against Rounding Error How the clipping threshold is chosen for a quantized tensor, why the minimum-error range is not the observed range, and how percentile and divergence criteria differ in what they preserve. inference systems · foundational
- Aug 3, 2022 Conservative Coalescing and the Conditions That Make It Safe Why merging the source and destination of a move can make a colorable graph uncolorable, and how the Briggs and George tests decide when the merge is guaranteed not to hurt. compilers · intermediate
-
July
Jul 31, 2022 Scatter-Gather Fan-Out and Tail Latency Multiplication A query over P partitions waits for the slowest one, so the 99th percentile of a single node becomes the median of the cluster. How hedged requests and partial results change the curve. distributed systems · intermediate - Jul 28, 2022 Floating-Point ABI Variants and the Linker Errors They Cause Soft, softfp, and hard float on 32-bit ARM decide where arguments travel rather than what arithmetic runs, and only the static linker notices when a build mixes them. systems programming · intermediate
- Jul 27, 2022 Grouping, Duplicate Elimination, and Grouping Sets What a GROUP BY actually computes, how the sort-based and hash-based forms differ in output order, and how ROLLUP and CUBE collapse into one scan. databases · intermediate