Complete archive

Archive

3,240 articles, newest first · page 41 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
Jun 26, 2024 TOTP Time Steps, Drift Windows, and Code Replay How a shared secret and a counter quantised to thirty seconds produce a six-digit code, why the verifier searches a window, and what makes a used code reusable. security · intermediate
Jun 25, 2024 Native Constraint Validation and the ValidityState Object How the browser evaluates required, pattern, min, and max attributes, what each ValidityState flag means, and where the built-in validation loop breaks down. accessibility · intermediate
Jun 24, 2024 Inhibition and Dependency Suppression Between Alerts How an inhibition rule mutes a set of derived alerts while an upstream alert is firing, why label equality is the whole matching mechanism, and what breaks when the suppression relation is wrong. observability · advanced
Jun 24, 2024 Repositories and the Persistence Boundary What a repository should expose, why it belongs to the aggregate root rather than the table, and which storage concerns it cannot hide from the model. software architecture · intermediate
Jun 24, 2024 Yield Points and What Makes a Task Cooperatively Schedulable Why a scheduler that cannot interrupt needs the compiler to place checkpoints, how the choice of checkpoint changes latency, and what a missing yield point does to every task behind it. language runtimes · foundational
Jun 23, 2024 Let-Polymorphism and Where Generalization Happens Why a let-bound definition can be used at several types while a lambda parameter cannot, how the level of a metavariable decides what gets generalized, and what the value restriction protects. compilers · advanced
Jun 23, 2024 Retry Accounting When the Scheduler Chooses the Moment How attempt counts, backoff, and jitter interact with deferral, why a retry that waits for a maintenance window needs different arithmetic, and where budgets go wrong. mobile computing · advanced
Jun 22, 2024 Retiming, Pipelining, and Register Balancing in the Fabric How moving registers across combinational logic changes which resources a path traverses, why the fabric makes retiming cheaper than in an ASIC, and where the technique stops helping. hardware engineering · intermediate
Jun 20, 2024 What Threads Share and What They Own A thread is a process that was created with fewer sharing flags, and the list of flags is the whole difference. What each shared resource costs. operating systems · foundational
Jun 19, 2024 Escaping Saddle Points in Nonconvex Optimization Why a vanishing gradient is not evidence of a minimum in high dimensions, how negative curvature is detected and followed, and what the escape guarantees cost per iteration. machine learning · advanced
Jun 19, 2024 Opaque Session Identifiers Versus Signed Tokens How server-side session lookup and self-contained signed tokens differ in revocation, verification cost, and failure behaviour when a key or a datastore goes away. security · intermediate
Jun 19, 2024 Static Memory Planning from Tensor Liveness Intervals Turning a liveness interval per tensor into an offset in one arena, why interval-graph colouring is optimal for monotone lifetimes, and where greedy packing loses bytes. inference systems · intermediate
Jun 19, 2024 The Accessibility Tree as a Test Oracle How browsers expose roles, names, states, and relations through the accessibility API, and how tests can assert on that projection instead of on markup. accessibility · foundational
Jun 19, 2024 What an HSM Boundary Actually Guarantees Which properties a hardware security module enforces, which it merely reports, and how key operations move across the boundary without exposing keys. cryptography · intermediate
Jun 18, 2024 Exact Inference by Variable Elimination and the Cost of Treewidth How factors are multiplied and summed out, why the elimination order determines the size of every intermediate table, and why exact inference is exponential in treewidth. machine learning · intermediate
Jun 18, 2024 How a Package Name Becomes a Download: Registry Lookup Order and Confusion The chain from a bare name in a manifest to a fetched artifact, how registries and scoped namespaces are consulted in order, and why that order is exploitable. software engineering · intermediate
Jun 18, 2024 Request Rate Limits and Why Key Prefixes Are Partitioned A bucket scales by splitting its keyspace across index partitions. Sequential keys hammer one partition, so the naming scheme decides the achievable request rate. cloud infrastructure · advanced
Jun 18, 2024 Result Grouping and Near-Duplicate Collapsing How a result list collapses many near-identical documents into a single entry with a cluster, and how the engine detects the duplicates fast enough to do it on every query. information retrieval · intermediate
Jun 17, 2024 Reservoir Sampling and Priority Sampling on a Single Pass How to hold a uniform sample of a stream of unknown length with one pass, how priority sampling generalises it to weighted elements with unbiased totals, and where the sample stops being uniform. algorithms · intermediate
Jun 16, 2024 Hash Flooding and the Case for Keyed Hash Functions Why a predictable hash lets an attacker collapse a table to a linked list, how SipHash and per-process seeding restore the expected bound, and what the defence costs. data structures · advanced
Jun 15, 2024 Decision Tables and Rule Completeness in Policy Specifications How a decision table exposes overlapping and missing rules in eligibility logic, why hit policies change behaviour, and what completeness costs as conditions multiply. software engineering · advanced
Jun 15, 2024 Pseudo-Relevance Feedback and the Rocchio Drift Problem How a system rewrites a query using its own top results, why the Rocchio weights and RM3 interpolation decide the outcome, and how feedback amplifies an initial ranking error. information retrieval · advanced
Jun 14, 2024 Page Tables for Sparse Virtual Textures How a texture is addressed through a page table, what happens when a page is missing during sampling, and how feedback selects the pages to load. computer graphics · intermediate
Jun 13, 2024 Decomposing Recovery Time into Detection, Diagnosis, and Mitigation Why a single mean time to recovery mixes intervals with different floors and different distributions, how concurrent incidents queue behind one responder, and how to measure each phase without corrupting the comparison. software engineering · advanced
Jun 12, 2024 Axis Conventions, Handedness, and Unit Scale on Import Which geometry formats declare their coordinate convention, which leave it implicit, and why converting between them is a reflection rather than a rotation. computer graphics · foundational
Jun 12, 2024 Recognizing the Point Where Further Optimization Stops Paying When remaining candidates fall inside the measurement noise floor or the untouchable remainder dominates, the correct action changes from optimizing to sizing or redesigning. performance engineering · advanced
Jun 11, 2024 Alert State, Hysteresis, and the Cost of Flapping How an alert moves between inactive, pending, firing, and resolved, why a condition that crosses its threshold repeatedly produces a notification storm, and what a hold duration or a second threshold does about it. observability · intermediate
Jun 11, 2024 The Runtime Cost of Indirection at Module Boundaries A cost model for boundary crossings: what inlining loses, what a virtual call and a cache miss actually cost, and when a coarse-grained interface beats a clean one. software architecture · advanced
Jun 10, 2024 Seccomp Filters and the Cost of Interception How a classic BPF program attached to a thread filters system calls, what it can and cannot inspect, and why tracing every call changes latency by orders of magnitude. operating systems · intermediate
Jun 9, 2024 Balanced Parentheses and Succinct Tree Navigation How a tree becomes a 2n-bit parentheses string, which rank and select combinations recover the parent and subtree boundaries, and what the extra index buys. data structures · advanced
Jun 9, 2024 Hard and Soft Mounts: What a Client Does When the Server Stops Answering A hung server turns every file operation into an indefinite wait. The mount option decides whether the client retries forever, gives up with an error, or interrupts the call, and each choice moves the failure somewhere else. filesystems · intermediate
Jun 8, 2024 Unsafe Abstraction Boundaries and What Soundness Actually Costs The contract an unsafe block transfers from compiler to programmer, the invariants a safe wrapper must maintain, and how those invariants fail in practice. programming languages · advanced
Jun 6, 2024 Term Dictionary Lookup Structures for Inverted Indexes How an index maps a query term to its postings offset, why the dictionary is kept in memory in a different layout from the postings, and what each structure trades for lookup speed. information retrieval · foundational
Jun 5, 2024 Multi-Stage Programming and Cross-Stage Persistence How staged languages type the distinction between code and its generation, what run and splice mean at each level, and why a value captured at one stage must be embeddable in the next. programming languages · advanced
Jun 5, 2024 Size-Depth Tradeoffs and the Block-Respecting Model How restricting a circuit to communicate only between fixed blocks of inputs turns depth into a measurable resource, and what the resulting bounds say about parity. computation theory · advanced
Jun 5, 2024 Unrolled Linked Lists and the Cost of a Cache Miss per Node Packing several elements per node cuts pointer chases by the node capacity, and the block size that minimises total cost follows from a cache line and a word. data structures · intermediate
Jun 4, 2024 Little's Law: Concurrency, Arrival Rate, and Time in System Why the identity L = λW holds without any assumption about the arrival distribution, how the choice of system boundary changes all three terms at once, and where the accounting breaks when requests are dropped or retried. performance engineering · foundational
Jun 4, 2024 PKCE: Binding an Authorization Code to the Client That Asked for It How the code verifier and S256 transformation stop intercepted codes from being redeemed, and why the plain transformation is a fallback rather than an equal. internet protocols · foundational
Jun 3, 2024 Copying Collection, Cheney Scanning, and the Bump Pointer Why a semispace collector trades half the heap for allocation in a few instructions, how Cheney's breadth-first scan avoids a recursion stack, and what forwarding costs. language runtimes · intermediate
Jun 3, 2024 Merge Queues and What Speculative Testing Actually Proves How a queue serialises candidate merges, tests each against the current tip rather than its own base, and why batching candidates changes the meaning of a green result. software engineering · advanced
Jun 3, 2024 Streamline Integration in Vector Fields and Where the Error Accumulates How a vector field becomes a curve through numerical integration, why cell-crossing interpolation dominates the error, and what separates a valid line from a decorative one. scientific computing · intermediate
Jun 3, 2024 The Inverse Ackermann Bound and Why It Is Effectively Constant How the α(n) function is defined, why the amortized cost of a disjoint-set sequence lands there, and what the matching lower bound says about improving it. data structures · foundational
May
May 31, 2024 Condition Codes, Flag Registers and the Dependency They Create How comparison results become flags, why an implicit flag register serialises code, and how architectures that compare directly into registers avoid the hazard. computer architecture · intermediate
May 31, 2024 ELF Program Headers and the Mapping a Loader Performs Before _start How PT_LOAD entries describe the bytes the kernel maps, why file offsets and virtual addresses must be congruent modulo the page size, and where the process stack layout comes from. systems programming · foundational
May 30, 2024 Attenuation and Revocation of Delegated Authority How a capability can be narrowed before it is passed on, why revocation in a capability system is either impossible or requires indirection, and what each indirection costs. language runtimes · intermediate
May 30, 2024 Faceted Navigation and the Counts on Each Filter How a search interface narrows a result set by attribute facets, and where the per-facet document counts come from without a full re-query. information retrieval · foundational
May 30, 2024 Middlebox Ossification and Frozen Invariants How on-path devices that parse protocol fields freeze a design, why visible invariants become dependencies, and the strategies that keep extension points usable. internet protocols · intermediate
May 30, 2024 Record Framing: Why a Log Line Needs a Delimiter Contract How a log stream is cut back into records, why newline delimiting breaks on embedded newlines, and what octet counting and escaping cost in exchange. observability · foundational
May 29, 2024 Rebuilding a Pinned Artifact Without Its Original Environment Keeping the recipe instead of the bytes only works if the toolchain, dependencies, and clock can be reconstructed. What a pinned environment has to name and what cannot be rebuilt at all. devops · advanced
May 27, 2024 Fractional Relaxation and the Knapsack Integrality Gap Why the density-ordered greedy rule is exactly optimal for fractional knapsack, how the 0/1 version loses a factor of two, and what value scaling buys back. algorithms · intermediate
May 27, 2024 LFSR Keystream Generators and the Linearity That Must Be Broken Why a shift register with linear feedback is a perfect pseudorandom generator and a useless cipher, and how combining several of them buys nonlinearity. cryptography · intermediate
May 27, 2024 Segment Arithmetic and the One-Megabyte Wall How sixteen-bit segment registers produce a twenty-bit address, why the resulting space wraps at the top, and what the A20 gate and the high memory area cost. computing history · advanced
May 26, 2024 Amdahl's Law as a Ceiling on Optimization Returns How the fraction of time a change addresses bounds its total payoff, why the bound is a filter rather than a forecast, and where the fixed-workload assumption breaks. performance engineering · foundational
May 25, 2024 Kernel Page Table Isolation and What It Costs on Every Trap Why splitting the kernel into a separate address space defends against speculative reads, how the switch is arranged to be nearly free, and where the remaining cost lands. memory systems · advanced
May 24, 2024 Ethernet Frame Layout and the 64-Byte Minimum The field-by-field layout of an Ethernet II frame, why the payload floor is 46 bytes, and how a receiver distinguishes padding from real data. networking · foundational
May 24, 2024 Kruskal, the Cut Property, and Why Any Minimum Edge Is Safe The cut and cycle properties that justify sorting edges by weight, how the proof differs from a plain exchange, and what happens when weights tie. algorithms · intermediate
May 23, 2024 Expansion Depth Limits and Token Opacity Why a recursive pattern-matching macro consumes one level of expansion depth per element it processes, how the recursion limit is raised, and why a captured fragment cannot be re-matched by a later pattern. programming languages · advanced
May 23, 2024 Referrers, Attachments, and the Artifact Graph How a registry indexes artifacts by the digest they describe, why the fallback naming convention is spoofable, and how a verifier discovers signatures and SBOMs without being told where to look. virtualization · intermediate
May 23, 2024 Session Fixation, Rotation, and Revocation Why authenticating in place hands an attacker a valid session, how rotation must be sequenced to survive concurrent requests, and what revocation can and cannot reach. backend systems · intermediate
May 22, 2024 Choosing What to Clean: Greedy, Cost-Benefit, and Age-Ordered Segment Policies The three classical segment selection rules, the objective function each one optimizes, and why weighting freed space by the age of the data beats always cleaning the emptiest segment. filesystems · intermediate

2024

May