Complete archive

Archive

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

2026
Jan 17, 2026 Install Scripts: The Code That Runs Before the Package Does What package managers execute at install time, why lifecycle hooks exist, and how their privilege, ordering, and failure semantics make them a separate trust boundary from the code being installed. software engineering · intermediate
Jan 16, 2026 Multiphase Buck Converters and Where Regulator Efficiency Goes How interleaved buck phases divide a hundred-ampere load, why ripple cancellation lets the inductors shrink, and which loss terms set the efficiency curve. hardware engineering · foundational
Jan 16, 2026 Residual Connections and the Identity Gradient Path How adding a block input to its output changes the Jacobian of a stack from a product of small factors into a sum that contains the identity, what that buys in depth, and where the argument stops holding. deep learning · intermediate
Jan 15, 2026 Futex Wait and Wake: How a Lock Sleeps Without a Syscall on the Fast Path How a 32-bit word in user memory plus a hashed kernel wait queue gives uncontended locks no kernel entry at all, and what requeue and priority inheritance add for the contended cases. operating systems · intermediate
Jan 14, 2026 A Completed Write Is Not Yet Durable: Persistence Domains and Ordering Why write and close return long before bytes reach media, how a persistence domain decides what a crash can lose, and why durability, ordering, and atomicity need separate mechanisms. memory systems · foundational
Jan 14, 2026 Page Program and Block Erase: The Asymmetry That Shapes Flash Software Why a flash array writes in pages of a few kilobytes but can only be cleared in blocks of hundreds, what that costs in area and time, and how the asymmetry propagates upward. hardware engineering · foundational
Jan 13, 2026 Diagnostics Delivery: Push, Pull, and Stale Results How errors and warnings travel from a language server to the editor: the push notification that owns a document, version binding, the pull request with result identifiers, and the ways a squiggle outlives the code it describes. developer tools · intermediate
Jan 13, 2026 Measuring Time a Thread Spends Blocked Instead of Running on-CPU sampling cannot see waiting; reconstructing blocked time requires scheduler tracepoints, state transitions, and a model of what "running" excludes. performance engineering · intermediate
Jan 13, 2026 Transcript Hashing and Handshake Binding in TLS 1.3 How a running hash over handshake messages commits each flight to the ones before it, which secrets consume the digest, and what breaks when a message is left out of it. cryptography · foundational
Jan 13, 2026 Watermarks as Completeness Signals How a watermark asserts that no earlier event will arrive, how it is propagated through operators, and what happens when the assertion is wrong. data engineering · foundational
Jan 12, 2026 Consistent Cuts and the Marker Algorithm for Global Snapshots Why a set of per-process snapshots taken at different moments is usually inconsistent, and how markers travelling on the same channels as messages capture a cut that could have occurred. distributed systems · advanced
Jan 12, 2026 Deadline-Aware Batch Assembly Turning latency targets into per-step scheduling decisions: slack, remaining-work estimates, and why maximising throughput and meeting deadlines diverge. inference systems · advanced
Jan 12, 2026 Draining a Worker Pool Without Losing or Doubling the Work The shutdown sequence for a job worker: stop claiming, cancel at a deadline, release leases instead of waiting for expiry, and keep heartbeats alive until the handlers stop. backend systems · advanced
Jan 12, 2026 Driver-Level Runtime Compilation and Module Loading The chain from kernel source to a loadable module: intermediate collection, per-device lowering, cached artefacts, and the failure modes at each stage of the load. gpu computing · advanced
Jan 12, 2026 Half-Space Coverage and the Edge Function Test How a rasterizer decides which pixels a triangle owns, why the test is written as three signed line equations, and what the top-left rule does for shared edges. computer graphics · foundational
Jan 12, 2026 Hardware Breakpoints and Watchpoints in the Debug Registers Four address slots, a length encoding with alignment rules, and a trap that fires after the store: what the processor can observe without editing code. developer tools · foundational
Jan 12, 2026 The Fiat-Shamir with Aborts Loop in ML-DSA How rejection sampling hides the signing nonce, why a signature leaks nothing but a transcript, and what the rejection rate costs in signing throughput. cryptography · intermediate
Jan 12, 2026 Vtable Layout and the Cost of a Virtual Call How virtual method slots are assigned, why overrides reuse a slot, how multiple inheritance adjusts the this pointer, and what the indirection costs at run time. programming languages · foundational
Jan 11, 2026 Conflict Markers, Merge Drivers, and Recorded Resolutions How conflict markers encode the three inputs, how an attribute-selected merge driver replaces the line-based algorithm, and how rerere replays a resolution it has seen before. software engineering · advanced
Jan 10, 2026 Indexed Binary Heaps and the Cost of Decrease-Key Why changing a key in place needs a handle from element to heap slot, how the position map is maintained through sifts, and what lazy deletion trades away. data structures · foundational
Jan 10, 2026 Liveness and Fairness in Temporal Specifications Why safety properties need only one bad state to fail while liveness needs an infinite execution, and how a fairness assumption turns a starving scheduler into a specification bug. software engineering · intermediate
Jan 9, 2026 Anatomy of a Cross Toolchain: Triples, Sysroots, and Multilibs How a compiler built for one machine produces code for another, what the target triple actually selects, and which ABI mismatches fail at link time versus silently at run time. embedded systems · foundational
Jan 9, 2026 Backfill Concurrency and Collisions with the Live Schedule Why reprocessing history competes with today's run for the same slots, how partition locks arbitrate, and where the contention actually appears. data engineering · intermediate
Jan 9, 2026 EDF, Utilization Bounds, and Schedulability Tests Why earliest-deadline-first reaches full utilization on one CPU, how the density test differs from the utilization test, and what breaks when deadlines exceed periods. operating systems · advanced
Jan 9, 2026 Masking Interrupts, Priorities, and Exclusive Access Without an OS The three mechanisms a bare-metal core offers for making a shared update atomic, what each one costs, and how to pick between them per invariant. embedded systems · intermediate
Jan 8, 2026 Approximate Nearest Neighbour Indexes and the Recall They Trade Away How graph, cluster, and hash indexes reduce a linear scan to a bounded walk, which knob controls recall, and why recall is a property of the query distribution rather than the index. inference systems · foundational
Jan 8, 2026 Cosine Similarity and the Geometry of Normalized Embedding Vectors What the cosine score actually measures, why length normalization turns it into a plain dot product, and when that normalization destroys information the model encoded. information retrieval · foundational
Jan 8, 2026 Error Recovery in Recursive Descent Parsers How a hand-written parser detects a syntax error, chooses a synchronisation point, and limits cascading diagnostics, including why panic-mode recovery beats local correction. compilers · intermediate
Jan 8, 2026 Federating Workloads with OIDC: Which Claims a Trust Policy Must Pin How a workload proves its identity with a signed token instead of a secret, why audience and subject both need pinning, and where claim matching goes wrong. cloud infrastructure · advanced
Jan 8, 2026 Hedged Requests and the Economics of Tail Tolerance How issuing a duplicate request after a delay caps the tail, what the duplicate costs in load, and how to choose the delay so the trade stays favourable. backend systems · advanced
Jan 8, 2026 Release Trains, Cut Points, and Hotfix Branches How a release branch is cut from a moving mainline, what the cut point guarantees, and how a hotfix reaches both the released line and the mainline without duplicating the change. devops · intermediate
Jan 8, 2026 Role Hierarchies and the Reachability Problem in RBAC How role-based access control assigns permissions through roles, why the role hierarchy is a partial order, and why reachability queries and separation-of-duty constraints dominate evaluation cost. security · foundational
Jan 8, 2026 The APK Signing Block and Whole-File Digest Verification How the v2 signature sits between the ZIP entries and the central directory, how a digest covers a file that contains the digest, and why JAR signing could not do this. mobile computing · foundational
Jan 8, 2026 What fsync Actually Waits For, and Why the Directory Counts The difference between fsync, fdatasync, and syncfs, why a durable file can still vanish after a crash, and what rename-based update protocols must flush to be correct. memory systems · foundational
Jan 7, 2026 Autoscaling as a Feedback Loop: Gain, Lag, and Why It Oscillates How a replica controller turns a metric into a desired count, why the control law is proportional rather than predictive, and how sampling lag and stabilisation windows prevent or cause oscillation. virtualization · advanced
Jan 7, 2026 Follow-the-Sun Coverage and the Cost of Every Handoff The arithmetic of covering a full day with regional shifts, the overlap a real transfer needs, and why an incident that crosses three shifts loses more than time. devops · advanced
Jan 7, 2026 Separate Chaining and the Load-Factor Threshold How a bucket array with per-bucket lists produces expected constant-time lookup, what the load factor controls, and why chained tables keep working above a load of one. data structures · foundational
Jan 7, 2026 Word Prediction and Accelerated Text Entry How word prediction and abbreviation expansion reduce the keystroke cost of text entry for switch and scanning users, and how the prediction model trades accuracy for input rate. accessibility · advanced
Jan 6, 2026 Augmented PAKE and What a Stolen Verifier Costs an Attacker How a password-authenticated key exchange lets a server store a value that is not a password hash, and why that changes the economics of a database breach without making weak passwords safe. security · advanced
Jan 6, 2026 How CART Scans Sorted Feature Values for the Best Split Threshold The greedy split search reduces to a single sorted pass per feature, with incremental class counts turning an apparent quadratic problem into a linear scan. machine learning · foundational
Jan 6, 2026 Test Oracles and Where Expected Values Come From Why deciding whether an observed result is correct is harder than producing the input, and the five practical oracle constructions with their failure modes. software engineering · foundational
Jan 6, 2026 Why the Busiest Stage Is Not Always the Critical Path Pipeline stages, parallel branches, and slack explain why time spent in the hottest function may not extend total latency, and how to identify the segment that actually does. performance engineering · foundational
Jan 5, 2026 Alternating Automata: Universal Branching and the Cost of Free Complementation What happens when a state may demand that all successors accept rather than one, how the acceptance game is played, and why one-way alternation shrinks descriptions without changing the exponential determinization bound. computation theory · advanced
Jan 5, 2026 Checksum Placement: Block Pointers, Metadata Trees, and Payloads Where a filesystem can store a block checksum, why the pointer is usually the right home for it, and how each placement choice changes what a torn write can do. filesystems · foundational
Jan 5, 2026 Global Snapshots Across Shards Without a Shared Clock How a transaction gets a consistent view of data spread over independent nodes, what a snapshot identifier must encode, and why the barrier between shards costs a round trip per query. distributed systems · intermediate
Jan 5, 2026 Integer Object Representation and Conversion at the Boundary How signed and unsigned values are stored, what integer promotion silently does to an operand, and which conversions are defined, implementation-defined, or undefined. systems programming · foundational
Jan 5, 2026 Preemption by Swap Versus Recomputation When the cache pool cannot serve a running sequence, the scheduler must take memory back; the two recovery strategies have different costs that depend on sequence length. inference systems · intermediate
Jan 3, 2026 Concurrent Descent and Page Latching in a Shared B-Tree How readers descend without blocking writers, why a split needs the parent as well as the child, and how the Lehman-Yao protocol avoids deadlock. databases · advanced
Jan 2, 2026 Byte-Range Reads: Partial Responses, Alignment, and Parallel Fetch A Range header turns one object into many concurrent reads. What the 206 response guarantees, why alignment matters for throughput, and where range requests break. cloud infrastructure · intermediate
Jan 2, 2026 Clock Derating and the Roofline That Moves Why the ceiling a kernel is measured against depends on power state and duration, and how sustained clocks change which side of the ridge a kernel occupies. gpu computing · advanced
Jan 2, 2026 Conformed Dimensions and the Bus Matrix Why two fact tables can only be compared when they share identical dimension keys and members, and how a bus matrix plans those dimensions before any table is built. data engineering · foundational
Jan 2, 2026 Recovery Ordering for Multi-Service Estates Why a restore is a topological problem, how legitimate designs create dependency cycles, and why the credentials needed to restore usually live inside the thing being restored. devops · advanced
Jan 2, 2026 Symbol Mangling and Linkage in Cross-Language Calls Why C++ and Rust rename functions before the linker sees them, how name mangling differs between compilers, and what dlsym requires of an exported symbol. language runtimes · foundational
Jan 2, 2026 Weight Variance and Effective Sample Size in Importance Sampling Reweighting a proposal sample is exact only in the limit, and the estimator variance is governed by the second moment of the weights, which the effective sample size summarizes. scientific computing · intermediate
Jan 2, 2026 Which Boundary Counts for Non-Text Contrast and Focus Indicators How the 3:1 requirement applies to component edges, icons, and focus rings, why the measured pair is the two colors on either side of a boundary, and how state changes are evaluated separately. accessibility · foundational
Jan 1, 2026 The BGP Best-Path Order and Why Its Steps Are Ordered That Way The comparison sequence a router applies to routes for one prefix, which attributes are local to an autonomous system, and how the tiebreak steps create hot-potato routing. networking · advanced
2025
Dec 31, 2025 Airtime Fairness and Why One Slow Client Halves a Cell How per-station throughput diverges from per-station airtime, how frame duration is computed from rate and size, and what a scheduler can do about it. networking · intermediate
Dec 31, 2025 Next-Event Time Advance and the Simplicity of the Priority Queue A discrete-event simulator advances time by jumping to the next scheduled event, and the correctness of that jump rests on a heap whose ordering and tie-breaking are both specified. scientific computing · advanced
Dec 31, 2025 Recursive Descent and the Cost of One Token of Lookahead How a hand-written parser decides which production to take from a single token, how FIRST and FOLLOW sets make that decision safe, and why the method fails on left-recursive and prefix-sharing grammars. compilers · foundational
Dec 30, 2025 Completeness and Accuracy: The Two Properties Every Failure Detector Trades Against Why a detector that never mistakes a live process for a dead one must sometimes wait forever, and how the completeness and accuracy properties make that trade precise. distributed systems · foundational

2026

2025