Complete archive

Archive

3,240 articles, newest first · page 13 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
Apr 20, 2026 Stop-Word Removal and the Phrase Queries It Breaks Why dropping the most frequent terms from the index saves little space today, how position gaps preserve phrase structure, and which queries silently lose meaning. information retrieval · foundational
Apr 20, 2026 The TLS 1.3 Handshake: What Each Flight Commits To The four-message exchange that produces keys: what ClientHello offers, what ServerHello selects, why the transcript hash is the spine, and when a retry costs an extra round trip. internet protocols · foundational
Apr 19, 2026 Heading Anchors and the Silent Failure of Fragment Links A fragment link is resolved in the browser and never requested from the server, so a renamed heading breaks every inbound reference without producing a single 404. software engineering · intermediate
Apr 19, 2026 Key Confirmation Ordering and What It Prevents Why a Finished message must come after the peer can no longer change the transcript, what an explicit key-confirmation exchange adds, and which attacks a misordered exchange leaves open. cryptography · intermediate
Apr 19, 2026 Pinned Host Memory and Why Pageable Transfers Cannot Be Asynchronous Why a copy engine cannot be handed an ordinary host pointer, what the driver does instead, and how the staging buffer turns an asynchronous copy into a synchronous one. gpu computing · foundational
Apr 18, 2026 Conservative Rasterization for Thin and Subpixel Geometry How expanding the coverage test to "the pixel touches the triangle" guarantees that no primitive is dropped, what the inner coverage variant adds, and which artifacts the expanded test creates. gpu computing · advanced
Apr 18, 2026 Iterative Depth-First Search Without Losing Finish Times Why a stack of vertices does not reproduce recursive DFS, how to keep an explicit frame with a resume index, and what changes when the traversal can be paused and resumed. algorithms · intermediate
Apr 18, 2026 UNIX Domain Sockets and Passing File Descriptors A socket in the filesystem namespace carries data without a network stack, and its control-message channel can hand a descriptor to another process. Address formats, the credential channel, and what a descriptor transfer actually copies. systems programming · intermediate
Apr 18, 2026 Verifying Provenance by Rebuilding What an independent rebuild proves, which nondeterministic packaging details decide whether it succeeds, and how to compare artifacts layer by layer rather than by image digest. virtualization · advanced
Apr 17, 2026 Cache Coherence Is Per Location, Consistency Is Not Why a machine can agree perfectly on the order of writes to every individual address and still produce an execution with no single global ordering. computer architecture · foundational
Apr 17, 2026 When Fragmentation Turns into a Latency Problem How address-space spread and shrinking TLB reach convert fragmentation from a capacity problem into a latency one, and how to detect the shift. performance engineering · advanced
Apr 16, 2026 Attack Graphs, Shared Subgoals, and Shortest Paths Through State Space How an attack graph differs from an attack tree, why shared subgoals force a DAG, and how monotone reachability analysis computes the closure of what an attacker can obtain. security · intermediate
Apr 16, 2026 Forced Colors Mode and the System Color Keywords How forced colors replaces author colors with a user-chosen palette, which properties survive, and the design habits that break when backgrounds are overridden but borders are not. accessibility · intermediate
Apr 16, 2026 Junction Temperature and the Thermal Resistance Network How a die's temperature is computed from ambient through a series of thermal resistances, what each interface contributes, and why the transient curve differs from the steady-state number. hardware engineering · intermediate
Apr 16, 2026 Nested Virtualization: Running a Hypervisor Inside a Guest Why the L1 hypervisor's control structure must be virtualized by L0, how exit causes are merged across two levels, and what the recursion costs in exit latency and state tracking. virtualization · advanced
Apr 16, 2026 Network Path Continuity Across a Migration Moving a guest changes the port its frames egress from. Switch forwarding tables, ARP caches, and in-flight TCP segments all have to be re-pointed, and the guest must not observe a reset connection. virtualization · intermediate
Apr 16, 2026 Referential Integrity and the Semantics of Foreign Key Actions What a foreign key actually asserts, how each ON DELETE and ON UPDATE action resolves the violated constraint, and why MATCH SIMPLE accepts a partially null key. databases · foundational
Apr 16, 2026 Stacked Changes and the Mechanics of Incremental Review How a chain of dependent changes lets each diff be read against its own base, what happens when the bottom of the stack changes, and why restacking is the expensive step. software engineering · intermediate
Apr 15, 2026 Owner References, Finalizers, and Why Deletion Is a Protocol How the API server tracks which object owns which, why a delete is a two-phase operation with an intermediate state, and what a finalizer that never completes does to a namespace. virtualization · advanced
Apr 15, 2026 Word Size, Endianness, and Structure Layout Across Architectures Why the same C source produces different bytes on a 32-bit and a 64-bit build, how endianness changes on-disk and on-wire structures, and where alignment padding hides. operating systems · advanced
Apr 14, 2026 Gradual Typing, Higher-Order Casts, and Blame How a boundary between typed and untyped code is enforced by casts, why a higher-order cast must wrap functions, and how blame is assigned when one fails. programming languages · advanced
Apr 14, 2026 Inside a Parquet File: Row Groups, Pages, and the Footer How a Parquet file arranges column chunks, pages, and a trailing metadata block, why the footer is written last, and what the layout forces on readers and writers. data engineering · intermediate
Apr 14, 2026 Tri-Colour Marking and the Barriers That Keep It Honest Why a concurrent marker must prevent a black object from pointing at a white one, how insertion and deletion barriers each enforce that, and what the invariant costs per store. language runtimes · intermediate
Apr 13, 2026 How Doctest Decides Whether a Documented Example Passed A transcript in a docstring is compared against captured output by a specific set of rules. Understanding those rules explains why examples drift and which ones cannot be verified at all. software engineering · foundational
Apr 13, 2026 Overcommitted Guest Memory: Ballooning, Page Sharing, and Whose Reclaim Runs First How a hypervisor hands out more memory than it owns, why the guest cannot see pages being taken away, and the two mechanisms that make the guest a participant rather than a victim. virtualization · intermediate
Apr 12, 2026 Block-Compressed Texture Bit Rates and What the Blocks Cost How fixed-size blocks turn a texture into a constant byte budget, why the smallest block is a fixed 16 bytes, and where the rate-distortion trade actually lands. computer graphics · intermediate
Apr 12, 2026 Convex Hulls by Monotone Chain How a lexicographic sort followed by two stack scans produces the convex hull in O(n log n), and why the collinearity rule decides which points survive. algorithms · foundational
Apr 11, 2026 Diversity-Aware Ranking and Subtopics How ambiguous queries are covered by selecting results that span subtopics, what maximal marginal relevance maximizes, and why diversity costs relevance. information retrieval · advanced
Apr 11, 2026 Review Metrics and the Confounders That Invert Them Why latency, comment density, and approval counts measure queueing and authorship as much as review quality, and which quantities remain interpretable under those confounders. software engineering · advanced
Apr 11, 2026 Self-Healing Reads: Reconstructing a Copy From Redundancy How a filesystem repairs a damaged block during a read, what the repair costs on mirrored and parity layouts, and why the repair itself can fail. filesystems · intermediate
Apr 11, 2026 Telling Saturation Apart From Contention A busy resource and a blocked one look identical in a latency graph. Queueing arithmetic, run-queue depth, off-CPU time, and steal time are what separate them. observability · advanced
Apr 10, 2026 Why HMAC Hashes Twice and What Length Extension Has to Do With It The nested construction that turns a plain hash into a keyed MAC, the Merkle-Damgard weakness it neutralises, and why the two fixed inner and outer pads are load-bearing. cryptography · foundational
Apr 9, 2026 Channel Programs: How a Mainframe Moved Data Without the CPU The command word format a channel executes, how chaining turns a list of commands into one operation, and why the channel is a separate processor rather than a DMA engine. computing history · intermediate
Apr 9, 2026 Incremental Rehashing: Spreading a Resize Across Operations How two tables and a migration cursor turn an O(n) resize pause into constant work per operation, and what lookups must do while both tables are live. data structures · intermediate
Apr 9, 2026 Miss Status Holding Registers and Memory-Level Parallelism How a cache tracks outstanding misses by line rather than by request, why secondary misses merge, and how the number of MSHRs caps the parallelism a core can expose. memory systems · advanced
Apr 9, 2026 Requests, Limits, and the Two Different Jobs They Do A request is a scheduling promise and a limit is an enforcement ceiling; conflating them produces nodes that look full but throttle, and pods that are evicted for reasons nobody expected. cloud infrastructure · intermediate
Apr 9, 2026 Scrub Passes: Finding Latent Damage Before It Is Needed What a scrub actually reads and in what order, why it must walk metadata rather than sweep the device, and how a pass is throttled so it does not starve foreground I/O. filesystems · intermediate
Apr 8, 2026 Burn-In, Lifetime Models, and the Bathtub Curve Why a fraction of dies fail early and separately from wear-out, how Arrhenius voltage and temperature acceleration are used to compress a lifetime into a test, and what burn-in costs. hardware engineering · advanced
Apr 8, 2026 Child Representation and the Branching Factor Problem in Tries A trie costs one child lookup per key byte, so the node layout decides memory and speed. Compares dense arrays, sorted and linked child lists, bitmaps with rank, and double-array layouts. data structures · foundational
Apr 7, 2026 AddressSanitizer and the Arithmetic of Shadow Memory How a one-eighth-scale shadow map turns every load and store into a validity query, what the poison values encode, and where the scheme cannot see. memory systems · intermediate
Apr 7, 2026 Late-Arriving Dimensions and Inferred Members What happens when a fact references an entity the dimension has never seen, how inferred rows let the fact load proceed, and why the placeholder key is a debt with an interest rate. data engineering · advanced
Apr 7, 2026 Why Monte Carlo Error Falls as the Square Root of the Sample Count The convergence rate follows from the variance of a sum, and the practical consequences are a fixed digit budget per factor of a hundred in work and an error bar that is itself estimated. scientific computing · intermediate
Apr 6, 2026 Code Cache Management and Invalidation How generated code and its metadata are stored, why stale code must be retired rather than deleted, and how a runtime finds every compiled method that depended on a class it can no longer trust. language runtimes · advanced
Apr 6, 2026 Disaggregated Prefill and Decode Pools Separating prompt processing from token generation into distinct pools, the cache handoff that joins them, and how the capacity ratio between pools is set. inference systems · advanced
Apr 6, 2026 ID Tokens: Validating the Claims That Establish Who the User Is The claim set OpenID Connect adds to a JWT, the ordered checks a client must perform, and why a valid signature is the least interesting part of validation. internet protocols · intermediate
Apr 6, 2026 Layout Invalidation and Dirty Bits: Why Some Changes Reflow Everything How a style change propagates into layout, where a reflow can be stopped at a layout root, and which changes defeat containment entirely. web platform · foundational
Apr 6, 2026 Static Rank Priors and Their Effect on Ranking How document-level signals that ignore the query accumulate into a prior, how that prior is combined with query-dependent scores, and why it can dominate a weak match. information retrieval · intermediate
Apr 6, 2026 Threads, Scheduler Activations and the Failed Promise of User-Level Scheduling How user-level threads multiplex onto kernel threads, what scheduler activations promised in exchange for replacing the kernel scheduler, and why the mechanism was displaced by kernel-managed blocking without ever being implemented widely. computing history · advanced
Apr 4, 2026 Compensating Transactions in Multi-Service Workflows How a saga replaces an impossible distributed commit with local steps and explicit undo actions, why the undo is not a rollback, and what becomes visible while the workflow is in flight. software architecture · advanced
Apr 4, 2026 Thermal Throttling: Duty Cycles, Ratio Capping, and Power Limits How a processor detects that it is too hot or drawing too much, which of several limiters acts first, and what each one does to frequency, voltage, and the workload's timing. hardware engineering · advanced
Apr 3, 2026 Implicit Live Values in status, alert, log, and timer Roles Live roles carry default politeness and atomicity from their definitions, so the role chooses behaviour the author never wrote. Where those defaults help, and where overriding them produces a contradictory tree. accessibility · advanced
Apr 3, 2026 Metropolis-Hastings: Detailed Balance and Proposal Design How a Markov chain is built so that an unnormalized density becomes its stationary distribution, what the acceptance ratio compensates for, and when a correctly implemented sampler still mixes badly. machine learning · intermediate
Apr 3, 2026 System-Scope Atomics and Memory Ordering Across the Bus Why an atomic operation on device memory is not automatically visible to the host, what the scope qualifier changes, and how release and acquire order a flag against its payload. gpu computing · intermediate
Apr 2, 2026 Amdahl and Gustafson Bounds in Capacity Models Why a serial fraction caps the throughput a fixed workload can reach, how scaled workload changes the bound, and what the usable-scalability limit means for sizing a fleet. performance engineering · intermediate
Apr 2, 2026 Flexbox and Weight Distribution Without a Constraint Solver How flex factors and layout weights divide leftover space, why the algorithm needs a freeze step, and what happens when the total demand exceeds the container. mobile computing · intermediate
Apr 2, 2026 Reading a Preprocessor Diagnostic Through Macro Expansion Preprocessor errors cite a line that may contain no error at all. Tracking the expansion stack, the difference between a file and a macro origin, and where note lines come from turns the output into a usable trace. compilers · intermediate
Apr 2, 2026 Remote Execution and Content-Addressed Input Trees How an action is expressed as a value with a digest, how its input tree is uploaded and reconstructed on a worker, and how partial uploads, timeouts and retries are handled. developer tools · advanced
Apr 2, 2026 Rendezvous and Buffering in CSP-Style Channels How an unbuffered channel makes send and receive a single synchronisation event, what a buffer actually buys, and why a blocked channel turns into a deadlock instead of an error. programming languages · foundational
Apr 2, 2026 Tacit Design Knowledge and the Cost of Unwritten Decisions Code records what the system does and discards why, so the constraints behind each structure survive only in memory. What decays, what it costs, and which artifacts carry rationale. software architecture · advanced
Apr 2, 2026 The CIE 1931 Colour Matching Functions and What Chromaticity Discards How two colour matches determine three unknowns, why the 1931 observer needs negative values, and what information survives when XYZ is projected to xy. computer graphics · foundational

2026