Complete archive
Archive
3,240 articles, newest first · page 5 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
Aug 21, 2026 Compute-Optimal Allocation Between Attention and Feed-Forward Width How parameter and flop budgets split between attention and MLP blocks, why the split shifts with sequence length, and which allocations survive a change in context size. deep learning · advanced - Aug 21, 2026 Profile-Guided Optimization and Hot-Cold Code Splitting Profile data turns optimization decisions from static guesses into frequency estimates, and splitting cold paths out of hot functions is what converts that knowledge into layout, register, and inlining wins. compilers · advanced
- Aug 21, 2026 Reading a Process Footprint: RSS, PSS, and Shared Pages Why resident set size double-counts shared pages, how proportional set size divides them between users, and which memory a process consumes that no per-process counter attributes to it. memory systems · foundational
- Aug 21, 2026 Rollback as a Question of Write Reversibility Why reverting traffic is easy and reverting state is not, how dual-write and tombstones change the rollback budget, and when a cutover becomes one-way. cloud infrastructure · intermediate
- Aug 21, 2026 Scheduling Batch Training Against Shared Accelerator Capacity Gang scheduling, quota partitioning, and preemption for training jobs: why a GPU job is not a long-running process, and what fair sharing costs. machine learning · advanced
- Aug 21, 2026 Similarity Metrics and the Normalisation They Require Why cosine, inner product, and Euclidean distance rank differently, what L2 normalisation changes about a vector index, and which failures come from mixing conventions. inference systems · intermediate
- Aug 20, 2026 Adaptive Step Size Control with Embedded Runge-Kutta Pairs How an embedded pair produces an error estimate from the same stages, why the controller takes the square root of the tolerance ratio, and how rejected steps and saturation are handled. scientific computing · intermediate
- Aug 20, 2026 Attribute Caching and Close-to-Open Consistency Every stat over the network is a round trip, so clients cache attributes with short leases and validate them on reuse. The guarantee that emerges is not POSIX coherence but a weaker promise tied to open and close. filesystems · foundational
- Aug 20, 2026 Deletes, Tombstones, and the Append-Only Sink Object storage cannot delete a row in place, so removal becomes a recorded fact with a retention period, and every reader must agree on how to apply it. data engineering · advanced
- Aug 20, 2026 Ephemeral Diffie-Hellman and What Forward Secrecy Actually Buys Why a fresh exponent per handshake protects past sessions after a key compromise, what the extra exponentiations cost, and how identity binding prevents the exchange from being hijacked. cryptography · intermediate
- Aug 20, 2026 Key Schedules: Why Subkeys Cannot Be Independent The key expansion that derives a round key from a short master key, the nonlinearity it must add, and the related-key and slide attacks that punish weak expansion. cryptography · foundational
- Aug 20, 2026 Reconstructing an Incident From Partial Evidence A timeline assembled from logs, traces, metrics, and control-plane records is a model with assumptions. Separating what was observed from what the model implies is what keeps the reconstruction honest. observability · advanced
- Aug 20, 2026 Role Assumption and the Shape of a Temporary Session How a caller exchanges long-lived identity for short-lived credentials, what the issued token actually carries, and why revocation is harder than expiry. cloud infrastructure · foundational
- Aug 20, 2026 Time-Slicing and What a GPU Context Switch Costs Preemption on a GPU is not one operation but several, each at a different granularity, and the cost of switching decides whether oversubscription is worth it. gpu computing · intermediate
- Aug 19, 2026 Bidirectional Type Checking and Where Annotations Flow Why checking a term against a known type is easier than inferring one, how the two judgments hand off to each other, and where the annotation burden returns. programming languages · intermediate
- Aug 19, 2026 Modular Exponentiation and the Cost of One Key Operation How square-and-multiply collapses a huge exponent into a few thousand multiplications, why private exponents cost far more than public ones, and where constant-time code changes the algorithm. cryptography · foundational
- Aug 19, 2026 Node Identity and Structural Mutation in the DOM Tree A DOM node is an object with one parent slot, and every insertion is a removal followed by an attach, with range adjustment, observer records, and adoption steps folded into that single call. web platform · foundational
- Aug 19, 2026 Right-to-Left Scanning and the Boyer-Moore Shift Tables How comparing the pattern from its end lets a matcher skip whole alignments, what the bad-character and good-suffix tables each guarantee, and where the two rules disagree about the shift. algorithms · foundational
- Aug 19, 2026 Robust Mesh Booleans and the Exact-Arithmetic Escape Union and difference on triangle meshes fail on coplanar faces and edge-on-edge contacts, and the standard answer is to compute the intersections exactly, then round once. computer graphics · advanced
- Aug 19, 2026 What a Distance Function Decides About Cluster Shape Squared Euclidean, cosine, Mahalanobis, and set distances each impose a different notion of similarity, and the choice fixes which clusters are available before any algorithm runs. machine learning · foundational
- Aug 19, 2026 Why t-SNE Preserves Neighborhoods but Distorts Distances The embedding minimizes one asymmetric divergence between two similarity distributions, so it pulls true neighbours together while almost ignoring far pairs, which makes cluster sizes and inter-cluster gaps artefacts of the optimization. machine learning · advanced
- Aug 18, 2026 Canonical Forms, Minterms, and the Cost of Two-Level Logic How any Boolean function is written as a sum of minterms or product of maxterms, and why literal count is the currency that minimization tries to spend. hardware engineering · foundational
- Aug 18, 2026 Earliest-Deadline-First and What Happens When the System Overloads Why dynamic deadline ordering is optimal on one processor, how the utilisation test differs from the fixed-priority one, and how the schedule degrades after a bounded overload. embedded systems · intermediate
- Aug 18, 2026 Fixed-Slice Partitioning of Shared Engines Inside One Device Splitting a GPU into isolated instances without separate PCI functions requires slicing the caches and memory controllers, and the slices that cannot be cut set the floor on granularity. gpu computing · intermediate
- Aug 18, 2026 URL Normalization as a Set-Equality Problem Which transformations are safe when deciding two URLs identify the same resource, why scheme and host case rules differ from path rules, and how over-normalization merges distinct pages. information retrieval · intermediate
- Aug 18, 2026 What a Version Range Selects: The Interval Algebra Behind Caret and Tilde How comparators, disjunction, and prerelease exclusion turn a version constraint into a concrete set of versions, and where the range language stops describing compatibility at all. software engineering · foundational
- Aug 17, 2026 Data Augmentation as an Invariance Specification Augmentations declare which transformations should not change a representation; the choice fixes what the embedding can ignore, and a mismatched set teaches the model to discard signal it needs later. deep learning · intermediate
- Aug 17, 2026 Encoder-Decoder Sequence Models and the Teacher Forcing Assumption How a pair of recurrent networks maps a sequence to a differently sized sequence, what the fixed-size conditioning vector costs, and why training with gold prefixes diverges from inference. deep learning · intermediate
- Aug 17, 2026 Raster State Validation and Why Draw Order Is the Only Ordering Primitive How per-draw state forms an opaque pipeline object, why changing render targets mid-command-buffer forces a flush of binned work, and why the API exposes almost no way to sequence fragments directly. gpu computing · advanced
- Aug 17, 2026 Roving tabindex and aria-activedescendant as Competing Models Two ways to keep one tab stop inside a composite widget: moving real DOM focus between items, or holding focus on a container and pointing at an item. Their costs differ in event routing, virtualisation, and IME handling. accessibility · intermediate
- Aug 16, 2026 Closure Gaps in Context-Free Languages Context-free languages are closed under union and star but not under intersection or complement, and the two failures are the same failure seen from two sides. computation theory · intermediate
- Aug 16, 2026 Stream Ordering: What a Queue Guarantees and What It Does Not The ordering contract of a command stream, how host-side submission stays asynchronous, and why two streams give no ordering at all without an explicit dependency. gpu computing · foundational
- Aug 15, 2026 Derive Macros and Structural Recursion Over Type Definitions How a derive macro walks a struct or enum field by field to generate implementations, what generic parameters and lifetimes force on the generated code, and why bound inference goes wrong. programming languages · intermediate
- Aug 15, 2026 Wall-Clock Timestamps Do Not Order Distributed Events Why two machines reading the same instant produce different numbers, how far the disagreement grows between synchronizations, and what an interval-bounded timestamp can still support. distributed systems · foundational
- Aug 14, 2026 Delete Files and the Cost of Merge-on-Read How a row-level delete is expressed without rewriting a data file, what a reader must do to apply it, and why position-based deletes are cheaper than equality-based ones. data engineering · intermediate
- Aug 14, 2026 Metastable Failure and the Load That Keeps a System Down Why some outages persist after the trigger is gone, how retries and cold caches hold a system in a low-capacity state, and what it takes to break the loop. backend systems · advanced
- Aug 14, 2026 Verifying a Backfill with Range Checksums Instead of Full Comparison How partitioning a dataset into key ranges and comparing per-range digests localises a skipped or double-written record, and why the digest must be order-independent. distributed systems · intermediate
- Aug 13, 2026 Buffer Pool Frames, Pin Counts, and Replacement Under Pin Pressure How a page identifier is mapped to a frame of memory, why a pin is not a lock, what happens when every candidate for eviction is pinned, and how clock sweeps approximate LRU. databases · foundational
- Aug 13, 2026 Bump Allocation and the Cost of Arena Reset Why a pointer-increment allocator can serve thousands of requests in a few cycles, what alignment bookkeeping it still needs, and the ownership rule that makes wholesale reset safe. memory systems · foundational
- Aug 13, 2026 NAPI and Interrupt Mitigation How a network driver switches from one interrupt per packet to a budgeted poll, what the weight and time limits protect, and where the scheme loses packets. operating systems · advanced
- Aug 13, 2026 Wrapping a Native SDK Behind a Shared Interface Third-party SDKs ship as binaries with their own threading, error, and lifecycle models. A plugin boundary has to normalise all three, and the normalisation is where most integration defects originate. mobile computing · advanced
- Aug 12, 2026 Catamorphisms and Anamorphisms over Recursive Functors How a recursive datatype becomes the least fixed point of a functor, why its fold is unique, and what an unfold adds that a fold cannot express. programming languages · intermediate
- Aug 12, 2026 Round-to-Nearest-Even and the Mechanics of Correct Rounding How an adder decides where to cut a result, what guard, round, and sticky bits encode, and why the tie case resolves toward an even last bit. scientific computing · foundational
- Aug 12, 2026 Verifying Crash Consistency with Fault Injection Why a crash-consistency claim needs an exhaustive state-space argument rather than a test, how to model a device that loses writes and reorders them, and which failures the method cannot find. memory systems · advanced
- Aug 11, 2026 Demand Paging and the First-Touch Fault What happens between mmap returning and a page becoming resident, the three fault outcomes a handler must distinguish, and why anonymous memory is zeroed lazily. memory systems · intermediate
- Aug 11, 2026 Priority Classes and Tenant Fairness in Shared Job Queues Why a single ordered queue lets one tenant or one class consume the whole worker pool, how weighted dispatch and per-tenant caps differ, and what to measure when fairness is the goal. backend systems · intermediate
- Aug 10, 2026 DWARF Line Tables and How an Address Becomes a Source Line The line-number program is a bytecode that reconstructs a table of address ranges to file, line, and column, and its sequence structure explains why lookups are not simple binary searches. systems programming · intermediate
- Aug 10, 2026 Query and Filter Caches in a Search Engine Which parts of a query can be cached without corrupting results, how a filter cache keys on the filter itself rather than the query, and why invalidation is the hard part. information retrieval · intermediate
- Aug 10, 2026 Retention Policy as a Storage Budget How per-stream retention windows turn into bytes on disk, why compression and index size dominate the estimate, and where deletion actually costs money. observability · intermediate
- Aug 8, 2026 Iteration-Level Batching: Reforming the Batch at Every Token How a serving loop rebuilds its batch before every forward pass, why request-level batching wastes half the machine, and which budget actually limits concurrency. inference systems · foundational
- Aug 8, 2026 Modeling Validity Over Time and Retroactive Correction Separating the time a fact was true from the time the system learned it, and the interval and constraint mechanics that keep an as-of query honest. software architecture · advanced
- Aug 7, 2026 Anatomy of a VM Exit: State Save, Exit Qualification, and Where the Cycles Go What the processor writes to the VMCS on every exit, which exit reasons dominate a running guest, and why the host-side handler usually costs more than the transition itself. virtualization · foundational
- Aug 7, 2026 NCP and the Limits That Forced TCP/IP How the ARPANET host-to-host protocol split messages into connections, why its addressing and flow control could not span multiple networks, and what TCP added to replace it. computing history · foundational
- Aug 7, 2026 Process States and the Transitions the Kernel Actually Tracks Why the kernel keeps a bitmask rather than a state enum, how runnable differs from running, and what the letter printed by ps leaves out. operating systems · foundational
- Aug 6, 2026 Abstract Machines: The CEK, the Krivine Machine, and Closure Conversion How an evaluator becomes an explicit state machine with a control string, an environment, and a continuation, and what each of the three registers costs. computation theory · advanced
- Aug 6, 2026 Congestion Control and Pacing in a Transport That Owns the Socket How a QUIC sender turns acknowledgements into a window, why the window must be spread into a packet schedule, and what changes when the controller is not in the kernel. internet protocols · advanced
- Aug 6, 2026 CRUSH Placement: Deterministic Mapping Over a Weighted Hierarchy How a pseudorandom placement function turns an object identifier and a cluster map into a device list, why straw selection replaced simpler bucket types, and what changes on topology edits. filesystems · intermediate
- Aug 6, 2026 Ports and Adapters and the Direction of the Dependency Arrow Why a hexagonal boundary is an interface owned by the application core rather than by the framework, and how driving and driven adapters differ in who initiates the call. software architecture · foundational
- Aug 6, 2026 Reference Counting and the Cycle It Cannot Break How an atomic count turns ownership into a distributed protocol, why strong counts cannot reclaim a cycle, and what weak references and trial deletion cost to add. programming languages · intermediate
- Aug 6, 2026 State Encoding: Why the Same State Machine Can Cost Three Flops or Eight How binary, one-hot, and Gray encodings trade register bits against next-state logic depth, and why the encoding chosen in code is not necessarily the encoding built. hardware engineering · intermediate