Complete archive

Archive

3,240 articles, newest first · page 35 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
Dec 27, 2024 How a Resident Monitor Chained Jobs Without an Operator The loop that read a control card, loaded the named program, and took control back when the job ended, and why an interval timer was required to make that loop reliable. computing history · foundational
Dec 27, 2024 UDP Source Port Entropy and Underlay ECMP Why a tunnel collapses many flows onto one underlay path, how deriving the outer source port from an inner-header hash restores path diversity, and when the hash runs out of entropy. networking · intermediate
Dec 26, 2024 Contribution Agreements: Certification, License Grants, and Assignment A project can only grant what its contributors gave it, so inbound terms are chosen from three mechanisms with different costs: a signed-off certification, a broad license grant to a steward, or a transfer of copyright. computing history · intermediate
Dec 26, 2024 Filtering and Scoring: How a Scheduler Picks One Node Out of Thousands The two-phase placement cycle, why feasibility is computed per node instead of per constraint, and how scoring turns a set of legal nodes into a single binding decision. virtualization · foundational
Dec 26, 2024 Postings Lists as Sorted DocID Arrays Why an inverted index keeps document identifiers in ascending order, how that ordering turns conjunction into a merge of cursors, and what the layout costs when lists grow long. information retrieval · foundational
Dec 26, 2024 Process Corners and Why Timing Sign-off Is a Set of Scenarios How transistor speed and interconnect parasitics are bounded by slow, fast, and nominal process corners, temperature, and voltage, and why static timing analysis closes each combination separately. hardware engineering · foundational
Dec 26, 2024 Rotary Position Embeddings and Why the Score Depends Only on the Offset How rotating query and key pairs by an angle proportional to index makes attention a function of relative distance, and what the rotation periods cost when context grows. deep learning · intermediate
Dec 26, 2024 Stride-1 Backbones and Dense Prediction with Skip Connections Why segmentation decoders rebuild resolution that the encoder discarded, what a skip connection restores beyond detail, and how dilated backbones avoid the reconstruction entirely. deep learning · advanced
Dec 25, 2024 Path Sensitivity and the Cost of Remembering Branch Conditions Why merging states at a join loses the correlation between variables, how path splitting and predicate abstraction recover some of it, and where the exponential cost is cut off. developer tools · intermediate
Dec 25, 2024 Throughput, Latency, and Why Concurrency Is Not Parallelism How the relation between completion rate, response time, and in-flight work constrains every scaling decision, and why overlapping waits and splitting computation buy throughput in different ways. performance engineering · foundational
Dec 24, 2024 Issue Width and the Structural Ceiling on Instructions per Cycle How a superscalar core decides how many instructions to start per cycle, which pipeline stage usually sets the limit, and why a four-wide machine rarely retires four instructions per cycle. computer architecture · foundational
Dec 24, 2024 Read Index and Leader Leases: Serving Reads Without a Log Entry Why a committed write is not yet a readable write, how a quorum heartbeat round establishes read freshness, and what a lease assumes about clocks. distributed systems · advanced
Dec 23, 2024 Cycle Counting When the Video Circuit Steals the Bus How display refresh suspends the processor on shared-memory machines, why the stolen cycles are unevenly distributed, and how timing loops are written so the loss is measurable. computing history · intermediate
Dec 23, 2024 How Sampling Rules Decide Which Evidence Survives The telemetry left after an incident is a sample drawn by a rule chosen before the question was asked. Tail sampling, log thresholds, and retention turn the surviving data into a biased census. observability · advanced
Dec 22, 2024 Retiring a Protocol Version Without a Flag Day Why old versions persist after they are known to be weak, how deprecation is staged across senders and receivers, and what actually forces a deployment off a protocol. internet protocols · advanced
Dec 20, 2024 Getting Initialised Data and BSS Ready Before main Runs Why a C static variable occupies two addresses, how the startup copy moves initialised data from flash into RAM, and why zeroed memory has to be zeroed by software. embedded systems · foundational
Dec 20, 2024 Shard Migration Cutover and the Dual-Write Window How a partition moves between machines without losing writes, why the cutover is a state machine rather than a copy, and what has to be true before the source is retired. distributed systems · intermediate
Dec 19, 2024 Blue-Green Cutover Mechanics at the Routing Layer Where the traffic switch actually happens, why DNS record changes make poor cutover levers, and what the standby fleet must be able to carry before and after the switch. devops · foundational
Dec 19, 2024 Maximal Munch and Dynamic-Programming Tiling Two ways to choose which instruction patterns cover an expression tree, why greedy top-down matching can be arbitrarily bad, and what the optimal algorithm costs to run. compilers · foundational
Dec 18, 2024 Function Call ABI: Register Assignment on x86-64 How the System V AMD64 ABI classifies arguments into eightbyte chunks, why some structures travel in registers and others on the stack, and what the callee must preserve. systems programming · foundational
Dec 18, 2024 Space-Based Architecture and the In-Memory Data Grid Removing the shared database removes the contention and makes memory the capacity limit. Replication windows, eviction, and write-behind persistence decide how much data loss the style concedes. software architecture · advanced
Dec 17, 2024 Leak Detection by Reachability Rather Than Allocation Count How heap profilers decide that a block is leaked: root sets, conservative scanning, and why a pointer held in a register or a stale stack slot changes the answer. systems programming · intermediate
Dec 17, 2024 Local Truncation Error in the Explicit Euler Method Where the O(h^2) per-step error in forward Euler comes from, why the global error drops to O(h), and how roundoff limits the step size from below. scientific computing · foundational
Dec 17, 2024 Subresource Integrity and the Trust Chain for Third-Party Scripts How the integrity attribute verifies fetched bytes, why cross-origin scripts need CORS for the check to run, and what hash pinning does and does not protect against. web platform · advanced
Dec 16, 2024 Alerting on Absent and Stale Data Why a missing series makes an alert rule evaluate to nothing rather than to health, how staleness markers and absence functions expose the difference, and why a firing alert can silently turn into a false resolution. observability · intermediate
Dec 16, 2024 Retry Budgets and the Load Multiplication They Prevent How per-client retry counts turn a partial dependency failure into a full outage, and why a budget denominated in successful requests bounds the amplification instead. backend systems · foundational
Dec 15, 2024 Deadline Propagation and the Shared Request Time Budget Why independent per-hop timeouts cannot bound end-to-end latency, and how an absolute deadline carried in request metadata turns the budget into arithmetic. backend systems · foundational
Dec 15, 2024 Private Endpoint Services and the Reverse-Direction Connection How a service in one VPC becomes reachable from another through an address that lives in the consumer subnet, why the connection is accepted by the provider, and what the endpoint does not hide. cloud infrastructure · advanced
Dec 15, 2024 Write-Ahead Logging and Crash Recovery in Search How a search index survives a crash without losing recently added documents, by logging mutations to a sequential write-ahead log and replaying it after restart. information retrieval · advanced
Dec 14, 2024 Line Box Construction and the Inline Formatting Context How inline-level boxes are packed into line boxes, what the strut contributes to line height, and why baseline alignment produces gaps that padding cannot remove. web platform · foundational
Dec 14, 2024 Point in Polygon: Crossing Number and Winding Number Why two standard containment tests disagree on self-intersecting polygons, how each handles rays through vertices, and what the boundary rule costs. algorithms · foundational
Dec 13, 2024 Adaptive Per-Host Rate Control from Latency and Error Signals How a crawler can raise and lower its request rate per host using response latency and rejection codes, and why the control loop is asymmetric and needs damping. information retrieval · advanced
Dec 13, 2024 Feature Definitions as Versioned Artifacts Why a feature needs a name, a query, an owner, and a version, and how change control on feature definitions prevents silently retrained models. machine learning · foundational
Dec 13, 2024 Information Hiding and the Parnas Decomposition Criterion How designing each module around a decision it conceals confines the cost of change, and what an interface must expose for that concealment to survive. software architecture · foundational
Dec 13, 2024 Work Distribution, Join Barriers, and Idle Time at the End of a Stage Why splitting a stage across parallel workers shortens the mean but lengthens the tail, what a join barrier does to a request that has one slow participant, and the arithmetic of straggler cost. performance engineering · intermediate
Dec 12, 2024 Minimal SSA Construction from Dominance Frontiers How the Cytron placement algorithm decides where phi functions belong using dominance frontiers, and why placing them minimally changes what later passes can assume. compilers · foundational
Dec 12, 2024 Optional Tags and the Implied End Tag Rules the Parser Enforces Only some tags may be omitted, and only where the tree builder already closes the element. The conformance conditions behind each omission, and the cases where leaving a tag out changes the tree. web platform · foundational
Dec 12, 2024 Rare-Event Estimation with Splitting and the Cross-Entropy Shift When the event of interest has probability a million to one, plain sampling sees nothing, and the standard tools bias the proposal or multiply the paths to reach the tail in bounded steps. scientific computing · advanced
Dec 12, 2024 Trust Boundaries in Data Flow Diagrams and Where Threats Localize How a data flow diagram encodes trust as lines rather than prose, why a boundary is only real where a principal loses authority, and how moving one line changes the entire threat list. security · foundational
Dec 12, 2024 Vector Clocks and the Detection of Concurrency Why one counter per process turns the happens-before relation into a comparison, how the merge rule is defined, and the per-message size that makes the scheme expensive at scale. distributed systems · foundational
Dec 11, 2024 Structured Clone, Transferables, and the Worker Message Boundary What postMessage copies, what it moves, and where the cost lands: serialization on the sender, deserialization on the receiver, and shared memory behind isolation. web platform · advanced
Dec 10, 2024 Count-Min Sketches and the Bias of Always Rounding Up A fixed grid of counters answers frequency queries with a one-sided error bounded by the stream length, and conservative updates cut the excess without changing the guarantee. data structures · intermediate
Dec 10, 2024 Triangle Setup: Subpixel Snapping and the Bounding Box What a rasterizer computes before it touches a single pixel, how vertex coordinates are quantized to a fixed-point grid, and why the bounding box is the cheapest large win in the pipeline. computer graphics · foundational
Dec 9, 2024 Directory Entries as a Name-to-Inode Map A directory is a file whose records map names to inode numbers, with a fixed record shape, a reserved pair of names, and a deletion policy that leaves gaps behind. filesystems · foundational
Dec 9, 2024 Fake Quantization and the Straight-Through Estimator Why a rounding operation has no useful gradient, how training simulates quantization in the forward pass, and what the straight-through substitute does to the scale update. inference systems · intermediate
Dec 9, 2024 Integrity Hashes and Registry Trust What a package digest actually covers, where it is recorded, and which attacks a lockfile digest stops and which it cannot, from republishing to dependency confusion. developer tools · advanced
Dec 9, 2024 Mapping Reductions and the Halting Problem How a computable function that maps one language into another transfers undecidability, why the halting problem follows from acceptance by a reduction in the opposite direction, and where the construction breaks. computation theory · foundational
Dec 8, 2024 Reviewing Tests in the Same Diff as the Code A test written beside its implementation tends to assert what the code does rather than what it should do, and the diff is where that circularity becomes visible. software engineering · intermediate
Dec 7, 2024 Dependency Confusion and the Order Registries Are Consulted When a build resolves a private package name against a public registry, an attacker can claim the name first. The mechanism is registry precedence, not a bug. security · intermediate
Dec 7, 2024 Idempotency Keys and Duplicate Suppression at Service Boundaries How to make a retried request safe when the first attempt had an unknown outcome, where the claim record must sit relative to the side effect, and when key-based deduplication is not enough. software architecture · intermediate
Dec 7, 2024 Separating Axes and Support Functions for Convex Intersection Tests How the Minkowski difference turns two convex bodies into one, why a finite set of axes suffices for polygons, and how GJK searches the difference without building it. algorithms · advanced
Dec 7, 2024 Thread-Local Caches and the Cost of a Remote Free Why per-thread free lists remove contention from malloc, what a free on the wrong thread must do, and how ownership transfer and rebalancing keep the design from stranding memory. memory systems · intermediate
Dec 6, 2024 Permanent, Temporary, and Situational Constraints as a Single Design Axis How the same underlying limitation appears as a permanent impairment, a temporary injury, or a situational condition, and why grouping requirements by function rather than by cause avoids duplicated and conflicting solutions. accessibility · foundational
Dec 5, 2024 Link Functions, Variance Functions, and Poisson Regression with Exposure How the log link keeps fitted rates positive and turns coefficients into multiplicative effects, why the mean-variance relation is a modelling assumption, and what an offset does that a predictor cannot. machine learning · advanced
Dec 5, 2024 Threshold Secret Sharing and Why t of n Beats Two Copies Shamir sharing over a finite field, the arithmetic that makes any t shares sufficient, and the difference between hiding a key and requiring several parties to use it. cryptography · advanced
Dec 4, 2024 Drawing Service Boundaries Around Consistency Requirements How invariants determine where a service boundary can fall, what a shared database does to that boundary, and which cross-service operations need a different mechanism entirely. software architecture · foundational
Dec 4, 2024 Eta Conversion, Extensionality, and When Two Functions Are the Same What the eta rule asserts about functions that differ only in an unused argument, why it is unsound under call-by-value, and how eta-expansion survives in compilers as an arity fix. computation theory · intermediate
Dec 4, 2024 Externalised Configuration and Immutable Artifacts: Where the Boundary Sits Why the same artifact should run in every environment, which configuration must move outside it, how the binding happens at startup, and what fails when the boundary is drawn wrong. devops · intermediate
Dec 4, 2024 How a Query Cost Model Reduces I/O and CPU to One Number Why planner costs are weighted units rather than milliseconds, how sequential and random page reads enter the sum, and which effects the arithmetic deliberately ignores. databases · foundational
Dec 4, 2024 Scrolling and the Compositor Thread: Why Scroll Handlers Break Smoothness How compositor-driven scrolling works, why a non-passive wheel listener forces the main thread into the loop, and which scroll-linked effects stay off it. web platform · advanced

2024