Complete archive

Archive

3,240 articles, newest first · page 42 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
May 21, 2024 Inline Assembly Constraints and What a Clobber List Does Not Say A compiler knows nothing about the instructions inside an assembly block, so every register, flag, and memory effect has to be declared, and an undeclared effect is silently miscompiled. systems programming · advanced
May 20, 2024 Heap Growth and the Pacing of Collection Cycles How a runtime decides when to collect and how much heap to add, why the live-set measurement after each cycle determines the next one, and how pacing trades memory against pause. language runtimes · advanced
May 19, 2024 Tree DP and Rerooting: Computing an Answer at Every Node Subtree DP evaluates a rooted tree in post-order, and a second top-down pass propagates the parent contribution so that every node gets the answer for the tree rooted at it. algorithms · advanced
May 17, 2024 Profiles and Conformance Classes: Narrowing a Standard Without Editing It How profiles make a broad specification testable for a specific market, what a conformance class promises, and why profiles proliferate. computing history · advanced
May 17, 2024 Register Retiming: Moving Flip-Flops Across Combinational Logic How a retiming tool redistributes registers along a path without changing the function, what the legal moves are, and why the resulting netlist no longer matches the RTL that was written. hardware engineering · advanced
May 17, 2024 Signal Handling in Shell Scripts: Traps, Races, and Termination Forwarding When a trap handler actually runs, which signals a script cannot catch, and how a wrapper passes SIGTERM to its children without orphaning them. developer tools · advanced
May 17, 2024 Sliding-Window Attention and the Reach of a Stacked Local Window How a fixed-width window bounds per-layer cost while the stack multiplies its reach, what the reach formula predicts, and where the prediction fails because information cannot travel that far. deep learning · advanced
May 16, 2024 Diff Algorithm Choice and the Noise It Adds to a Review Myers, histogram, and patience strategies produce different edit scripts for the same two files, and the choice determines whether a reviewer sees structure or a wall of moved lines. software engineering · foundational
May 16, 2024 Memory Pressure, Reclaim Order, and the Kill Decision How a mobile system decides which process to kill under memory pressure, why the score is an out-of-memory adjustment rather than a priority, and how file-backed pages change the arithmetic. mobile computing · advanced
May 15, 2024 Byte-Range Locks and What Happens When a Client Dies The server owns the lock, the client owns the local enforcement, and neither can see the other side. That split explains lock leasing, the difference between local and NLM locking, and why a dead client blocks a range until the server notices. filesystems · intermediate
May 15, 2024 Expression-Oriented Syntax and the Value of a Block What changes when every construct produces a value, how a block’s trailing expression becomes its result, and why the statement form survives in languages that removed it. programming languages · intermediate
May 15, 2024 How Differential Cryptanalysis Broke SHA-1 The modular-difference search, message-modification steps, and near-collision blocks that turn a 160-bit digest into two colliding PDFs, and why the margin was thinner than the bound implied. cryptography · advanced
May 14, 2024 Path Copying and the Cost of Persistence in Balanced Trees Why an update to an immutable balanced tree rewrites one path, how the sharing structure changes the balance invariants, and where the allocation cost actually goes. data structures · advanced
May 14, 2024 Pre-Aggregating Map Output with Combiners The associativity contract a combiner must satisfy, where the framework applies it, and how much shuffle volume it removes when key cardinality is low. data engineering · intermediate
May 14, 2024 Worker Leases, Heartbeats, and the Zombie Task Problem How a lease turns liveness into a deadline, why an expired lease cannot prove a task stopped, and how fencing tokens contain the overlap. data engineering · advanced
May 13, 2024 Bit Rot, Link Rot, and Replaying an Analysis Years Later What degrades in a stored computation over time, which failures are recoverable, and what has to be captured at creation time to make a late replay possible at all. scientific computing · advanced
May 13, 2024 How the PLT and GOT Turn a Library Call Into Writable Memory Lazy binding keeps resolution out of process startup by routing calls through a stub that patches a table, which leaves a writable function pointer for every imported symbol. security · foundational
May 13, 2024 Issue-Limited Kernels and the Cost of Divergence When the instruction stream rather than the memory system sets the runtime, how warp divergence turns one instruction into several, and how to tell the two apart with counters. gpu computing · intermediate
May 13, 2024 The RTP Fixed Header: Twelve Bytes That Carry a Media Stream What each field of the 12-byte RTP header means, why sequence numbers and timestamps are independent, and which failures the design accepts to stay small. internet protocols · foundational
May 11, 2024 Plan Caching, Generic Plans, and the Parameter Sensitivity Problem Why a reused plan is compiled for a parameter it will never see again, how the choice between custom and generic plans is made, and why parameter sniffing produces plans that fit one value. databases · intermediate
May 10, 2024 Golomb-Rice Coding for Postings Gaps How splitting a gap into a quotient and remainder against a tuned divisor makes an optimal code for geometric distributions, and how the divisor is chosen without knowing the data. information retrieval · advanced
May 9, 2024 Gradient Signal Propagation Through Depth at Initialization How the product of layer Jacobians determines whether a deep stack can be trained at all, why that product is easier to keep benign in residual architectures, and what the propagation analysis predicts about depth and width. deep learning · advanced
May 9, 2024 Posterior Collapse and the KL Term That Wins Why a latent variable model can learn to ignore its latents entirely, how the KL term competes with reconstruction, and which interventions change the balance. deep learning · foundational
May 9, 2024 Postmortem Causation: Triggers, Latent Conditions, and Failed Defences Why a single root cause discards the information needed to prevent recurrence, how counterfactual reasoning behaves in stochastic systems, and how to rebuild a sequence from telemetry with its uncertainty intact. software engineering · intermediate
May 9, 2024 Reading an ELF Image: Sections, Symbols, and DWARF How a debugger maps a source line to a flash address, what the symbol table contributes that DWARF does not, and why a stripped image still debugs correctly. embedded systems · foundational
May 8, 2024 Credentials on the Wire and Identity Squashing The client asserts who the caller is on every request, and the server decides whether to believe it. That decision is where network filesystems diverge from local permission checking, and where the root account becomes the recurring problem. filesystems · advanced
May 8, 2024 Packfiles and Delta Chains: How Git Stores Similar Objects Once The pack and index file formats, how delta instructions rebuild an object from a base, and what chain depth costs on read. developer tools · intermediate
May 8, 2024 Per-Host Request Rate Limits and the Cost of a Fixed Delay Why a constant delay between requests is the simplest defensible politeness policy, how concurrency multiplies the rate a server actually sees, and where the model fails. information retrieval · foundational
May 8, 2024 Saturating Activations and Gradient Flow Through Depth How the derivative of a squashing function caps the signal that reaches early layers, why squaring the error makes the vanishing worst exactly when the network is most wrong, and which structural changes restore the signal. deep learning · intermediate
May 7, 2024 Markov Random Fields and the Intractability of the Partition Function Why undirected models factorize over cliques, how the normalizing sum becomes a partition function, and why that single constant governs both inference and learning. machine learning · intermediate
May 6, 2024 Quantization Step Size, the Six-Decibel Rule, and Dither Why each added bit buys roughly six decibels of signal-to-noise ratio, when the uniform-error model stops holding, and what dither trades away to fix it. scientific computing · foundational
May 6, 2024 Session Guarantees: Read-Your-Writes and Monotonic Reads How four per-session guarantees are implemented with version tracking, why they are cheaper than global consistency, and where client redirection breaks them. distributed systems · intermediate
May 5, 2024 Detecting Drift Between Reference Material and the Code It Describes Documentation goes stale one claim at a time. Separating checkable claims from judgement calls shows which kinds of drift a build can catch and which only review can. software engineering · advanced
May 4, 2024 Exponential Histograms and the Mergeable Bucket Layout How boundaries derived from a growth factor give uniform relative error, why an offset and a scale factor are enough to merge two histograms, and where the resolution limits sit. observability · intermediate
May 4, 2024 Partition Refinement: Minimizing a DFA by Splitting Blocks How Hopcroft-style minimization refines an initial partition into equivalence classes of states, why splitting the smaller half gives O(n log n), and where the implementation gets it wrong. computation theory · intermediate
May 2, 2024 Federated Session State: Logout, Propagation, and the Limits of Single Sign-Out Why a logout at one relying party cannot reliably end sessions at others, how back-channel and front-channel logout differ, and what session identifiers can and cannot carry. internet protocols · advanced
May 2, 2024 Softmax Coupling versus One-vs-Rest Probabilities What the normalising constant does to multiclass estimates, why one-vs-rest scores need not sum to one, and how the two parameterisations differ under class imbalance. machine learning · intermediate
May 1, 2024 Error-Free Transformations and Double-Double Arithmetic How TwoSum and TwoProduct recover the exact rounding error of an operation, what a double-double pair really represents, and where the transformations stop being exact. scientific computing · advanced
May 1, 2024 Seqlocks: Consistent Reads Without Reader-Side Writes How an even/odd sequence counter lets readers detect a concurrent update, why the read side must be free of side effects, and what the retry cost looks like under write-heavy load. systems programming · intermediate
April
Apr 30, 2024 HTTP/1.1 Message Framing and the Cost of Connection Reuse How a server decides where one HTTP message ends and the next begins, why chunked encoding exists, and what persistent connections change about failure handling. backend systems · foundational
Apr 29, 2024 Chiplets and the Cost of Leaving the Die What partitioning buys in yield and reticle headroom, and what the die-to-die interface costs in energy per bit, latency, and package complexity. computer architecture · advanced
Apr 28, 2024 Mirroring Widget State Into ARIA Attributes Without Drift Why every interactive custom widget keeps state in two places, which attributes the tree actually reads, and how a render boundary prevents the two copies from disagreeing. accessibility · foundational
Apr 28, 2024 Newton and IRLS Fitting for Logistic Regression Why logistic regression is fitted by repeated weighted least squares, how the Hessian decides the step, and what happens when the weights collapse under separation. machine learning · intermediate
Apr 28, 2024 Quantiles from Finite Samples and Their Confidence Bands What a p99 computed from a few hundred observations actually estimates, how the order statistic maps to a binomial interval, and why tail claims need sample sizes that frequently do not exist. performance engineering · intermediate
Apr 27, 2024 Stack Frame Layout and Why a Linear Overflow Reaches the Return Address How the System V x86-64 frame places locals, the saved frame pointer, and the return address, and why writing past a buffer lands on control data. security · foundational
Apr 26, 2024 Acquire and Release: What Each Ordering Forbids The precise prohibitions that acquire and release each impose, why the pair cannot order a store against a later load, and when a standalone fence is the only option. systems programming · foundational
Apr 26, 2024 Atomicity and Ordering Are Separate Guarantees in the C Memory Model Why making a shared object atomic removes lost updates but not stale reads, how the C memory model defines a data race, and what happens-before does and does not cover. systems programming · foundational
Apr 26, 2024 Relocation Entries and the Arithmetic a Linker Performs How REL and RELA entries encode the patch a linker must apply, why the addend is sometimes stored in the section and sometimes in the entry, and what R_X86_64_RELATIVE actually computes. systems programming · foundational
Apr 24, 2024 Adaptive Plans: Choosing the Join Algorithm After Execution Starts How a statistics collector at a plan node defers the choice between nested loop and hash join, what the switch costs mid-flight, and why re-planning after a blocking operator is a different mechanism. databases · advanced
Apr 22, 2024 Combining Decision Procedures with the Nelson–Oppen Method How separate decision procedures for arithmetic, arrays, and uninterpreted functions are made to agree on shared variables, why stable infiniteness is required, and where non-convex theories force case splits. computation theory · advanced
Apr 22, 2024 Environment Parity as a Byte-Level Claim: What Divergence Between Stages Actually Costs Why staging and production diverge even when both are built from the same configuration, which differences change behaviour, and how to make parity a measurable property. devops · intermediate
Apr 21, 2024 Characterization Tests as a Refactoring Safety Net When code has no specification, the only available oracle is the code itself. Recording current behavior turns a rewrite into a comparison against captured output. software engineering · intermediate
Apr 19, 2024 Decoupling Capacitors and the Impedance of a Power Distribution Network Why a regulator cannot supply a load that changes in nanoseconds, how a network of capacitors is chosen to hold a target impedance across frequency, and where the anti-resonances come from. hardware engineering · foundational
Apr 18, 2024 Certificate, Profile, and Entitlement Binding in iOS Code Signing How a provisioning profile licenses one signing identity to assert a specific set of entitlements, and why the kernel rejects an app whose entitlements exceed its profile. mobile computing · foundational
Apr 18, 2024 Cross-Encoder Reranking and the Cost of Reading Every Pair Why a reranker sees query and passage together, what that buys over a dual encoder, and how candidate depth turns a quality gain into a latency bill. inference systems · intermediate
Apr 18, 2024 Worst-Case Response Time of a CAN Message Under Fixed-Priority Arbitration Why the identifier is a priority, how the blocking and interference terms of a response-time bound are computed for a bit-stuffed frame, and where the analysis stops being optimistic. embedded systems · advanced
Apr 17, 2024 Virtually Indexed Caches and the Page Coloring Problem Why a cache can start its lookup from a virtual address and finish with a physical tag, when that creates synonyms, and how page coloring controls which sets a process occupies. memory systems · advanced
Apr 17, 2024 What the Unsafe Keyword Actually Disables The unsafe marker gates a short, enumerable list of operations rather than switching off the type system, and the obligations it transfers reach past the block that names it. systems programming · foundational
Apr 16, 2024 Interlocks, Bubbles, and How a Stall Propagates Backwards How a pipeline detects a dependency in hardware, freezes the stages behind it, and injects a no-operation, including the reason a stall must be signalled backwards and not forwards. computer architecture · intermediate
Apr 15, 2024 Shingled Magnetic Recording and the Write Cursor Why overlapping written tracks raise areal density, how that turns every random write into a band rewrite, and what a zoned interface has to expose to make the constraint usable. hardware engineering · intermediate

2024

April