Complete archive

Archive

3,240 articles, newest first · page 44 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
Feb 29, 2024 Cardinality Explosion and Where It Comes From How label combinations multiply into series count, why an unbounded label value destroys an index, and which containment measures actually bound the growth. observability · intermediate
Feb 29, 2024 Hinge Loss, Maximum Margin, and the Points That Decide the Boundary Why the hinge loss produces a sparse solution supported only on near-boundary points, what the margin constraint actually constrains, and how C trades margin width against violations. machine learning · advanced
Feb 29, 2024 Split APKs and App Bundles: How One Build Becomes Many Downloads Why an Android App Bundle is not installable, how configuration splits are selected at install time, and what the bundletool size model assumes about the target device. mobile computing · foundational
Feb 27, 2024 Compare-and-Swap Retry Loops and the ABA Problem on a Versioned Register Why an optimistic update loop can silently apply a stale decision, how version numbers close the window, and what the loop costs when contention is high. distributed systems · intermediate
Feb 27, 2024 Triangles and Connectivity in Edge-Stream Graphs Why graph streams get n polylog n space rather than sublinear space, how wedge sampling estimates triangle counts, and how l0 samplers build spanning forests without storing edges. algorithms · advanced
Feb 26, 2024 Incomplete LU Preconditioning and Dropped Fill How a factorization restricted to the original sparsity pattern still clusters the spectrum, what the level-of-fill and threshold variants trade, and why the triangular solves limit parallelism. scientific computing · advanced
Feb 25, 2024 The Parabolic Step Limit in Explicit Diffusion Schemes Why an explicit update of the heat equation requires a step proportional to the square of the mesh spacing, what the amplification analysis shows, and how implicit treatment removes the restriction. scientific computing · intermediate
Feb 24, 2024 Data Race Detection with Vector Clocks and Happens-Before Order How ThreadSanitizer replaces happens-before with vector clocks per memory access, why the shadow word costs eight bytes per four, and where the ordering it assumes is wrong. systems programming · advanced
Feb 22, 2024 Prefix-Based Environments and Why Activation Is Only Path Surgery How a virtual environment isolates packages by rewriting interpreter paths and sys.path, why moving one breaks its scripts, and what containers change about the same problem. language runtimes · advanced
Feb 22, 2024 Provenance Statements and the Subject Digest How a build attestation names the artifact it describes, what the subject field binds, and why a valid attestation is not the same as an attestation about the image being deployed. virtualization · intermediate
Feb 21, 2024 Reflow Under Magnification: What a Layout Must Give Up at 320 CSS Pixels How text scaling and page zoom change the effective viewport, which layout techniques fail first under magnification, and the constraints that keep content usable when the viewport shrinks to a narrow column. accessibility · advanced
Feb 20, 2024 The KV Cache Memory Budget and What It Costs per Token Deriving bytes per cached token from attention shapes, then turning the freed capacity into a hard ceiling on concurrency and a floor on cost per token. inference systems · foundational
Feb 19, 2024 Coverage Criteria and What They Cannot See How statement, branch, and condition coverage are defined as adequacy criteria, why 100 percent coverage is reachable without testing the requirement, and how data-flow coverage closes part of the gap. software engineering · intermediate
Feb 19, 2024 What fork Copies, and Why Copy-on-Write Defers Almost All of It How the kernel duplicates an address space by sharing page frames read-only, what a write does to break the sharing, and why fork without exec is expensive. operating systems · foundational
Feb 17, 2024 CCM: Combining a MAC and a Counter Inside One Mode How CCM derives a CTR nonce, a CBC-MAC IV, and a length-encoded authentication header to authenticate before encrypting, and what the two passes and the 16-byte block size cost. cryptography · intermediate
Feb 17, 2024 Learning Rate Warmup and the Early Instability Window Why the first few hundred optimization steps are different from the rest, what large early updates do to adaptive optimizers, and how warmup bounds the damage. deep learning · foundational
Feb 17, 2024 Routing Traces Through a Collector Pipeline by Trace ID Why a stateful tracing stage cannot sit behind a round-robin load balancer, how consistent hashing keeps one trace on one worker, and what happens when the worker set changes. observability · advanced
Feb 17, 2024 Scope Chains and Name Resolution: Why Spelling Is Not Identity How a linter builds a scope tree, resolves each reference to a declaration, and avoids reports that confuse two unrelated variables with the same name. developer tools · foundational
Feb 16, 2024 Behavioral Detection versus Indicator Matching in Alert Pipelines How signature rules and behavioral rules differ in what they can express, why indicator matching decays, and what the cost of a rule is in false positives per unit of signal. security · intermediate
Feb 16, 2024 Doublewrite Buffers and the Torn Page Problem Why a page write is not atomic on real hardware, how a shadow copy restores the page after a partial write, and what the extra sequential write costs. databases · intermediate
Feb 16, 2024 Personalization Signals and Click-Based Reranking How a search engine folds a user history and click behaviour into a ranking that was previously query-only, and what the feature vectors and the training targets actually look like. information retrieval · advanced
Feb 14, 2024 Second-Order Boosting and the Regularized Split Gain A quadratic expansion of the loss gives closed-form leaf weights from gradient and curvature sums, turning each split into a comparison of two ratios and making regularization part of the objective. machine learning · intermediate
Feb 13, 2024 Negotiation Round Trips and What They Cost How capability discovery is paid for in latency, why the cheapest negotiation is one that reuses state, and where a saved round trip becomes a security problem. internet protocols · advanced
Feb 12, 2024 Content-Hash Caching and Early Cutoff How build tools key actions on cryptographic hashes of their inputs and command lines, and why comparing output digests lets a rebuild stop propagating before it reaches the link step. developer tools · foundational
Feb 10, 2024 Quasi-Newton Methods and the L-BFGS Two-Loop Recursion How secant equations build a Hessian approximation from successive gradient differences, why the limited-memory form stores only a few vector pairs, and how line searches keep the approximation positive definite. machine learning · intermediate
Feb 8, 2024 Mach-O Load Commands and the Segments a dyld Image Is Built From How the Mach-O header addresses its command list, why __PAGEZERO occupies the low address space, and how chained fixups replaced the older rebase and bind opcode streams. systems programming · intermediate
Feb 8, 2024 Session Fixation and Why Identifiers Must Rotate How an attacker who chooses a session identifier inherits the victim's authenticated session, and which state transitions require a fresh identifier to break the link. security · intermediate
Feb 8, 2024 Used Values and the Containing Block How a declared width becomes a pixel length: which box the percentages resolve against, what box-sizing changes, and how auto margins and min-max constraints are resolved. web platform · foundational
Feb 7, 2024 Stable Error Codes as Documentation Identifiers Human-readable messages change with wording and locale. A code that never changes, is never reused, and is documented once is what lets callers and support engineers agree on which failure occurred. software engineering · intermediate
Feb 6, 2024 Hierarchical Fair Share and Lag Accounting How group scheduling keeps one container from multiplying its share by spawning threads, what lag measures, and why the bound is per-level rather than global. operating systems · advanced
Feb 6, 2024 Invariants and Illegal States: Making Invalid Combinations Unrepresentable How sum types, smart constructors, and parse-at-the-boundary design remove whole classes of runtime checks, and where the technique stops paying for itself. software architecture · foundational
Feb 5, 2024 Reachability from Roots and the Transitive Closure How a tracing collector enumerates its root set, walks the object graph to a fixed point, and why unreachability rather than uselessness is the property it can actually compute. language runtimes · foundational
Feb 5, 2024 Strong and Weak Scaling: What Amdahl and Gustafson Actually Bound The two scaling questions, the arithmetic behind their ceilings, and how to read a measured curve without attributing every bend to the algorithm. scientific computing · intermediate
Feb 4, 2024 Posting List Encoding and the Cost of a Term Lookup How inverted indexes compress sorted document lists with delta and variable-byte codes, why skipping is needed for intersections, and where compression stops paying. algorithms · advanced
Feb 3, 2024 Lockfiles as Reproducibility Contracts and Why They Drift What a lockfile must record to make an install repeatable, which inputs it cannot capture, and how lockfiles fall out of sync with manifests without either side being wrong. language runtimes · foundational
Feb 2, 2024 Automatic NUMA Balancing and Its Failure Modes How the kernel samples faults to discover which node a task is really using, moves pages toward the task, and why the mechanism sometimes makes a workload slower than leaving it alone. memory systems · advanced
Feb 2, 2024 Presumed Abort and Presumed Commit: Two Defaults for Missing Decisions How a participant resolves a transaction when no decision record exists anywhere, what each presumption costs in log writes and retained state, and why presumed abort dominates in practice. distributed systems · foundational
Feb 2, 2024 The Depth Hierarchy: NC, AC, and the Cost of Wide Gates How NCi and ACi interleave, why the hierarchy collapses if NC1 equals NC, and what the known separations at the bottom actually prove. computation theory · intermediate
Feb 1, 2024 Constant-Time Comparison in Credential Checks Why byte-wise equality on secrets leaks prefix information through timing, how the standard constant-time primitives are built, and which comparisons in a login path actually need them. security · foundational
Feb 1, 2024 Idempotency Keys and Command Resources That Cannot Be Described Declaratively Why some operations cannot be expressed as desired state, how guard and sentinel patterns approximate idempotence, and why the approximation leaks under concurrency. devops · foundational
Feb 1, 2024 Trigger Rules and Failure Propagation Across a Dependency Graph Why all-success is only one of several completion conditions, how per-edge skip states propagate downstream, and what an any-failed branch costs. data engineering · foundational
Feb 1, 2024 Why Perplexity Is Not Comparable Across Tokenizers Perplexity measures average surprise per token, so the vocabulary decides the unit. Converting to bits per byte removes the unit but not every confound. inference systems · foundational
January
Jan 30, 2024 Allocator Mismatch and Cross-Runtime Deallocation Why freeing memory across a language boundary corrupts the heap, how separate C runtimes end up with separate heaps, and which API shapes make the allocator identity explicit. language runtimes · intermediate
Jan 30, 2024 Delay Slots and the Burden They Move to the Compiler Why some architectures require the instruction after a branch to execute unconditionally, which instructions are legal in that slot, and what the scheduler must prove before filling it. computer architecture · intermediate
Jan 30, 2024 Required Owned Elements and Structural Constraints Which roles require children, which require a parent, how engines repair an orphaned widget, and why the repair changes reading order. accessibility · advanced
Jan 30, 2024 Traffic Analysis Against TLS: Record Lengths, Timing, and Padding What ciphertext lengths reveal about plaintext, how padding is expressed in the record layer, and why uniform padding is not the same as hiding a request. internet protocols · advanced
Jan 28, 2024 Church Encodings and the Cost of Representing Data as Functions How numerals, booleans, and pairs are built from nothing but abstractions, why predecessor is the hard case, and what unary representation costs in reduction steps. computation theory · intermediate
Jan 28, 2024 Reference Implementations and the Conformance Laboratory How a second independent implementation turns a specification into a testable claim, and what conformance suites certify versus what they leave to precedent. computing history · intermediate
Jan 27, 2024 Stack Bytecode: Fixed Stack Effects and the Dispatch Loop How a stack machine encodes operands implicitly in the stack pointer, why verifiers care about static stack depth, and what the dispatch loop costs per instruction. programming languages · foundational
Jan 26, 2024 Detecting Benchmark Contamination from the Model Side A score on a public test set measures memorization as well as skill. N-gram overlap against training data, perturbation tests, and the limits of each detector. inference systems · advanced
Jan 26, 2024 Filesystem Timestamps and Why Timestomping Leaves a Seam Which timestamps an application can set, which only the kernel writes, and how the divergence between them exposes an attempt to backdate a file. security · advanced
Jan 26, 2024 Pipe Buffers, PIPE_BUF, and the Absence of Message Boundaries Why a pipe is an uninterpreted byte stream with a fixed kernel buffer, what the atomicity guarantee for small writes actually covers, and how writers detect the reader is gone. computing history · intermediate
Jan 25, 2024 Sources of Nondeterminism in Compiled Artifacts and How They Are Removed Two builds of the same source can differ in embedded timestamps, temporary paths, hash-map iteration order, and archive member metadata. Each leak has a specific mechanism and a specific suppression. compilers · intermediate
Jan 24, 2024 Beam Search Decoding: Scoring, Length Normalization, and Pruning How a decoder searches over sequences instead of choosing per step, why accumulated log-probabilities need a length term, and how beam width trades compute for coverage. deep learning · advanced
Jan 24, 2024 Delta and Cumulative Temporality in Collection Pipelines How the two ways of reporting a sum interact with resets, why one is cheaper to transmit and the other cheaper to align, and how a pipeline converts between them without losing increments. observability · intermediate
Jan 24, 2024 What an ELF Core File Preserves of a Process How the kernel encodes a dead process as an ELF object: loadable segments for memory, note records for registers and mappings, and what the dump deliberately leaves out. systems programming · foundational
Jan 23, 2024 Attribute Closure and the Mechanical Derivation of Candidate Keys How Armstrong axioms generate the closure of a dependency set, why closure of an attribute set is computed by repeated scanning, and how to enumerate minimal keys without exponential search. databases · foundational
Jan 23, 2024 Method Semantics: Safe, Idempotent, and Cacheable Requests What the three method properties actually license a client, cache, or proxy to do, and where the definitions stop matching what real methods do. internet protocols · foundational
Jan 22, 2024 Sequential Consistency and the Cost of One Global Memory Order What Lamport's definition of sequential consistency requires of a machine, which reorderings it forbids, and why every commercial processor relaxes it. computer architecture · foundational
Jan 21, 2024 Exception Tables and Frame Unwinding in Bytecode How a thrown exception finds its handler using a table of protected ranges, and why the table is separate from the code rather than encoded as instructions. language runtimes · intermediate

2024

January