Complete archive
Archive
3,240 articles, newest first · page 54 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.
-
2022
Apr 12, 2022 Softmax Cross-Entropy and Its Collapsed Gradient Why the gradient of the cross-entropy loss with respect to logits reduces to the prediction minus the target, what that saves computationally, and how to keep the exponentials from overflowing. deep learning · intermediate - Apr 9, 2022 The Virtio Split Ring: Descriptor Tables, Available Rings, and the Notification Suppression How a guest and a hypervisor exchange buffers without a trap per request, what the three-ring layout enforces, and why the notification flags matter more than the data path. virtualization · intermediate
- Apr 7, 2022 Reproducibility, Replicability, and the Boundaries Between Them The distinct claims implied by re-running an analysis, rebuilding it from raw data on new instruments, and getting the same conclusion from an independent study, and which evidence each one requires. scientific computing · foundational
- Apr 6, 2022 Sector Counting and Why Cache Hit Rate Misleads How memory transactions are accounted in sectors, why a high hit rate can coexist with poor performance, and how to read the traffic counters that separate the two. gpu computing · intermediate
- Apr 1, 2022 Standard I/O, Terminal Allocation and Exit Status Propagation How a runtime wires stdin, stdout and stderr for a container process, when a pseudo-terminal is allocated, and how the exit status travels back to the caller. virtualization · intermediate
-
March
Mar 30, 2022 Known-Good-Die and the Trust Problem in Multi-Die Assembly Why assembling individually working dies does not produce a working module, what a stack test standard can and cannot verify, and what must move on-die to make multi-die packages economical. hardware engineering · advanced - Mar 27, 2022 HTML Parsing Contexts and Why One Escape Function Is Never Enough How the HTML tokenizer switches states by context, what each state treats as dangerous, and why encoding rules must be chosen per insertion point rather than per application. security · foundational
- Mar 23, 2022 Mount Namespaces and the Propagation of Mount Events How each process gets its own mount table, why a mount made in one namespace can appear in another, and what the shared, slave, private and unbindable propagation flags actually control. operating systems · foundational
- Mar 21, 2022 What an Inode Stores, and Why It Stores No Name The inode is the object a filesystem calls a file: its fields, what it deliberately omits, how stat exposes it, and why a full inode table can refuse a write on a filesystem with free space. filesystems · foundational
- Mar 20, 2022 Push and Pull Collection Models and Who Owns the Sample Clock Why a scrape loop and a push agent produce different failure signals, how staleness replaces absence detection, and where each model breaks down at scale. observability · foundational
- Mar 19, 2022 Plan and Apply Across a Fleet: Partial Convergence and the Limits of Ordering Why a fleet-wide apply cannot be ordered like a single host, what the plan file captures and where it is stale, and how batches expose half-migrated intermediate states. devops · advanced
- Mar 18, 2022 Happens-Before and the Definition of a Data Race How sequenced-before and synchronizes-with compose into a partial order, why a race is a pair of unordered conflicting accesses, and what the standard does once one exists. memory systems · foundational
- Mar 15, 2022 Heartbeats, Leases, and the Timeout That Declares a Node Dead Why node liveness is a leased lease with a bounded renewal, how the kubelet's lease write differs from its status report, and what a false positive costs when the network partitions. virtualization · intermediate
- Mar 11, 2022 Cue Timing in Captions and the Problem of Describing What Is Not Said How WebVTT cues are placed in time and space, what reading-rate limits imply about line length, and why audio description has to fit into gaps that the mix does not leave. accessibility · advanced
- Mar 10, 2022 What a Pipe Holds: Kernel Buffering, Atomic Writes, and SIGPIPE The pipe as a bounded in-kernel queue, why writes below PIPE_BUF never interleave, and how a closed read end turns into a signal rather than an error. developer tools · foundational
- Mar 9, 2022 Null Representation: Validity Bitmaps Against Sentinel Values How a columnar format records the absence of a value, why a separate bitmap costs one bit per value, and when an in-band sentinel breaks the type system. data engineering · foundational
- Mar 4, 2022 Two-Address Instructions and Destructive Operands Why many instruction sets overwrite an input register to produce a result, how that constraint turns selection into a copy-insertion problem, and what the copies cost. compilers · intermediate
-
February
Feb 28, 2022 Independent Deployability and Cross-Service Contracts What must be true for two services to be released on separate schedules, how wire formats absorb change, and why a passing contract test does not prove compatibility. software architecture · advanced - Feb 24, 2022 Christofides: Matching the Odd Vertices to Reach 3/2 Why doubling a minimum spanning tree gives a factor of 2, how a minimum-weight matching on the odd-degree vertices recovers the remaining half, and where the metric assumption is spent. algorithms · advanced
- Feb 23, 2022 Poison, Undef, and What an IR Must Say About Speculation How deferred undefined behaviour lets an IR move and duplicate operations that might trap, why poison propagates through flags like nsw, and what a freeze instruction buys in exchange for lost optimisation. compilers · advanced
- Feb 21, 2022 Exact Area Coverage and the A-Buffer Computing a pixel's covered fraction analytically instead of sampling it, the data structure that keeps fragment lists per pixel, and the memory cost that keeps the approach off most GPUs. computer graphics · intermediate
- Feb 19, 2022 In-Kernel Aggregation: Counting Stacks in a Hash Map Instead of Shipping Them How a kernel-side profiler folds samples into a map before userspace sees them, why that removes the ring buffer from the hot path, and where the map's limits bite. observability · advanced
- Feb 18, 2022 Sea of Nodes: Scheduling Without a Fixed Instruction Order How a graph-based IR represents data, control, and memory dependences as edges with no block order, what scheduling then becomes, and which analyses become harder when nothing is sequential. compilers · advanced
- Feb 16, 2022 From Postmortem to Alert Change: Closing the Detection Loop How a reconstructed timeline becomes a specific detection gap, how action items are classified so they change alerts and runbooks, and how to prove the change took effect. devops · advanced
- Feb 15, 2022 Node Distance and the Real Cost of a Remote Memory Access How a cache-coherent link turns an ordinary load into a transaction between two sockets, why distance values are ranks rather than nanoseconds, and which resource a remote access actually consumes. memory systems · foundational
- Feb 11, 2022 Return Address Stacks and the Prediction of Indirect Branches Why returns and indirect jumps cannot be predicted from address history alone, how a call stack mirror in the fetch unit handles returns, and what indirect predictors store instead. computer architecture · intermediate
- Feb 9, 2022 Content-Addressed Artifact Identity and the Cost of Mutable Tags Why a digest derived from bytes is the only stable name for a build output, how Merkle chunking makes large artifacts hashable, and what a mutable tag hides between resolution and pull. devops · foundational
- Feb 7, 2022 Post-Cutover Reconciliation and Drift Detection How to prove that a destination holds the same state as its source after the switch, why checksums over large tables lie, and how to detect divergence that appears later. cloud infrastructure · advanced
-
January
Jan 30, 2022 Matching Paths in robots.txt: Longest Rule, Not First Rule How a robots.txt file is split into groups, why the winning rule is chosen by octet count rather than by order, and what the protocol requires when the file cannot be fetched. information retrieval · foundational - Jan 25, 2022 Saved Plans, State Serial, and Why Apply Must Be Pinned A saved plan is a reviewable artifact tied to one state snapshot. What it records, why apply rejects a stale one, and where the guarantee stops. devops · intermediate
- Jan 23, 2022 How Cookie Attributes Bound a Session Credential What the Domain, Path, Secure, HttpOnly, and SameSite attributes actually constrain, which of them are enforced by the browser versus the server, and where the scope model leaks. security · foundational
- Jan 23, 2022 Which Defects a Diff Reader Can Actually Detect Local defects that live inside the changed lines are findable by reading, while invariant violations, races, and resource-lifecycle bugs mostly are not, and the difference sets the ceiling on review. software engineering · intermediate
- Jan 13, 2022 Dropout Masks, Train-Time Scaling, and Inference Behaviour What the Bernoulli mask does to the expectation of an activation, why one convention scales during training instead of at test time, and how the mask changes what reaches the layers below. deep learning · intermediate
- Jan 9, 2022 RSA Key Generation and the Prime Search Generating two large primes, testing them for primality, deriving the private exponent, and why the resulting key has structure that must be checked rather than assumed. cryptography · foundational
- Jan 6, 2022 Erasure and Reification of Generic Types Why Java cannot ask whether a list holds strings, how erasure turns generics into casts, and what monomorphization and reification cost instead. programming languages · intermediate
- Jan 5, 2022 LZ77, LZ78, and the Shift from Symbols to Substrings How dictionary coders replace repeated substrings with back-references, why their output is not bounded by the source entropy, and how the parser design determines the compression actually obtained. computation theory · intermediate
- Jan 3, 2022 Alternation and the Structure of the Polynomial Hierarchy How stacking existential and universal quantifiers over polynomial-length certificates produces a hierarchy of classes, why it collapses if any two levels coincide, and what complete problems look like at each level. computation theory · advanced
-
2021
Dec 31, 2021 Stratified Pixel Sampling and the Aliasing of Regular Grids Why a fixed sample grid folds high-frequency geometry into moire patterns, how stratification bounds the per-stratum count, and what the resulting error actually scales as. computer graphics · intermediate - Dec 26, 2021 Co-Partitioned Datasets and Shuffle-Free Joins How persisting a hash or range partitioning in the table layout lets later joins read bucket against bucket, and the metadata mismatches that silently undo it. data engineering · advanced
- Dec 24, 2021 FIR Design by Windowing and the Gibbs Ripple Why truncating an ideal impulse response produces passband ripple, how window shape trades transition width against stopband rejection, and what the design formulas predict. scientific computing · intermediate
- Dec 22, 2021 How a Compiler Driver Dispatches Work to Preprocessor, Compiler, Assembler, and Linker The program named cc compiles nothing itself. It parses one command line, routes each option to the stage that understands it, and chains four subprocesses through temporary files. compilers · foundational
- Dec 17, 2021 Why Tone Mapping Shifts Hue, and the Two Fixes That Keep Colour Stable The nonlinear RGB curve that pushes highlights toward the last-saturating primary, why luminance-only compression avoids it, and what each approach costs. computer graphics · advanced
- Dec 16, 2021 Dynamic Import, Module Maps, and Top-Level Await What import() actually schedules, how the module map keys records by URL, and why top-level await turns a synchronous graph into an asynchronous one. web platform · intermediate
- Dec 15, 2021 Sequence Numbers and the Sliding Window Arithmetic How a 32-bit byte counter replaces per-byte bookkeeping, why the window variables are indices into a modular sequence space, and where the arithmetic breaks. networking · foundational
- Dec 13, 2021 Trial Boot, Confirmation, and Automatic Rollback How a new image is allowed to run under supervision, what counts as proof that it works, and why the confirmation step has to come from the application rather than the bootloader. embedded systems · intermediate
- Dec 12, 2021 Free Monads and Defunctionalized Interpreters How a free monad turns a program into a syntax tree of requests, why the interpreter is a fold, and where the left-nested bind makes that tree quadratic. programming languages · advanced
- Dec 8, 2021 Live Ranges as the Input to Register Allocation How backward liveness analysis turns a control-flow graph into the per-value program points that every allocator reasons over, and where that abstraction stops being exact. compilers · foundational
- Dec 7, 2021 Answer Normalization and the Fragility of Exact Match Exact-match scoring turns a string comparison into a quality verdict. The normalization pipeline in front of the comparison decides how much of the score is measurement. inference systems · intermediate
- Dec 6, 2021 Fairness and Tail Latency in Task Schedulers Average latency hides the requests that wait behind a queue. How scheduler policy, queue discipline, and batching each move the tail, and why a fair scheduler can still produce an unfair system. language runtimes · advanced
- Dec 5, 2021 Utility Trees, Sensitivity Points, and Tradeoff Points How a ranked tree of scenarios drives a structured walkthrough of a design, and how the decisions that move two quality attributes at once are separated from the ones that move only one. software architecture · intermediate
-
November
Nov 30, 2021 Heat Pipes and Vapor Chambers: Moving Heat by Phase Change How a sealed wick structure transports heat with a temperature drop far smaller than copper conduction, and which of the four transport limits binds first in a processor cooler. hardware engineering · intermediate - Nov 27, 2021 Dependency Objectives: Propagating Budgets Across a Call Graph How a caller composes its own objective from the objectives of services it depends on, and why consistent fan-out makes end-to-end targets arithmetically impossible. observability · advanced
- Nov 26, 2021 Disjunction-Max Combination for Multi-Field Scoring Why scoring each field separately and summing produces runaway scores, and how max-plus-tiebreaker combination keeps field evidence bounded. information retrieval · foundational
- Nov 25, 2021 The Origin Private File System and Synchronous Access Handles How OPFS exposes a private per-origin directory tree, what an exclusive sync access handle offers a worker, and where byte-addressable storage beats record stores. web platform · advanced
- Nov 22, 2021 Span Anatomy: Trace IDs, Span IDs, and Parent Links How a trace is assembled from spans, why two identifiers with different scopes are needed, and what a span record must carry for the tree to be reconstructible offline. observability · foundational
- Nov 14, 2021 Resolving Identifier Uses Against a Stack of Lexical Scopes How a semantic pass turns each identifier token into a reference to exactly one declaration, what the scope stack must record, and where a single pass over the tree is not enough. compilers · foundational
- Nov 11, 2021 DNS Message Format and Name Compression on the Wire How the twelve-byte header, length-prefixed labels, and 0xC0 compression pointers carry a query and its answer, and which encodings a parser must reject. internet protocols · foundational
- Nov 7, 2021 Debounce, Dwell, and Key-Repeat Filtering How assistive input systems distinguish a deliberate activation from switch bounce, tremor, and held keys, and how dwell and repeat timing are computed. accessibility · advanced
- Nov 4, 2021 IO-Aware Attention: Tiling the Score Matrix Without Materializing It Why the intermediate attention tensors cost more than the arithmetic, how blockwise softmax stays exact, and what the online rescaling step has to preserve. deep learning · intermediate
-
October
Oct 25, 2021 How Diff Produces Hunks: Myers, Patience, and Hunk Sliding The shortest-edit-script problem behind line diffs, why the minimal answer often reads badly, and how hunk boundaries get moved after the fact. developer tools · intermediate