October 2026
81 articles.
-
Rust Pin and Unpin Explained
How Rust uses Pin and Unpin to keep self-referential values and async futures at a stable memory address.
-
How AWS IAM Policy Evaluation Works
Learn how IAM combines identity, resource, boundary, and organization policies—and why one matching deny defeats every allow.
-
Linux Page Cache and Dirty-Page Writeback
How Linux caches file data in memory, serves reads and writes through cached pages, and flushes dirty data to durable storage.
-
Property-Based Testing and Shrinking
Learn how property-based testing generates structured inputs and shrinks failures into small, reproducible counterexamples.
-
JavaScript Objects, Hidden Classes, and Inline Caches
How JavaScript engines give objects shapes, speed repeated property access, and fall back when those shapes stop matching optimized code.
-
Tail-Based Distributed-Trace Sampling
How collectors buffer spans, make trace-wide sampling decisions, and keep complete useful traces without exhausting memory or ingestion capacity.
-
Metastability and Two-Flop Synchronizers
How setup and hold violations make flip-flops metastable, and how a two-flop synchronizer keeps that uncertainty out of downstream logic.
-
Git Packfiles and Delta Compression
How Git packs objects, resolves delta chains, and uses garbage collection and repacking to balance repository size against read and write speed.
-
DNS Negative Caching: NXDOMAIN and NODATA
How recursive resolvers cache DNS absence, derive its lifetime from SOA records, and delay visibility of newly created names.
-
Python Asyncio Task Cancellation
How asyncio delivers CancelledError at await points, propagates it through coroutines, and still runs cleanup during cancellation.
-
How Compiler Register Allocation Uses Interference and Spilling
Register allocation assigns live intermediate values to CPU registers, building interference constraints and spilling selected values to memory when registers run out.
-
Amazon SQS Visibility Timeouts and Receipt Handles
How SQS hides received messages, uses receipt handles for deletion, and produces duplicate processing when workers outlive visibility timeouts.
-
Perturb-and-Observe Maximum-Power-Point Tracking
How a solar inverter nudges panel voltage, measures power changes, and follows the changing point of highest photovoltaic output.
-
TCP Slow Start and Congestion Avoidance
How TCP grows its sending rate, reacts to acknowledgements and loss, and discovers how much capacity a network path can support.
-
Database Write-Ahead Logs and Crash Recovery
How write-ahead logging protects database updates and lets recovery replay committed work after a crash without leaving inconsistent pages.
-
Consistent Hashing and Virtual Nodes
See how a hash ring assigns keys to members, and why membership changes remap only a small, predictable portion of the data.
-
Browser Microtasks and the Render Queue
How browsers drain promise callbacks between tasks and rendering, and why that ordering changes logs, DOM updates, timers, and responsiveness.
-
Copy-on-Write fork() and Copying Page Faults
How Linux makes fork() cheap by sharing memory pages until parent or child writes to one.
-
Schmitt Triggers and Hysteresis
Positive feedback gives a Schmitt trigger separate rising and falling thresholds, turning noisy or slow analog signals into stable digital edges.
-
AWS Lambda Execution Environments and Cold Starts
How Lambda initializes execution environments, reuses their state, and creates separate environments as concurrent invocations increase.
-
Bloom Filters: Bit Arrays, Hash Probes, and False Positives
Learn how Bloom filters use hashed bit positions for cheap membership checks, and why sizing and probe count control false positives.
-
EUV Reflective Masks, Mirrors, and Vacuum Optics
How EUV masks and projection mirrors pattern wafers, and why 13.5-nanometer light forces the entire optical path into vacuum.
-
How Work-Stealing Deques Reduce Scheduler Contention
A work-stealing deque gives each worker fast local task operations while letting idle workers take tasks from the opposite end.
-
Static Single Assignment Form and Phi Functions
How SSA gives each value one definition, while φ-functions merge control-flow paths so compiler optimizations remain correct.
-
How a Buck Converter Reduces DC Voltage
A buck converter turns a higher DC voltage into a regulated lower one by switching current through an inductor and controlling duty cycle.
-
Linux epoll Interest and Ready Lists
How epoll records monitored file descriptors, reports readiness, and changes an event loop’s obligations under level- and edge-triggered modes.
-
Go’s G-M-P Scheduler Explained
How Go’s scheduler maps goroutines onto OS threads, uses processors, and steals work when blocking would otherwise stop progress.
-
TLS 1.3 Handshake and Shared Traffic Keys
How TLS 1.3 combines ephemeral Diffie–Hellman, transcript hashes, and Finished messages to create keys and detect tampering or downgrade attempts.
-
Raft Leader Election and Majority Voting
How Raft uses terms, randomized timeouts, and majority votes to elect one leader and keep conflicting log entries from being committed.
-
TLB Shootdowns and Cross-Core Translation Invalidation
How operating systems keep per-core address-translation caches correct when a process’s page tables change.
-
Chemical-Mechanical Planarization in Semiconductor Fabrication
How a rotating pad, reactive abrasive slurry, and feedback controls flatten wafer layers while preserving the devices underneath.
-
AES-GCM Nonces, Counters, and Authentication Tags
How AES-GCM encrypts with a nonce-derived counter stream, authenticates data with a tag, and fails catastrophically when nonces repeat.
-
RCU Read-Side Critical Sections and Grace Periods
How RCU lets readers access shared data without locks while writers publish replacements and reclaim old versions safely.
-
Git Reflog and Recovering Lost Commits
Git’s reflog records reference movements so you can find and recover commits after resets, rebases, deleted branches, and other history changes.
-
Windows I/O Completion Ports
How Windows queues overlapped I/O completions to a bounded worker pool for scalable servers and services.
-
Transformer Key-Value Cache During Generation
A transformer KV cache keeps earlier attention keys and values so each generated token avoids rebuilding the entire prefix.
-
Pulse-Doppler Radar Range and Velocity Processing
How coherent pulse trains separate echo delay from Doppler phase, and why PRF creates blind speeds and ambiguous range-Doppler measurements.
-
Python Descriptors: Properties, Methods, and Slots
How Python’s __get__, __set__, and __delete__ hooks control attribute access and power properties, bound methods, and slot-based storage.
-
Linux cgroup v2 memory.high and Memory Reclaim
How memory.high applies reclaim and throttling before memory.max can trigger an out-of-memory kill, including hierarchical accounting.
-
Droop Control in Generators and Grid Inverters
How frequency-based power adjustment lets generators and inverters share changing grid load without a central real-time controller.
-
TCP Retransmission Timeout Estimation
How TCP combines measured round-trip time and its variability to choose a timeout that avoids duplicate retransmissions and slow loss recovery.
-
MVCC Snapshots and Row Version Visibility
How MVCC snapshots choose visible row versions so SQL readers and writers can run concurrently without blocking each other.
-
Ethereum Merkle Patricia Tries Explained
How Ethereum’s keyed, hashed tries commit to account and contract storage state—and let a verifier check values using only a root and proof nodes.
-
Go’s Concurrent Garbage Collector
How Go combines tri-color marking, write barriers, and brief pauses to reclaim unreachable heap objects while goroutines keep running.
-
Linux io_uring Shared Rings and Batching
How io_uring moves requests through shared submission and completion rings, and how batching and polling reduce syscall and scheduling costs.
-
Linux Page Cache and Dirty-Page Writeback
How Linux serves file reads from memory and turns modified cached pages into storage writes and durable data.
-
SQL Query Cardinality Estimation and Histograms
How SQL planners use table statistics to estimate predicate results and choose scans, joins, and execution strategies.
-
QUIC Connection IDs and Network Path Migration
QUIC connection IDs let endpoints recognize the same encrypted connection after its IP address, port, or network path changes.
-
Lithium-Ion State of Charge Estimation
How battery-management systems integrate current to estimate charge, then use rested voltage to correct the drift that makes calibration necessary.
-
Linux Futexes: User-Space Fast Paths and Kernel Wait Queues
Futexes let synchronization stay in user space when uncontended and use kernel wait queues only when threads must sleep.
-
DNS Negative Caching: NXDOMAIN, NODATA, and SOA TTLs
How DNS caches missing names and records, and why NXDOMAIN or NODATA can outlive the change that fixes them.
-
The AI Agent Tool-Calling Loop
How a model requests tools, how the host validates and runs them, and how results become context for the next model turn.
-
Go Interface Values: Dynamic Types, Values, and Typed Nil
Understand the type-and-value pair inside every Go interface and why an interface holding a typed nil is not itself nil.
-
Argon2 Memory-Hard Password Hashing
How Argon2 uses configurable time, memory, and parallelism costs to make offline password guessing expensive.
-
HTTP/2 HPACK Header Compression
How HPACK uses shared tables, indexed fields, and Huffman coding to reduce HTTP/2 header overhead without losing decoder synchronization.
-
Hybrid Logical Clocks
How hybrid logical clocks combine wall-clock readings and counters to preserve causality across distributed systems despite clock skew.
-
Python’s Vectorcall Protocol
How CPython passes callable arguments as arrays to avoid temporary tuples, dictionaries, and bound methods on common calls.
-
CPython’s Cyclic Garbage Collector
How CPython finds reference cycles that reference counting cannot reclaim, and how generations and thresholds decide when to collect them.
-
OAuth 2.0 PKCE and Authorization Code Binding
PKCE binds an OAuth authorization code to the client request that created it, preventing intercepted codes from being redeemed by an attacker.
-
Skip Lists and Expected Logarithmic Index Operations
Layered linked lists let skip lists search, insert, and delete ordered data in expected logarithmic time through randomized node heights.
-
Shallow-Trench Isolation in Semiconductor Manufacturing
How etched, lined, and dielectric-filled trenches keep neighboring semiconductor devices electrically separate on the same silicon wafer.
-
Acquire and Release Memory Ordering
How release operations publish prior writes to acquire operations without forcing every atomic access into one global order.
-
SQL Write-Ahead Logs and Crash Recovery
A write-ahead log records transaction changes durably before data pages, allowing a SQL database to recover committed work after a crash.
-
FinFETs and Multi-Sided Gate Control
How a raised silicon fin lets the gate control the channel from multiple sides, reducing leakage as transistor dimensions shrink.
-
Copy-on-Write Memory During Linux fork
How Linux lets forked processes share physical pages safely until a write requires a private copy.
-
Browser Microtasks and the Render Queue
How promise callbacks run between browser tasks, and how long microtask chains can delay rendering and user input.
-
Atomic Layer Deposition and Conformal Semiconductor Films
How alternating, self-limiting surface reactions deposit uniform films inside the smallest semiconductor features.
-
CPython’s Global Interpreter Lock
How CPython’s GIL protects interpreter state, makes threads contend, and affects CPU-bound and I/O-bound programs differently.
-
Quorum Reads and Writes in Replicated Datastores
How N, R, and W thresholds trade consistency for availability when replicated datastore nodes fail or lag.
-
AWS Signature Version 4 Request Authentication
How AWS SigV4 canonicalizes requests, derives scoped HMAC keys, checks timestamps, and proves a request was not altered.
-
Git Packfiles and Delta Compression
How Git packfiles combine objects, store deltas and chains, and change repository size and lookup behavior during repacking.
-
Linux TLB Shootdowns on Multicore Systems
How Linux keeps per-CPU virtual-to-physical translation caches correct, and why invalidating them with IPIs can hurt multicore performance.
-
Speculative Decoding with Draft and Target Models
Speculative decoding uses a fast model to propose tokens and a slower model to verify several of them in parallel, reducing generation latency.
-
Consistent Hashing Rings and Virtual Nodes
Learn how hash rings and virtual nodes assign cache keys so adding or removing a host remaps only a fraction of the keyspace.
-
Compiler Escape Analysis and Stack Allocation
How compilers follow object references to decide whether an allocation can stay in a stack frame or must be managed on the heap.
-
TypeScript Structural Assignability and Excess Properties
Why TypeScript compares object shapes, yet may reject a direct object literal that a variable with the same fields can pass.
-
Python Asyncio Task Cancellation
Understand how asyncio injects CancelledError, propagates cancellation through awaited tasks, and lets coroutines clean up safely.
-
HTTP ETags and If-None-Match Revalidation
Learn how clients revalidate cached HTTP responses with ETags, and why 304 Not Modified is different from sending a 200 response body.
-
Rapid Thermal Annealing of Ion-Implanted Wafers
How a brief high-temperature pulse repairs implant damage and activates dopants while keeping junctions from spreading by diffusion.
-
How W3C Trace Context Propagates Distributed Traces
Learn how traceparent carries trace identity, parent-child span relationships, and sampling decisions across service boundaries.
-
The Go Scheduler’s G-M-P Model
How goroutines, OS threads, processors, parking, wake-ups, and work stealing cooperate to keep Go code running efficiently.