Complete archive

Archive

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

2022
Jul 27, 2022 Scheduling Without a Scheduler: Superloops and Their Latency Budget How a main loop plus interrupt handlers bounds worst-case response time, where jitter creeps in, and the point at which the structure stops meeting its deadlines. embedded systems · advanced
Jul 27, 2022 The Break-Even Hit Rate for Adding a Cache A cache costs a lookup on every access and pays back only on hits, which gives a hit-rate threshold below which the cache makes the system slower. performance engineering · intermediate
Jul 25, 2022 BM25 Term Saturation and Document Length Normalization How the BM25 scoring function bounds the reward for repeated query terms, what the k1 and b parameters actually control, and where the model breaks down. information retrieval · foundational
Jul 25, 2022 The Simplify and Select Loop of Chaitin-Style Coloring Why coloring a register interference graph is done by repeatedly removing low-degree nodes and pushing them back on a stack, what the degree test really guarantees, and when the greedy result is optimal. compilers · foundational
Jul 21, 2022 Clock Skew Injection and the Failures That Depend on Wall Time The difference between clock offset, skew, and drift, the two ways to inject a time fault without breaking the host, and which classes of software fail when wall time jumps. devops · intermediate
Jul 21, 2022 DBSCAN, Density Reachability, and the Parameter Cliff A cluster as a maximal set of density-connected points needs only a radius and a count, produces non-convex shapes and explicit noise, and is order sensitive only at the boundary of a cluster. machine learning · intermediate
Jul 19, 2022 Hash Joins and Hash Aggregation: Build, Probe, and Spill How a hash table is built from one join input, why the probe side must be streamed, and what happens when the build side exceeds the memory grant. databases · intermediate
Jul 17, 2022 The Analytic Signal and Instantaneous Frequency How a Hilbert transform turns a real signal into a complex one with one-sided spectrum, why the derived phase derivative is not always a frequency, and where it fails. scientific computing · advanced
Jul 14, 2022 Two-Bit Saturating Counters and the Bimodal Predictor Why a two-bit hysteresis counter beats a single bit for branch prediction, how the index is computed, and where the table fails: aliasing, short loops, and correlated branches. computer architecture · foundational
Jul 14, 2022 Unlink While Open and the Life of an Orphaned Inode Removing the last name does not free a file that is still open; how the link count and the description reference interact, and why deleted files keep consuming disk. filesystems · advanced
Jul 9, 2022 Automatic Semicolon Insertion and Restricted Productions How JavaScript decides where statements end without semicolons, why the rule lives in the parser rather than the lexer, and which line breaks silently change meaning. programming languages · foundational
Jul 4, 2022 Closure Conversion: Flat Closures, Displays, and Boxed Upvalues How a nested function that references an outer variable becomes a heap object with a specific layout, and what each representation of the captured environment costs per call. programming languages · intermediate
Jul 4, 2022 Sparse Conditional Constant Propagation Across the SSA Graph How SCCP combines constant propagation with reachability so that unreachable branches stop contributing values, and why the sparse formulation converges faster than a dense lattice iteration. compilers · intermediate
Jul 2, 2022 Aho–Corasick Failure Links and Multi-Pattern Scanning Why a trie of patterns needs a second set of edges, how the failure link of a node is derived from its parent, and what output propagation costs when patterns nest. algorithms · intermediate
Jul 1, 2022 Gang Scheduling: All-or-Nothing Allocation for Distributed Workloads Why a training job or MPI rank set cannot be placed one member at a time, how reservation schemes avoid deadlock, and what each scheme costs the rest of the cluster. cloud infrastructure · advanced
June
Jun 30, 2022 What a Software License Does to a Copyright Default Copyright reserves reproduction, modification and distribution from the moment code is fixed, so a license is a conditional permission that lifts specific rights; permissive and copyleft terms differ only in the conditions attached. computing history · foundational
Jun 27, 2022 Interpreter Dispatch Overhead and the Cost That Justifies Compilation Why a bytecode interpreter spends most of its cycles on dispatch rather than on the program, and how that per-instruction cost sets the break-even point for compiling code at run time. language runtimes · foundational
Jun 27, 2022 What a Page Must Carry to Be Actionable The fields a notification needs so a responder can decide whether to act, where to look first, and who else is affected, within the length limits of a phone screen. devops · intermediate
Jun 27, 2022 Why Token Billing Diverges from GPU-Seconds The gap between what a request costs in hardware time and what it costs at a per-token price, and the workload shapes that make the two accounting systems disagree. inference systems · advanced
Jun 26, 2022 Committing a Dataset to an Object Store Without a Rename Table formats publish by writing a pointer, not by moving a directory. How snapshots, manifest lists, and garbage collection work when the commit is one small object. cloud infrastructure · advanced
Jun 24, 2022 DCF Backoff and the Contention Window Growth Rule How a station decides when to transmit after the medium goes idle, why the backoff is counted in slots rather than microseconds, and how the window doubles after loss. networking · foundational
Jun 23, 2022 Bounded Contexts and the Cost of a Shared Model Why one organisation-wide model accumulates nullable fields, how context boundaries are drawn around consistency, and what a context map records about the relationships between them. software architecture · intermediate
Jun 23, 2022 Type-Length-Value Framing and the Extension Contract Why a self-describing field is the precondition for every extension mechanism, where length fields count from, and what TLV framing cannot express. internet protocols · foundational
Jun 19, 2022 Linearity and Aliasing as a Confinement Discipline How unique ownership, borrowing, and linear types let a compiler prove that a value crosses a boundary exactly once, and where the proof stops being able to say anything about authority. language runtimes · intermediate
Jun 18, 2022 Multi-Level Feedback Queues and Priority Decay How a set of priority queues plus a demotion rule approximates shortest-job-first without knowing job lengths, and the gaming and starvation problems that follow. operating systems · foundational
Jun 17, 2022 Key Escrow for Encrypted Backups How envelope encryption separates the key that protects data from the key that protects keys, why rotation is cheap until it is not, and how escrow can outlive the system it protects. devops · advanced
Jun 16, 2022 App Container Layout and Which Files Belong in a Backup How the sandbox directory tree separates durable user data from regenerable caches, what the platform backup excludes by rule, and why the restore path is the one that breaks. mobile computing · intermediate
Jun 15, 2022 Confluence and the Church-Rosser Theorem for Beta Reduction Why the order of beta reductions cannot change the final answer, how the diamond property is proved by parallel reduction, and what the standardisation theorem adds. computation theory · intermediate
Jun 15, 2022 Tail-Based Sampling: Buffering Traces Until the Outcome Is Known Why deciding after the trace completes requires holding spans in memory, how the buffering window and the trace-ID routing rule interact, and where the pipeline loses traces it intended to keep. observability · intermediate
Jun 13, 2022 Gates in LSTM and GRU Cells: What Each Gate Controls How multiplicative gates create an additive path through time, what the forget, input and output gates each multiply, and how a two-gate cell removes one of them. deep learning · intermediate
Jun 10, 2022 Expand and Contract: Schema Changes That Survive an Overlap The three-phase pattern that keeps two application versions reading one schema, which DDL operations take heavy locks, and how to bound the lock window with batched backfills. devops · intermediate
Jun 10, 2022 Why Three Literals Is the Pivot for Satisfiability The reduction from general CNF to 3-SAT, why 2-SAT is solvable in linear time while 3-SAT is complete, and how clause length controls the shape of the search space. computation theory · intermediate
Jun 3, 2022 Bounding Online Guessing with Rate Limits and Lockouts How attempt budgets, keyed counters, and timing equalisation set an upper bound on password guessing, and which limit designs convert a defence into a denial of service. security · advanced
Jun 3, 2022 Why an In-Order Pipeline Stalls and What an Instruction Window Buys How dependencies, latency, and a fixed instruction supply bound an in-order pipeline, and why a sliding window of decoded instructions is the cheapest way out. computer architecture · foundational
May
May 30, 2022 Inside ML-KEM: Noise Growth from Keygen to Decapsulation A concrete walk through KeyGen, Encaps and Decaps in FIPS 203, tracking the error term as powers of two so the compression parameters and failure bounds make sense. cryptography · intermediate
May 24, 2022 Job Classes, Initiators, and How a Batch Queue Gets Ordered Why a batch scheduler separates jobs into classes consumed by independent initiators, what an initiator costs in storage, and how starvation and throughput pull against each other. computing history · advanced
May 23, 2022 Lateral Movement Inferred from Authentication Records How a domain authentication log encodes the machine a logon came from, why that field is forgeable, and which patterns distinguish traversal from ordinary administration. security · advanced
May 21, 2022 Versioning, Delete Markers, and What a Delete Actually Removes Enabling versioning turns overwrite into append and delete into a placeholder. The state machine has three modes, and the suspended mode is where most surprises live. cloud infrastructure · foundational
May 21, 2022 What Behavior-Preserving Change Cannot Preserve Cost, stack shape, interleaving, and resource lifetime fall outside the observation set by design. The cases where that exclusion stops being acceptable are the ones that matter. software engineering · advanced
May 19, 2022 Keyframe Interpolation and the Cubic Hermite Segment How a sparse animation channel becomes a continuous function of time, why cubic tangents carry units of value per second, and which degenerate segments an evaluator must survive. computer graphics · foundational
May 19, 2022 Sparse Files and the Gap Between Length and Allocation A file can report a length of terabytes while occupying a few blocks, and the interface keeps the two numbers separate; seeks into the gap, hole punching, and the copy that silently fills it. filesystems · intermediate
May 14, 2022 Compressed BVH Nodes and Quantized Bounds How bounds shrink to byte and short quanta, what the inverse mapping costs per test, and why the compressed tree changes traversal arithmetic and memory traffic. computer graphics · advanced
May 12, 2022 Grouped Splits When Observations Are Not Independent How shared subjects across rows inflate a random split, what group-aware partitioning guarantees, and how to choose the grouping key when several exist. machine learning · intermediate
May 12, 2022 The Control Hazard and Why Fetch Must Guess the Next Instruction How a pipelined front end turns every branch into a bet, what a wrong bet costs in cycles, and why stalling instead of guessing is worse than it looks. computer architecture · foundational
May 9, 2022 Control-Flow Graphs and the Dominance Relation How basic blocks and edges are built from syntax, how dominators are computed, and why unreachable-code reports depend on modelling exceptions and non-returning calls. developer tools · intermediate
May 5, 2022 Fixed-Window Models and the Hidden State They Cannot Represent Why a predictor restricted to the last k inputs cannot count, track nesting, or carry information past its window, and what a learned hidden state changes about that limit. deep learning · foundational
May 4, 2022 Event Time and Processing Time in a Stream Operator Why the clock an operator reads decides whether a replay reproduces its output, and how the two clocks diverge when a source falls behind. data engineering · foundational
May 4, 2022 Indexed Triangle Meshes and the Vertex Cache Why a triangle list repeats every vertex, what an index buffer saves in bytes, and how vertex ordering interacts with a fixed-size post-transform cache. computer graphics · foundational
May 1, 2022 Where a Packet Capture Sits Determines What It Shows How capture points on hosts, bridges, and taps differ in what they observe, and why segmentation offload and checksum offload make a local capture disagree with the wire. networking · foundational
April
Apr 29, 2022 Termination Checking and the Price of Consistency Why a total language cannot have a general fixpoint, how structural and size-change checks approximate termination, and what each approximation rejects. computation theory · advanced
Apr 25, 2022 Pointwise, Pairwise, and Listwise Training Objectives What each learning-to-rank formulation optimizes, why pairwise ranking losses match the evaluation better than regression, and what listwise gradients buy. information retrieval · intermediate
Apr 24, 2022 Derivations, Sentential Forms, and What a Parse Tree Actually Records How a grammar rewrites strings step by step, why leftmost derivations and parse trees are two views of one object, and where the correspondence breaks when a grammar is ambiguous. computation theory · foundational
Apr 22, 2022 Atomics and Contention in Counters and Aggregates Why a single global atomic counter serialises a kernel, how per-warp and per-block aggregation cuts that traffic, and which failure modes survive the optimisation. gpu computing · advanced
Apr 20, 2022 Hash Partitioning and the Range Query It Destroys How modulo hashing places keys on nodes without any directory, why the same function makes ordered access impossible, and what a resize really moves. distributed systems · foundational
Apr 20, 2022 Sequential Impulse and the Contact It Solves One Pair at a Time How a rigid-body contact constraint is solved as a sequence of per-contact impulses, why warm starting makes the solver converge, and what happens when too many contacts share one body. computer graphics · advanced
Apr 19, 2022 Discrete Logarithms and Why Group Order Decides Their Difficulty How Pohlig-Hellman reduces a discrete logarithm to its prime factors, why safe primes and Schnorr groups exist, and what small-subgroup confinement does to a protocol. cryptography · foundational
Apr 18, 2022 Service Level Objectives for a Platform, Not for a Service A platform SLO measures whether tenants can get work done, not whether a component is up. How to define the request journey, choose indicators that tenants feel, and handle the shared-dependency problem. virtualization · advanced
Apr 16, 2022 Signal-Driven Sampling: How a Profiler Captures a Stack Without Instrumenting Code How a timer, a signal handler, and an async-signal-safe buffer produce periodic stack samples, and why the delivery path decides what a sample can mean. observability · foundational
Apr 14, 2022 Fencing Tokens and the Worker That Did Not Notice It Was Replaced How a monotonic lease epoch stored beside the protected data stops a stale worker from committing, why a timestamp cannot serve as the token, and what the guarantee excludes. backend systems · advanced
Apr 12, 2022 Canary Releases and the Statistics of Deciding to Promote How traffic is split between two versions without a shared load balancer, why the promotion decision needs a sample-size calculation, and what a canary cannot detect at any sample size. virtualization · intermediate

2022

June

May

April