Complete archive
Archive
3,240 articles, newest first · page 47 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
Oct 17, 2023 Computing Relative Luminance and Contrast Ratios from sRGB Values The linearisation step, the weighted sum behind relative luminance, and why the WCAG ratio adds a constant to both values before dividing them. accessibility · foundational - Oct 17, 2023 Constant Folding and Algebraic Rewrites on a Fixed Graph How a compiler evaluates constant subgraphs at build time, which algebraic identities survive floating-point arithmetic, and why rewrite order determines the result. inference systems · foundational
- Oct 16, 2023 Garbage Collection Under Space Pressure: When Cleaning Cannot Outrun Writes What happens when a log-structured volume fills to the point that the collector must run in the foreground, why the reclaim rate collapses near full, and the reserved-capacity arithmetic that prevents it. filesystems · advanced
- Oct 16, 2023 Request Coalescing and Probabilistic Early Expiration What happens when a hot key expires under load, how single-flight and leases reduce the burst to one load, and how early recomputation spreads the remaining work before the deadline arrives. backend systems · intermediate
- Oct 15, 2023 Batch Normalization and the Train-Eval Gap Why batch statistics at training time and running averages at inference time produce different outputs, and how that mismatch is exploited to estimate what a network actually learned. deep learning · foundational
- Oct 14, 2023 Snapshot Reference Counts and Why Deleting One Costs So Much How a snapshot is a copied root plus shared blocks, how per-extent reference counts make sharing safe, and why removal requires walking what it owned. filesystems · advanced
- Oct 13, 2023 Applicative and Generative Functors in Modular Type Checking Why two applications of the same functor may or may not produce compatible abstract types, how path-based strengthening decides it, and what sealing hides. programming languages · advanced
- Oct 13, 2023 Instruction Encoding on the Harvard Mark I Paper Tape How a 24-channel tape carries three eight-bit fields per instruction, what the index numbers address, and why a one-way sequence unit made program loops physical. computing history · intermediate
- Oct 12, 2023 Counting Function Calls Without Losing the Call Count to Inlining Entry-point instrumentation gives exact invocation counts and a cost model that sampling cannot; inlining, tail calls, and recursion each break the correspondence between hooks and source functions. performance engineering · intermediate
- Oct 12, 2023 Smoothed Analysis: Why the Simplex Method Beats Its Worst Case Worst-case bounds are exponential and average-case bounds assume a distribution nobody can justify. Perturbing the input by a Gaussian turns the question into a function of how much noise the input carries. algorithms · advanced
- Oct 12, 2023 Symbol Versioning and the Two Hash Tables Behind Every Lookup How a symbol name acquires a version suffix at runtime, what SysV and GNU hash tables each optimise for, and why a lookup that succeeds on one distribution can fail on another. systems programming · advanced
- Oct 12, 2023 What a Slice Descriptor Holds and Why It Is Three Words The pointer, length and capacity triple that makes a slice cheap to pass, how subslicing shares storage, and where the shared-buffer aliasing shows up. data structures · foundational
- Oct 11, 2023 Pull-Through Caches and Where the Trust Anchor Sits How a caching proxy changes the set of parties that can influence an image, why the cache must not also serve the keys used to verify it, and what staleness does to revocation. virtualization · advanced
- Oct 11, 2023 Randomized Incremental Construction and Backward Analysis How building a structure by inserting elements in random order turns a quadratic insertion cost into an expected linear one, and why the analysis runs the process backwards. algorithms · intermediate
- Oct 10, 2023 Constant-Time Arithmetic for Lattice Schemes Which operations in ML-KEM and ML-DSA leak through timing or cache behaviour, and how the standard techniques for secret-dependent branches and indexing apply to polynomial arithmetic. cryptography · advanced
- Oct 9, 2023 Delta Updates: Applying a Patch to an Image Already in Flash How a difference between two firmware builds is expressed as copy and insert operations, why block alignment decides the patch size, and where the reconstructed image goes. embedded systems · advanced
- Oct 7, 2023 ISA Families, Extension Levels and Binary Compatibility How architectures partition optional instructions into named levels, how a binary discovers what the current processor implements, and where forward compatibility quietly breaks. computer architecture · advanced
- Oct 7, 2023 Thermal Throttling and Why Sustained Frame Rate Diverges from Peak Frame Rate How the system converts power into heat, why a workload that is comfortable for seconds becomes janky for minutes, and how frame pacing decisions change the shape of the decline. mobile computing · advanced
- Oct 6, 2023 Encoding Guest Memory for the Migration Stream Zero pages, compression, and delta encoding decide how many bytes a migration actually sends. The choice trades host CPU and per-page framing overhead against bandwidth, and each option fails on a different workload. virtualization · intermediate
- Oct 6, 2023 Multi-Step Form State and What Survives a Step What a wizard loses between steps when each step is a fresh document, how a step boundary changes validation, and how to make back navigation non-destructive. accessibility · advanced
- Oct 6, 2023 Point Lookups, Tombstones, and Read Amplification in LSM Trees How a single-key lookup consults memtables, filters, and runs, why deletion must write a tombstone, and when the tombstone can finally be dropped. databases · intermediate
- Oct 6, 2023 Register Renaming and the Elimination of False Dependencies Why architectural register names serialize otherwise independent code, how a rename table maps names to physical registers, and what the mapping costs in area and latency. computer architecture · foundational
- Oct 5, 2023 802.11 Address Fields and the Four-Address Distribution System Why a Wi-Fi frame carries up to four MAC addresses, how the ToDS and FromDS bits select which is which, and what breaks when a bridge is inserted. networking · foundational
- Oct 4, 2023 Object Shapes, Inline Caches, and the Cost of a Polymorphic Site Why property access is fast when objects share a hidden class, how shapes transition, and what turns an inline cache from a lookup into a hash probe. web platform · intermediate
- Oct 4, 2023 Relations as Sets: Why the Relational Model Excludes Duplicate Rows How Codd defined a relation as a subset of a Cartesian product, what follows from value-based identity, and why SQL tables are multisets instead. databases · foundational
- Oct 2, 2023 How a Padding Check Becomes a Decryption Oracle Byte-at-a-time plaintext recovery against CBC from a single bit of observable padding validity, the arithmetic that makes it work, and why constant-time unpadding does not close the hole. cryptography · foundational
- Oct 2, 2023 Write Ordering and the Crash Window Between Metadata Updates Why a filesystem that issues correct writes in the right order can still be corrupt after a power loss, and how ordering constraints, atomicity, and recovery strategies separate. filesystems · foundational
-
September
Sep 30, 2023 Stranded Credit: Why Amortized Bounds Fail Under Persistence and Laziness Credit earned by earlier operations is only spendable if the state carrying it survives, so persistent versions and deferred computation can strand potential, and the potential argument has to be redesigned rather than reapplied. algorithms · advanced - Sep 28, 2023 Little's Law and the Size of a Request Pool Why the number of requests in flight equals arrival rate times service time, how that identity fixes a pool size, and why adding workers past that point buys no throughput. backend systems · foundational
- Sep 27, 2023 Cancellation, Progress, and Partial Results in the Language Server Protocol How a client abandons work that is no longer needed, how a server reports bounded progress on work that is, and why streaming results are framed so that the final reply carries nothing. developer tools · advanced
- Sep 27, 2023 Synchronous and Asynchronous Replication: Where the Commit Point Sits How the moment a write is acknowledged determines durability, latency, and the amount of data a failover can lose, and why semi-synchronous replication is the usual compromise. distributed systems · foundational
- Sep 27, 2023 Version Ranges as Sets of Versions How a constraint such as ^1.2.3 becomes an explicit set of admissible versions, how two constraints intersect, and why prerelease rules stop that set from being an interval. developer tools · foundational
- Sep 26, 2023 Administrative Models, Safety Analysis, and Sandhu's Schematic Protection Model How to reason about whether a protection system can leak a right, why safety is undecidable in general, and which restricted models admit tractable analysis. security · advanced
- Sep 26, 2023 How free Recovers a Size From a Bare Pointer The address arithmetic that turns a returned pointer back into its block header, the alignment assumptions that make it work, and the cases where the original base cannot be reconstructed. memory systems · intermediate
- Sep 26, 2023 Padding, Packing, and Masking for Variable-Length Sequence Batches What it costs to batch sequences of different lengths behind a rectangular tensor, how masks keep padding out of losses and attention, and how packed sequences avoid the wasted arithmetic. deep learning · intermediate
- Sep 26, 2023 Wave Quantization and the Tail Effect Why a grid that fills the device one-and-a-bit times wastes the surplus, how to compute the number of waves, and which grid shapes avoid a long final wave. gpu computing · intermediate
- Sep 25, 2023 FLP Impossibility and Why Real Protocols Assume Partial Synchrony The bivalent-configuration argument behind the FLP result, why the proof needs only one faulty process, and how partial synchrony and randomized termination step around it. distributed systems · foundational
- Sep 23, 2023 Frequency Moments and the Tug-of-War Sketch How a random sign vector turns the second frequency moment into a sum of squares, why the estimator is unbiased, and how the same construction generalises to higher moments. algorithms · foundational
- Sep 21, 2023 Client Authentication: Secrets, Assertions, and Certificates What each token endpoint authentication method actually proves, why a shared secret is the weakest of them, and how a signed assertion avoids transmitting one. internet protocols · advanced
- Sep 20, 2023 Process Groups, Sessions, and the Controlling Terminal How job control is built from two identifiers, why a background job stops when it reads, and how a session leader loses its terminal. operating systems · advanced
- Sep 19, 2023 Kernel Decompression and Physical Relocation Why a compressed kernel image relocates itself before decompressing, how the position-independent stub finds free memory, and what has to change in the page tables when the kernel moves. operating systems · intermediate
- Sep 19, 2023 Modeling Throughput Growth and Service Demand Drift Why per-request cost rises across releases and with load, how to separate traffic growth from efficiency change in a capacity series, and what a drift budget means for a sizing horizon. performance engineering · intermediate
- Sep 19, 2023 Multiplexers, Decoders, and Shannon Expansion as Logic Realization Why a 2-to-1 multiplexer can implement any function once its data inputs are tied to constants, and how decoder-and-OR structures realize sum-of-products forms. hardware engineering · intermediate
- Sep 18, 2023 Quantifier Scope and Undefined Terms in Requirement Statements Why "all users can see their orders" admits several incompatible readings, how scope ambiguity survives review, and what a rewrite into explicit quantifiers costs. software engineering · intermediate
- Sep 17, 2023 From Regular Expression to DFA Table: Inside a Lexer Generator Thompson construction, subset construction, and table compression, and why a generated lexer scans in time linear in the input no matter how many patterns were declared. compilers · foundational
- Sep 15, 2023 Framebuffer Arithmetic: What a Bitmap Mode Costs in Memory Character cells versus linear bitmaps, the byte counts each requires at common resolutions, and why early machines split the difference with attribute bytes and planar layouts. computing history · intermediate
- Sep 15, 2023 Nested Cross-Validation and the Optimism of Tuned Scores Why a cross-validated score from a tuned procedure is biased, how the inner and outer loops separate selection from estimation, and what the procedure costs. machine learning · advanced
- Sep 15, 2023 The Structure of False Positives: Over-Approximation and Suppression Debt Why a sound static analysis must report impossible paths, how technical and effective false positives differ, and what suppression comments cost over the life of a codebase. developer tools · advanced
- Sep 14, 2023 Bitemporal Dimension History: Effective Time and Assertion Time Why a single validity interval cannot express both when an attribute was true and when the warehouse believed it, and what two intervals cost in keys, joins and corrections. data engineering · advanced
- Sep 14, 2023 How a System Call Transfers Control to the Kernel What the x86-64 syscall instruction actually changes, why the kernel cannot switch stacks for free, and how the two return paths back to user mode differ. operating systems · foundational
- Sep 14, 2023 Work Stealing: Per-Processor Deques and Why Thieves Take the Oldest Task How a work-stealing scheduler keeps locality by pushing and popping on one end of a deque while idle processors take from the other, and where the contention lands. algorithms · foundational
- Sep 13, 2023 Header Folding and the Line Limits That Shape MIME Encoding How the 998-octet line limit, dot-stuffing, and the 75-character encoded-word bound force the transfer encodings that mail still uses. internet protocols · foundational
- Sep 12, 2023 Calling Conventions as Precolored Constraints on the Graph How the ABI fixes which registers hold arguments, returns, and preserved values, and how those obligations enter the interference graph as edges to nodes that already have a color. compilers · intermediate
- Sep 9, 2023 Boot Metadata Persistence and the Commit Record The record format that survives an interrupted write, how many copies are enough, and why the sequence number rather than the timestamp decides which copy wins. embedded systems · intermediate
- Sep 9, 2023 Inferring Query Intent from Click Entropy and Reformulation How the distribution of clicks across results, and the way users rewrite a failing query, distinguish navigational from exploratory intent without any labelled training data. information retrieval · advanced
- Sep 8, 2023 Detecting Periodic Beacons in Flow Telemetry Why fixed-interval check-ins are visible in timing even when the payload is encrypted, how jitter and distribution shape change the test, and where the statistical approach fails on sparse data. security · advanced
- Sep 7, 2023 ptrace and the Stop-Notify Model Behind a Debugger Attaching is a signal, every stop must be answered, and the same SIGTRAP means different things. How a tracer distinguishes the events it receives. developer tools · intermediate
- Sep 7, 2023 Reverse-Time SDEs and the Probability-Flow ODE How the time-reversed diffusion process is defined by the score, why a deterministic ODE shares its marginals, and what the two formulations trade against each other. deep learning · intermediate
- Sep 6, 2023 Counting Distinct Values Without Storing Every Record How log-frequency analysis uses register-based sketches, what the relative error formula implies for sizing, and when an exact set is the cheaper answer. observability · advanced
- Sep 6, 2023 Sub-topic Judgments and Diversity Metrics How aspect-level qrels make novelty and coverage measurable, and what the two knobs in alpha-nDCG and intent-aware measures actually control. information retrieval · advanced