Complete archive
Archive
3,240 articles, newest first · page 48 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.
-
2023
Sep 5, 2023 Per-Lane Program Counters and Independent Thread Scheduling What changes when each lane carries its own program counter and call stack, how divergence stops being a strict two-phase serialization, and why implicit reconvergence disappears. gpu computing · advanced - Sep 2, 2023 802.1Q Tagging and the Four-Byte Insertion Where the VLAN tag sits in a frame, what PCP and DEI carry, how untagged and priority-tagged frames are told apart, and what a trunk port must do. networking · intermediate
- Sep 2, 2023 Pre-Retrieval Query Performance Prediction How a system estimates, before seeing any judged results, whether a query will be answered well, using score distributions, term specificity, and clarity over the collection language model. information retrieval · advanced
- Sep 2, 2023 Timer Prescalers, Auto-Reload and the Arithmetic Behind a Period How the prescaler and auto-reload registers divide a clock into a period, why the achievable periods are quantised, and how update events and preload buffering change when a new period takes effect. embedded systems · advanced
- Sep 1, 2023 Schema Evolution Without Rewriting Files Why field names cannot identify a column across versions, how numeric field identifiers make renames and reordering safe, and which schema changes remain illegal regardless of identifiers. data engineering · intermediate
-
August
Aug 30, 2023 Exit Status, Zombies, and What waitpid Can Tell a Parent A terminated process leaves a status word and an entry that must be reaped. Status encoding, the reason the record survives termination, and the four ways a parent can wait without deadlocking. systems programming · intermediate - Aug 30, 2023 High-Level Synthesis: Scheduling, Binding, and Inferred Hardware How a C function becomes a datapath, why the clock period constraint drives scheduling decisions, and what the interface protocol synthesis chooses on the designer's behalf. hardware engineering · advanced
- Aug 30, 2023 Pareto Frontiers When No Single Setting Wins Configuration spaces have several objectives that trade against each other; dominance analysis reduces them to a frontier and explains why the frontier, not a score, is the deliverable. performance engineering · advanced
- Aug 28, 2023 Ordering Across the Device Boundary: DMA, MMIO, and Posted Writes Why a device can read stale data after a synchronising store, how posted writes hide completion, and which barriers cross the boundary in each direction. computer architecture · advanced
- Aug 26, 2023 The Order of Focus and Blur Events Focus moves in a fixed sequence of four events, only two of which bubble. How relatedTarget identifies the other end of the move, and why calling focus() from inside a blur handler behaves unexpectedly. accessibility · advanced
- Aug 25, 2023 Delaunay Triangulation and the Empty Circumcircle Test Why maximising the minimum angle reduces to a single determinant test, how incremental insertion repairs the mesh locally, and what happens when four points share a circle. algorithms · intermediate
- Aug 25, 2023 Pointwise Nonlinearity and the ReLU Family of Activations Why one elementwise nonlinear function is enough to break the collapse of stacked affine layers, how the rectifier behaves at its kink, and what makes a unit permanently dead. deep learning · foundational
- Aug 24, 2023 Resource-Constrained Shortest Paths and Label-Setting with Dominance Why a second additive cost breaks the optimal-substructure argument, how multi-dimensional labels and a dominance rule restore a workable search, and what makes the label count explode. algorithms · advanced
- Aug 24, 2023 Variance-Stabilising Transforms for Counts and Proportions Why the log, square root, and arcsine transforms equalise variance across a mean-variance relation, and what changes when the counts include zeros. machine learning · intermediate
- Aug 23, 2023 How Capability Sets Split Root Authority The five capability sets a Linux process carries, the transitions between them at exec, and why dropping a capability is not the same as dropping a file permission. virtualization · intermediate
- Aug 22, 2023 Deep Pipelines and Why More Stages Stop Paying The arithmetic of latch overhead, the growing penalty for branches and exceptions, and the point at which another stage costs more throughput than it returns. computer architecture · intermediate
- Aug 20, 2023 Autoscaling Model Servers on Queue Depth Rather Than Utilization Utilization-based autoscaling assumes work is interruptible and cheap to queue; for inference it produces oscillation, so the control signal has to be the wait time a request would experience. inference systems · advanced
- Aug 20, 2023 SRv6 Segment Lists as a Source-Routed Overlay How a 128-bit IPv6 address doubles as a forwarding instruction, what the segment list in the routing header encodes, and why path state moves from the core to the edge. networking · advanced
- Aug 18, 2023 Double Hashing and Quadratic Probing Without Primary Clustering How per-key strides and triangular offsets break the runs that linear probing creates, what each costs in arithmetic, and why the table size must cooperate. data structures · intermediate
- Aug 17, 2023 Instability, Abstractness, and the Main Sequence Metric How afferent and efferent coupling produce an instability score, why stable packages should be abstract, and where the distance-from-the-main-sequence number misleads. software architecture · intermediate
- Aug 16, 2023 Text-to-Speech Synthesis Under the Hood How a speech engine turns an SSML document into audio through text normalization, phoneme conversion, and prosody, and where screen-reader latency comes from. accessibility · intermediate
- Aug 15, 2023 Comparing Two Classifiers with Paired Tests on the Same Rows How to test whether an observed difference in error is larger than fold noise, why the resampled t-test fails, and what the corrected alternatives assume. machine learning · advanced
- Aug 15, 2023 Metadata Filtering Inside a Vector Index and the Selectivity Collapse Why post-filtering silently returns fewer results than requested, how pre-filtering degrades graph traversal, and what the filter selectivity threshold does to each index family. information retrieval · intermediate
- Aug 14, 2023 Interprocedural Summaries and the Context-Sensitivity Bill How a function is summarized for callers, how call graphs are built under virtual dispatch, and why distinguishing call sites multiplies cost without always buying precision. developer tools · intermediate
- Aug 14, 2023 Measuring Freshness From Event Time, Not Arrival Time A table can be loaded on schedule and still be stale: lag is a distribution over records, and comparing the newest row timestamp to the clock hides the tail. data engineering · foundational
- Aug 12, 2023 Page Table Mirroring Between CPU and Device How the kernel lets a device driver snapshot a process page table, why the snapshot needs an invalidation callback, and what breaks when the two disagree. gpu computing · advanced
- Aug 12, 2023 Point-in-Time Feature Reads and the Skew They Prevent Training a model on features computed after the fact and serving it on features computed at request time yields two different distributions; point-in-time joins are the mechanism that forces them to agree. inference systems · intermediate
- Aug 12, 2023 Reboot-Required and Live Kernel Patching What the reboot flag actually tracks, why a replaced shared library keeps running inside existing processes, and which kernel changes a live patch cannot make. devops · foundational
- Aug 9, 2023 The AES State Matrix: Byte Ordering, ShiftRows, and MixColumns How sixteen key bytes map onto a four-by-four matrix, why the row shift moves different distances, and what MixColumns does to a column as a polynomial. cryptography · foundational
- Aug 8, 2023 Partitioning a Crawl Across Machines Without Duplicate Fetches Why host-based partitioning is the only split that preserves politeness, how a frontier survives reassignment, and what happens when one partition dies. information retrieval · advanced
- Aug 7, 2023 Sampling Error, Skid, and How Many Samples a Profile Needs Why a profile is a binomial estimate, how instruction skid biases samples toward long-running instructions, and what confidence a given sample count actually supports. observability · intermediate
- Aug 6, 2023 Quadric Error Metrics and What an Edge Collapse Actually Costs Each vertex accumulates the planes it can see as a 4x4 symmetric matrix; collapsing an edge sums two of them, and the result predicts geometric error without measuring it. computer graphics · advanced
- Aug 4, 2023 Admission Control as the Enforcement Point for a Golden Path Validating and mutating admission sit between the tenant and the stored object. How they differ, why mutation order is undefined, and what a rejection should tell the tenant. virtualization · intermediate
- Aug 4, 2023 Dependency Resolution as a Satisfiability Problem How version selection encodes into boolean clauses, why the decision problem is NP-complete, and what that bound predicts about real installs and about optimisation criteria. developer tools · intermediate
- Aug 4, 2023 Early Depth Tests and the Ordering Constraints They Impose Rejecting hidden fragments before shading is the largest single saving in a raster pipeline, and it is legal only when the fragment shader is known not to change depth or discard. computer graphics · advanced
- Aug 3, 2023 Encrypted Client Hello and the Limits of Hiding a Hostname How the outer and inner ClientHello split works, what the ECHConfig commits the server to, and which parts of a connection remain visible after ECH. internet protocols · advanced
- Aug 3, 2023 Zombies, Orphans, and the Mechanics of Reaping Why an exited process keeps a task structure, what the wait call does to release it, and how subreapers keep orphaned descendants from accumulating. operating systems · intermediate
- Aug 2, 2023 Transporting a Key Versus Agreeing on One Key transport and key agreement solve the same problem with different assumptions about who holds what, and differ in what a compromise of one party yields. cryptography · intermediate
- Aug 1, 2023 Custom Element Reactions and Their Synchronous Callback Contract Lifecycle callbacks are queued reactions invoked at the end of the DOM operation that caused them, which makes them synchronous but batched, and explains upgrade ordering. web platform · advanced
- Aug 1, 2023 Voting Redundancy and Average Probability of Failure on Demand How 1-out-of-2 and 2-out-of-3 architectures change the PFD calculation, why the common-cause term dominates the result, and what a voter must do when its channels disagree. embedded systems · intermediate
-
July
Jul 31, 2023 Finding Seams in Legacy Code That Was Never Built to Have Them How object, link, and preprocessor seams let behaviour be substituted without editing the code under test, and what each kind of indirection costs at runtime and in maintenance. software architecture · foundational - Jul 28, 2023 CQRS and the Consistency Window Between Writes and Read Models Separating the write model from query models buys shape and contention relief, and pays for it with a lag the user can observe. Checkpoints, version tokens, and read-your-writes routing decide whether that lag is tolerable. software architecture · intermediate
- Jul 27, 2023 Anti-Corruption Layers at System Edges How a translation layer keeps an external model and its failure semantics out of the domain, where the layer belongs in the call path, and when it costs more than it saves. software architecture · advanced
- Jul 25, 2023 Deriving a Safety Integrity Level from Risk Parameters How tolerable risk, demand mode, and consequence parameters become a SIL or ASIL target, and why the resulting number constrains architecture and evidence rather than code quality. embedded systems · foundational
- Jul 23, 2023 L2 Slices, Address Hashing, and Partition Camping Why the last-level GPU cache is physically distributed across memory controllers, how addresses are spread over it, and how a stride that resonates with the mapping leaves most of the memory system idle. gpu computing · advanced
- Jul 23, 2023 View Recycling and Virtualization in Long Scrolling Lists How list widgets bound the number of mounted children while scrolling through unbounded content, what the recycling contract requires of item views, and where the reuse goes wrong. mobile computing · intermediate
- Jul 21, 2023 Litmus Tests and Store Buffering How a five-line litmus test distinguishes total store order from sequential consistency, why the x86 store buffer permits a forbidden outcome, and what each outcome costs to rule out. systems programming · advanced
- Jul 20, 2023 Contract Tests for Stateful ARIA Widgets A role-specific contract of states, key bindings, and announcements that can be asserted mechanically, and where the ARIA authoring practices stop being testable. accessibility · advanced
- Jul 20, 2023 The Streaming Model: One Pass, Sublinear Space, Approximate Answers What the one-pass model forbids, how cash-register and turnstile streams differ, and why exact answers cost linear space while sketches can be merged by addition. algorithms · foundational
- Jul 19, 2023 SIV and the Two-Pass Design of a Misuse-Resistant AEAD How deriving the nonce from the plaintext with a keyed hash removes the catastrophic failure of nonce reuse, at the cost of a second pass and the loss of streaming encryption. cryptography · intermediate
- Jul 16, 2023 Repetition and Definition Levels in Nested Columns How two small integers per value encode the full structure of nested and repeated fields, what an empty list looks like on disk, and why the encoding stays independent of the record shape. data engineering · advanced
- Jul 14, 2023 Amortized Cost per Token: Depreciation, Power, and Idle Capacity Building a total cost of ownership for a token service from hardware life, power draw, and utilization, and showing why idle capacity is the largest term. inference systems · advanced
- Jul 14, 2023 Quality-Attribute Scenarios as the Unit of Architectural Evaluation Why adjectives such as scalable or maintainable cannot be evaluated, and how a six-part scenario converts them into statements one can test, disagree about, and rank. software architecture · foundational
- Jul 13, 2023 Action Cache Keys and Shared Build Caches The two-level structure of an action cache over a content-addressed store, what has to be in a key for cross-machine hits to be safe, and how eviction and poisoning failures present themselves. developer tools · intermediate
- Jul 13, 2023 Sandboxed Frames and the postMessage Trust Boundary Which capabilities the sandbox attribute strips and which tokens restore them, why allow-scripts with allow-same-origin defeats the frame, and how to validate a message without racing a navigation. web platform · intermediate
- Jul 11, 2023 Adaptive Sampling: Feedback Control over Span Volume How a sampler adjusts its rate from observed traffic instead of a fixed configuration, why per-operation rates are needed, and the statistical damage caused by a rate that keeps changing. observability · advanced
- Jul 11, 2023 Registry Index Metadata and Resolution Without Downloading Artifacts How registries expose version lists, dependency metadata, and hashes as separate resources, and why fetching full archives during resolution is a design error. language runtimes · intermediate
- Jul 11, 2023 Thread-Local Storage Access Models The four TLS access sequences the compiler can emit, what each costs per access, and why a module loaded after startup cannot use the cheapest ones. compilers · advanced
- Jul 10, 2023 Count-Min Sketch: Why the Minimum of Overestimates Is the Estimate The counter grid, the derivation of width e over epsilon and depth ln of one over delta, and why conservative update shrinks error without changing the guarantee. algorithms · intermediate
- Jul 9, 2023 Tenant Isolation and the Channels Performance Interference Travels Through Separating address spaces does not separate throughput; the shared resources that remain determine how much one tenant can slow another and which controls can bound it. gpu computing · advanced