Tech

Tech / 23 Sep 2026 / 5 min read

TCP Keepalive Probes Detect Silent Dead Peers

An established TCP connection can remain quiet for a long time. Silence alone does not mean either endpoint has failed: an application may simply have no data to exchange. That property is useful for long-lived sessions, but it also creates an operational problem when a peer disappears without sending FIN or RST. A machine can lose power, a network path can fail, or state in an intermediate device can vanish. The surviving endpoint may retain a socket that still appears established because no packet has arrived to prove otherwise. TCP keepalive provides an optional mechanism for testing such idle connections.

TCP Networking

Tech / 23 Sep 2026 / 6 min read

PCIe Posted Writes Separate Transmission from Device Observation

PCI Express does not treat every request as a round trip. A Memory Write Request is normally a posted transaction: the requester sends a transaction layer packet carrying the write, but the completer does not return a Completion TLP for that individual request. This removes completion traffic from a common high-volume path, while placing more importance on ordering and explicit synchronization when software needs evidence that a write has progressed far enough.

PCI Express Hardware

Tech / 23 Sep 2026 / 5 min read

Linux RCU Grace Periods Separate Removal from Reclamation

Read-Copy Update, commonly called RCU, is a synchronization family used throughout the Linux kernel for data that is read frequently and changed less often. Its central move is to separate two events that ordinary locking often treats as one: removing an object from a shared structure and reclaiming the memory that stored it. A writer can publish a new state or unlink an old object while readers continue through read-side critical sections. The old storage remains valid until the kernel has established that every reader that could have observed the old reference has passed through a quiescent state. That interval is an RCU grace period.

Linux RCU

Tech / 23 Sep 2026 / 5 min read

Linux fork Uses Copy-on-Write to Delay Private Page Copies

fork() creates a new process with a virtual address space derived from the caller, but Linux does not need to duplicate every private physical page at the instant the syscall returns. For ordinary private writable mappings, the kernel can arrange parent and child page tables so both processes initially refer to the same physical memory while writes are constrained by copy-on-write state. This design makes process creation proportional to page-table and kernel bookkeeping rather than to the full amount of resident private data. Physical copying is deferred until a write requires the two address spaces to diverge.

Linux Virtual Memory

Tech / 23 Sep 2026 / 7 min read

epoll Readiness Modes Change How Event Loops Drain File Descriptors

Linux epoll lets one thread wait on readiness changes across many file descriptors without scanning every descriptor on each iteration. The interface is common in network servers, proxies, runtimes, and other programs that keep large sets of sockets active. The registration mode matters. Level-triggered operation keeps reporting a descriptor while the relevant condition remains ready. Edge-triggered operation reports transitions in readiness and expects the application to consume available work until the descriptor would block.

Linux epoll

Tech / 22 Sep 2026 / 6 min read

TCP TIME_WAIT Keeps Closed Connections Distinct from Delayed Segments

A TCP connection can finish exchanging application data and still leave a socket record behind. The familiar TIME_WAIT state is part of TCP’s close machinery, not evidence that a process forgot to close a descriptor. The endpoint that performs the active close commonly enters TIME_WAIT after the closing handshake. It keeps enough state for a bounded interval so late segments from the old connection cannot be confused with traffic from a later connection using the same endpoint identity.

Networking TCP

Tech / 22 Sep 2026 / 7 min read

NVMe Completion Queue Phase Tags Mark Reused Entries

An NVMe completion queue is a fixed-size circular array in host memory. The controller writes completion queue entries as commands finish, while host software consumes those entries and advances the queue head. Eventually both sides return to slots that already contain data from an earlier circuit of the ring. Reusing memory creates a small but important ambiguity. A slot can contain a perfectly formed completion entry even when the controller has not written a new completion there yet. Clearing every consumed entry would add memory traffic and still require careful coordination between the host and controller.

Storage NVMe

Tech / 22 Sep 2026 / 6 min read

NVMe Completion Queue Phase Tags Distinguish New Entries After Ring Wrap

An NVMe completion queue is a circular memory structure shared by a controller and host software. The controller posts completion queue entries after commands finish, while the host consumes those entries and advances its queue head. Once either side reaches the final slot, its index wraps to slot zero. That wrap creates a small but important state problem. Queue memory still contains bytes from earlier completions. Reading a nonzero entry at the current head is not enough to prove that the controller has posted a fresh completion there. NVMe solves this with a one-bit Phase Tag carried in every completion queue entry.

NVMe Storage

Tech / 22 Sep 2026 / 7 min read

NUMA First-Touch Placement Ties Physical Pages to the Faulting CPU

