Complete archive

Archive

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

2024
Jan 20, 2024 Entering Long Mode From a Boot Loader The exact register sequence that turns on 64-bit addressing on x86-64, why paging must be enabled in the same instruction that commits to long mode, and the page tables that must exist beforehand. operating systems · intermediate
Jan 20, 2024 Pagination Contracts and Why Cursors Drift Less Than Offsets How offset and keyset pagination fail under concurrent writes, what a cursor must encode, and which stability guarantees an API can honestly promise. software architecture · foundational
Jan 20, 2024 Re-Reference Interval Prediction in Shared Last-Level Caches How a two-bit prediction value per line resists scan thrashing, why set dueling picks a policy without simulating every access, and where shared-cache insertion policy goes wrong. memory systems · advanced
Jan 19, 2024 Deterministic Replay: Recording a Thread Schedule and Playing It Back What must be captured to reproduce an execution exactly, why recording the interleaving is not enough, and how replay trades observability for the ability to repeat a failure. systems programming · advanced
Jan 19, 2024 Measured Boot and the Chain of Trust From Firmware to Kernel How each boot stage hashes the next into a TPM before executing it, why the measurements go into append-only PCRs, and what an attestation actually proves about a running system. operating systems · advanced
Jan 18, 2024 Deadline Servers and Admission Control How a constant-bandwidth server gives any thread a deadline without trusting its behaviour, and why the admission test is what turns a priority into a guarantee. operating systems · advanced
Jan 17, 2024 Background Sync and Deferred Work How sync tags schedule retries after a failed request, why the payload must live in IndexedDB, and what the periodic variant does and does not guarantee about timing. web platform · intermediate
Jan 17, 2024 Lenses and Traversals as Composable Immutable Accessors How the van Laarhoven encoding represents a lens as a function over functors, why the laws are not enforced, and what composition costs at run time. programming languages · advanced
Jan 16, 2024 Level-Triggered Reconciliation and the Desired-State Loop How a platform controller converges observed state toward declared state, why it re-reads everything on every pass, and what that costs in API traffic and correctness. devops · foundational
Jan 16, 2024 Wildcard Semantics in Resource ARNs and Why They Span Separators How the star and question-mark metacharacters match against ARN strings, where their reach exceeds the intent of the author, and how policy variables substitute before matching. cloud infrastructure · foundational
Jan 15, 2024 Redundant Encoding: When Color Cannot Be the Only Signal Why hue collapses under monochrome rendering and common color vision deficiencies, and the concrete channels — shape, position, texture, text — that carry the same information in parallel. accessibility · foundational
Jan 11, 2024 File Descriptor Lifetime, Inheritance, and Table Exhaustion What a descriptor actually indexes, how the process and system tables share file descriptions, and why closing in the wrong process leaves the resource open. systems programming · intermediate
Jan 11, 2024 Hierarchical Timing Wheels for Millions of Timeouts A heap of deadlines costs O(log n) per insertion and O(1) to read the next one. A hashed wheel with cascading levels makes insertion O(1) and confines expiry to one bucket, at the price of resolution and a bounded maximum interval. language runtimes · advanced
Jan 11, 2024 The Burrows–Wheeler Transform and Backward Search in the FM-Index Why sorting cyclic rotations clusters equal characters, how the LF mapping inverts the transform, and how the same mapping turns the last column into a searchable index. algorithms · intermediate
Jan 10, 2024 Method Resolution Order in Multiple Inheritance How C3 linearisation produces a consistent method order from a class graph, why depth-first search fails on diamonds, and what the monotonicity property forbids. programming languages · intermediate
Jan 10, 2024 Snapshot Expiry, Reference Counting, and Files That Nothing Points To Why deleting an old snapshot does not delete its files, how a sweeper decides which objects are unreferenced, and the two ways that decision goes wrong in opposite directions. data engineering · advanced
Jan 9, 2024 Conservative Stack Scanning Without Type Maps How a collector can treat any word that falls inside the heap as a pointer, why that forces a non-moving heap, and what the ambiguity costs in retention and false roots. language runtimes · advanced
Jan 9, 2024 Distribution-Free Comparison When the Data Is Not Normal What rank tests actually test, how permutation and bootstrap procedures produce intervals on a benchmark difference without assuming a shape, and where each method loses power. performance engineering · intermediate
Jan 7, 2024 Collision Resistance and the Birthday Bound Why a hash needs roughly twice the output bits of the security level it claims, how the three resistance notions differ, and where the generic attacks stop applying. cryptography · foundational
Jan 7, 2024 Cursor Columns and Where the Next Incremental Read Starts How a polling connector decides which rows are new, why a timestamp cursor loses rows at ties and clock skew, and what a composite keyset cursor fixes. data engineering · foundational
Jan 7, 2024 The Reset Vector and the First Instruction Executed Why an x86 processor begins executing at 0xFFFFFFF0 in real mode, how that address reaches the firmware ROM, and what the sixteen bytes at the top of memory must contain. operating systems · foundational
Jan 6, 2024 Property-Based Testing and How Shrinking Finds the Minimal Case Why random generation finds inputs a hand-written table misses, how generators compose, and the reduction algorithm that turns a failing 400-element list into a failing 3-element one. software engineering · intermediate
Jan 6, 2024 Seams: The Places Where Behavior Can Be Substituted A seam is a point where an edit can change behavior without editing at that point. Link seams, object seams, and preprocessor seams cost different amounts and fail differently. software engineering · intermediate
Jan 5, 2024 Zero-Result Queries and Automatic Query Relaxation How a search interface responds when no document matches, the sequence of constraint relaxations it can try in order, and how it decides which relaxation to show. information retrieval · advanced
Jan 4, 2024 Two-Level Hierarchies for Instanced Scenes How a top-level structure over instances plus a shared bottom-level mesh keeps memory flat, what the transform costs per ray, and why overlapping instances defeat the pruning. computer graphics · advanced
Jan 1, 2024 Clustered and Secondary Access Paths and the Cost of a Row Fetch What separates a clustered index from a secondary index, how a secondary lookup pays for a second descent, and why covering indexes change the plan. databases · foundational
2023
Dec 29, 2023 Calibrating Scores Before Choosing an Operating Point How to measure whether a score means what it claims, why Platt scaling and isotonic regression behave differently at the ends, and what calibration cannot fix. machine learning · advanced
Dec 29, 2023 Opus: Two Codecs Behind One Payload Type SILK and CELT cover different frequency bands and latencies, and the hybrid mode that combines them explains most of Opus configuration decisions. internet protocols · intermediate
Dec 29, 2023 Positional Indexes and Phrase Verification Why phrase queries need positions and not just identifiers, how a positional postings list stores them compactly, and the cost of exact phrase matching. information retrieval · intermediate
Dec 29, 2023 Proxy Boundaries, Forwarded Headers, and the Hop-by-Hop Contract Which headers stop at an intermediary, how the client address is reconstructed without trusting the wrong hop, and why framing disagreement produces smuggling. backend systems · advanced
Dec 29, 2023 Sequential Scans, Hardware Prefetch, and the Page Walk What happens between a linear loop over an array and the memory it reads, why huge pages change the cost, and where a scan stops being sequential. data structures · intermediate
Dec 28, 2023 In-Situ Analysis and the Bandwidth That Is Not There Why moving simulation output to a separate visualization process stops working at scale, how coupling the analysis into the solver changes the algorithm, and what the shared-memory boundary costs. scientific computing · advanced
Dec 28, 2023 Lyndon Factorization and the Structure of Minimal Rotations How Duval splits any word into a non-increasing sequence of Lyndon words in linear time, why the longest Lyndon prefix equals the next smaller suffix, and how that decides the smallest rotation. algorithms · advanced
Dec 28, 2023 Moving Workloads with Overlapping Private Address Space Why two RFC 1918 networks that both use 10.0.0.0/8 cannot be joined by routing alone, how translation state makes the link fragile, and where addresses embedded in payloads defeat it. cloud infrastructure · intermediate
Dec 27, 2023 Tile Selection: Cost Models Against Measurement A fused kernel still needs a tile shape and a loop order, and the compiler must choose them either by estimating cost or by measuring candidates on the device. inference systems · intermediate
Dec 26, 2023 Polymorphic and Megamorphic Inline Caches What a cache does when a second and then a fourth layout arrives at the same site, how the compare chain and the hash stub differ, and where the threshold between them sits. language runtimes · intermediate
Dec 26, 2023 Why Boot Loaders Are Split Into Stages The 512-byte first sector, the real-mode address space that constrains where a second stage can live, and how chainloading hands control from firmware to a loader to a kernel. operating systems · foundational
Dec 25, 2023 ARX Ciphers: Carry Chains as the Only Nonlinearity Why modular addition provides nonlinearity in add-rotate-xor designs, how carries propagate as a probabilistic process, and why diffusion is measured in bits. cryptography · intermediate
Dec 25, 2023 What ICMP Echo and TTL Probing Actually Measure The difference between the forward and return paths a traceroute samples, why hop times are often wrong, and what rate limiting on the control plane does to the numbers. networking · intermediate
Dec 24, 2023 Marshalling Across the Language Boundary Every call between shared code and platform code crosses a runtime boundary with a serialisation step, a scheduler hop, and a lifetime problem. The cost is dominated by crossings, not by bytes. mobile computing · foundational
Dec 22, 2023 Byte Ranges, Partial Responses, and Range Request Cost How Range and Content-Range select a byte window, when a server must answer 206 rather than 200, and why many small ranges are a denial-of-service shape. internet protocols · advanced
Dec 22, 2023 Checkpoint and Restart: Making a Multi-Hour Batch Job Resumable What a checkpoint must capture for a job to continue correctly, why sequential files need repositioning information rather than byte counts, and how generation data sets make reruns safe. computing history · advanced
Dec 21, 2023 Perceptually Uniform Colormaps and the Failure of Rainbow Ramps How a scalar field becomes color through a lookup table, why monotonic lightness and equal perceptual steps are the two constraints that matter, and where banding and false contours come from. scientific computing · foundational
Dec 20, 2023 Listener Identity, Options, and Removal During Dispatch Registrations are keyed by type, callback, and capture flag alone, so options like once and passive stick to the first registration, and removal criteria are narrower than most callers expect. web platform · foundational
Dec 20, 2023 Rename Atomicity and the Replacement of a Directory Entry How rename changes two directory entries without a window of invisibility, which cross-filesystem cases the guarantee excludes, and why the call is the primitive behind atomic file updates. filesystems · intermediate
Dec 20, 2023 Unit-Cost RAM, Word RAM and Bit Complexity as Three Different Machines The same algorithm can be linear, logarithmic or quadratic depending on whether operations are charged per step, per word, or per bit, and the choice of model decides which bounds are comparable. algorithms · intermediate
Dec 19, 2023 Schema Drift at the Connector Boundary A source that adds a column or widens a type breaks a connector in ways that depend on whether the change is read-time, write-time, or decode-time. data engineering · intermediate
Dec 18, 2023 Arrow Buffer Layout and Where Zero-Copy Stops How an Arrow array is a handful of flat buffers plus a length, which conversions can reuse memory in place, and which schema and lifetime conditions force a copy. data engineering · advanced
Dec 16, 2023 Write-Ahead Journaling and the Three-Phase Commit Record How a journal turns many unordered block writes into one atomic transaction, why the commit block must be a single sector, and how replay stays idempotent. filesystems · foundational
Dec 15, 2023 Ephemeral Preview Environments: Naming, Lifetime, and Cost Control A per-change environment needs a deterministic name, a lifecycle bound to something that can be observed, and a cost ceiling. Where each of those decisions fails, and why cleanup is the hard part. virtualization · intermediate
Dec 15, 2023 Hidden Subtrees and Presentational Roles The difference between aria-hidden, display none, visibility hidden, and role presentation, and which of them removes a node from the tab order. accessibility · intermediate
Dec 15, 2023 Shadow Page Tables: Keeping Two Guest Mappings Consistent With One Hardware Walk Why a hypervisor must build its own page tables from the guest's, which guest writes force a rebuild, and how the reverse-map and write-protection machinery bounds the cost of keeping them honest. virtualization · foundational
Dec 14, 2023 Active-Mask Accounting and Issue Slot Efficiency How to compute the fraction of lane capacity a warp actually delivers from its active masks, and why instruction issue rather than lane count is the resource that runs out. gpu computing · intermediate
Dec 12, 2023 Admission Control for Background Work: Keeping Scans Off the Critical Path Why a fixed batch size cannot protect foreground latency, how a feedback controller turns saturation signals into a work rate, and where the loop becomes unstable. distributed systems · intermediate
Dec 12, 2023 Graded Gains and the NDCG Discount How discounted cumulative gain combines a gain mapping and a rank discount, why the logarithmic discount was chosen, and what normalisation does and does not fix. information retrieval · intermediate
Dec 12, 2023 Mutual Information and the Capacity of a Noisy Channel How the largest reliable transmission rate is defined as a maximum of mutual information, why the binary symmetric channel peaks at an interior input distribution, and what the capacity formula does not promise. computation theory · foundational
Dec 12, 2023 Partial Reconfiguration: Static and Dynamic Partitions How a region of an FPGA is redefined while the rest keeps running, what the boundary between static and dynamic logic requires, and why the decoupler is not optional. hardware engineering · advanced
Dec 12, 2023 Recall-Oriented Summary Scoring with ROUGE Why summarization metrics divide by reference length rather than output length, how longest-common-subsequence scoring differs from n-gram counts, and what the recall direction lets a system get away with. inference systems · foundational
Dec 12, 2023 Scheduling Actions Across a Dependency Graph How a build executor chooses among the actions that are currently runnable, why the longest path through the graph bounds the achievable speedup, and where local and distributed execution diverge. developer tools · intermediate
Dec 12, 2023 What a Plan File Records and Why Applying It Is Not a Re-Plan How the plan is computed, what it stores beyond the proposed changes, and why the saved artifact can disagree with the world it is applied to. cloud infrastructure · intermediate

2024

2023