Complete archive
Archive
3,240 articles, newest first · page 38 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
Oct 4, 2024 Suffix Arrays, Prefix Doubling, and the Kasai LCP Scan How sorting all suffixes of a text supports substring queries with one integer array, why doubling sorts in O(n log n), and how the LCP array is computed in a single pass. algorithms · intermediate - Oct 3, 2024 Sliding Windows and Exponential Histograms for Recent Data Why a window over the last W items needs a different summary from a whole-stream sketch, how bucket merging bounds error to a constant factor, and what late-arriving data does to the guarantee. algorithms · intermediate
- Oct 2, 2024 Measuring Contrast From Rendered Pixels Why the contrast ratio is simple arithmetic but the colour inputs are not, how effective backgrounds are composited, and what sampling rendered pixels can and cannot settle. accessibility · intermediate
- Oct 2, 2024 Robin Hood Hashing and the Distribution of Probe Lengths How equalizing displacement from the home slot bounds the worst probe sequence, why the variance collapses, and what early termination buys on lookups. data structures · intermediate
- Oct 1, 2024 Git's Object Model: Content-Addressed Blobs, Trees, and Commits How Git frames and hashes objects, why a rename leaves no trace in storage, and what the four object types cost when content changes. developer tools · foundational
- Oct 1, 2024 Residency Hints and the Arithmetic of Managed-Memory Thrashing How preferred-location and accessed-by advice changes where a managed page lives, why advice is not a guarantee, and how to tell a capacity problem from a policy problem. gpu computing · intermediate
-
September
Sep 29, 2024 Solving Quadratic Ray Intersections Without Losing the Far Root Why the textbook quadratic formula fails for distant spheres, how the stable form differs by an addition of magnitudes, and what the determinant sign means geometrically. computer graphics · foundational - Sep 28, 2024 Catalogs, Table Identity, and What a Table Name Resolves To Why a table needs a registry separate from its files, how the catalog performs the pointer swap that makes a commit visible, and what breaks when the name and the location drift apart. data engineering · advanced
- Sep 28, 2024 Detecting Distribution Drift in Production Data How to measure a shift in a feature or prediction distribution, which statistics survive high dimensionality, and how alert thresholds avoid false alarms. machine learning · intermediate
- Sep 27, 2024 Atomics, Fences, and Memory Scopes in Device Code What a device-scope atomic orders, why relaxed operations reorder across a barrier, and how scope qualifiers change what a fence must flush. gpu computing · advanced
- Sep 27, 2024 Fieldset and Legend Group Semantics How fieldset and legend give a set of controls one shared name, how the browser exposes that grouping, and where the element falls short of what a group needs. accessibility · foundational
- Sep 27, 2024 How argv and envp Reach a New Program Image The argument vector as a byte layout the kernel copies onto the new stack, the size limits that constrain it, and why the environment is a separate array rather than more arguments. computing history · intermediate
- Sep 27, 2024 Multi-Queue Block Dispatch and Why One Lock Was Not Enough The single-queue block layer, the contention that replaced it, and how software queues, hardware queues, and tags carry a request from submit to completion. filesystems · intermediate
- Sep 27, 2024 One Description, Two Design Languages Material and Apple design languages differ in elevation, corner treatment, motion, and safe-area insets. A shared description has to keep semantics while letting the visual layer diverge per platform. mobile computing · advanced
- Sep 26, 2024 Dependency Resolution and Partial Upgrades Why installing one package can remove another, how versioned dependencies and library sonames constrain an upgrade, and what differs between upgrade commands. devops · foundational
- Sep 26, 2024 Version Fields, Feature Detection, and Downgrade Semantics Why a version number in the header is a weak signal, how peers actually establish a common dialect, and what a negotiated downgrade exposes to an attacker. internet protocols · foundational
- Sep 25, 2024 Anti-Corruption Layers and the Cost of Model Translation What a translation boundary between a replacement system and a legacy one must handle beyond field renaming, where information is lost in the mapping, and when the layer is not worth its cost. software architecture · intermediate
- Sep 25, 2024 Hardware Dirty-Bit Tracking for Guest Memory How second-level page tables record which guest pages changed, why the first pass needs write protection, and what the bitmap costs in exits when the CPU cannot set the bit itself. virtualization · foundational
- Sep 25, 2024 Product Quantization and the Asymmetric Distance Computation How splitting a vector into subspaces and coding each against a small codebook replaces a distance computation with table lookups, and where the reconstruction error shows up in the ranking. information retrieval · intermediate
- Sep 25, 2024 Tick Accounting and How a Slice Is Measured Timer interrupts, sampled versus switch-time accounting, and why the kernel charges time at coarse granularity to the thread that happened to be running. operating systems · foundational
- Sep 24, 2024 How a Partitioner Maps Keys to Reduce Tasks Why the reduce task count is fixed before any record is read, what hash-modulo partitioning guarantees, and why changing the count remaps almost every key. data engineering · foundational
- Sep 24, 2024 Launch Geometry and the Arithmetic of Thread Indexing How a grid extent becomes a linear identifier, what the block and grid dimension limits are, and why a non-multiple block size leaves a guard predicate in every kernel. gpu computing · foundational
- Sep 22, 2024 Folded Stacks, Call Trees, and What Aggregation Destroys Two representations of the same samples, what each preserves, and why the choice determines whether a profile can be merged across hosts or read as a flame graph. observability · intermediate
- Sep 22, 2024 Slow Start: Exponential Probing and the Initial Window Problem A new connection has no estimate of path capacity, so it doubles its window each round trip until a threshold or a loss. The cost is a burst that a small buffer cannot absorb. networking · foundational
- Sep 22, 2024 Work-Stealing Deques and Why the Thief Takes the Oldest Task Per-worker deques with LIFO local execution and FIFO stealing keep hot data on one core, and the memory-ordering requirements that make the concurrent deque correct are narrower than they look. language runtimes · intermediate
- Sep 20, 2024 Dual Writes, Replication Lag, and Read-Your-Writes Through a Cache Why a cache turns one write into two writes with no shared transaction, which orderings lose updates, and the session-level guarantees that make a client see its own changes without giving up the cache. backend systems · advanced
- Sep 20, 2024 Versioning the Platform Interface Under Existing Tenants How a self-service interface changes without breaking its consumers: explicit versions, compatibility guarantees, and why the parts nobody uses break first. devops · advanced
- Sep 19, 2024 Reading a QUIC Packet: Header Protection, Varints, and Frame Types The byte layout of long and short headers, how header protection hides the packet number, and how the frame type space is partitioned between transport and extension use. internet protocols · foundational
- Sep 18, 2024 Modal Inertness: What a Dialog Must Remove From the Rest of the Page A dialog is modal only if the rest of the document is unreachable by keyboard, pointer, and the accessibility tree. The containment mechanics, and the focus restoration that fails when the trigger is gone. accessibility · intermediate
- Sep 18, 2024 Voltage and Frequency Scaling with a Performance Constraint Why lowering frequency alone rarely saves what it appears to, how voltage follows frequency, and where the quadratic voltage term stops paying for itself. embedded systems · intermediate
- Sep 17, 2024 Decision Procedures for Word Equations and Unification How Makanin’s algorithm decides whether two words with variables can be made equal, why the bound on solution length is enormous, and what unification gains from restricting to free function symbols. computation theory · intermediate
- Sep 17, 2024 From Hardware Line to Virtual IRQ Number How the kernel maps a controller-specific interrupt source onto a stable software number, what the irq_desc and irq_chip split buys, and why shared lines need an action list. operating systems · foundational
- Sep 16, 2024 Descriptor Rings and the Producer-Consumer Contract How a ring buffer carries work from a driver to a device without locks, what the ownership bit buys, and why the wrap-around index is the hard part. computer architecture · foundational
- Sep 16, 2024 Task Sources and the Ordering Guarantees of the Event Loop Why the browser runs callbacks from several independent queues, what ordering the specification actually promises, and where cross-queue assumptions break. web platform · foundational
- Sep 16, 2024 Where a Schema Contract Is Enforced, and What It Cannot Catch Write-time validation against a declared schema, read-time inference, and the class of errors that survives both: structural checks constrain types, not meanings. data engineering · foundational
- Sep 16, 2024 Write Amplification and Garbage Collection in Flash Translation Layers Why a flash device rewrites more bytes than it is given, how the mapping granularity decides the multiplier, and which access patterns turn a modest write rate into sustained internal copying. performance engineering · advanced
- Sep 15, 2024 Learning Optimizers: Learned Cardinality Models and Plan Regression What a learned selectivity model replaces in the catalog, why a plan that is cheaper on average can be a regression for one query, and how plan management contains the damage. databases · advanced
- Sep 15, 2024 Perceptual Contrast Models and Why Weight and Polarity Change the Verdict WCAG 2 contrast is a ratio between two colors; newer models predict lightness difference from a background and scale it by text size and weight, which makes polarity and stroke thickness part of the result. accessibility · intermediate
- Sep 14, 2024 Aliasing Rules for References and the Role of UnsafeCell A shared reference is a promise of immutability that the optimiser acts on, and UnsafeCell is the single opt-out that makes interior mutability representable without lying to the compiler. systems programming · intermediate
- Sep 14, 2024 Dependent Types: Pi and Sigma as Generalised Function and Pair How quantifying over a type lets the result type mention the argument, why checking such types needs conversion, and where the dependent eliminators differ from the simply typed ones. computation theory · intermediate
- Sep 13, 2024 Cache Flushes and FUA: The Two Ordering Primitives Below the Filesystem How a flush drains a volatile device cache, how forced unit access bypasses it for a single write, and why both are required to build a write barrier out of a queue that reorders. memory systems · foundational
- Sep 13, 2024 The Training Memory Budget: Parameters, Optimizer State, Gradients, Activations How device memory is consumed during training, why a model that fits for inference can be four times too large to train, and which term to cut first. deep learning · foundational
- Sep 12, 2024 Addressing Modes and How an Effective Address Is Computed How base, index, scale and displacement fields combine into an address, why some ISAs fold memory operands into arithmetic, and what each mode costs in the datapath. computer architecture · foundational
- Sep 12, 2024 Multiplexing Green Threads onto Kernel Threads How an M:N scheduler maps lightweight tasks onto a fixed pool of OS threads, what work stealing does to locality, and where a blocking call forces the scheduler to compensate. programming languages · intermediate
- Sep 12, 2024 Platform Tags and Binary Compatibility in Distributed Artifacts How wheels encode interpreter, ABI, and platform into a compatibility tag, how that tag is matched against an ordered list of supported tags, and where the encoding leaks. language runtimes · intermediate
- Sep 11, 2024 Deriving Least Privilege from Recorded Access Instead of from Intent Why an audit trail is an incomplete oracle for permissions, how to turn call history into a candidate policy, and what such a policy systematically omits. cloud infrastructure · advanced
- Sep 11, 2024 Order-Statistic Augmentation and Rank Queries How a subtree count maintained through every rotation answers rank and select in logarithmic time, and why the aggregate must be recomputable from children alone. data structures · advanced
- Sep 11, 2024 Packet-Level Fault Injection: Latency, Loss, and Partitioning How delay, loss, and reordering are emulated in the kernel queueing discipline, why DROP and REJECT produce different failures in callers, and how TCP converts a small packet loss into a long stall. devops · intermediate
- Sep 11, 2024 The baggage Header: Limits, Trust Boundaries, and Misuse How W3C Baggage carries arbitrary key-value pairs alongside a trace, the member and byte limits that force dropping, and why every entry crossing a trust boundary is untrusted input. observability · intermediate
- Sep 9, 2024 Checksum Granularity and the Read-Modify-Write Penalty How the size of the region one checksum covers sets both the precision of damage reporting and the cost of small overwrites, and why 4 KiB sectors made granularity a hard constraint. filesystems · intermediate
- Sep 9, 2024 The Memory Gap and the Arithmetic of Average Access Time How the latency of each level combines into one average, why a small miss rate can dominate the total time, and where the model stops describing real hardware. memory systems · foundational
- Sep 8, 2024 Reading Request Bodies Without Holding Them in Memory How to consume a request body as a stream, what backpressure means at the socket, and where size limits, decompression, and multipart parsing go wrong. backend systems · intermediate
- Sep 7, 2024 Sizing a Replica Pool from Arrival Rate and Latency Target Queueing arithmetic that converts requests per second and a latency objective into a number of replicas, including the headroom that utilization hides. inference systems · intermediate
- Sep 6, 2024 Classifier-Free Guidance as an Interpolation of Two Predictions How a single conditional model can be pushed toward its conditional distribution by extrapolating away from its unconditional prediction, and what that costs. deep learning · intermediate
- Sep 6, 2024 Discard and TRIM: Telling the Device Which Blocks Are Free How discard requests travel from the filesystem to the device, why they are advisory, what a secure erase adds, and the cost of queuing them badly. filesystems · intermediate
- Sep 6, 2024 KV Cache Arithmetic: Bytes per Token, Layers, and the Batch Size Ceiling How the decode-time key and value cache is sized, why it scales with every layer rather than only the last, and how its growth sets the maximum batch on a fixed device. deep learning · intermediate
- Sep 6, 2024 Node Splits, Merges, and What the Fill Factor Buys How a B-tree page divides when it overflows, why merges are rarely performed, and what setting a fill factor at build time actually changes. databases · intermediate
- Sep 6, 2024 Spherical Harmonics for Irradiance Probes How low-order spherical harmonic coefficients compress a lighting environment, what convolution by the clamped cosine does to those coefficients, and why ringing appears at sharp boundaries. computer graphics · intermediate
- Sep 6, 2024 ZeRO Stages: Sharding Optimizer State, Gradients, and Parameters How the three partitioning stages divide training state across data-parallel ranks, what communication each one adds, and why stage 3 changes the residency model rather than just the arithmetic. deep learning · intermediate
- Sep 5, 2024 The WebAuthn Ceremony and Origin Binding What the browser signs, what the relying party verifies, and why the challenge and the origin check are what make the credential resistant to relay and phishing. security · intermediate