On a NUMA machine, reserving virtual address space does not necessarily choose the physical NUMA node that will supply every page. For anonymous memory, physical allocation commonly happens later, when a CPU first faults on a page. Under the default local allocation policy, that fault can make initialization order part of the memory-placement decision. This behavior is often called first-touch placement. The thread that first writes or otherwise faults a page can cause Linux to allocate backing memory near the NUMA node on which that thread is running, subject to the active memory policy, cpuset constraints, available memory, and kernel fallback behavior.

Linux NUMA

Tech / 22 Sep 2026 / 6 min read

Linux TCP Receive Autotuning Expands Buffer Capacity with Flow Demand

A TCP receiver can accept data only while it has room to hold bytes that the application has not consumed. On Linux, that capacity does not have to remain fixed at the small amount available when a connection starts. Receive autotuning can enlarge the socket’s receive buffer as the connection develops, subject to system limits and the state of the flow. That behavior matters most when a connection carries sustained traffic across a path with a sizable bandwidth-delay product. A receiver with too little usable window can constrain the sender even when the network and sender could carry more data. Extra receive capacity gives TCP room to keep data in flight while the application drains the socket.

Linux TCP

Tech / 22 Sep 2026 / 5 min read

Linux Buffered Writes Separate Write Completion from Storage Persistence

A successful buffered write() does not generally mean that the new file data has already reached non-volatile storage. On Linux, the common buffered I/O path places file data in the page cache, marks the affected cache state dirty, and lets storage I/O occur later. That separation is central to normal filesystem I/O. Memory absorbs application writes at CPU-accessible speed, while the kernel can schedule backing-device traffic independently. The result improves flexibility and can reduce immediate storage stalls, but it also creates a boundary between syscall completion and persistence.

Linux Storage

Tech / 22 Sep 2026 / 4 min read

io_uring Registered Buffers Pin User Pages for Repeated I/O

Linux io_uring can submit asynchronous I/O with ordinary user buffers, but repeated operations may still require the kernel to resolve and pin the relevant user pages for each request. Registered buffers move part of that work into an explicit setup phase. An application registers one or more memory regions with the ring. The kernel records those regions and keeps the backing pages pinned while the registration remains active. Later requests can refer to a registered region by index instead of presenting an arbitrary buffer that must be prepared from scratch.

Linux io_uring

Tech / 19 Sep 2026 / 4 min read

Write-Combining Device Memory Can Merge CPU Stores Before I/O

Write-Combining Device Memory Can Merge CPU Stores Before I/O A sequence of CPU stores to device memory does not necessarily become an identical sequence of bus transactions. With a write-combining mapping, the processor may collect adjacent stores and emit a larger transfer later. That behavior suits framebuffer-like regions and other device buffers built for bulk writes, but it changes the ordering and transaction assumptions a driver can safely make. Linux exposes this mapping class through interfaces such as ioremap_wc(). It is distinct from the default ioremap() mapping used for ordinary control registers.

MMIO Linux

Tech / 19 Sep 2026 / 5 min read

When a Transformer Surface Can Become an Electric-Shock Hazard

A transformer can have exposed metal around its core, frame, mounting hardware, or enclosure while carrying hazardous voltage on its windings. Those metal parts are not automatically live simply because the transformer is energized. Whether touching them can produce an electric shock depends on the transformer’s construction, insulation condition, protective earthing, and the electrical path between the person and the circuit. The important distinction is between a conductor intended to carry voltage and an accessible conductive part that should remain separated from it.

Transformer Electrical Safety

Tech / 19 Sep 2026 / 7 min read

What Happens When a Charger Cannot Supply Enough Current

A charger’s current rating is a capacity limit, not a fixed amount of current that it forces into a device. A 5 V, 3 A supply does not continuously push 3 A into every connected load. The load draws current according to its circuitry, while the source must keep its output within specification up to the current it is designed to provide. The interesting case begins when the device would benefit from more power than the source can supply. Depending on the charger, cable, charging protocol, and device power-management circuit, the result can be slower charging, reduced input voltage, source shutdown, repeated reconnects, or battery discharge even while the charger remains connected.

Charging Power Supply

Tech / 19 Sep 2026 / 5 min read

What Actually Receives a Radio Signal: Antenna, Tuning, Detection, and Amplification

A radio receiver does not begin with a transistor. It begins at the antenna terminals, where an electromagnetic field produces a small RF voltage and current that the rest of the circuit can process. That distinction matters in discrete-transistor projects. An antenna, a tuned network, a detector, and an amplifier perform different electrical jobs. Combining their names into “the radio circuit” hides the boundary that determines whether a receiver can select a station, recover its modulation, and produce enough output to hear.

Electronics Radio

Tech / 19 Sep 2026 / 8 min read

What a DT-9205A Digital Multimeter Can Measure and Where Its Limits Matter

