Complete archive

Archive

3,240 articles, newest first · page 51 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
Feb 8, 2023 Signed Cookie Tokens and the Limits of Statelessness How a signed token encodes session facts, what the signature actually guarantees, and which operations stop being possible once the server keeps no record. backend systems · foundational
Feb 8, 2023 Specialisation as an Energy Strategy Why a fixed-function unit beats a general-purpose core on energy per operation, how Amdahl and utilisation bound the payoff, and what the built-in generality of a core is worth. computer architecture · advanced
Feb 7, 2023 Checkpoint Barriers and Aligned Snapshots How a barrier injected at the source cuts a consistent snapshot across a distributed operator graph, and what alignment costs when one channel stalls. data engineering · advanced
Feb 6, 2023 Microsegmentation and Policy at the Workload Boundary Why per-workload policy beats address-based rules, how enforcement located in the host kernel changes the failure model, and what has to be observed before a policy can be written at all. security · intermediate
Feb 2, 2023 Escalation Policies as Timeout-Driven State Machines How an alert moves from first notification to a human who acknowledges it, what each timer actually measures, and where the routing logic breaks down. devops · foundational
January
Jan 31, 2023 Connection Tracking Under NAT How address and port translation rewrites the five-tuple, why the mapping table is the real policy state, and which behaviours the NAT requirement documents leave to the implementation. security · foundational
Jan 30, 2023 Cache Line Transfer, False Sharing, and the Cost of Contention Why an atomic operation on an uncontended location is cheap and on a contended one is not, what coherence protocol traffic each attempt generates, and how padding and sharding change the shape of the cost. systems programming · intermediate
Jan 30, 2023 Decomposing Path Latency into Propagation, Serialization, and Queueing The four terms that sum to the delay across a network path, how each scales with distance, link rate, and load, and which ones a sender can actually influence. networking · foundational
Jan 30, 2023 DREAD Scores and Why Ordinal Risk Ratings Do Not Multiply What the five DREAD dimensions actually ask, why averaging ordinal ranks produces a number with no meaning, and how to replace the arithmetic with a comparison that survives review. security · intermediate
Jan 30, 2023 Register Bytecode and Windowed Register Allocation in Lua How a register-based VM names operands inside a per-call window, why that cuts instruction count, and what the compiler must compute to keep the window small. programming languages · foundational
Jan 30, 2023 Registry Allocation: First Come, First Served and Its Failure Modes How a single registry clerk in the early Internet years allocated namespaces, why the policy scaled badly, and what the replacement bodies inherited. computing history · intermediate
Jan 27, 2023 When One Graph Contains Several Copies of the Same Package How flat installation trees force duplicate versions into a single directory, what breaks when two copies coexist, and how hoisting decides which copy a require call finds. software engineering · intermediate
Jan 25, 2023 Communication-Avoiding Algorithms and the Latency Floor How restructuring the arithmetic to block inner products and use fewer global synchronization steps changes the scaling exponent, and what it costs in numerical stability. scientific computing · advanced
Jan 24, 2023 Keyless Signing and Transparency Logs for Build Artifacts Short-lived certificates bound to an OIDC identity remove long-lived keys from the signing path, and an append-only log makes a signature public evidence rather than a private promise. security · advanced
Jan 23, 2023 Retransmission and the Duplicate Request Cache A lost reply is indistinguishable from a lost request, so a client resends and a server must decide whether the operation already ran. The reply cache is the mechanism that turns at-least-once delivery into at-most-once execution. filesystems · foundational
Jan 23, 2023 The Fabricated Machine: ACPI Tables, SMBIOS, and PCI Configuration Space How a hypervisor describes hardware that does not exist, which tables the guest kernel trusts for topology and interrupt routing, and why a wrong table entry survives every test until the guest boots on real silicon. virtualization · advanced
Jan 19, 2023 Asymmetric Partitions and What a Set of Conflicting Suspicion Reports Means How to read a matrix of who can reach whom, why a single suspicion report cannot distinguish a dead peer from a broken path, and what a system can safely conclude from per-observer evidence. distributed systems · advanced
Jan 19, 2023 Undo Records and Reconstructing Older Row Versions How engines that keep only the current row in the heap rebuild earlier versions from before-images in undo segments, and what that indirection costs on the read path. databases · intermediate
Jan 18, 2023 Version Vectors and Hybrid Logical Clocks for Mobile Sync Ordering Why wall-clock timestamps cannot order edits made on different devices, how a version vector detects concurrent writes, and what a hybrid logical clock adds without needing agreement on time. mobile computing · advanced
Jan 17, 2023 Applying STRIDE per Element Instead of per System Why the six threat classes are property violations, which of them are vacuous for each diagram element type, and how the per-element grid turns a mnemonic into an assignable work list. security · intermediate
Jan 17, 2023 Storage Lifecycle Transitions and Minimum Durations How a lifecycle rule becomes a charge: the transition request, the per-object metadata charge in each class, minimum storage durations, and early-deletion fees. cloud infrastructure · intermediate
Jan 16, 2023 Compilation Budgets and Recompilation Policy How a runtime bounds the CPU it spends compiling, what triggers a second compilation of code that already compiled, and why unbounded recompilation is a denial-of-service on the application itself. language runtimes · intermediate
Jan 16, 2023 Deprecation Windows and the Gates That Must Close Before Removal How to announce an end date, measure who still depends on an interface, and sequence soft warnings, hard failures, and deletion so that removal is boring. software architecture · intermediate
Jan 16, 2023 Document-at-a-Time and Term-at-a-Time Evaluation Two ways to turn postings lists into ranked results: accumulate per document, or merge per term. What each order costs in memory, latency, and early termination. information retrieval · intermediate
Jan 14, 2023 Detecting Drift Without Recreating the World How a refresh distinguishes remote change from remote absence, why some differences cannot be seen at all, and what remediation does to the objects that were changed outside the tool. cloud infrastructure · intermediate
Jan 13, 2023 Cookie Scope and the Attributes That Restrict Sending How the Domain and Path attributes decide which requests carry a cookie, and how Secure, HttpOnly, and expiry constrain what can be done with it once stored. web platform · foundational
Jan 13, 2023 Landlock Rulesets: Path Hierarchies and Access Masks How Landlock binds access rights to directory hierarchies instead of syscalls, how the handled-access mask determines what a ruleset can enforce, and where the model stops. virtualization · intermediate
Jan 13, 2023 Position-Independent Code and the Global Offset Table Why shared code cannot contain absolute addresses, how the GOT turns one pointer indirection into position independence, and what the PLT adds for functions. compilers · intermediate
Jan 12, 2023 Sampling Allocation Profilers and the Statistics of Estimates How a profiler that records one allocation in a few thousand still reports accurate totals, why the sampling must be size-weighted, and how the confidence interval is computed. memory systems · intermediate
Jan 10, 2023 Min-Max Heaps and Double-Ended Extraction How alternating min and max levels let one array serve both ends of a priority queue, why sift-down needs two directions, and what the layout gives up. data structures · advanced
Jan 10, 2023 Relocating the Vector Table and Running It from RAM How the table base register changes where exceptions dispatch, why a misaligned base fails silently, and what a writable copy of the table enables. embedded systems · intermediate
Jan 10, 2023 Stratified k-Fold Cross-Validation and the Variance of the Estimate How k-fold partitioning produces a spread estimate, why the folds are not independent, and what stratification actually removes from the variance. machine learning · foundational
Jan 9, 2023 Containing Focus Inside a Modal Surface How the dialog element traps Tab natively, what a hand-rolled focus trap has to reimplement, and why returning focus to the opener is part of the containment contract. accessibility · intermediate
Jan 9, 2023 Correctly Rounded Decimal Conversion and Shortest Round-Trip Printing Why parsing a decimal string to the nearest double needs exact arithmetic in the hard cases, and how the shortest string that maps back is found without searching. scientific computing · intermediate
Jan 8, 2023 Describing Breaking Changes So Consumers Can Act on Them Why a one-line note that an API changed forces every consumer to read the diff, and the shape of an entry that names the affected surface, the failure it produces, and its replacement. devops · intermediate
Jan 8, 2023 Why a Larger Context Window Does Not Remove the Need for an Index The arithmetic that separates a corpus from a prompt, what a retrieval step buys in tokens and memory, and the narrow cases where loading everything still wins. inference systems · foundational
Jan 5, 2023 Blocked and Rolling-Origin Validation for Time-Ordered Data Why random folds fail on time series, how expanding and sliding origins differ in what they measure, and where the gap between folds must be inserted. machine learning · intermediate
Jan 3, 2023 The Stop-and-Copy Boundary in Live Migration Why a migrating virtual machine must freeze its vCPUs at one exact instant, what state that instant must capture, and how the residual copy sets the floor on downtime. virtualization · foundational
2022
Dec 30, 2022 Gradient Accumulation: What Micro-Batching Preserves and What It Does Not Splitting a batch into micro-batches keeps the arithmetic of a large batch but changes normalisation, batch-dependent layers, and the timing of every state update. deep learning · intermediate
Dec 30, 2022 Module Interfaces and the Cost of Hiding Structure Why a module boundary turns a graph into a black box, which abstractions leak through the interface, and how validation and outputs shape what callers can express. cloud infrastructure · advanced
Dec 30, 2022 Spinlock Design from Test-and-Set to Ticket Locks How a test-and-set lock starves its waiters, why test-and-test-and-set helps, and how a ticket lock turns a race into a queue without a fairness guarantee. systems programming · intermediate
Dec 30, 2022 X.400 Versus SMTP: When a Better-Designed Messaging System Loses How the OSI message handling system specified store-and-forward routing, naming and delivery reports, why its design was technically more complete than SMTP, and what prevented it from displacing an internet mail architecture that was already deployed. computing history · intermediate
Dec 29, 2022 Sampling Rate, Aliasing, and the Folding of the Spectrum Why the Nyquist criterion constrains the signal rather than the converter, how aliasing folds frequencies arithmetically, and what reconstruction actually requires. scientific computing · foundational
Dec 28, 2022 Immutable Artifact Coordinates and Why Digests Matter How a version-plus-repository name identifies a byte string, what breaks when the mapping can change, and how attestations bind a build input set to the digest that was published. devops · advanced
Dec 28, 2022 Stack Unwinding: Rebuilding the Call Stack from Frame Rules Why a backtrace cannot be read off the stack directly, how call frame information describes each prologue, and where unwinding gives up on corrupted or signal frames. developer tools · intermediate
Dec 27, 2022 Impact-Ordered Postings and Early Termination How reordering postings by score contribution instead of document identifier enables early termination, and what it does to merge semantics, memory, and result quality. information retrieval · advanced
Dec 26, 2022 Content Negotiation and Representation Formats How Accept headers, quality values, and the Vary header decide which representation a cache may reuse, and why most APIs settle on a single format. backend systems · intermediate
Dec 26, 2022 Variance and the Effective Capacity of a Replica Pool How service-time variance and partially correlated demand shrink the throughput a pool can sustain at a latency target, and why replica count, not average load, sets the tail. performance engineering · intermediate
Dec 25, 2022 Slotted Pages: Fitting Variable-Length Records into Fixed-Size Blocks Why a page keeps its records at the end and its directory at the front, how item identifiers decouple record addresses from byte offsets, and where the free space goes. databases · foundational
Dec 23, 2022 Lower Bound, Upper Bound, and the Invariant That Makes Binary Search Correct Why binary search is best expressed as a loop invariant over a half-open interval, how lower and upper bound answer different questions, and which arithmetic breaks first. algorithms · foundational
Dec 23, 2022 Retained Native Widgets or an Owned Render Tree Two architectures dominate cross-platform mobile UI: delegating drawing to the platform widget toolkit, or owning the render tree and painting it. Each fixes a different kind of fidelity and breaks the other. mobile computing · foundational
Dec 23, 2022 Salted Password Hashing and the Cost of a Verification How salts, iteration counts, and memory hardness set the price of an offline guess, and why the stored record must carry its own parameters. security · foundational
Dec 21, 2022 Dependent Loads and the Cost of Pointer Chasing Why linked structures serialise the memory system, how a dependent load chain differs from independent accesses, and what prefetchers cannot see. performance engineering · intermediate
Dec 20, 2022 Critical Path, Float, and Why the Longest Chain Sets the Date How the forward and backward passes compute earliest and latest dates, what total float measures, and why a zero-float path is not necessarily the riskiest one. software engineering · foundational
Dec 19, 2022 Flex Basis, Free Space, and the Grow-Shrink Algorithm How a flex container assigns base sizes, computes free space along the main axis, and resolves growth and shrinkage when items are clamped by minimums. web platform · intermediate
Dec 18, 2022 Unpacking an Initramfs and Switching to the Real Root How the kernel unpacks a compressed cpio archive into a temporary filesystem, what pivot_root and switch_root change, and why the old root cannot simply be unmounted. operating systems · advanced
Dec 16, 2022 Sunsetting a Golden Path Without Breaking the Tenants on It Retiring a path means migrating every instantiated copy. How to inventory the fleet, freeze adoption, migrate in waves, and decide when a path is retired rather than repaired. virtualization · advanced
Dec 15, 2022 Building the Dependency Graph from Manifests Why a manifest describes requirements rather than edges, how node identity is decided, which dependency kinds the walk follows, and why the graph only exists after versions are chosen. developer tools · foundational
Dec 13, 2022 Sizing the Window: Why More Entries Stop Paying The diminishing returns of a larger instruction window, the queueing model that explains them, and the second-order effects that make big windows expensive. computer architecture · advanced
Dec 8, 2022 Ordered Shutdown, Exit Handlers, and What the Kernel Reclaims Why exit handlers run in reverse order with no error reporting, what survives a call to _exit, and how to drain work before the kernel releases descriptors and mappings. systems programming · advanced

2023

January

2022