Complete archive

Archive

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

2025
Jun 5, 2025 SACK Blocks and the Retransmission Queue How selective acknowledgement turns a cumulative ACK into a map of received ranges, why the sender keeps a scoreboard, and what the option length limit costs. networking · intermediate
Jun 4, 2025 Emulated MMIO: Instruction Decode, Register Semantics, and Exit Storms How a write to an emulated device register becomes a trap, what the hypervisor must decode before it can act, and why a driver that pokes registers in a loop degrades an entire host. virtualization · foundational
Jun 4, 2025 The Cost Tiers of a Single Allocation Request One allocation call can cost tens of cycles or tens of thousands depending on which tier it stops at: thread cache, shared free list, kernel mapping, or first write. performance engineering · foundational
Jun 3, 2025 Option Parsing Contracts and the Ambiguities of Command-Line Syntax How POSIX utility syntax constrains argument order, what changes when GNU permutation is enabled, and why optional option-arguments are a design trap. developer tools · intermediate
Jun 3, 2025 The SLI Ratio: Numerator, Denominator, and Measurement Point Why an availability target fixes nothing until the fraction behind it is defined, and how moving the counting location changes the reported number. observability · foundational
Jun 2, 2025 Anti-Entropy Repair: Merkle Trees, Read Repair, and the Cost of Finding Divergence How replicas that missed writes discover what they missed, why a Merkle tree narrows comparison to a logarithmic path, and what repair cannot fix. databases · advanced
Jun 2, 2025 Latch Coupling and Deadlock Avoidance in the Buffer Pool Why latches are not locks, how lock coupling keeps a B-tree descent deadlock-free, what a partitioned buffer pool hash table buys, and where contention concentrates. databases · advanced
Jun 1, 2025 Shared Virtual Addressing and Peer-to-Peer Transfers What changes when a device uses the process page table directly, why a PASID is needed, and what must happen before one device writes into another device's memory. computer architecture · intermediate
May
May 30, 2025 Bentley–Ottmann: Reporting All Crossings with a Sweep Line How a moving vertical line reduces segment intersection from all-pairs to neighbour checks, which events drive the sweep, and why degeneracies make the textbook algorithm hard to ship. algorithms · intermediate
May 30, 2025 Cluster Validity, Stability, and Choosing the Number of Clusters Internal indices measure geometry that a clustering may not assume, stability is not a consistent selector, and chance-corrected agreement between resampled partitions answers a narrower question than it appears to. machine learning · advanced
May 30, 2025 Secure Debug Lifecycle: Authentication, Locked Ports, and Recovery How a debug port is gated by device life-cycle state and certificates, what an open port exposes once keys are readable, and why the lock is one-way once the device ships. embedded systems · advanced
May 30, 2025 Simultaneous Multithreading and the Slots It Fills How several threads share one out-of-order pipeline, which structures must be replicated to make that useful, and why adding a second thread buys less than doubling the issue width. computer architecture · advanced
May 30, 2025 What volatile Guarantees in Memory-Mapped Register Access volatile forces a compiled access to happen, but it does not make the access atomic, ordered, or visible to the device in the order the source implies. embedded systems · foundational
May 29, 2025 Convergent State Application and Why a Run That Changes Nothing Still Costs Money How a desired-state tool decides whether a resource already matches, why that decision is a diff and never a comparison of files, and what idempotence actually guarantees. devops · foundational
May 29, 2025 Profiling JIT Code and Runtimes That Manage Their Own Memory Generated code has no ELF symbol table and moved objects confuse address attribution; profiling a managed runtime requires per-method code maps and object-aware heap analysis. performance engineering · advanced
May 29, 2025 Skip Lists: Express Lanes over a Sorted Chain Layered forward pointers turn a linear scan into an expected O(log n) search, and the geometric level distribution is what makes the expected bound hold without rebalancing. data structures · advanced
May 29, 2025 Tensor-Parallel Residency and Interconnect Pressure Sharding a model across devices splits weights and key-value heads, but every decode step becomes a collective; how that changes the memory and latency balance. inference systems · advanced
May 28, 2025 Staged Rollout Cohorts and What Halt Actually Does How a percentage rollout maps devices to cohorts, why halting stops new adoption but not installed copies, and what the store can and cannot undo after a release is live. mobile computing · intermediate
May 27, 2025 Bracket Abstraction: Compiling Lambda Terms into Combinators How the lambda-free basis S and K can express every abstraction, the translation that removes binders one at a time, and why the naive translation explodes in size. computation theory · advanced
May 27, 2025 Copysets and the Tail of Random Placement Why uniformly random replica placement produces objects whose copies share a failure set, how many nodes one rack loss can take with it, and what bounded placement changes. filesystems · advanced
May 27, 2025 Dependencies, RCsc, and RCpc Acquire on ARMv8 How address and data dependencies order accesses without a barrier, and why ARMv8.3 added a second, cheaper form of acquire load alongside the original one. memory systems · advanced
May 27, 2025 Packrat Parsing and the Linear-Time Guarantee How memoising PEG results buys guaranteed linear parse time, what the memo table costs in memory, and why ordered choice removes ambiguity by fiat rather than by analysis. compilers · intermediate
May 26, 2025 Delegations, Callback Channels, and Recall A server can hand a client authority over a file so the client stops asking, but it must be able to take that authority back. The mechanism is a lease with a reverse direction, and its hard part is the recall path. filesystems · intermediate
May 26, 2025 Health Signals for Gating a Progressive Rollout Why readiness probes cannot decide whether a new version is good, which signals can, and how probe timing and baseline choice set the number of bad requests before an abort. devops · intermediate
May 26, 2025 One-Hot Encoding as Geometry and the Dummy Variable Trap Why one-hot columns span a subspace whose dimensions are the category count minus one, what collinearity the redundant column introduces, and when the penalty makes it harmless. machine learning · foundational
May 26, 2025 Placeholders as a Fallback Name and Why They Fail How the placeholder attribute enters the accessible name computation, why it ranks last, and the concrete failures that follow from using it as a label. accessibility · intermediate
May 26, 2025 The Cutover Boundary of a Workload and Why It Is Never One Process How to decide which processes, data stores, and identities must move as one unit, what breaks when a boundary is drawn too small, and the cost of drawing it too large. cloud infrastructure · foundational
May 26, 2025 Why Compatible Standards Still Fail to Interoperate The layers above the encoding where two conforming products diverge: version negotiation, timeouts, error handling and the assumptions each side makes about the other. computing history · advanced
May 25, 2025 Match-Action Pipelines and Flow Caching in Software Switches How a packet is classified by a sequence of table lookups, why the first packet of every flow takes a slow path, and how a wildcard cache shortens the common case without breaking correctness. networking · advanced
May 25, 2025 seccomp-BPF and the Filtering of System Calls How a BPF program attached to a process inspects syscall numbers and arguments before dispatch, why argument filtering cannot dereference pointers, and what the return actions cost. operating systems · advanced
May 24, 2025 Layout Assignment and the Elimination of Transposes A tensor has one logical shape and many physical orders; choosing one per value turns transpose chains into bookkeeping and decides which kernels can read their inputs directly. inference systems · intermediate
May 24, 2025 The Dual-Write Problem and the Transactional Outbox Why committing to a database and publishing to a broker cannot both be atomic, which failure windows open between them, and how an outbox table turns the problem into a delivery guarantee consumers must absorb. software architecture · intermediate
May 23, 2025 Attack Tree Semantics: AND/OR Nodes and the Cost of the Cheapest Path How attack trees represent alternative and conjunctive attacker actions, how cost and probability propagate through the two node types, and why the cheapest path is rarely the most likely one. security · intermediate
May 23, 2025 B-Tree Node Occupancy, Splits, and the Minimum Degree Why a B-tree fixes node size rather than height, how a split propagates to the root, and what the minimum degree buys in depth versus split frequency. data structures · intermediate
May 23, 2025 Constraints Down, Sizes Up: Why Layout Is a Single Pass The layout protocol that passes size limits to children and returns chosen sizes to parents, why one pass suffices, and where intrinsic measurement forces a second. mobile computing · foundational
May 23, 2025 Score Normalization and Rank Fusion Across Retrievers Why scores from different retrievers cannot be compared, how score distributions are normalized, and what reciprocal rank fusion gives up to avoid the problem. information retrieval · foundational
May 23, 2025 SONAME, DT_NEEDED, and Symbol Versioning in Shared Libraries How a shared object records the name it wants to be found under, why DT_NEEDED names a soname rather than a file, and how version definitions keep old binaries working. compilers · intermediate
May 22, 2025 Dynamic Address Translation and the 16 MB Line How a two-level segment and page table turns a 24-bit virtual address into a real one, why the page tables themselves had to live in real storage, and what the 16 MB ceiling forced. computing history · advanced
May 21, 2025 Many-One Reductions and What Completeness Requires The mechanics of Karp reductions, why hardness and completeness are different properties, and the closure conditions a class must satisfy for a complete problem to exist. computation theory · foundational
May 21, 2025 Priority Inversion and How Bounded It Can Be Why a low-priority task holding a shared lock delays a high-priority one, how inheritance and ceiling protocols change the blocking term, and what each still leaves unbounded. embedded systems · foundational
May 21, 2025 Readiness and Completion: Two Ways to Ask the Kernel for I/O Readiness notification tells a program when an operation can start; completion notification tells it when one has finished. The difference decides how many syscalls a runtime makes and where its buffers live. language runtimes · intermediate
May 21, 2025 Sequential Consistency as the Reference Memory Model Lamport's two conditions, the executions they exclude, and why every weaker model is described by which of those exclusions it gives up. memory systems · foundational
May 20, 2025 Block Groups and the Cost of Metadata Locality Why a filesystem carves itself into groups with their own bitmaps and inode tables, what the descriptor table records, and how allocation policy turns locality into seek distance. filesystems · foundational
May 20, 2025 How a Probe Reads Memory Without the CPU: Debug Ports and Access Ports The transaction sequence a debug probe uses over SWD or JTAG to halt a core and touch memory, and why some reads return stale data even though the transfer succeeded. embedded systems · intermediate
May 20, 2025 Offline Navigation, App Shell, and Fallback Routing Why navigation requests need their own handling in a service worker, the trade between shell-based and per-URL caching, and how navigation preload removes the worker-startup delay from the critical path. web platform · intermediate
May 19, 2025 Rasterization Rules: Pixel Centers and the Top-Left Fill Convention Why a triangle becomes a set of fragments at sample points rather than pixel areas, and how the top-left rule keeps shared edges from being drawn twice or not at all. gpu computing · foundational
May 19, 2025 Recovering the GCM Authentication Key from a Repeated Nonce Two messages encrypted under the same GCM nonce turn the tag difference into a polynomial in the hash subkey, whose roots yield the key and permit arbitrary forgery. cryptography · intermediate
May 18, 2025 Bounded Queues and Backpressure as Throughput Control Why an unbounded queue converts overload into latency and then into collapse, how a bound pushes the refusal upstream, and which drop policy makes refusal cheap. performance engineering · intermediate
May 17, 2025 Aliasing, Tournament Predictors, and Per-Branch Selection When two predictor tables disagree, a choice predictor decides which to believe; the mechanics of tagged entries, confidence counters, and the cost of mispredicting the chooser itself. computer architecture · advanced
May 17, 2025 Discovery and Finish Times: What DFS Edge Classification Encodes How the two timestamps recorded by depth-first search partition a directed graph into tree, back, forward, and cross edges, and why undirected graphs admit only two of those classes. algorithms · foundational
May 17, 2025 Measuring What a Component Costs by Taking It Away Ablation measures a component by disabling it and observing the change in a metric, which answers a different question than profiling and is easy to apply incorrectly. performance engineering · intermediate
May 16, 2025 Declaring Long-Running Tasks Without Being Killed How an app asks for continued execution after it leaves the screen, what each declaration actually grants, and why the grant is audited rather than trusted. mobile computing · intermediate
May 15, 2025 Cooperative Cancellation and the Cancel-Safety Contract Why asynchronous cancellation needs an explicit protocol, what cancel safety means for an operation interrupted at an await point, and where the guarantee is impossible to provide. programming languages · intermediate
May 15, 2025 Grid-Wide Barriers and Persistent Work Queues How a barrier that spans every block is built from atomics and counters, what residency it requires, and how a persistent grid replaces the launch queue with a device-side one. gpu computing · advanced
May 15, 2025 How a Format String Becomes an Arbitrary Write The %n conversion stores a count through a pointer the caller supplies on the stack, and variadic argument handling makes that pointer reachable from the format itself. security · intermediate
May 14, 2025 Error Tolerance and Recovery as a Layout Requirement Why reversible actions, confirmations that name their consequence, and recovery paths must be designed as structure rather than added as dialogs, and how undo stacks and draft persistence change the cost of a mistake. accessibility · intermediate
May 14, 2025 Key Size Equivalence Across RSA, Diffie-Hellman, and Curves Why 2048-bit RSA, 2048-bit finite-field Diffie-Hellman, and 256-bit elliptic curves are treated as comparable, and where the equivalence table comes from. cryptography · intermediate
May 14, 2025 Linear Sketches and Recovering Sparse Signals from Bucket Measurements How a sketch that only stores bucket sums can still return the identities of heavy items, why recovery needs a median over rows, and what the restricted isometry property guarantees. algorithms · advanced
May 13, 2025 Batch Size, Occupancy, and the Marginal Cost of a Token How the cost of one more concurrent request falls as the batch grows, where it stops falling, and why the knee of that curve sets the price floor. inference systems · foundational
May 13, 2025 Cold Start Phases and Where Launch Time Is Spent The stages an app passes through between a tap and its first frame, which stages scale with code size, and why the reported launch time depends on where the clock starts. mobile computing · foundational

2025

May