The DT-9205A is a manual-ranging digital multimeter built around a 3½-digit LCD, typically displaying values up to 1999 counts. Its rotary switch selects both the measurement function and the range, so the meter depends more heavily on correct setup than an autoranging instrument. The DT-9205A name is used by multiple manufacturers and sellers. Functions and maximum ranges can differ between versions, even when the front panels look similar. The markings on the actual meter and its supplied manual therefore take precedence over specifications found for another DT-9205A variant.

Digital Multimeter DT-9205A

Tech / 19 Sep 2026 / 7 min read

Web3 Domains Do Not Replace DNS: The ENS Resolution Boundary

A name such as alice.eth looks like an Internet domain, but its resolution path is not the same as example.com. A conventional domain normally enters the Domain Name System, where resolvers follow the DNS hierarchy to obtain records such as A, AAAA, MX, or TXT. An ENS name enters a different naming system whose authoritative state is expressed through Ethereum smart contracts. That distinction is the practical boundary behind many claims about “Web3 domains.” The name can be globally meaningful to software that implements ENS resolution while remaining unknown to a DNS resolver. A browser, wallet, or dApp therefore needs an ENS-aware resolution path before .eth can behave like a useful name.

Tech Web3

Tech / 19 Sep 2026 / 6 min read

TLB Shootdowns Extend Page-Table Changes Across CPUs

TLB Shootdowns Extend Page-Table Changes Across CPUs Changing a page-table entry in memory does not by itself retire every translation derived from that entry. A CPU that previously used the mapping can retain it in a translation lookaside buffer, or TLB. On a multiprocessor system, other CPUs may hold their own cached copies, so a mapping change can require coordination beyond the CPU that modified the page table. Linux exposes this distinction through its TLB-flush interfaces. After page-table state changes, architecture code must make the affected translations unusable on every relevant CPU before software relies on the new mapping or releases memory that the old mapping could reach.

CPU TLB

Tech / 19 Sep 2026 / 7 min read

TLB Shootdowns Coordinate Page-Table Changes Across CPUs

A page-table entry can change in memory while another CPU still holds the old address translation in its translation lookaside buffer (TLB). Updating the page table alone therefore does not necessarily make the new mapping effective on every processor that has executed the affected address space. Operating systems close that gap with TLB invalidation. When a mapping change can make a cached translation unsafe, processors that may retain the translation must invalidate it before the kernel treats the change as globally complete. On a multiprocessor system, coordinating those remote invalidations is commonly called a TLB shootdown.

CPU Memory Management

Tech / 19 Sep 2026 / 5 min read

The Same 100 Ohm Resistor Behaves Differently at 3 V and 5 V

A 100 Ω resistor is still a 100 Ω resistor whether it is connected to 3 V or 5 V, provided it remains within its specified operating conditions. What changes is not the nominal resistance but the electrical state around it: current, voltage drop, and power dissipation. That distinction matters because a resistor does not generate an output voltage on its own. Its voltage and current are determined by the surrounding circuit.

Electronics Resistor

Tech / 19 Sep 2026 / 5 min read

Streaming DMA Mappings Transfer Buffer Ownership Between CPU and Device

Streaming DMA Mappings Transfer Buffer Ownership Between CPU and Device A DMA buffer can be valid memory for both a CPU and a device while still requiring a strict handoff between them. Linux streaming DMA mappings express that handoff. The mapping API supplies a device-visible DMA address and gives the DMA layer a point at which architecture-specific cache maintenance, address translation, or bounce buffering can occur. This matters most on systems where device DMA is not automatically coherent with CPU caches, but the ownership rules are part of the portable DMA API even on machines where cache maintenance becomes a no-op.

DMA Linux

Tech / 19 Sep 2026 / 7 min read

SMTP Does Not Grant Sender Identity: From Headers, SPF, DKIM, and DMARC

SMTP answers a transport question: which server accepts this message and relays it toward its destination? It does not, by itself, prove that the address displayed in the message’s From: header belongs to the system that opened the SMTP connection. That distinction explains a common surprise. A mail client can connect to an external SMTP service, authenticate successfully, and submit a syntactically valid message with From: user@gmail.com. The SMTP login proves that the client may use that service. It does not give the service authority over gmail.com.

SMTP Email

Tech / 19 Sep 2026 / 7 min read

Reliable ESP32 IR Air-Conditioner Control Needs Hysteresis and State Synchronization

An ESP32 can turn a conventional infrared air conditioner into a temperature-driven controller without modifying the AC itself. The basic signal path is simple: a room-temperature sensor feeds the ESP32, the firmware decides whether cooling is required, and an IR LED transmits the same kind of frame the handheld remote would send. The difficult part is not producing infrared light. It is keeping the control loop stable while working with an appliance whose IR protocol may encode the remote’s complete state in every transmission.

ESP32 Infrared