Complete archive
Archive
3,240 articles, newest first · page 39 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
Sep 4, 2024 B-Tree Fanout Arithmetic and the Cost of a Point Lookup Why page-sized nodes give B-trees a fanout in the hundreds, how that collapses tree height to three or four levels, and where the arithmetic stops paying off. algorithms · intermediate - Sep 4, 2024 Nested Interrupt Entry, Tail-Chaining and Late Arrival in the NVIC How the interrupt controller decides which of several pending interrupts runs first, why back-to-back handlers skip the full restore, and what happens when a request arrives during entry. embedded systems · foundational
- Sep 3, 2024 Zero-Phase Filtering by Forward-Backward Passes Running a filter twice in opposite directions cancels its phase at the cost of squaring its magnitude, and the initial-condition choice decides how much edge transient survives. scientific computing · intermediate
- Sep 2, 2024 Reading a Target Triple as an ABI Contract What each field of a target triple selects, how GCC and Clang disagree about defaults, and why two triples naming the same CPU can produce objects that refuse to link. systems programming · foundational
- Sep 2, 2024 Where Latency Is Measured, and Why Percentiles Do Not Average A serving latency number is a function of the point where the clock starts, and percentiles computed at different layers cannot be combined; both facts determine whether a monitoring figure means anything. inference systems · intermediate
-
August
Aug 31, 2024 Uniform Random Permutations and the Fisher-Yates Shuffle Why swapping each element with a random position from the whole array produces biased permutations, and how the inside-out variant shuffles a stream without knowing its length. algorithms · foundational - Aug 30, 2024 BLS Aggregation and the Rogue-Key Attack It Invites A pairing lets many signatures collapse into one, but the straightforward multisignature construction lets the last signer choose a key that frames the others. cryptography · advanced
- Aug 30, 2024 Elliptic Curve Point Arithmetic and Validation The group law on a short Weierstrass curve, why scalar multiplication uses a ladder rather than double-and-add, and which malformed points a peer can send. cryptography · intermediate
- Aug 30, 2024 Hybrid Logical Clocks: Physical Time With a Logical Counter How HLC timestamps stay close to wall-clock time while preserving causality, why the counter only appears inside the uncertainty window, and what a bounded timestamp costs. distributed systems · intermediate
- Aug 29, 2024 Semantics Trees and the Platform Accessibility Bridge How a declarative interface is projected into a second tree that assistive technology reads, what the platform expects of that tree, and why merging and clearing nodes is a correctness problem rather than a labelling one. mobile computing · advanced
- Aug 29, 2024 SRTP Key Derivation and Per-Packet IV Construction How one master key produces separate encryption, authentication, and salting keys, and why the packet index rather than the sequence number feeds the counter block. internet protocols · advanced
- Aug 27, 2024 The Git Index: A Sorted Path Table Between Worktree and Commit What the binary index file stores, how the stat cache avoids rehashing every file, and why merge conflicts appear as three entries for one path. developer tools · foundational
- Aug 27, 2024 WebAssembly Imports as the Only Channel to the Host Why a validated module can reach nothing but its own linear memory and its declared imports, and how host functions, tables, and shared memories widen that surface. language runtimes · intermediate
- Aug 26, 2024 Severity Classification as a Routing Input How a severity level selects the channel, the responders, and the update cadence, and why definitions anchored in observable impact outperform definitions anchored in alarm. devops · intermediate
- Aug 23, 2024 Checking Contrast Against What Renders, Not What Is Declared Computed styles, compositing, canvas readback, and the sampling decisions that decide whether a measured ratio corresponds to anything a reader sees. accessibility · advanced
- Aug 23, 2024 Delegation and Zone Cuts: Where Authority Changes Hands How an NS RRset at a delegation point splits a namespace into zones, why glue records are necessary, and what makes a delegation lame or unreachable. internet protocols · foundational
- Aug 23, 2024 False Negatives and Batch Composition Every off-diagonal entry in a contrastive batch is treated as a negative, including entries that are semantically identical; the resulting pressure shapes the space and is controlled by what goes into the batch. deep learning · intermediate
- Aug 23, 2024 From Invalidation to Present: The Frame Pipeline on a Mobile Device The stages between a state change and a lit pixel, why the pipeline is driven by the display refresh signal rather than by input, and what happens when a stage overruns its deadline. mobile computing · advanced
- Aug 23, 2024 Measuring Alert Fatigue Instead of Describing It Which quantities make page volume and actionability comparable across rotations, how to collect them without rewarding the wrong behaviour, and how the numbers drive deletion. devops · intermediate
- Aug 22, 2024 A* and the Conditions on a Heuristic Admissibility versus consistency, why a consistent heuristic removes the need to reopen closed nodes, and what weighting the heuristic buys and costs in solution quality. algorithms · intermediate
- Aug 22, 2024 Paxos Prepare and Accept: What the Promises Are For Why acceptors must promise not to accept older proposals, how the highest-numbered proposal wins a phase, and what breaks when the two phases are collapsed. distributed systems · intermediate
- Aug 22, 2024 Sparse Parity-Check Codes and Iterative Decoding How a low-density parity-check matrix defines a code, why belief propagation on its Tanner graph approaches capacity, and where trapping sets produce an error floor. computation theory · advanced
- Aug 21, 2024 Ack Clocks and the Congestion Window: How a Sender Infers Available Capacity Why a TCP sender measures the path with returning acknowledgements instead of a timer, how the congestion window combines with the receive window, and what a stalled clock does to the estimate. networking · foundational
- Aug 21, 2024 Estimating Change Rates from Interval-Censored Fetches Why a page observed to change once in ten fetches does not have a ten percent change rate, and how a Poisson model with a Gamma prior turns sparse observations into a revisit interval. information retrieval · intermediate
- Aug 20, 2024 Constant Memory and the Read-Only Load Path How a 64 KB host-written bank gets a fast path to the pipelines, why uniform reads inside a warp are almost free while divergent ones serialize, and what the non-coherent load promises the compiler. gpu computing · intermediate
- Aug 19, 2024 Hedged Requests and the Arithmetic of Tail Latency Why the slowest of several parallel calls sets the latency of a fan-out, and how a delayed second attempt trades a fixed slice of extra load for a large reduction in the tail. backend systems · intermediate
- Aug 19, 2024 Pointer Provenance and the Cost of Integer Round-Trips A pointer carries more than an address, and converting it to an integer and back can discard the derivation the optimiser needs to justify its transformations. systems programming · foundational
- Aug 19, 2024 Proving a Legacy Component Is Unused Before Deleting It Why an absence of observed traffic is not evidence of absence, how deliberate denial turns a guess into a measurement, and what must be checked before code and data are removed for good. software architecture · advanced
- Aug 19, 2024 Small File Accumulation and What Compaction Must Preserve Why frequent small commits degrade a table long after the commits stop, how a compaction job rewrites files without breaking snapshots, and which invariants it cannot violate. data engineering · intermediate
- Aug 19, 2024 Splaying: Amortized Restructuring Without Stored Balance How a splay step moves an accessed node to the root, why zig-zig pairing matters, and how a potential function yields O(log n) amortized access with zero metadata. data structures · advanced
- Aug 19, 2024 The Rendering Equation as a Linear Operator How the rendering equation is written as a fixed-point problem, what the Neumann series expansion means physically, and why convergence depends on the spectral radius of the transport operator. computer graphics · foundational
- Aug 18, 2024 Hit Testing and Gesture Arbitration Across Overlapping Views How a touch becomes a gesture, why the framework must decide which recognizer wins before it knows what the user intends, and how touch slop and failure requirements make that decision reversible. mobile computing · advanced
- Aug 18, 2024 Lock-Free Reclamation: ABA, Tagged Pointers, and Hazard Pointers Why a compare-and-swap pop can succeed against a pointer that was freed and reused, and what tagging, hazard pointers, and epoch schemes each cost to close that hole. operating systems · advanced
- Aug 18, 2024 Portable Single-Source Layers and Where They Leak How SYCL, OpenMP offload, and Kokkos present one source file for host and device, and which abstractions fail to compile, fail to perform, or silently diverge in results. gpu computing · intermediate
- Aug 18, 2024 Provider Versions, Schema Changes, and State Migration How a provider upgrade can change the meaning of stored state, why schema versions exist per resource type, and what an upgrade path can and cannot fix. cloud infrastructure · advanced
- Aug 18, 2024 Switch Access and Row-Column Scanning How a single switch lets a user navigate every control on screen through timed scanning, and how the scan timing and group layout determine entry speed. accessibility · foundational
- Aug 17, 2024 Recomposition Scopes: How Granularity Decides What Reruns Why a state read is only observed by the nearest enclosing scope, how dependency tracking limits the work a single value change triggers, and why state hoisting changes cost. mobile computing · intermediate
- Aug 16, 2024 Cycle Time, Work-in-Progress Limits, and Little's Law in Delivery Queues How the identity L = lambda W ties items in flight to delivery time, why operating near full capacity inflates waiting, and how to size a work-in-progress limit from a target cycle time. software engineering · foundational
- Aug 16, 2024 Membership Change Under Joint Consensus Why a configuration cannot be edited in place, how C_old,new requires dual majorities during the transition, and what single-server changes cost in safety margin. distributed systems · intermediate
- Aug 15, 2024 Unification and the Hindley–Milner Inference Algorithm How ML-family languages recover types without annotations: unification variables, the occurs check, and the level discipline that keeps generalization cheap. programming languages · foundational
- Aug 13, 2024 MESI Transitions and the Traffic an Invalidation Generates What each coherence state permits, which transactions move a line between them, and why a false sharing pattern produces more bus traffic than the data it writes. memory systems · intermediate
- Aug 13, 2024 Type Feedback and the Speculation Budget How a runtime decides what to speculate about from what the interpreter observed, why the counters that trigger optimization are the same counters that guard it, and what happens when a speculative bet loses. language runtimes · intermediate
- Aug 12, 2024 Standing Queues and the Buffer Sizing Trade-Off Why deep buffers turn into permanent added latency, how the bufferbloat diagnosis differs from ordinary congestion, and what the bandwidth-delay product says about how much buffer is needed. networking · foundational
- Aug 12, 2024 Strict Aliasing and the Cases Where Type Punning Is Legal The effective type rules permit far more access through differing types than the folklore suggests, and the sanctioned escape hatches are narrower than the compiler flags that disable the analysis. systems programming · intermediate
- Aug 12, 2024 Version Precedence and the Semantics of Range Operators How version strings are ordered, why caret and tilde ranges expand the way they do, and where precedence rules diverge between ecosystems badly enough to change an install. language runtimes · foundational
- Aug 10, 2024 Establishing Onset Before Correlating It With Changes Detection time is not onset time. Finding the minute a failure actually began, and knowing the base rate of changes in that window, is what decides whether a correlation is evidence. observability · intermediate
- Aug 10, 2024 Memory and CPU Limits Under the cgroup v2 Unified Hierarchy How memory.max, memory.high and cpu.max are enforced, why reclaim happens before the OOM killer, and what the pressure stall counters measure. virtualization · intermediate
- Aug 9, 2024 Belief Propagation on Trees and Why Loopy Message Passing Fails How sum-product messages re-derive exact marginals on a tree, and what a fixed point on a graph with cycles does and does not guarantee. machine learning · intermediate
- Aug 9, 2024 Probe Sequences in Open-Addressed Hash Tables How linear, quadratic and double hashing differ in clustering behaviour, why deletion needs tombstones or backward shifting, and what Robin Hood ordering buys. algorithms · intermediate
- Aug 8, 2024 The GDB Remote Serial Protocol: Packets, Checksums, and Stubs A debugger talking to a target it cannot link against needs a wire format. How RSP frames commands, negotiates capabilities, and survives a serial line. developer tools · advanced
- Aug 7, 2024 Adversary Capability Models and the Assumptions They Encode How an attacker profile is really a list of things the attacker cannot do, why network position and time budget dominate the labels, and where capability tiers mislead. security · foundational
- Aug 7, 2024 Termination, Cure, and Enforcement of License Conditions A failed condition removes the permission rather than merely breaking a promise, so the GPLs terminate rights automatically and then offer defined windows to get them back; who can sue is decided by who holds copyright. computing history · advanced
- Aug 7, 2024 Where an API Contract Ends and the Implementation Begins Which parts of an HTTP exchange callers may depend on, which are incidental, and why undocumented behaviour still turns into a maintenance obligation. software architecture · foundational
- Aug 6, 2024 Noise Schedule Shape and the Signal-to-Noise Ratio Curve Why the choice of β schedule changes where a diffusion model spends its capacity, how variance-preserving and variance-exploding conventions differ, and when a cosine schedule beats a linear one. deep learning · advanced
- Aug 5, 2024 Execution Contexts, Environment Records, and What a Closure Keeps Alive How identifier resolution walks a chain of environment records, why the per-iteration binding of let changes closure behaviour, and which storage a closure pins in memory. web platform · intermediate
- Aug 5, 2024 Header Dependency Discovery: Why the Compiler Records Includes, Not the Build Tool Reconstructing a translation unit's header list by scanning source text fails on conditional and computed includes. The front end already knows which files it opened, and it can write that list as a makefile fragment. compilers · foundational
- Aug 5, 2024 Transaction Groups, Checkpointing, and Reclaiming Journal Space Why a committed transaction cannot free its journal space until its blocks are in place, and how checkpointing turns the log into a fixed-size ring. filesystems · intermediate
- Aug 4, 2024 JSON-RPC Framing and the LSP Initialize Handshake How JSON-RPC messages are framed on the wire with a byte-counted header, which message shapes the protocol allows, and how the initialize exchange decides which features exist for the rest of the session. developer tools · intermediate
- Aug 4, 2024 Pseudo-Polynomial Knapsack: Why the Capacity State Is Not Polynomial The O(nW) knapsack table is polynomial in the capacity value and exponential in its bit length, which is why the problem stays NP-hard and why scaling the weights yields an approximation scheme. algorithms · intermediate
- Aug 3, 2024 Struct Passing and Register Classification Across ABIs How a compiler decides whether a struct travels in registers or in memory, what the eightbyte classification rules encode, and where layouts diverge between C and other languages. language runtimes · foundational