<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>miti99</title><link>https://miti99.com/en/</link><description>Recent content on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/index.xml" rel="self" type="application/rss+xml"/><item><title>My Late-2026 Workspace Setup: DeskMini at Home, code-server in the Cloud</title><link>https://miti99.com/en/post/2026/11/04/</link><pubDate>Wed, 04 Nov 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/11/04/</guid><description>&lt;p&gt;I wanted to be able to open my workspace from any device, let coding agents shoulder more and more of the heavy lifting, and make the most of long-term free tiers. After plenty of rounds of installing, testing, and tearing things down, my late-2026 setup has settled into three parts:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;In the cloud:&lt;/strong&gt; &lt;code&gt;code-server&lt;/code&gt; running inside a container on OCI Always Free ARM, deployed via Coolify from &lt;a href="https://github.com/tiennm99/composes" rel="noopener noreferrer"&gt;tiennm99/composes&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;At home:&lt;/strong&gt; an ASRock DeskMini X600 running Ubuntu, handling heavy builds, containers, and coding agents for remote access.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;On the go:&lt;/strong&gt; a lightweight ThinkPad acting as a thin client to connect to the other two over SSH, Tailscale, or &lt;code&gt;code-server&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Getting here took plenty of trial and error: switching &lt;code&gt;code-server&lt;/code&gt; images, hunting for a good browser-based terminal, and spending two weeks wrestling with remote Linux desktop solutions. Some things stuck; others now live only in my archive folder.&lt;/p&gt;
&lt;p&gt;This post was drafted with AI assistance from my Git history, plans, and notes, and I then filled in the reasoning behind each decision. I didn&amp;rsquo;t check the DeskMini live while writing; anything unverified or where I no longer remember the exact reason is called out explicitly in the relevant section.&lt;/p&gt;
&lt;h2 id="starting-point-code-server-in-a-container"&gt;Starting Point: &lt;code&gt;code-server&lt;/code&gt; in a Container&lt;/h2&gt;&lt;p&gt;I&amp;rsquo;ve been self-hosting Coolify since at least May 2025. On August 14, 2026, while reorganizing my &lt;code&gt;composes&lt;/code&gt; repo, I added &lt;code&gt;code-server&lt;/code&gt; using the LinuxServer.io image (lsio for short). Go, Node, and Python were installed via &lt;code&gt;DOCKER_MODS&lt;/code&gt;, and extra packages via &lt;code&gt;INSTALL_PACKAGES&lt;/code&gt;. The &lt;code&gt;abc&lt;/code&gt; user&amp;rsquo;s home directory lived at &lt;code&gt;/config&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Running that image under Coolify had a few annoyances. Every redeploy recreated the container, re-downloaded the mods, and forced &lt;code&gt;apt&lt;/code&gt; to resolve the entire &lt;code&gt;INSTALL_PACKAGES&lt;/code&gt; list from scratch — enough that I had to trim the package list down. Worse, if a mod failed to install, the error was simply logged and ignored: the editor still opened, just missing tools. Freshly created workspace volumes were also owned by &lt;code&gt;root&lt;/code&gt;, which I had to work around in a Dockerfile.&lt;/p&gt;
&lt;p&gt;Those were the friction points with lsio. The reason I switched to Coder&amp;rsquo;s official image was to stay closer to upstream. I added &lt;code&gt;codercom/code-server&lt;/code&gt; with a custom Dockerfile on October 6, then removed the lsio setup and moved it to the archive on October 12.&lt;/p&gt;
&lt;p&gt;The new Dockerfile bakes in the tools I need right at build time: build-essential, &lt;code&gt;bubblewrap&lt;/code&gt;, networking CLIs, search and linting tools, database clients, plus &lt;code&gt;gh&lt;/code&gt;, Docker CLI, Compose, Buildx, &lt;code&gt;glab&lt;/code&gt;, and &lt;code&gt;gt&lt;/code&gt;. That way, helper commands and shell completions are ready out of the box. I use &lt;code&gt;FROM codercom/code-server:latest&lt;/code&gt; because the official image doesn&amp;rsquo;t publish major-version tags.&lt;/p&gt;
&lt;p&gt;So that &lt;code&gt;agent-browser&lt;/code&gt; can run headlessly on ARM64, the image includes Debian&amp;rsquo;s Chromium package along with the required fonts, and I tuned shared memory so Chromium wouldn&amp;rsquo;t crash. GTK and WebKitGTK are included for headless Tauri builds and tests.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Language toolchains, on the other hand, stay in my home directory outside the image:&lt;/strong&gt; &lt;code&gt;fnm&lt;/code&gt;, &lt;code&gt;uv&lt;/code&gt;, &lt;code&gt;rustup&lt;/code&gt;, Go from the official tarball, and SDKMAN. Baking another copy into the image would only bloat the build while getting shadowed by the versions in &lt;code&gt;$HOME&lt;/code&gt; anyway. Keeping them separate also prevents a container redeploy from silently upgrading the compiler or runtime version I&amp;rsquo;m in the middle of using.&lt;/p&gt;
&lt;p&gt;One remaining annoyance is typing Vietnamese inside the browser terminal when using Claude Code. As of my last notes on October 18, I still haven&amp;rsquo;t found an officially supported fix. Backspace events and diacritic composition have to travel through the entire chain of browser → &lt;code&gt;xterm.js&lt;/code&gt; → WebSocket → PTY. For now, I just type longer Vietnamese text outside and paste it in.&lt;/p&gt;
&lt;h2 id="things-i-evaluated-tried-and-removed-on-the-server"&gt;Things I Evaluated, Tried, and Removed on the Server&lt;/h2&gt;&lt;p&gt;Alongside switching the &lt;code&gt;code-server&lt;/code&gt; image, I looked for ways to use a terminal and coding agents directly in the browser. Between September and early November, several tools came and went on the server:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;OpenHands:&lt;/strong&gt; tried from September 18 to 19 — about a day.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;opencode web:&lt;/strong&gt; tried from September 18 to October 5 for a browser-based shell.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Paseo:&lt;/strong&gt; used from September 16 to November 3 (last tweaked on October 6). This daemon initially seemed like a good fit, but each agent CLI needed around 200 MB installed at startup. I eventually dropped it because Orca and T3 Code offered better features and a smoother experience.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;For OpenHands and opencode web, I didn&amp;rsquo;t write down why I removed them.&lt;/p&gt;
&lt;p&gt;The Zellij web client was the one I really wanted to make work. I ran it in a container from October 21 to November 3, but immediately ran into keyboard shortcut conflicts: the browser reserves &lt;code&gt;Ctrl+T&lt;/code&gt;, &lt;code&gt;Ctrl+W&lt;/code&gt;, &lt;code&gt;Ctrl+N&lt;/code&gt;, and &lt;code&gt;Ctrl+Tab&lt;/code&gt; — the exact combinations I needed for Zellij&amp;rsquo;s modes. With the Unlock-First layout, &lt;code&gt;Ctrl+G&lt;/code&gt; opened Firefox&amp;rsquo;s find bar instead, so I had to rebind it to &lt;code&gt;Alt+G&lt;/code&gt;. On top of that, opening the root URL always spawned a brand-new session that I couldn&amp;rsquo;t clean up from the UI. Ultimately, the shortcut conflicts were what made me drop it.&lt;/p&gt;
&lt;p&gt;While setting it up, I also used &lt;code&gt;socat&lt;/code&gt; as a relay and ran into a quirk where Zellij exited silently if its config file was missing.&lt;/p&gt;
&lt;p&gt;Typing occasionally felt laggy too, though I never proved Zellij was the culprit. The container itself was barely under any load; an incorrect &lt;code&gt;TERM&lt;/code&gt; variable, Vietnamese IME input through the browser, or network latency could all have played a part. I did fix one specific bug where &lt;code&gt;TERM=unknown&lt;/code&gt; caused Backspace to move the cursor to the right.&lt;/p&gt;
&lt;p&gt;An alternative I evaluated on October 24 was &lt;code&gt;tmux&lt;/code&gt; over &lt;code&gt;ttyd&lt;/code&gt;. Because &lt;code&gt;tmux&lt;/code&gt; uses &lt;code&gt;Ctrl+B&lt;/code&gt; as its prefix, its default bindings clash much less with browser shortcuts than Zellij&amp;rsquo;s modal bindings — though it still has to live within whatever keys the browser allows through.&lt;/p&gt;
&lt;p&gt;I added a &lt;code&gt;ttyd&lt;/code&gt; template to the repo but never actually deployed it. Soon after, Orca and T3 Code covered my needs, so I archived the template too. A bare terminal alone still felt too limiting anyway: having to ask Claude just to inspect a single file felt unnecessarily roundabout.&lt;/p&gt;
&lt;p&gt;On November 3, I moved Paseo, Zellij, and the &lt;code&gt;ttyd&lt;/code&gt; template into the archive in a single commit. The Zellij container was removed; the only browser terminals I still use are Cloudflare&amp;rsquo;s browser SSH to the DeskMini and the integrated terminal inside &lt;code&gt;code-server&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-deskmini-at-home"&gt;The DeskMini at Home&lt;/h2&gt;&lt;p&gt;The machine sitting at home is an ASRock DeskMini X600: X600M-STX motherboard, Ryzen 7 8700G (8 cores, 16 threads, integrated Radeon 780M graphics), and 32 GB of RAM. It has two 500 GB NVMe drives — one for the OS and one for my workspace. As of my October 21 check, it runs Ubuntu 26.04 Desktop with GNOME on Wayland.&lt;/p&gt;
&lt;p&gt;I picked the DeskMini because it&amp;rsquo;s compact yet powerful and has a capable iGPU, making it a great &lt;strong&gt;always-on home Linux box for heavy workloads and remote access&lt;/strong&gt;. My Windows desktop is even more powerful, but I didn&amp;rsquo;t want to run a Windows rig 24/7 for that role. When I&amp;rsquo;m at home, I still sit at my Windows desktop; when I&amp;rsquo;m at the office and need a beefy homelab, I open Orca on the DeskMini over Tailscale.&lt;/p&gt;
&lt;p&gt;That keeps my ThinkPad light and cool: compiling, running containers, language toolchains, and long-running tasks all happen on the DeskMini or the cloud server. The DeskMini doesn&amp;rsquo;t run Coolify — services there use plain Docker Compose and &lt;code&gt;systemd&lt;/code&gt;, with browser access routed through Cloudflare Tunnel and Access.&lt;/p&gt;
&lt;p&gt;I gradually set up its toolchains starting in late October: Node via &lt;code&gt;fnm&lt;/code&gt;, Python via &lt;code&gt;uv&lt;/code&gt;, Go from the official tarball with &lt;code&gt;GOTOOLCHAIN=auto&lt;/code&gt;, Rust via &lt;code&gt;rustup&lt;/code&gt;, and Java 21 via SDKMAN, alongside &lt;code&gt;gcc&lt;/code&gt;, &lt;code&gt;git&lt;/code&gt;, &lt;code&gt;gh&lt;/code&gt;, Docker, &lt;code&gt;glab&lt;/code&gt;, and later &lt;code&gt;gt&lt;/code&gt;. One easy-to-forget gotcha when writing automation scripts: &lt;code&gt;fnm&lt;/code&gt; and SDKMAN are loaded in interactive &lt;code&gt;zsh&lt;/code&gt; startup files, so &lt;code&gt;cron&lt;/code&gt; jobs and &lt;code&gt;systemd&lt;/code&gt; services won&amp;rsquo;t see them automatically.&lt;/p&gt;
&lt;p&gt;Since October 22, the DeskMini has had its own dedicated notes in my workspace repo. At that time, its role was also tied to something I really wanted to get working smoothly: opening a full Linux desktop right inside the browser via Apache Guacamole.&lt;/p&gt;
&lt;h2 id="two-weeks-chasing-a-browser-based-linux-desktop"&gt;Two Weeks Chasing a Browser-Based Linux Desktop&lt;/h2&gt;&lt;p&gt;My goal at the time was very specific: open my Linux desktop from anywhere in a browser without installing any client software on the machine in front of me. That meant routing through Cloudflare Tunnel and Access rather than requiring Tailscale on the client machine.&lt;/p&gt;
&lt;p&gt;Among the options I surveyed on October 19, Guacamole stood out as free, self-hosted, clientless, and capable of speaking RDP to both Linux and Windows. Cloudflare&amp;rsquo;s browser RDP ranked lower in my comparison notes, yet I tried it first anyway. On October 21, GNOME Remote Desktop rejected the connection with:&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;Client did not advertise support for the Graphics Pipeline, closing connection&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;GNOME requires the RDP Graphics Pipeline extension, and Cloudflare&amp;rsquo;s IronRDP client didn&amp;rsquo;t advertise support for it at the time, causing GNOME to close the connection immediately. Cloudflare&amp;rsquo;s documentation also listed only Windows targets as supported. So that path was a dead end with GNOME in my test.&lt;/p&gt;
&lt;p&gt;VNC was also in my survey notes, though I never installed it. With GNOME on Ubuntu 26.04 in this configuration, everything runs on Wayland with GNOME Remote Desktop speaking RDP. The VNC options I looked into required either X11 or &lt;code&gt;wlroots&lt;/code&gt;, and older guides referencing a VNC toggle in GNOME Settings no longer matched this release.&lt;/p&gt;
&lt;p&gt;So I moved on to Guacamole, deploying &lt;code&gt;guacamole&lt;/code&gt;, &lt;code&gt;guacd&lt;/code&gt;, and PostgreSQL via Docker on the DeskMini over October 21–22. I pinned version &lt;code&gt;1.6.0&lt;/code&gt; because it was the first release supporting the RDP Graphics Pipeline (and the &lt;code&gt;latest&lt;/code&gt; tag at the time pointed to an &lt;code&gt;amd64&lt;/code&gt;-only development build).&lt;/p&gt;
&lt;p&gt;The desktop connected, but sessions kept dropping mid-use. The drops happened over both QUIC and HTTP/2 tunnels, and &lt;code&gt;cloudflared&lt;/code&gt; logged no errors corresponding to the disconnects — so switching the tunnel transport didn&amp;rsquo;t help. In the logs I captured, &lt;code&gt;guacd&lt;/code&gt; reported &lt;code&gt;User is not responding.&lt;/code&gt; after 15 seconds of silence and closed the RDP connection. Those 15-second timeouts are hardcoded at compile time and cannot be changed via configuration.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;I still haven&amp;rsquo;t pinned down the root cause.&lt;/strong&gt; At first I suspected the browser was throttling timers in background tabs, but sessions dropped even while the tab was focused right in front of me. The most plausible theory at the time was a set of regressions in Guacamole 1.6.0 — specifically &lt;code&gt;GUACAMOLE-2118&lt;/code&gt;, its duplicate reports, and &lt;code&gt;GUACAMOLE-2081&lt;/code&gt;. Those bugs had already been fixed on the &lt;code&gt;1.6.1&lt;/code&gt; branch, which hadn&amp;rsquo;t been released yet when I investigated.&lt;/p&gt;
&lt;p&gt;Even so, I never ran a pure LAN test to rule out the Cloudflare Tunnel completely. There was also one occasion where both SSH and RDP froze simultaneously despite running in separate &lt;code&gt;guacd&lt;/code&gt; processes, which that bug theory doesn&amp;rsquo;t neatly explain either.&lt;/p&gt;
&lt;p&gt;For SSH through Guacamole, disconnects were even more painful: because the shell was tied directly to the browser connection, a single drop could kill a running command and lose unsaved state. That&amp;rsquo;s what pushed me to move terminal workflows out of Guacamole altogether. I had already drafted the Zellij template on October 21 prior to this debugging session, and the Guacamole SSH drops only reinforced how much I needed terminal sessions that outlive a browser tab.&lt;/p&gt;
&lt;p&gt;Initially, I planned to stay on &lt;code&gt;1.6.0&lt;/code&gt; and wait for &lt;code&gt;1.6.1&lt;/code&gt;, falling back to &lt;code&gt;1.5.5&lt;/code&gt; only if the drops became unbearable (downgrading required backing up PostgreSQL and preparing a &lt;code&gt;1.5.5&lt;/code&gt; schema since Guacamole doesn&amp;rsquo;t support reverse migrations).&lt;/p&gt;
&lt;p&gt;By November 3, I stopped using Guacamole and archived its setup because the connection just wasn&amp;rsquo;t reliable enough. Cloudflare&amp;rsquo;s browser-rendered SSH was sufficient for quick terminal access, and whenever I need a full desktop, I use Tailscale with the official Windows RDP app. My original goal was making everything 100% browser-based, but in the end I compromised on using a native RDP client for desktop sessions.&lt;/p&gt;
&lt;h2 id="whats-running-on-the-deskmini-today"&gt;What&amp;rsquo;s Running on the DeskMini Today&lt;/h2&gt;&lt;p&gt;As of the state recorded when writing this post, browser SSH, &lt;code&gt;code-server&lt;/code&gt;, T3 Code, and Orca are all accessible through &lt;strong&gt;Cloudflare Tunnel and Access&lt;/strong&gt;, while Tailscale connects my personal devices directly.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;code-server&lt;/code&gt;&lt;/strong&gt; is installed from the official &lt;code&gt;.deb&lt;/code&gt; package, runs via &lt;code&gt;systemd&lt;/code&gt;, and has been in my machine notes since October 22. Since it can&amp;rsquo;t use official VS Code Settings Sync, I plan to keep its configuration and extension list — Claude Code plus a theme — in my dotfiles and apply them via a manual script. I haven&amp;rsquo;t applied those dotfiles to the DeskMini yet.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Orca and T3 Code&lt;/strong&gt; were recently migrated from desktop GUI launches to &lt;code&gt;systemd&lt;/code&gt; user services. I installed Orca (&lt;code&gt;stablyai/orca&lt;/code&gt;) from its &lt;code&gt;.deb&lt;/code&gt; package on October 27 (I didn&amp;rsquo;t record the exact date I installed T3 Code). According to my notes, the goal of moving them to user services in early November was having them come up automatically on boot without needing to log into the desktop session first. One quirk with Orca: when run with &lt;code&gt;--supervise&lt;/code&gt;, the service waits if another Orca instance is already serving the same profile, so launching the desktop app first can make the background service wait.&lt;/p&gt;
&lt;p&gt;In my November 2 comparison notes, Orca is described as a desktop workspace built around Git worktrees that runs agent CLIs directly inside terminals, whereas T3 Code organizes work around conversation threads, drives agents through adapters, and offers a lightweight web UI. That comparison was based purely on documentation rather than side-by-side testing, and its conclusion was to keep Orca as my primary tool while trying T3 Code for steering agents from a phone or browser. Today, both run as services, and Orca is the app I use the most.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Tailscale and &lt;code&gt;cloudflared&lt;/code&gt;&lt;/strong&gt; split responsibilities cleanly: Cloudflare Tunnel + Access handle remote sign-in and web UIs, while Tailscale handles direct traffic between my own devices. I went with this split because I found it simpler than setting up WARP-to-WARP. For GNOME Remote Desktop, my research notes distinguish between remote login at the GDM login screen and desktop sharing after logging in, though I don&amp;rsquo;t have recorded test results for that part yet.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Gitea and &lt;code&gt;gitea-mirror&lt;/code&gt;&lt;/strong&gt; run from my &lt;code&gt;composes&lt;/code&gt; repo as my local GitHub backup on the DeskMini. I already told the story of AI crawlers discovering my Gitea instance in &lt;a href="https://miti99.com/en/post/2026/10/29/"&gt;the October 29, 2026 post&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Setting up the mirror had its own hiccups: Gitea&amp;rsquo;s default timeouts cut off multi-gigabyte clones mid-transfer, and Bun&amp;rsquo;s &lt;code&gt;fetch&lt;/code&gt; aborted connections after five minutes without data, leaving half-imported repos behind. Bumping the timeouts fixed that. Health checks polling the GitHub API without a token also hit anonymous rate limits until I lowered their frequency. And in the CLI tooling, I replaced &lt;code&gt;tea&lt;/code&gt; with &lt;code&gt;gt&lt;/code&gt; after &lt;code&gt;tea&lt;/code&gt; was archived upstream and &lt;code&gt;gt&lt;/code&gt; hit &lt;code&gt;1.0.0&lt;/code&gt;. As for why I moved the backup instance from the cloud server to my home DeskMini, I didn&amp;rsquo;t write the reason down, so I won&amp;rsquo;t attribute it to a specific incident.&lt;/p&gt;
&lt;h2 id="remote-power-on-from-rtc-wake-to-a-smart-plug"&gt;Remote Power-On: From RTC Wake to a Smart Plug&lt;/h2&gt;&lt;p&gt;Originally, waking the machine remotely wasn&amp;rsquo;t even in scope. My research notes mentioned using an ESP32 listening to a Telegram bot to send Wake-on-LAN / power signals, though I never built it.&lt;/p&gt;
&lt;p&gt;Starting October 28, I used RTC wake (&lt;code&gt;rtcwake&lt;/code&gt;) via a &lt;code&gt;systemd&lt;/code&gt; unit to schedule the DeskMini to boot itself up. The catch with RTC wake is that a power outage or hard shutdown can cause the machine to miss setting the next wake alarm.&lt;/p&gt;
&lt;p&gt;On November 3, I removed the OS-level RTC wake schedule and switched toward using a smart plug paired with the BIOS &amp;ldquo;restore on AC power loss&amp;rdquo; setting. I didn&amp;rsquo;t record the exact trigger for dropping RTC wake, but the planned workflow is:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Shut the OS down cleanly first — never cut power while the PC is running.&lt;/li&gt;
&lt;li&gt;Turn the smart plug off for about 30 seconds, then turn it back on to trigger boot.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;This part isn&amp;rsquo;t finished yet.&lt;/strong&gt; I still need to disable the RTC alarm in the BIOS, set &lt;em&gt;Restore on AC Power Loss&lt;/em&gt; to &lt;em&gt;Power On&lt;/em&gt;, and test the full smart-plug power cycle as well as simulated power outages. So I can&amp;rsquo;t claim remote power-on via smart plug is working in production just yet.&lt;/p&gt;
&lt;h2 id="coolify-and-two-always-free-cloud-servers"&gt;Coolify and Two Always Free Cloud Servers&lt;/h2&gt;&lt;p&gt;On the cloud side, Coolify manages two OCI Always Free ARM servers running Ubuntu 24.04 Minimal, fronted by Traefik v3 and Let&amp;rsquo;s Encrypt. I chose OCI for its generous, non-expiring free tier. Choosing Coolify over Dokploy came down to personal impression — it felt more stable to me in day-to-day use, though I haven&amp;rsquo;t run formal benchmarks comparing the two. In my compose files, I still keep Dokploy-compatible sections ready just in case.&lt;/p&gt;
&lt;p&gt;My shared deployment configs live in the public &lt;code&gt;composes&lt;/code&gt; repo under the Apache 2.0 license. Each service gets its own folder with a &lt;code&gt;compose.yml&lt;/code&gt;, a &lt;code&gt;README.md&lt;/code&gt;, and an &lt;code&gt;.env.example&lt;/code&gt;, wired up to its own Coolify application with path-filtered webhooks so changes to one service don&amp;rsquo;t trigger redeploys of another. Inline comments explain &lt;em&gt;what&lt;/em&gt; the config does, while the &lt;code&gt;README.md&lt;/code&gt; records &lt;em&gt;why&lt;/em&gt; I chose it. Tools I wrote myself keep their &lt;code&gt;compose.yml&lt;/code&gt; inside their own repositories.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;archive/&lt;/code&gt; directory makes it easy to look back at what I tried and when I retired it. What&amp;rsquo;s occasionally missing is the &lt;em&gt;why&lt;/em&gt; — I didn&amp;rsquo;t always write down the reason I dropped a tool at the moment I removed it.&lt;/p&gt;
&lt;h2 id="keeping-everything-consistent-across-machines"&gt;Keeping Everything Consistent Across Machines&lt;/h2&gt;&lt;p&gt;What keeps both me and my coding agents from getting lost across all these machines is a shared workspace repository checked out everywhere. The repo started on July 25 just to hold a few GitHub audit skills and grew organically from there. By late October, I reorganized per-machine notes so agents only load the context relevant to the host they&amp;rsquo;re running on. Claude Code and Codex share the same rule definitions (though I primarily use Claude Code), and my AgentKit CLI installs the kit into each agent&amp;rsquo;s home directory.&lt;/p&gt;
&lt;p&gt;I split context by how it gets consumed: &lt;strong&gt;rules&lt;/strong&gt; are loaded into every session, &lt;strong&gt;skills&lt;/strong&gt; are read on demand per task, and &lt;strong&gt;memory&lt;/strong&gt; has an always-loaded index pointing to topic files. Hooks block costly mistakes; notes and plans track upcoming work; Git history and docs preserve what already happened. Memory is tracked in Git too. One important lesson I have to keep in mind: only rules are guaranteed to be loaded — if you put a behavioral instruction inside memory, the agent might never read it.&lt;/p&gt;
&lt;p&gt;Dotfiles synchronization, meanwhile, &lt;strong&gt;hasn&amp;rsquo;t been rolled out to any machine yet&lt;/strong&gt;. In my October 29 comparison, I picked &lt;code&gt;chezmoi&lt;/code&gt;: it was the only tool in the group that ships as a single native binary on Windows, supports per-machine templates, prompts once for machine variables, integrates with &lt;code&gt;sops&lt;/code&gt; when applying files, and offers a dry-run diff preview. &lt;code&gt;dotter&lt;/code&gt; came in second, while Ansible required WSL on Windows and felt too heavy compared to managing config files directly.&lt;/p&gt;
&lt;p&gt;My toolchain plan evolved too: on October 30, I dropped &lt;code&gt;mise&lt;/code&gt; from the plan in favor of ecosystem-native managers — &lt;code&gt;rustup&lt;/code&gt;, &lt;code&gt;uv&lt;/code&gt;, &lt;code&gt;fnm&lt;/code&gt;, SDKMAN (or Temurin via &lt;code&gt;winget&lt;/code&gt; on Windows), and the official Go binary with &lt;code&gt;GOTOOLCHAIN=auto&lt;/code&gt;. I didn&amp;rsquo;t log any specific bug with &lt;code&gt;mise&lt;/code&gt; when making that switch.&lt;/p&gt;
&lt;p&gt;For the shell, I plan to switch from &lt;code&gt;oh-my-zsh&lt;/code&gt; + &lt;code&gt;powerlevel10k&lt;/code&gt; to &lt;code&gt;zsh&lt;/code&gt; + &lt;code&gt;zimfw&lt;/code&gt; + Starship. Among the frameworks I compared, &lt;code&gt;zimfw&lt;/code&gt; was the most popular actively maintained option and the fastest in recorded benchmarks, with built-in completions covering nearly everything I need — whereas &lt;code&gt;powerlevel10k&lt;/code&gt;&amp;rsquo;s README explicitly notes that project maintenance is now very limited. That switch is still on the to-do list; the servers are still running &lt;code&gt;oh-my-zsh&lt;/code&gt; for now.&lt;/p&gt;
&lt;h2 id="unfinished-tasks-and-lessons-learned"&gt;Unfinished Tasks and Lessons Learned&lt;/h2&gt;&lt;p&gt;As of November 4, 2026, two items are still unfinished:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Updating the DeskMini BIOS settings and testing smart-plug power-on, including recovery after a power cut.&lt;/li&gt;
&lt;li&gt;Rolling out the dotfiles repo across my machines.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Looking back over all these iterations, a few lessons stand out:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Record the &lt;em&gt;why&lt;/em&gt;, not just the &lt;em&gt;what&lt;/em&gt;.&lt;/strong&gt; Git history reconstructs &lt;em&gt;what&lt;/em&gt; changed and &lt;em&gt;when&lt;/em&gt;, but it can&amp;rsquo;t tell you your motivation if you didn&amp;rsquo;t write it down. Jotting down the reason at decision time saves you from having to reconstruct it later like I did for this post.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Browser-based remote desktops have to be tested against your exact display stack.&lt;/strong&gt; On my GNOME Wayland setup, the RDP Graphics Pipeline requirement ruled out one browser RDP option right away, and older VNC guides no longer applied.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Terminal sessions should survive closing a browser tab.&lt;/strong&gt; Tying a shell&amp;rsquo;s lifecycle directly to a browser connection means a single hiccup can take down whatever command was running.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Separating language toolchains from the container image keeps version upgrades under your control.&lt;/strong&gt; Redeploying a container shouldn&amp;rsquo;t silently swap out the compiler or runtime version you&amp;rsquo;re actively working with.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Splitting access paths by use case makes daily life much simpler.&lt;/strong&gt; Cloudflare Tunnel + Access handle browser logins and web UIs; Tailscale handles direct device-to-device connections.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;This setup will surely keep evolving. Right now, I spend most of my time in Orca, keep &lt;code&gt;code-server&lt;/code&gt; around for opening workspaces in a browser, and let the DeskMini and cloud servers do the heavy lifting. Every tool I tried and retired along the way made it much clearer what I actually need next time.&lt;/p&gt;</description></item><item><title>When AI Crawlers Went Strolling Through My Self-Hosted Gitea</title><link>https://miti99.com/en/post/2026/10/29/</link><pubDate>Thu, 29 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/29/</guid><description>&lt;p&gt;I self-host Gitea on an OCI Always Free server to keep mirrors of my GitHub repositories. I always thought of it as a quiet little corner only I ever visited — until I discovered three regular &amp;ldquo;guests&amp;rdquo; dropping by: ClaudeBot, GPTBot, and Reflectionbot. Starting from a few unusual signs in the logs, I tracked down a private repository that had unintentionally been made public, then figured out how to block the crawlers while keeping all my other apps running smoothly. Here is the full story, from discovery to mitigation and follow-up monitoring.&lt;/p&gt;
&lt;h2 id="discovery"&gt;Discovery&lt;/h2&gt;&lt;p&gt;On the morning of October 29, 2026, I noticed that the server running Gitea in Japan was unusually busy. When I opened Traefik&amp;rsquo;s access log, I realized the logs were rotating so fast that the retained portion only covered about 4.5 hours — from 17:55 to 22:22 UTC on October 28. In just that window, there were &lt;strong&gt;86,765 requests&lt;/strong&gt;.&lt;/p&gt;
&lt;table&gt;
 &lt;thead&gt;
 &lt;tr&gt;
 &lt;th&gt;User agent&lt;/th&gt;
 &lt;th&gt;Requests&lt;/th&gt;
 &lt;/tr&gt;
 &lt;/thead&gt;
 &lt;tbody&gt;
 &lt;tr&gt;
 &lt;td&gt;ClaudeBot (Anthropic)&lt;/td&gt;
 &lt;td&gt;39,860&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;GPTBot (OpenAI)&lt;/td&gt;
 &lt;td&gt;26,901&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Reflectionbot (Reflection AI)&lt;/td&gt;
 &lt;td&gt;16,412&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Bun (my own &lt;code&gt;gitea-mirror&lt;/code&gt; syncing)&lt;/td&gt;
 &lt;td&gt;3,587&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Others (DuckDuckBot, OAI-SearchBot)&lt;/td&gt;
 &lt;td&gt;5&lt;/td&gt;
 &lt;/tr&gt;
 &lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Around 95% of the HTTP 200 responses came from &lt;code&gt;src&lt;/code&gt;, &lt;code&gt;commit&lt;/code&gt;, and &lt;code&gt;raw&lt;/code&gt; pages across 86 mirrored repositories. The crawlers were walking through &lt;strong&gt;every single commit of every single repo&lt;/strong&gt;, and each commit had multiple pages to fetch. Added together, the request volume snowballed fast.&lt;/p&gt;
&lt;p&gt;Looking back at the full month&amp;rsquo;s metrics, traffic was virtually zero until October 10. Starting October 11, it spiked and stayed consistently high:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/requests-by-day.png" alt="Daily request count from September 30 to October 28"&gt;&lt;/p&gt;
&lt;p&gt;In total, that came out to nearly &lt;strong&gt;13.9 million requests&lt;/strong&gt; and &lt;strong&gt;1.48 TB&lt;/strong&gt; of bandwidth — all to serve a Gitea instance meant for an audience of one:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/traffic-overview.png" alt="Traffic overview: requests, unique visitors, bandwidth, error rate, and P95 latency"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;If you self-host on a VPS, keep a close eye on bandwidth costs.&lt;/strong&gt; Data downloaded by bots still counts toward your server&amp;rsquo;s outbound transfer quota. Depending on your provider and plan, going over your allowance can mean surprise overage charges or throttled speeds. I got lucky because OCI&amp;rsquo;s outbound bandwidth allowance is very generous, so this incident didn&amp;rsquo;t cost me anything extra. On a VPS with a tighter cap, though, 1.48 TB from crawlers alone could easily turn into an unexpected bill.&lt;/p&gt;
&lt;p&gt;Nearly all of the traffic came from bots, and almost all of it originated in the United States:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/client-types.png" alt="Client type breakdown: almost entirely Bots"&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/traffic-by-country.png" alt="Traffic by country: United States accounts for 13.51 million requests"&gt;&lt;/p&gt;
&lt;p&gt;ClaudeBot alone accounted for 10.82 million requests and 1.4 TB of bandwidth. GPTBot chipped in another 2.52 million requests:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/ai-bots.png" alt="AI agents &amp;amp; bots table: ClaudeBot and GPTBot"&gt;&lt;/p&gt;
&lt;h2 id="figuring-out-the-cause"&gt;Figuring Out the Cause&lt;/h2&gt;&lt;p&gt;My first worry was whether my account had been compromised. Checking the logs, I found:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Every single request was anonymous — none of them were authenticated.&lt;/li&gt;
&lt;li&gt;No external client sent any POST, PATCH, push, or API requests. All write operations came from the server itself via &lt;code&gt;gitea-mirror&lt;/code&gt; running its sync jobs.&lt;/li&gt;
&lt;li&gt;All three crawlers were legitimate: GPTBot&amp;rsquo;s IPs matched OpenAI&amp;rsquo;s published ranges, ClaudeBot came from Anthropic&amp;rsquo;s IP space, and Reflectionbot&amp;rsquo;s reverse DNS resolved back to &lt;code&gt;reflection.ai&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/crawler-verification.png" alt="Verifying the three crawlers: Reflectionbot, GPTBot, and ClaudeBot are all genuine bots"&gt;&lt;/p&gt;
&lt;p&gt;Nothing pointed to an account breach. The bots were simply crawling pages that Gitea left publicly accessible to anonymous visitors: they requested &lt;code&gt;/robots.txt&lt;/code&gt; first, got a 404 because none existed, and proceeded to scrape every page returning HTTP 200. Looking back, I had left the front door wide open without realizing it; the primary issue to fix was my own configuration.&lt;/p&gt;
&lt;p&gt;While auditing further, I uncovered something much more concerning: &lt;strong&gt;one private repository had been exposed&lt;/strong&gt;. The source repo on GitHub was private, but its mirror on Gitea was &lt;strong&gt;public&lt;/strong&gt;, and Reflectionbot had already fetched 48 pages from it. Tracing the sync history led me to a stale record that &lt;code&gt;gitea-mirror&lt;/code&gt; had reused:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Originally, that repository name belonged to a public repo. When importing it the first time, &lt;code&gt;gitea-mirror&lt;/code&gt; saved the flag &lt;code&gt;is_private = 0&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Later, that public repo was moved to a different namespace.&lt;/li&gt;
&lt;li&gt;I created a new &lt;strong&gt;private&lt;/strong&gt; repository under the old name. The existing record in &lt;code&gt;gitea-mirror&lt;/code&gt; still pointed to that URL and kept the public flag. Because the tool treated it as the same repository, it never re-checked its visibility.&lt;/li&gt;
&lt;li&gt;Gitea kept pulling updates from that URL using my GitHub token. As a result, the contents of the new private repo were synced straight into the public mirror on Gitea.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Even setting &lt;code&gt;visibility: &amp;quot;private&amp;quot;&lt;/code&gt; in &lt;code&gt;gitea-mirror&lt;/code&gt; didn&amp;rsquo;t prevent this: that setting only applies to organizations created by the tool, whereas individual repository visibility is still taken from the GitHub private flag captured at the initial import.&lt;/p&gt;
&lt;p&gt;I audited everything and found 105 repositories readable without signing in, all under my personal Gitea account. All other organizations were private. Out of those 105 public mirrors, only the one I had just caught corresponded to a private repo on GitHub.&lt;/p&gt;
&lt;p&gt;Why Cloudflare hadn&amp;rsquo;t blocked the bots was even simpler: every DNS record for my apps was an &lt;code&gt;A&lt;/code&gt; record set to &lt;strong&gt;DNS only&lt;/strong&gt; (grey cloud). Bots were hitting the origin server directly, so their requests never passed through Cloudflare to be filtered in the first place.&lt;/p&gt;
&lt;h2 id="mitigation"&gt;Mitigation&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;Step one was stopping any further data exposure.&lt;/strong&gt; I stopped both Gitea and &lt;code&gt;gitea-mirror&lt;/code&gt;, then switched the exposed repository to private.&lt;/p&gt;
&lt;p&gt;Initially, I considered putting all my applications behind Cloudflare Tunnel and Cloudflare Access. However, that approach would have required quite a bit of rework: changing URLs in Coolify to &lt;code&gt;http://&lt;/code&gt;, reconfiguring each app, and sorting out webhooks. I set that aside for later and chose a less invasive first step: &lt;strong&gt;enabling the Cloudflare proxy (orange cloud)&lt;/strong&gt; on my DNS records. They still point to the same IP, Traefik and Coolify keep working the same way, and Cloudflare sits in the middle to filter out bots.&lt;/p&gt;
&lt;p&gt;On the afternoon of October 29, I rolled out the changes step by step:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Switched SSL/TLS from Full to Full (strict).&lt;/strong&gt; Traefik continues using its Let&amp;rsquo;s Encrypt certificates and renews them via HTTP-01 even with the proxy enabled. I avoided Flexible mode because Traefik already redirects HTTP to HTTPS; combining the two would cause an infinite redirect loop.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Tested on a low-risk app first&lt;/strong&gt; — a web-based terminal. I verified the &lt;code&gt;server: cloudflare&lt;/code&gt; response header, page loading, and WebSocket connectivity.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the bot-blocking layers&lt;/strong&gt; available on the Cloudflare Free plan:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;AI bot policies&lt;/strong&gt;: set Training, Agent, and Search to Block, since I have no reason for these self-hosted apps to show up in AI search results.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Bot Preference Sync&lt;/strong&gt; (Cloudflare-managed &lt;code&gt;robots.txt&lt;/code&gt;): automatically injects &lt;code&gt;Disallow&lt;/code&gt; rules for AI bots into &lt;code&gt;robots.txt&lt;/code&gt;, or serves one if the app doesn&amp;rsquo;t have its own.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;A custom WAF rule&lt;/strong&gt; to catch anything the built-in policies might miss:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-text" data-lang="text"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;(cf.verified_bot_category in {&amp;#34;AI Crawler&amp;#34; &amp;#34;AI Assistant&amp;#34; &amp;#34;AI Search&amp;#34;})
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;or (http.user_agent contains &amp;#34;Reflectionbot&amp;#34;)
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the proxy on the wildcard record&lt;/strong&gt; &lt;code&gt;*.miti99.dev&lt;/code&gt;. Flipping that single switch covered nearly 20 apps at once, and any new app using the wildcard record will be proxied by default. If I ever need to roll back, I can just toggle the proxy off.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the proxy on Coolify last&lt;/strong&gt;, then tested GitHub push deployment webhooks, Sentinel metrics coming from my second server, MCP, and real-time WebSocket connections.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Configured Traefik to trust Cloudflare&amp;rsquo;s IP ranges&lt;/strong&gt; via &lt;code&gt;forwardedHeaders.trustedIPs&lt;/code&gt;, so backend applications see the real visitor IP instead of Cloudflare&amp;rsquo;s edge IP.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;I also deliberately &lt;strong&gt;left Bot Fight Mode turned off&lt;/strong&gt;. On the Free plan, its challenge mechanism can block legitimate automated traffic, and WAF rules aren&amp;rsquo;t allowed to bypass it. For my setup, turning it on risked breaking GitHub webhooks, Sentinel, MCP, Nextcloud sync, and even Git operations over HTTP.&lt;/p&gt;
&lt;p&gt;Testing with &lt;code&gt;curl&lt;/code&gt;, requests with a normal browser user agent returned HTTP 200, while requests spoofing GPTBot, ClaudeBot, or Reflectionbot user agents received an immediate HTTP 403 at Cloudflare&amp;rsquo;s edge. Once that was confirmed, I started Gitea back up behind the proxy.&lt;/p&gt;
&lt;p&gt;Even so, routing traffic through Cloudflare comes with a few limitations to keep in mind:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Request bodies larger than 100 MB are rejected. Nextcloud uses chunked uploads, so it isn&amp;rsquo;t affected by this limit.&lt;/li&gt;
&lt;li&gt;Requests that take longer than ~100 seconds without sending data can hit an HTTP 524 timeout. Long-running LLM calls that don&amp;rsquo;t stream responses are something to watch out for.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The origin server IP is still reachable directly.&lt;/strong&gt; Any bot that already knows the origin IP can talk straight to Traefik. Proxying filters crawlers that resolve via DNS through Cloudflare, but it doesn&amp;rsquo;t replace proper access control.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="follow-up-monitoring"&gt;Follow-Up Monitoring&lt;/h2&gt;&lt;p&gt;The post-cutover logs illustrated that last point clearly. I enabled the proxy for Gitea at 09:14 UTC (16:14 Vietnam time), then filtered the access log on the origin server to see whether the three bots were still getting through:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;for&lt;/span&gt; ua in GPTBot ClaudeBot Reflectionbot&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;&lt;span class="nv"&gt;$ua&lt;/span&gt;&lt;span class="s2"&gt; &lt;/span&gt;&lt;span class="k"&gt;$(&lt;/span&gt;grep -c &lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;&lt;span class="nv"&gt;$ua&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;&lt;/span&gt; access.log&lt;span class="k"&gt;)&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;done&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;ClaudeBot&lt;/strong&gt; stopped completely at 09:14:20 — almost immediately after the DNS change.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reflectionbot&lt;/strong&gt; trickled in for about 6 more minutes, likely due to DNS caching.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;GPTBot&lt;/strong&gt; kept sending requests directly to the origin IP — another &lt;strong&gt;7,056 requests over the next hour&lt;/strong&gt; — before finally stopping at 10:14. The &lt;code&gt;ClientAddr&lt;/code&gt; field showed OpenAI&amp;rsquo;s IPs rather than Cloudflare&amp;rsquo;s. My guess is that the bot caches DNS responses longer than the record&amp;rsquo;s TTL.&lt;/li&gt;
&lt;li&gt;From that point until the time of writing — about 4 hours — the origin server recorded &lt;strong&gt;0 requests&lt;/strong&gt; from all three bots.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;To make sure this setup stays effective, here&amp;rsquo;s what I&amp;rsquo;ll continue monitoring:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Security → Events&lt;/strong&gt; in Cloudflare: verify that AI bots continue to be blocked and check whether any new user agents need to be added to the WAF rule.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Traefik access logs on the origin server&lt;/strong&gt;: filter using the snippet above. If a crawler reappears with a &lt;code&gt;ClientAddr&lt;/code&gt; outside Cloudflare&amp;rsquo;s IP ranges, it&amp;rsquo;s hitting the origin IP directly. At that point, I&amp;rsquo;ll either lock the firewall down to allow only Cloudflare IPs or revisit the Cloudflare Tunnel approach.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;robots.txt&lt;/code&gt; on each host&lt;/strong&gt;: run &lt;code&gt;curl https://&amp;lt;app&amp;gt;.example.com/robots.txt&lt;/code&gt; to confirm Cloudflare&amp;rsquo;s AI bot &lt;code&gt;Disallow&lt;/code&gt; rules are present.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;New applications&lt;/strong&gt;: Coolify creates new DNS records in DNS-only mode by default. Any host with its own dedicated record needs the proxy toggled on manually; forgetting one leaves a direct path open again.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cloudflare IP ranges&lt;/strong&gt;: although they rarely change, I still need to keep Traefik&amp;rsquo;s &lt;code&gt;trustedIPs&lt;/code&gt; list updated when they do.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I still have a few follow-up tasks left: enabling &lt;code&gt;REQUIRE_SIGNIN_VIEW&lt;/code&gt; so Gitea requires authentication before viewing any page, wiping the existing mirrors, and rotating the GitHub token used by &lt;code&gt;gitea-mirror&lt;/code&gt;. Requiring sign-in is what truly stops outsiders from reading repositories; the Cloudflare proxy is just an extra layer of defense in front. I&amp;rsquo;m also considering sending data deletion requests to Reflection AI, OpenAI, and Anthropic.&lt;/p&gt;
&lt;h2 id="takeaways"&gt;Takeaways&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Anything public on the internet will eventually be scraped thoroughly.&lt;/strong&gt; AI crawlers don&amp;rsquo;t stop at your homepage — they will walk through every single commit.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Double-check visibility settings when syncing across systems.&lt;/strong&gt; A single stale record under a reused repo name was enough to mirror a private GitHub repository into a public Gitea repo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;If you want Cloudflare to filter traffic, traffic actually has to go through the proxy.&lt;/strong&gt; For my small self-hosted setup, flipping on the proxy was a practical first step before moving to tunnels.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Audit your automated integrations before enabling Bot Fight Mode.&lt;/strong&gt; When your server also receives webhooks and serves non-browser clients, bot protection has to account for those workflows too.&lt;/li&gt;
&lt;/ul&gt;</description></item><item><title>Newsletter #139</title><link>https://miti99.com/en/post/2026/10/07/</link><pubDate>Wed, 07 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #139.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-go-taught-us-about-java-garbage-collection"&gt;&lt;a href="https://dev.to/codenameone/what-go-taught-us-about-java-garbage-collection-25ha" rel="noopener noreferrer"&gt;What Go Taught Us About Java Garbage Collection&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Comparing ParparVM (Codename One&amp;rsquo;s ahead-of-time Java-to-C virtual machine) against Go&amp;rsquo;s runtime, the author initially assumed Go&amp;rsquo;s low memory footprint and snappy pauses came down to escape analysis and stack allocation—only to discover how much came from &lt;em&gt;when&lt;/em&gt; Go triggers a GC cycle and how it shares marking work across threads. ParparVM&amp;rsquo;s first win was lowering its hardcoded 24 MB minimum allocation floor before triggering a GC: throughput and p99 latency barely budged, while resident memory (RSS) dropped from 98 MB down to 38 MB. An attempt to pace GC dynamically against the live heap size failed because internal counters missed objects in partial pages, thread-local mutator pages, and large-object allocations, so the team exposed the allocation floor as a build-time tunable instead. On their &lt;code&gt;GcPause&lt;/code&gt; benchmark, scaling parallel mark threads from one to four cut worst-case pause times from 2.2–3.3 seconds down to 0.3–0.9 seconds (compared to ~20 ms in Go), and adding Go-style &lt;em&gt;mutator assist&lt;/em&gt;—where an allocating thread that outruns the background collector pitches in to mark a small batch of objects itself—smoothed out allocation spikes further.&lt;/p&gt;
&lt;p&gt;The second half tackles image caching and reference types. Previously, ParparVM implemented &lt;code&gt;WeakReference&lt;/code&gt; by storing the referent as a normal struct field that the GC traced as a strong reference, while iOS apps relied on a separate strong-reference cache table that simply dumped everything on an OS memory warning. A new PR moves the referent pointer into &lt;code&gt;java.lang.ref.Reference&lt;/code&gt; directly, teaches the C translator to register reference discovery hooks instead of tracing referents strongly, and lets the collector decide whether to preserve or clear soft references based on memory pressure. The trickiest concurrency hazard occurs when a mutator thread calls &lt;code&gt;ref.get()&lt;/code&gt; mid-mark phase and resurrects a pointer the GC is about to sweep; logging &lt;code&gt;get()&lt;/code&gt; reads through a snapshot-at-the-beginning (SATB) read barrier and filtering already-marked objects dropped mark-termination passes from 32 down to 1. Updating a recency timestamp on each &lt;code&gt;get()&lt;/code&gt; so frequently used images survive longer boosted cache hit rates under a 160 MB cap from 87.99% to 97.44% while simultaneously shrinking memory footprint from 91 MB to 82.1 MB.&lt;/p&gt;
&lt;h2 id="how-we-built-a-real-time-stock-pricing-system-at-scale"&gt;&lt;a href="https://itnext.io/how-we-built-real-time-stock-pricing-at-mofid-brokerage-031015ce1301" rel="noopener noreferrer"&gt;How We Built a Real-Time Stock Pricing System at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mofid Securities, Iran&amp;rsquo;s largest stock brokerage, needed to stream real-time stock and fund price ticks to tens of thousands of concurrent traders. Market ticks from the exchange core are ingested in C++ and published to Kafka as Protobuf messages at roughly 1,900 messages per second—spiking to 3x that during volatile market opens. For fan-out distribution, the team chose Redis Pub/Sub over heavier durable brokers: stock prices are ephemeral state where a missed tick is immediately superseded by the next tick a moment later, making &lt;code&gt;at-most-once&lt;/code&gt; delivery semantics ideal, and Redpanda Connect pipes messages from Kafka into Redis without writing custom glue services. On the browser side, they picked Server-Sent Events (SSE) over WebSockets because price streaming is strictly unidirectional, runs over standard HTTP, and handles reconnection natively; they used the &lt;code&gt;eventsource&lt;/code&gt; package to attach auth headers, batched UI updates on the client to avoid layout thrashing, closed streams when tabs navigated away, and fetched an initial REST snapshot before applying the live delta stream.&lt;/p&gt;
&lt;p&gt;Inside the .NET backend, a single hosted background service per Redis channel writes incoming ticks into a bounded &lt;code&gt;System.Threading.Channels&lt;/code&gt; ring buffer (capacity 100,000, configured with &lt;code&gt;DropOldest&lt;/code&gt; backpressure), while a connection coordinator spins up lightweight per-user channels that filter and forward only the specific ticker symbols currently visible on that user&amp;rsquo;s screen. Rolled out gradually from 30% to 100% of traffic behind an Unleash feature flag, the production cluster serves tens of thousands of concurrent streams across just &lt;strong&gt;six pods&lt;/strong&gt;, each using ~55 MB of RAM and ~20% CPU at peak market hours with maximum queue depth never exceeding 15 messages. Key operational lessons: disable reverse-proxy response buffering via &lt;code&gt;X-Accel-Buffering: no&lt;/code&gt;, dispose per-client channels immediately on disconnect to prevent memory leaks, and send a lightweight heartbeat comment every 20 seconds so intermediate load balancers don&amp;rsquo;t drop idle connections.&lt;/p&gt;
&lt;h2 id="saving-another-100tb-of-ram-with-math-and-rust"&gt;&lt;a href="https://blog.cloudflare.com/saving-100-tb-of-ram-with-math/" rel="noopener noreferrer"&gt;Saving another 100TB of RAM with math (and Rust)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare freed up another 100+ TB of RAM across its global edge fleet by shrinking &lt;code&gt;pingora-ketama&lt;/code&gt;, the consistent hashing library that Pingora Backend Router uses to route requests to cache servers by URL. Because compliance rules and tiered caching configurations require maintaining a separate consistent hash ring for every unique combination of cache features, some router processes were burning up to 6 GB of RAM just holding Ketama rings in memory. Step one was shrinking each point on the ring in Rust. The original &lt;code&gt;Point&lt;/code&gt; struct stored &lt;code&gt;hash: u32&lt;/code&gt; and &lt;code&gt;index: u32&lt;/code&gt; (8 bytes per point). Simply changing &lt;code&gt;index&lt;/code&gt; from &lt;code&gt;u32&lt;/code&gt; to &lt;code&gt;u16&lt;/code&gt; saved zero bytes because Rust aligns the struct to a multiple of its largest field (&lt;code&gt;u32&lt;/code&gt;, 4-byte alignment), adding 2 bytes of tail padding; packing each entry into a byte array &lt;code&gt;[u8; 6]&lt;/code&gt; with helper accessors bypassed the alignment padding and immediately cut ring memory by 25%.&lt;/p&gt;
&lt;p&gt;Step two used probability theory to slash the &lt;em&gt;number&lt;/em&gt; of virtual nodes (points) placed on the ring per server. Deriving the exact closed-form formula for load variance across $n$ servers with $k$ points each revealed steeply diminishing returns: for 100 servers, NGINX&amp;rsquo;s default of 160 points per server already drops load standard deviation from ~99% down to ~8%, whereas scaling all the way to 100,000 points per server spends the last 90,000 points buying just a 0.7% reduction in variance—and at extreme point counts, 32-bit hash collisions actually cause load imbalance to &lt;em&gt;worsen&lt;/em&gt; again. Dropping the point count by 90% left load distribution virtually unchanged. Because changing hash rings in place would invalidate cached assets and trigger a thundering herd to origin servers, Cloudflare held both the old and new rings in memory temporarily—saving 65% net RAM even while dual-running—and shifted traffic gradually by hashing requests into rollout buckets across data center tiers.&lt;/p&gt;
&lt;h2 id="postgres-delete-can-actualy-scale"&gt;&lt;a href="https://www.dbos.dev/blog/scaling-deletions-in-postgres" rel="noopener noreferrer"&gt;Postgres DELETE Can Actualy Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In high-throughput PostgreSQL systems, &lt;code&gt;DELETE&lt;/code&gt; has a reputation for being so slow that conventional wisdom says to avoid it altogether in favor of &lt;code&gt;TRUNCATE&lt;/code&gt; or dropping time-partitioned tables. The team at DBOS, however, needed row-level &lt;code&gt;DELETE&lt;/code&gt; for their Postgres-backed durable workflow engine, which executes tens of thousands of workflows and steps per second while enforcing granular, per-workflow retention policies. What makes &lt;code&gt;DELETE&lt;/code&gt; expensive in Postgres is MVCC: deleting a row doesn&amp;rsquo;t free space immediately—it merely stamps the tuple&amp;rsquo;s &lt;code&gt;xmax&lt;/code&gt; header with the deleting transaction ID, leaving a &amp;ldquo;dead tuple&amp;rdquo; behind for &lt;code&gt;autovacuum&lt;/code&gt; to clean up later, and because Postgres indexes don&amp;rsquo;t store visibility metadata, every index scan still has to visit heap pages to check whether matching rows are dead.&lt;/p&gt;
&lt;p&gt;DBOS&amp;rsquo;s initial schema relied on foreign keys with &lt;code&gt;ON DELETE CASCADE&lt;/code&gt; from the parent &lt;code&gt;workflow_status&lt;/code&gt; table to child tables like &lt;code&gt;operation_outputs&lt;/code&gt;. While convenient, cascading deletes scattered random I/O across thousands of heap pages because a long-running workflow&amp;rsquo;s steps are spread out over time—to the point where deleting expired workflows took longer than executing them! The team dropped the foreign keys and rewrote retention as a two-step batch job: first delete expired rows from &lt;code&gt;workflow_status&lt;/code&gt;, then batch-delete orphaned rows from each child table ordered by creation time (maximizing page cache locality) using a &lt;code&gt;NOT EXISTS&lt;/code&gt; anti-join against &lt;code&gt;workflow_status&lt;/code&gt; so active long-running workflows are never touched. When they hit a second wall—finding the retention cutoff timestamp on the &lt;code&gt;created_at&lt;/code&gt; B-tree index occasionally stalled for 20 minutes scanning millions of unvacuumed dead tuples piled up at the front of the index—running an explicit &lt;code&gt;VACUUM&lt;/code&gt; right before and after each deletion batch eliminated the stall completely, speeding up retention deletes by &lt;strong&gt;10x&lt;/strong&gt;.&lt;/p&gt;
&lt;h2 id="where-postgresql-stores-row-locks"&gt;&lt;a href="https://boringsql.com/posts/row-locks-on-the-page/" rel="noopener noreferrer"&gt;Where PostgreSQL stores row locks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Unlike many databases that maintain an in-memory lock table for row-level locks, PostgreSQL stores row locks &lt;strong&gt;directly inside the tuple header on the data page itself&lt;/strong&gt;. Specifically, the &lt;code&gt;t_xmax&lt;/code&gt; field—which normally records the transaction ID that deleted or updated a tuple—does double duty by storing the XID of the transaction currently locking the row, while bit flags in &lt;code&gt;t_infomask&lt;/code&gt; indicate the lock strength and clarify that &lt;code&gt;t_xmax&lt;/code&gt; is a lock rather than a deletion. That design means PostgreSQL can lock millions of rows without exhausting shared RAM, at the cost of dirtying the data page (and generating WAL) even on a read-only &lt;code&gt;SELECT ... FOR SHARE&lt;/code&gt;. When the locking transaction commits, Postgres doesn&amp;rsquo;t go back to clear &lt;code&gt;t_xmax&lt;/code&gt;; future readers simply check the commit log, see the transaction has finished, and ignore the expired lock marker until &lt;code&gt;VACUUM&lt;/code&gt; or a subsequent locker overwrites it. Postgres supports four row-lock modes so foreign-key checks don&amp;rsquo;t stall updates: inserting a child row takes the weakest &lt;code&gt;FOR KEY SHARE&lt;/code&gt; lock on the parent row, a normal &lt;code&gt;UPDATE&lt;/code&gt; that doesn&amp;rsquo;t touch key columns takes &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt;, while &lt;code&gt;DELETE&lt;/code&gt; and key-modifying updates take &lt;code&gt;FOR UPDATE&lt;/code&gt; (which conflicts with everything—meaning developers who reflexively write &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; on parent rows unnecessarily block concurrent child inserts that &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt; would allow).&lt;/p&gt;
&lt;p&gt;When a second transaction tries to lock an already-locked row, it waits on the holder&amp;rsquo;s &lt;code&gt;transactionid&lt;/code&gt; lock in &lt;code&gt;pg_locks&lt;/code&gt; and acquires a heavyweight &lt;code&gt;tuple&lt;/code&gt; lock solely to establish fair queue ordering—which is why &lt;code&gt;pg_locks&lt;/code&gt; only shows &lt;em&gt;waiting&lt;/em&gt; row lockers, never the session actively holding an uncontended row lock. And when multiple transactions concurrently hold shared locks (&lt;code&gt;FOR KEY SHARE&lt;/code&gt; or &lt;code&gt;FOR SHARE&lt;/code&gt;) on the same tuple, &lt;code&gt;t_xmax&lt;/code&gt; stores a &lt;code&gt;MultiXactId&lt;/code&gt; pointing to an on-disk member list in &lt;code&gt;pg_multixact/&lt;/code&gt;. The post demonstrates how a single long-running transaction holding &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt; on parent rows while 5,000 autocommit transactions insert child rows creates 5,000 distinct multixacts; at ~5 bytes per member and a hard $2^{32}$ member offset limit (~20 GB), runaway multixact creation can trigger &lt;code&gt;multixact &amp;quot;members&amp;quot; limit exceeded&lt;/code&gt; outages or emergency anti-wraparound vacuums even when a table has zero dead tuples—making &lt;code&gt;mxid_age()&lt;/code&gt;, &lt;code&gt;relminmxid&lt;/code&gt;, and &lt;code&gt;next_multi_offset&lt;/code&gt; critical production metrics to monitor.&lt;/p&gt;
&lt;h2 id="a-40ms-go-gc-pause-caused-by-swap"&gt;&lt;a href="https://frn.sh/go-gc/" rel="noopener noreferrer"&gt;A 40ms Go GC pause caused by swap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After enabling Linux swap on production nodes to absorb brief memory spikes gracefully, the author noticed something alarming in their Go service metrics: stop-the-world (STW) garbage collection pauses were occasionally spiking to &lt;strong&gt;40 ms&lt;/strong&gt;—roughly 800x slower than the normal 51 µs median pause. The container cgroup hosted two processes: the latency-sensitive Go service (which read request payloads via &lt;code&gt;io.ReadAll&lt;/code&gt; and decoded them with &lt;code&gt;proto.Unmarshal&lt;/code&gt;) and a nearly idle helper HTTP server. Initially, the author assumed that because the Linux kernel tracks memory pressure per cgroup, cold pages from the idle helper process would be swapped out first, or that if the Go process itself got swapped out, normal mutator threads would fault those pages back in during everyday execution rather than inside a sub-millisecond STW window. Both assumptions turned out to be wrong.&lt;/p&gt;
&lt;p&gt;Attaching a custom eBPF probe between the Go runtime&amp;rsquo;s STW start and stop tracepoints to count major page faults while all goroutines were frozen revealed the smoking gun: the worst 39,902 µs STW pause suffered &lt;strong&gt;228 major page faults&lt;/strong&gt;, which alone accounted for 39,013 µs (97.8%) of the pause! Resolving the faulting instruction pointers with &lt;code&gt;addr2line&lt;/code&gt; pointed straight to &lt;code&gt;runtime.(*spanSet).reset&lt;/code&gt; and &lt;code&gt;runtime.nextMarkBitArenaEpoch&lt;/code&gt; inside &lt;code&gt;sweepTerm&lt;/code&gt;—the brief STW phase at the start of a new GC cycle. Because the Go runtime stores off-heap GC bookkeeping metadata (like span sets and mark-bit arenas) in memory regions that are reused across cycles but touched &lt;em&gt;only&lt;/em&gt; during GC transitions, the Linux kernel&amp;rsquo;s LRU page reclaimer saw those pages sitting untouched between GC cycles, classified them as cold, and paged them out to disk. The moment the next GC cycle froze every goroutine to reset those metadata structures, the STW thread had to page-fault 228 pages back in from disk sequentially while the entire program sat frozen. Swap also degraded normal heap allocations (&lt;code&gt;io.ReadAll&lt;/code&gt; on a 511 KiB payload jumped from 3–5 ms to 105 ms on local NVMe swap and 903 ms on network block storage). The takeaway: swap and garbage-collected runtimes with off-heap metadata are a dangerous mix for latency-sensitive services.&lt;/p&gt;
&lt;h2 id="how-to-optimize-when-you-cant-do-anything"&gt;&lt;a href="https://hdombrovskaya.wordpress.com/2026/08/25/how-to-optimize-when-you-cant-do-anything/" rel="noopener noreferrer"&gt;How to optimize when you can’t do anything!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Database veteran Hettie Dombrovskaya shares a real-world PostgreSQL war story where every textbook optimization was off the table. The culprit was an unpartitioned &lt;strong&gt;750 GB table holding 16 billion rows&lt;/strong&gt;. A critical production query that found all records whose &lt;code&gt;[start_date, end_date]&lt;/code&gt; interval covered a given target date alongside three equality filters (&lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt;, &lt;code&gt;c&lt;/code&gt;) had started timing out, taking anywhere from several seconds to several minutes. The textbook fix—a GiST range index on &lt;code&gt;(a, b, c, daterange(start_date, end_date))&lt;/code&gt;—was impossible during an active incident because building a new index on 16 billion rows would take well over 24 hours. Meanwhile, the best existing B-tree index was on &lt;code&gt;(a, start_date, end_date)&lt;/code&gt;, where &lt;code&gt;a&lt;/code&gt; had terrible selectivity and filtering &lt;code&gt;start_date &amp;lt;= target_date&lt;/code&gt; for a recent target date matched nearly the entire 16-billion-row history.&lt;/p&gt;
&lt;p&gt;Every standard SQL rewrite hit a wall: adding an arbitrary lower bound like &lt;code&gt;start_date &amp;gt;= target_date - interval '1 year'&lt;/code&gt; wasn&amp;rsquo;t allowed because the customer genuinely needed long-lived historical records; computing &lt;code&gt;MIN(start_date)&lt;/code&gt; grouped by &lt;code&gt;a&lt;/code&gt; didn&amp;rsquo;t help because each &lt;code&gt;a&lt;/code&gt; bucket contained ancient rows; and creating a partial index covering only the customer&amp;rsquo;s specific &lt;code&gt;(a, b, c)&lt;/code&gt; combinations brought execution under 100 ms in staging, but only helped that single customer. The breakthrough came from looking closely at a spreadsheet the customer had sent over: it happened to list the exact date each of their ~2,000 &lt;code&gt;(a, b, c)&lt;/code&gt; combinations was first created! Loading those ~2,000 rows into a tiny lookup table (and in production, exposing the table from another database via a read-only &lt;code&gt;postgres_fdw&lt;/code&gt; foreign table since DDL on the primary database was restricted) allowed the query to join against the lookup table and pass that exact per-combination inception date as a tight lower bound &lt;code&gt;start_date &amp;gt;= lookup.first_seen_date&lt;/code&gt; into the existing &lt;code&gt;(a, start_date, end_date)&lt;/code&gt; index. Query runtime immediately dropped from minutes to &lt;strong&gt;under 100 ms&lt;/strong&gt;. Her takeaway: when you can&amp;rsquo;t build an index on a massive table, a tiny auxiliary lookup table encoding domain knowledge can act as your &amp;ldquo;index.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="four-ways-to-do-super-fast-packet-processing-in-go"&gt;&lt;a href="https://toonk.io/packetio/" rel="noopener noreferrer"&gt;Four ways to do super fast packet processing in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andree Toonk notes that parsing network packets in Go is easy—the hard part is moving tens of millions of packets per second between the physical NIC and your Go userspace process without the Linux kernel network stack melting your CPU. Because each high-speed packet I/O mechanism has a completely different C API and memory model, Toonk built &lt;strong&gt;&lt;code&gt;packetio&lt;/code&gt;&lt;/strong&gt;, a unified Go library that puts four backends behind a single clean interface. &lt;strong&gt;AF_PACKET&lt;/strong&gt; (the standard raw socket used by &lt;code&gt;tcpdump&lt;/code&gt;) works everywhere out of the box, but traverses most of the kernel networking stack. &lt;strong&gt;AF_XDP&lt;/strong&gt; hooks an eBPF program into the NIC driver early to redirect frames straight into a shared userspace/kernel ring buffer (&lt;code&gt;UMEM&lt;/code&gt;) while leaving normal kernel networking (like SSH and ARP) intact. &lt;strong&gt;DPDK&lt;/strong&gt; bypasses the kernel entirely via poll-mode drivers in userspace at the cost of taking over the whole NIC and a steep learning curve, while &lt;strong&gt;mlx5 Direct Verbs&lt;/strong&gt; talks directly to the hardware queues of NVIDIA/Mellanox ConnectX NICs via &lt;code&gt;rdma-core&lt;/code&gt; without needing the massive DPDK runtime. Switching backends in &lt;code&gt;packetio&lt;/code&gt; is practically a one-line change to &lt;code&gt;Open()&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Toonk benchmarked all four backends in Go across two AMD EPYC servers wired back-to-back with 100 GbE NVIDIA ConnectX-6 Dx NICs blasting minimum-size 64-byte UDP packets at full line rate (&lt;strong&gt;148.8 million packets per second&lt;/strong&gt;), carefully measuring &lt;em&gt;system-wide&lt;/em&gt; CPU utilization including kernel &lt;code&gt;softirq&lt;/code&gt; cores. On receive (RX), &lt;code&gt;AF_PACKET&lt;/code&gt; topped out at just 2.3 Mpps while burning 52.8 CPU cores; &lt;code&gt;AF_XDP&lt;/code&gt; hit 146.5 Mpps using 11.4 cores; and both &lt;code&gt;Direct Verbs&lt;/code&gt; and &lt;code&gt;DPDK&lt;/code&gt; saturated the full 100 GbE line rate at &lt;strong&gt;148.6 Mpps&lt;/strong&gt; using just 10 and 8 cores respectively. On transmit (TX), &lt;code&gt;DPDK&lt;/code&gt; hit line rate using only 3 cores while &lt;code&gt;AF_XDP&lt;/code&gt; needed 20 cores. On full L2 packet forwarding (RX + TX), &lt;code&gt;Direct Verbs&lt;/code&gt; took first place at &lt;strong&gt;147.4 Mpps across 12 cores&lt;/strong&gt;. Notably, measuring only the Go process&amp;rsquo;s CPU hides the fact that &lt;code&gt;AF_XDP&lt;/code&gt; spends over half its CPU budget inside kernel &lt;code&gt;softirq&lt;/code&gt; handlers driving the NIC ring. Toonk&amp;rsquo;s rule of thumb: use &lt;code&gt;Direct Verbs&lt;/code&gt; on Mellanox/NVIDIA ConnectX hardware, &lt;code&gt;AF_XDP&lt;/code&gt; on general Linux NICs when you still need kernel coexistence, &lt;code&gt;DPDK&lt;/code&gt; when you need broad multi-vendor poll-mode driver support, and &lt;code&gt;AF_PACKET&lt;/code&gt; only for low-rate packet capture.&lt;/p&gt;
&lt;h2 id="how-uber-protects-against-retry-storms"&gt;&lt;a href="https://www.uber.com/us/en/blog/protecting-against-retry-storms/" rel="noopener noreferrer"&gt;How Uber Protects Against Retry Storms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;At Uber&amp;rsquo;s microservice scale, naive retries are a recipe for self-inflicted outages: when a caller service receives an error from a downstream dependency, it typically has no idea whether that downstream service failed on its own or is merely forwarding an error from five hops deeper in the call graph. Retrying transient network blips works fine in isolation, but when a deep leaf service is overloaded, independent retries at every layer of a 7-hop call chain multiply exponentially: if each of the 6 upstream layers retries just once (&lt;code&gt;2x&lt;/code&gt;), load on the struggling leaf service amplifies by &lt;strong&gt;$2^6 = 64\times$&lt;/strong&gt; (or $8\times$ across a 4-hop chain). Even enforcing a standard per-client 10% retry budget still compounds across hops ($1.1^3 \approx 1.33\times$ or higher during partial brownouts) because each caller evaluates its budget locally without realizing upstream callers are &lt;em&gt;also&lt;/em&gt; retrying the exact same failed request.&lt;/p&gt;
&lt;p&gt;Uber solved this cascading amplification by introducing &lt;strong&gt;Error Ownership&lt;/strong&gt; (&lt;code&gt;x-uber-error-claim&lt;/code&gt;). The core insight is simple: any given failure in a call tree has exactly one &lt;em&gt;originating&lt;/em&gt; service, and only the immediate parent of that originating service should ever be allowed to retry it. A background control-plane component called &lt;em&gt;Service Dependency Analysis&lt;/em&gt; correlates inbound and outbound error rates across Uber&amp;rsquo;s service mesh to determine whether a service is generating errors internally or passively propagating downstream failures; when a service is the true origin of an error, the shared RPC middleware attaches an &lt;code&gt;x-uber-error-claim&lt;/code&gt; header to its error response. Its immediate caller sees the claim, performs its configured retries, and—if all retries still fail—&lt;strong&gt;strips the claim header&lt;/strong&gt; before propagating the error further upstream, signaling every ancestor in the call chain not to retry again. Because the logic lives inside Uber&amp;rsquo;s standard Go/Java RPC middleware, services got protection automatically without application code changes. During a major production incident on November 18, 2025, when a core leaf service sitting 5+ hops deep began failing, retry budgets alone would have amplified its traffic by 46–135%; Error Ownership blocked &lt;strong&gt;9.5 million redundant retry requests&lt;/strong&gt;, shrinking the maximum retry-storm blast radius from 25 hops down to 3 (and the average from 20 down to 2).&lt;/p&gt;
&lt;h2 id="the-real-cost-of-a-single-insert-in-postgres"&gt;&lt;a href="https://www.tigerdata.com/blog/real-cost-of-single-insert-in-postgres" rel="noopener noreferrer"&gt;The Real Cost of a Single Insert in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How many bytes does PostgreSQL actually write to disk when you insert a single 40-byte row? Tiger Data (the creators of TimescaleDB) measures the exact &lt;strong&gt;write amplification factor&lt;/strong&gt; of single-row &lt;code&gt;INSERT&lt;/code&gt; statements in PostgreSQL 16 on a realistic table with three B-tree indexes. First comes storage layout overhead: every heap tuple carries a 23-byte MVCC header (&lt;code&gt;t_xmin&lt;/code&gt;, &lt;code&gt;t_xmax&lt;/code&gt;, &lt;code&gt;t_cid&lt;/code&gt;, &lt;code&gt;t_ctid&lt;/code&gt;, infomasks) padded to 24 bytes, plus a 4-byte line pointer (&lt;code&gt;ItemIdData&lt;/code&gt;) in the page header—turning a 40-byte payload into 68 bytes on the heap (1.7x amplification before touching an index). Next, PostgreSQL updates every index synchronously inside the same transaction: three indexes mean three B-tree traversals and three modified 8 KiB index leaf pages. While a monotonically increasing timestamp index concentrates inserts into the rightmost leaf page sitting hot in shared buffers, a high-cardinality index (like a random UUID or device ID) scatters writes across the entire B-tree, dirtying cold pages all over the buffer pool. And for durability, inserting into the heap plus three indexes emits &lt;strong&gt;four separate WAL records&lt;/strong&gt; per row, each carrying its own 24-byte WAL record header and block reference metadata.&lt;/p&gt;
&lt;p&gt;Running a controlled benchmark of 100,000 single-row &lt;code&gt;INSERT&lt;/code&gt; transactions and measuring exact WAL generation via &lt;code&gt;pg_current_wal_lsn()&lt;/code&gt; and &lt;code&gt;pg_stat_wal&lt;/code&gt; reveals the true multiplier. Immediately after a &lt;code&gt;CHECKPOINT&lt;/code&gt;, write amplification hits &lt;strong&gt;10.74x&lt;/strong&gt; because the first modification to any 8 KiB heap or index page after a checkpoint must write a &lt;em&gt;Full Page Image&lt;/em&gt; (FPI) into the WAL to guard against torn pages. Even in a warm steady state with zero checkpoints, write amplification is &lt;strong&gt;8.73x&lt;/strong&gt; (~345 bytes of WAL per 40-byte row—meaning 50,000 inserts/sec generates ~17 MB/s of raw WAL stream alone, before counting dirty 8 KiB buffer flushes by the checkpointer). Dropping all three indexes drops steady-state WAL amplification down to &lt;strong&gt;2.44x&lt;/strong&gt;, proving that roughly &lt;strong&gt;70% of write volume comes from index maintenance&lt;/strong&gt;. To tame write amplification, the author recommends a prioritized playbook: batch inserts via &lt;code&gt;COPY&lt;/code&gt; or multi-row &lt;code&gt;INSERT ... VALUES (), ()&lt;/code&gt; so multiple rows share page locks and WAL overhead; drop unused indexes (check &lt;code&gt;pg_stat_user_indexes.idx_scan&lt;/code&gt;); enable &lt;code&gt;wal_compression = lz4&lt;/code&gt; or &lt;code&gt;zstd&lt;/code&gt; to shrink full-page writes; and tune &lt;code&gt;max_wal_size&lt;/code&gt; and &lt;code&gt;checkpoint_timeout&lt;/code&gt; to spread checkpoints further apart.&lt;/p&gt;</description></item><item><title>Newsletter #138</title><link>https://miti99.com/en/post/2026/10/06/</link><pubDate>Tue, 06 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #138.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i-believe-about-the-future-of-software-development"&gt;&lt;a href="https://thorstenball.com/blog/2026/09/19/what-i-believe-about-the-future-of-software-development/" rel="noopener noreferrer"&gt;What I believe about the future of software development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball reposts to his blog a series of predictions that sparked intense debate on X, capturing a snapshot of what he believes in September 2026. In his view, line-by-line human code review is effectively dead: humans will stop hunting for syntax or logic bugs in model-generated diffs and instead review system architecture and how components fit together. Unit tests as we know them may fade too, now that frontier models can one-shot 900 lines of working Arduino C on the first try. The craft of hand-writing code will atrophy much like cobbling shoes by hand, while the craft of &lt;em&gt;building software&lt;/em&gt;—solving real business problems, knowing when to ship, and tightening feedback loops—will matter more than ever. Most future bugs will be specification bugs (&amp;ldquo;you asked for the wrong thing&amp;rdquo;) rather than implementation bugs, and hand-crafted performance optimization by humans will remain a rare specialty.&lt;/p&gt;
&lt;p&gt;His spicier predictions go further: terminals, shells, and CLIs will cease to be human-first interfaces; tokens are the new compute primitive of the &amp;ldquo;post-binary&amp;rdquo; era; the classic PM/Design/Engineering triad alongside Agile and Scrum rituals will dissolve, and engineers who act merely as &amp;ldquo;meat proxies&amp;rdquo; translating Jira tickets into agent prompts will lose their jobs. Even our notion of &amp;ldquo;clean, maintainable code&amp;rdquo; exists primarily to serve human working-memory limits, so it may stop mattering once agents perform the vast majority of edits. Developers priced out of frontier token budgets risk getting left behind, and bespoke UIs will be generated on the fly. Still, Ball acknowledges it will take a full generation for &amp;ldquo;new software&amp;rdquo; to replace &amp;ldquo;old software&amp;rdquo;—ten years from now people will still be hired to write code by hand, though the real question is whether you&amp;rsquo;ll want that job.&lt;/p&gt;
&lt;h2 id="trying-the-software-factory-pattern"&gt;&lt;a href="https://lethain.com/software-factory-experiment/" rel="noopener noreferrer"&gt;Trying the Software Factory pattern.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson reflects that in 2026, effective AI engineering patterns are emerging faster than he can adopt them. At his company Imprint, the year&amp;rsquo;s progression moved rapidly: in January, getting every engineer using Claude Code daily; in March, expanding Claude Code and Claude Cowork to every non-engineering function; in April, hitting the limits of local &lt;code&gt;git worktree&lt;/code&gt; setups and provisioning ~10 full multi-repo workspace checkouts per developer so agents could open coordinated PRs across monorepos; in June, migrating the entire company off Jira onto Linear so agents had clean, low-friction access to task context without permission headaches; and in July, launching &amp;ldquo;Agent Fleet,&amp;rdquo; an internal cloud orchestration harness inspired by Stripe&amp;rsquo;s Minions for autonomously knocking out small tickets.&lt;/p&gt;
&lt;p&gt;The next frontier Larson is experimenting with is the &lt;strong&gt;Software Factory&lt;/strong&gt; pattern: pointing a long-running harness at a broad multi-week project goal and letting it drive progress continuously. His first prototype, a &lt;code&gt;/linear-project-loop&lt;/code&gt; skill, reads a Linear project and checks whether it has both a Notion RFC (defining goals, metrics, and technical approach) and a Datadog dashboard or Snowflake query tracking those metrics—collaborating with the human to create them if missing. On subsequent runs, the loop checks live metrics and open issues, files missing follow-up tasks, and picks up unblocked work like drafting PRs, nudging reviewers, or posting clarifying questions. Running the loop immediately exposed how much project context Larson had been keeping in his own head rather than writing down, and proved especially valuable &lt;em&gt;after&lt;/em&gt; launch—automatically flagging a spike in passkey error rates and queueing up remediation tasks. His takeaway: these pieces only compound when wired together—Datadog MCP, Snowflake, Linear as a single source of truth, and a cloud harness that keeps running when your laptop closes.&lt;/p&gt;
&lt;h2 id="back-to-coupling-and-cohesion"&gt;&lt;a href="https://bastrich.tech/coupling-and-cohesion/" rel="noopener noreferrer"&gt;Back to Coupling and Cohesion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich argues that junior developers and Clean Code zealots routinely over-apply acronyms like SOLID, GRASP, and KISS, producing labyrinthine codebases that look impressive on a whiteboard but are miserable to maintain. In his view, every one of those principles is really just a specialized corollary of managing &lt;strong&gt;coupling&lt;/strong&gt; and &lt;strong&gt;cohesion&lt;/strong&gt; across different scales. Coupling measures how tightly components are entangled such that changing one forces changes in others; cohesion measures the degree to which everything inside a single component serves one unified purpose. To move past hand-wavy intuition, Bastrich proposes quantifying both directly from real development history: for every task, log the effort spent across each touched component; for each component, log the effort spent across each business concern. Using formulas analogous to the Gini-Simpson diversity index and Herfindahl-Hirschman index, coupling is $1 - \frac{\sum e_i^2}{(\sum e_i)^2}$ across components for a task, while cohesion is $\frac{\sum e_i^2}{(\sum e_i)^2}$ across concerns inside a component.&lt;/p&gt;
&lt;p&gt;For example, if changing a password-length rule requires editing both the registration form (effort 4) and the password-reset form (effort 6), the task&amp;rsquo;s coupling score is &lt;code&gt;0.48&lt;/code&gt;, even though each form has a cohesion of &lt;code&gt;1.0&lt;/code&gt;. Framing design around these two forces maps every classic rule back to first principles: Single Responsibility is simply high cohesion; Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, DRY, and the Law of Demeter all exist to reduce coupling or raise cohesion; and KISS bounds the working memory required to hold a component in your head. Even so, Bastrich reminds readers that low coupling and high cohesion aren&amp;rsquo;t free—in ultra-low-latency trading systems, embedded firmware, or throwaway scripts, tightly coupled code is often the right engineering trade-off.&lt;/p&gt;
&lt;h2 id="introducing-system-one-models--jev"&gt;&lt;a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev" rel="noopener noreferrer"&gt;Introducing System One Models &amp;amp; Jev&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diogo Almeida—founder of TypeSafe AI and an early OpenAI researcher who worked on the foundations of ChatGPT—poses a pointed question: LLMs surpassed human-level chat years ago, so why hasn&amp;rsquo;t enterprise automation caught up? Coming out of two years in stealth, TypeSafe AI introduces &lt;strong&gt;System One Models&lt;/strong&gt;, a new class of frontier models purpose-built to make fast, structured, calibrated decisions inside software pipelines rather than chatting with humans. Built on a custom architecture, a parallel sampler, and a training methodology called &lt;em&gt;Reinforcement Learning for Calibrated Decisions&lt;/em&gt; (RLCD), their debut model &lt;strong&gt;Jev&lt;/strong&gt; (now in early access) acts like a &amp;ldquo;frontier-intelligence function call&amp;rdquo;: it ingests unstructured context and returns strongly typed decisions paired with calibrated probabilities. By abandoning token-by-token autoregressive text generation, Jev cannot produce syntax/type errors or free-form hallucinations, evaluates multiple structured questions in parallel in a single pass, responds in 70–500 ms, and costs just &lt;code&gt;$0.042&lt;/code&gt; per million input tokens with &lt;strong&gt;free output&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To benchmark real-world utility, the team built a code-level workflow evaluation suite comparing Jev against an ensemble consensus of &lt;code&gt;GPT-6 Astra&lt;/code&gt; and &lt;code&gt;Fable 5.1&lt;/code&gt;. Across those workflows, Jev ran &lt;strong&gt;193.6x faster&lt;/strong&gt; and &lt;strong&gt;444.6x cheaper&lt;/strong&gt; at matching accuracy (though the team transparently notes that benchmark figure sits at the upper end of their target distribution). Ideal use cases include acting as a &amp;ldquo;smart &lt;code&gt;if&lt;/code&gt; statement&amp;rdquo; inside application control flow, massive map-reduce classification over unstructured data, real-time interactive agents, and fast guardrail verification over LLM outputs—illustrated by live demos of Jev playing &lt;em&gt;DOOM&lt;/em&gt; at 10 queries per second for ~$7/hour and playing Wikipedia &lt;em&gt;Wikiracing&lt;/em&gt;. The category name nods to Daniel Kahneman&amp;rsquo;s &lt;em&gt;Thinking, Fast and Slow&lt;/em&gt;, while &amp;ldquo;Jev&amp;rdquo; honors economist William Stanley Jevons: make machine intelligence orders of magnitude faster and cheaper, and entirely new software architectures become viable.&lt;/p&gt;
&lt;h2 id="system-one-models--explained"&gt;&lt;a href="https://unzip.dev/0x025-system-one-models/" rel="noopener noreferrer"&gt;System One Models 🚦 Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Agam More breaks down how System One models—led by TypeSafe AI&amp;rsquo;s Jev—work in practice, describing them as a fast, dirt-cheap &lt;code&gt;if&lt;/code&gt; statement that knows exactly how confident it is. Instead of asking a model to generate an essay, you pass unstructured context alongside a typed schema of closed-ended questions, and the model returns a JSON object with calibrated probabilities for every option, like grading a multiple-choice exam in a single forward pass. Jev exposes three primitives: &lt;code&gt;Choice&lt;/code&gt; (picking one option from an enum), &lt;code&gt;Score&lt;/code&gt; (rating along a defined rubric scale), and &lt;code&gt;Noul&lt;/code&gt; (estimating the boolean probability that a proposition is true). Given a support ticket complaining that a Stripe integration has been broken for three days, for instance, Jev routes it to &lt;code&gt;technical&lt;/code&gt; with probability &lt;code&gt;0.85&lt;/code&gt; and flags &lt;code&gt;urgent: true&lt;/code&gt; in under 100 ms. Under the hood, Jev undergoes standard pretraining followed by RLCD post-training on synthetic data that explicitly rewards Brier-score calibration so a &lt;code&gt;0.80&lt;/code&gt; confidence score genuinely means the model is right 80% of the time.&lt;/p&gt;
&lt;p&gt;More advises reaching for a System One model whenever your backend asks an LLM the exact same closed-ended routing, triage, moderation, or extraction question thousands of times a second—letting you auto-execute high-confidence predictions (&lt;code&gt;p &amp;gt; 0.95&lt;/code&gt;) and route low-confidence edge cases to a heavier reasoning model or human queue. On the public &lt;code&gt;JevBench&lt;/code&gt; suite, Jev is 6x to 7x cheaper per decision than &lt;code&gt;GPT-5.6 Luna&lt;/code&gt; or &lt;code&gt;Gemini 3.1 Flash-Lite&lt;/code&gt;. Conversely, don&amp;rsquo;t use it when the answer space isn&amp;rsquo;t known up front, when you need free-form text generation, or when deep multi-step reasoning matters more than latency; also remember to include an explicit &lt;code&gt;&amp;quot;none_of_the_above&amp;quot;&lt;/code&gt; enum variant if inputs can fall outside your categories. Competing approaches in this emerging space include SemIf, Laya, Kev, GLiNER2, and grammar-constrained decoding via Outlines.&lt;/p&gt;
&lt;h2 id="how-data-is-replicated-in-distributed-systems--raft-from-scratch---part-1"&gt;&lt;a href="https://sushantdhiman.dev/blog/raft/" rel="noopener noreferrer"&gt;How Data Is Replicated In Distributed Systems | Raft From Scratch - Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sushant Dhiman kicks off a two-part hands-on series with a foundational distributed systems problem: when you replicate a stateful service like a database across five machines for fault tolerance, how do the nodes agree on a single leader without split-brain? His answer walks through &lt;strong&gt;Raft&lt;/strong&gt;, the consensus algorithm designed by Diego Ongaro and John Ousterhout specifically to be easier to understand and implement than Paxos. Consensus ensures that a cluster of replicas agrees on a single ordered sequence of operations even in the face of crashes and network partitions, preventing scenarios where one replica commits 10 transactions while another only sees 7. Part 1 focuses entirely on &lt;strong&gt;Leader Election&lt;/strong&gt;. In Raft, every node is in one of three states at any moment: the &lt;em&gt;Leader&lt;/em&gt; handles client writes and coordinates replication, &lt;em&gt;Followers&lt;/em&gt; passively respond to RPCs from the leader, and a &lt;em&gt;Candidate&lt;/em&gt; is a follower that steps up to call an election after its leader heartbeat times out. Two RPCs drive the entire protocol: &lt;code&gt;AppendEntries&lt;/code&gt; (used both to replicate log entries and to send periodic empty heartbeats) and &lt;code&gt;RequestVote&lt;/code&gt; (sent by candidates campaigning for leadership).&lt;/p&gt;
&lt;p&gt;When a leader crashes or gets partitioned away, followers stop receiving heartbeats; once a follower&amp;rsquo;s randomized election timeout (say, between 150 ms and 300 ms) expires, it increments its monotonic &lt;em&gt;election term&lt;/em&gt; (which acts as a Lamport logical clock), transitions to Candidate, votes for itself, and sends &lt;code&gt;RequestVote&lt;/code&gt; RPCs to all peers. Randomized timeouts ensure nodes rarely campaign at the exact same millisecond, preventing endless split votes; within any given term, each node grants its vote to at most one candidate on a first-come, first-served basis, and any node that observes a message carrying a higher term number immediately steps down to Follower. Dhiman concludes with a clean educational implementation in Go and gRPC—wiring up the election timer loop, &lt;code&gt;RequestVote&lt;/code&gt;, heartbeat &lt;code&gt;AppendEntries&lt;/code&gt;, and protobuf definitions across three local nodes on ports &lt;code&gt;5001–5003&lt;/code&gt;—saving log replication and persistence for Part 2.&lt;/p&gt;
&lt;h2 id="jev-means-structured-output-is-interesting-again"&gt;&lt;a href="https://www.seangoedecke.com/jev-means-structured-output-is-interesting-again/" rel="noopener noreferrer"&gt;Jev means structured output is interesting again&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke rarely writes about new model releases, but makes an exception for TypeSafe AI&amp;rsquo;s &lt;strong&gt;Jev&lt;/strong&gt;. Standard LLMs generate text autoregressively one token at a time, which makes them wonderfully general-purpose at the cost of high latency and occasional formatting quirks. Jev accepts arbitrary natural-language prompts but &lt;em&gt;only&lt;/em&gt; emits structured classification/scoring outputs—and leaning completely into that constraint unlocks compelling systems properties. Because Jev doesn&amp;rsquo;t generate tokens sequentially and instead evaluates multiple structured decisions in parallel within a single pass, its latency is tightly bounded between 70 ms and 500 ms—fast enough to play &lt;em&gt;DOOM&lt;/em&gt; in real time from text descriptions of the screen state. To Goedecke, sub-100 ms, dirt-cheap structured intelligence feels like a genuine new computing primitive: once you can sprinkle 100 ms probabilistic judgements directly into standard control flow, you can build software that looks nothing like a chatbot.&lt;/p&gt;
&lt;p&gt;That said, Goedecke offers a sober technical reality check: fast structured output from small models was already possible if you cared to optimize for it. Most structured-output pipelines feel slow only because developers ask frontier chat models to emit massive nested JSON schemas via grammar-constrained decoding. For closed-ended classification, you can simply prefill the assistant response up to &lt;code&gt;&amp;quot;choice&amp;quot;: &amp;quot;&lt;/code&gt; and run a single forward pass constrained to valid option tokens—an experiment Goedecke ran locally with &lt;code&gt;Qwen2.5-1.5B-Instruct&lt;/code&gt; that immediately sped up classification by 2x to 3x. Consequently, Jev&amp;rsquo;s architectural moat may be shallower than advertised (though post-training specifically for calibrated probabilities via RLCD is a real differentiator), it will never match frontier reasoning models on problems that require test-time chain-of-thought compute, and calling wrong answers &amp;ldquo;classification errors&amp;rdquo; instead of &amp;ldquo;hallucinations&amp;rdquo; is mostly semantics. Even so, he hopes Jev succeeds and pressures the major labs to ship dedicated ultra-low-latency structured-output endpoints of their own.&lt;/p&gt;
&lt;h2 id="why-do-we-listen-to-people-with-no-skin-in-the-game"&gt;&lt;a href="https://rednafi.com/zephyr/no-skin-in-the-game/" rel="noopener noreferrer"&gt;Why do we listen to people with no skin in the game?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from the trenches of industrial software engineering, Redowan Delowar argues a simple rule borrowed from Nassim Taleb: if someone doesn&amp;rsquo;t bear the consequences of running the software in production, their opinions about how to build it are probably wrong. Influence does not equal correctness, and talking about code online is a completely different sport from shipping and maintaining production systems under real organizational constraints. A classic culprit is the &amp;ldquo;AI-pilled&amp;rdquo; executive or director who spends a Saturday afternoon vibe-coding a throwaway greenfield app, concludes that software engineering is completely solved, and shows up Monday demanding 10x feature velocity while dismissing compliance, legacy integration, and operational friction as excuses. Delowar uses LLMs heavily every day, which is precisely why he hits their sharp edges far more often than someone who only one-shots toy todo apps. You still have to humor your management chain to keep your paycheck, he notes, but never confuse organizational authority with technical truth—the person with real skin in the game is the one holding the pager when &amp;ldquo;vibe-slop&amp;rdquo; catches fire at 3 a.m.&lt;/p&gt;
&lt;p&gt;The second group with zero skin in the game is software influencers peddling engagement-bait absolutes like &lt;em&gt;&amp;ldquo;rewrite everything in Rust,&amp;rdquo;&lt;/em&gt; &lt;em&gt;&amp;ldquo;TypeScript is dead,&amp;rdquo;&lt;/em&gt; or &lt;em&gt;&amp;ldquo;Kotlin is Temu Java&amp;rdquo;&lt;/em&gt;—because nuanced engineering trade-offs don&amp;rsquo;t please social media algorithms, and selling hot takes and courses is far more lucrative than maintaining a five-year-old billing service. Podcast guests who actually built systems are often worth listening to, while professional hosts and course-sellers—many of whom pivoted seamlessly from JS framework bootcamps to Web3/NFTs and now to &amp;ldquo;AI agent mastery&amp;rdquo;—should be tuned out. Real companies choose tech stacks based on local hiring pools, iteration speed, and what the founding engineers already know, and LLMs haven&amp;rsquo;t changed that fundamental reality. Talk is cheap; always check whether the speaker will be around when the pager goes off.&lt;/p&gt;
&lt;h2 id="you-can-run-git-on-object-storage-if-you-re-make-packfiles"&gt;&lt;a href="https://www.tigrisdata.com/blog/objgit-packfiles/" rel="noopener noreferrer"&gt;You can run git on object storage if you re-make packfiles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Xe Iaso is building &lt;code&gt;objgit&lt;/code&gt;, an open-source Git server backed directly by Tigris S3-compatible object storage. A naive first prototype that mapped loose Git objects onto an object-storage filesystem hit a brick wall on real-world repositories. At its core, Git is a content-addressable store of millions of tiny objects—the Linux kernel repository alone contains roughly 11 million objects, so fetching them one by one at 10 ms per &lt;code&gt;GetObject&lt;/code&gt; HTTP call would take over 30 hours. Standard Git solves this with &lt;em&gt;packfiles&lt;/em&gt; (&lt;code&gt;.pack&lt;/code&gt; + &lt;code&gt;.idx&lt;/code&gt;), which bundle objects together and delta-compress them, but the Git packfile format was designed around local disks and &lt;code&gt;mmap&lt;/code&gt;, where random seeks cost nanoseconds rather than a 10 ms network round trip. Worse, standard &lt;code&gt;.idx&lt;/code&gt; files record only each object&amp;rsquo;s byte offset and &lt;em&gt;uncompressed&lt;/em&gt; size—not its compressed byte length in the pack—making it impossible to construct an exact HTTP &lt;code&gt;Range: bytes=start-end&lt;/code&gt; request to fetch a single object out of S3 without reading neighboring headers.&lt;/p&gt;
&lt;p&gt;Drawing inspiration from 1990s CD-ROM &lt;code&gt;.bin&lt;/code&gt;/&lt;code&gt;.cue&lt;/code&gt; rip files, Iaso designed a cloud-native packfile format for &lt;code&gt;objgit&lt;/code&gt;: compressed objects are concatenated into &lt;code&gt;.bin&lt;/code&gt; blobs capped at 128 MiB, while a separate binary &amp;ldquo;cue sheet&amp;rdquo; index stores every object&amp;rsquo;s offset alongside &lt;strong&gt;both&lt;/strong&gt; its compressed and uncompressed sizes—effectively turning a Git repository into a columnar store. With the exact compressed byte span in hand, &lt;code&gt;objgit&lt;/code&gt; can fire precise HTTP &lt;code&gt;Range&lt;/code&gt; requests for individual objects at the tail of a packfile while streaming the full packfile in the background until the sequential download catches up, all compressed with &lt;code&gt;zstd&lt;/code&gt;. Reinventing Git&amp;rsquo;s packfile format sounds like violating Chesterton&amp;rsquo;s Fence, Iaso admits, but because Git itself is distributed and content-addressed, if the server&amp;rsquo;s storage format breaks you can simply &lt;code&gt;git push&lt;/code&gt; again from a local clone. The payoff was dramatic: pushing the &lt;code&gt;Xe/x&lt;/code&gt; repository dropped from &lt;strong&gt;3 minutes 29 seconds down to 14.3 seconds&lt;/strong&gt;, and S3 API calls fell from over 9,000 down to 30. (&lt;code&gt;objgit&lt;/code&gt; still lacks authentication and authorization, so don&amp;rsquo;t expose it to the public internet yet.)&lt;/p&gt;
&lt;h2 id="why-cafebabe"&gt;&lt;a href="https://www.artima.com/insidejvm/whyCAFEBABE.html" rel="noopener noreferrer"&gt;Why CAFEBABE?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in May 1996, while writing his &lt;em&gt;&amp;ldquo;The Class File Lifestyle&amp;rdquo;&lt;/em&gt; column for &lt;em&gt;JavaWorld&lt;/em&gt;, Bill Venners got curious about the famous magic number sitting at the start of every compiled Java &lt;code&gt;.class&lt;/code&gt; file: why must the first four bytes always be &lt;code&gt;0xCAFEBABE&lt;/code&gt;? Venners posted the question to the &lt;code&gt;comp.lang.java&lt;/code&gt; Usenet newsgroup and archived the entire thread on this page. Readers chimed in with clever theories: a 32-bit magic number is fast to check on 32-bit architectures and unlikely to collide with ASCII text; the Java team wanted a coffee-themed hex constant, and since hexadecimal only gives you the letters &lt;code&gt;A&lt;/code&gt; through &lt;code&gt;F&lt;/code&gt; (no &lt;code&gt;J&lt;/code&gt; or &lt;code&gt;V&lt;/code&gt;), combinations using &lt;code&gt;CAFE&lt;/code&gt; beat out alternatives like &lt;code&gt;0xAFABCAFE&lt;/code&gt;, &lt;code&gt;0xCAFEFACE&lt;/code&gt;, or the ominous &lt;code&gt;0xABADCAFE&lt;/code&gt;—while one reader wished they had picked &lt;code&gt;0x00C0FFEE&lt;/code&gt; (reading the leading zeros as the letters &lt;code&gt;&amp;quot;OO&amp;quot;&lt;/code&gt; for &amp;ldquo;Object-Oriented Coffee&amp;rdquo;).&lt;/p&gt;
&lt;p&gt;The Usenet thread also serves as a charming mini-museum of computing folklore around hex magic numbers: the Burroughs B6700 initialized unused memory to &lt;code&gt;0xBADBADBADBAD&lt;/code&gt;; classic IBM systems and AIX RS/6000s filled uninitialized memory with &lt;code&gt;0xDEADBEEF&lt;/code&gt; so pointer bugs jumped right out in a debugger; classic Mac OS placed &lt;code&gt;0x50FFC001&lt;/code&gt; at address &lt;code&gt;0x0&lt;/code&gt; so dereferencing a &lt;code&gt;NULL&lt;/code&gt; code pointer would immediately trap; SGI IRIX started shared arena files with &lt;code&gt;0xDEADBABE&lt;/code&gt;; and debug builds of Solaris overwrote freed heap blocks with &lt;code&gt;0xCAFEFEED&lt;/code&gt;. Another reader pointed out that NeXTSTEP had already used &lt;code&gt;0xCAFEBABE&lt;/code&gt; as the magic number for multi-architecture &amp;ldquo;fat&amp;rdquo; binaries alongside &lt;code&gt;0xFEEDFACE&lt;/code&gt; for Mach-O object files. Finally, Patrick Naughton—one of the original members of Sun&amp;rsquo;s Green Project that created Oak (later renamed Java)—replied with the authoritative answer: he picked &lt;code&gt;0xCAFEBABE&lt;/code&gt; himself years before the name &amp;ldquo;Java&amp;rdquo; even existed! He simply wanted a fun, memorable 32-bit hex constant for the object file format, and &lt;code&gt;0xcafebabe&lt;/code&gt; beat out the runner-up &lt;code&gt;0xdeadbabe&lt;/code&gt;. Any connection to the baristas at Peet&amp;rsquo;s Coffee or the eventual name &amp;ldquo;Java&amp;rdquo; was pure serendipity.&lt;/p&gt;</description></item><item><title>Newsletter #137</title><link>https://miti99.com/en/post/2026/10/05/</link><pubDate>Mon, 05 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #137.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-to-name-things"&gt;&lt;a href="https://kolemannix.com/blog/how-to-name-things/" rel="noopener noreferrer"&gt;How to name things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Koleman Nix argues that naming is one of the most foundational skills in software engineering, because clear language almost always reflects clear thinking. Every time we name a variable, function, API endpoint, or database column, we are communicating with both future human teammates and LLMs. Coding models fly through clean, well-named greenfield codebases, yet gradually bog down as terminology across a repo becomes inconsistent and &amp;ldquo;slop-fried&amp;rdquo;—meaning sustainable velocity with AI agents requires continuously pruning and sharpening your domain vocabulary. Properly understood, DRY means every piece of domain knowledge has a single authoritative representation, not merging two numbers that happen to be equal: a maximum username length of 64 and a work-queue depth of 64 are two completely separate truths that belong in two separate named constants. Nix pushes back against rigid mechanical naming conventions, which often serve as an excuse to avoid thinking; what should be consistent is your naming &lt;em&gt;process&lt;/em&gt;—capturing what a thing &lt;em&gt;is&lt;/em&gt; rather than how it happens to be used today, and respecting symmetry like &lt;code&gt;src&lt;/code&gt; and &lt;code&gt;dst&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Good naming is an act of intellectual empathy, whereas naming something after your immediate caller&amp;rsquo;s need is short-sighted. A &lt;code&gt;created_at&lt;/code&gt; column makes sense for an internal row timestamp, but a scanned birth certificate uploaded in 2023 needs distinct &lt;code&gt;uploaded_at&lt;/code&gt; and &lt;code&gt;record_date&lt;/code&gt; fields. Similarly, a helper named &lt;code&gt;mergeTargetValuesIntoSourceTemplate&lt;/code&gt; obscures the fact that the function is simply a generic map merge (&lt;code&gt;++&lt;/code&gt;). And a vague field like &lt;code&gt;documentDate&lt;/code&gt; invites two different services to interpret it differently, breeding subtle bugs. His rule of thumb: name things for their intrinsic essence, not their momentary use case.&lt;/p&gt;
&lt;h2 id="postgres-locks-explained"&gt;&lt;a href="https://postgreslocksexplained.com/" rel="noopener noreferrer"&gt;Postgres Locks Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Postgres Locks Explained&lt;/em&gt; is an interactive visual guide to PostgreSQL locking—&amp;ldquo;from beginner to expert&amp;rdquo;—created by Brian (&lt;code&gt;@TheOtherBrian1&lt;/code&gt;), a customer reliability engineer specializing in Postgres administration and observability, who built the resource he wished he&amp;rsquo;d had when first learning how Postgres locks work. The &lt;em&gt;Concepts&lt;/em&gt; section uses step-by-step animations to show why locks exist in the first place: without coordination, a &lt;code&gt;SELECT&lt;/code&gt; reading a page mid-&lt;code&gt;DELETE&lt;/code&gt; could observe half-deleted state, or a concurrent &lt;code&gt;DROP TABLE&lt;/code&gt; could pull the rug out from under an active query. &lt;em&gt;Locks by Example&lt;/em&gt; walks through hands-on two-session scenarios you can run locally, such as how an uncommitted &lt;code&gt;ALTER TABLE&lt;/code&gt; holding an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock blocks even simple &lt;code&gt;SELECT&lt;/code&gt; queries behind it, or how &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; preserves application-level uniqueness invariants when two transactions race to update the same logical entity. An interactive &lt;em&gt;Lock Blocking Graph&lt;/em&gt; lets you click any SQL command—from &lt;code&gt;SELECT&lt;/code&gt; and &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; to &lt;code&gt;VACUUM FULL&lt;/code&gt;—to see every lock mode it acquires and which other commands it blocks.&lt;/p&gt;
&lt;p&gt;The &lt;em&gt;Troubleshooting&lt;/em&gt; section distills lessons from investigating thousands of production databases a year: lock contention is rarer than unindexed queries or connection-pool exhaustion, which is precisely why developers are often caught flat-footed when a lock queue brings production to a halt. It covers deadlocks, exhausting the shared-memory lock table (&lt;code&gt;out of shared memory&lt;/code&gt; requiring higher &lt;code&gt;max_locks_per_transaction&lt;/code&gt;), cascading lock queues behind a waiting DDL statement, and full-table lockouts, recommending enabling &lt;code&gt;log_lock_waits&lt;/code&gt; so any query waiting longer than &lt;code&gt;deadlock_timeout&lt;/code&gt; is logged automatically. Finally, the &lt;em&gt;Monitoring&lt;/em&gt; section shows how to join &lt;code&gt;pg_locks&lt;/code&gt;, &lt;code&gt;pg_stat_activity&lt;/code&gt;, and &lt;code&gt;pg_blocking_pids()&lt;/code&gt; to pinpoint the root blocker at the head of a lock chain, alongside the exact lock-tree queries used by Datadog and pganalyze.&lt;/p&gt;
&lt;h2 id="a-deep-and-fuzzy-dive-into-search"&gt;&lt;a href="https://serenedb.com/blog/fuzzy-search-deep-dive" rel="noopener noreferrer"&gt;A Deep (and Fuzzy) Dive Into Search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SereneDB CTO Andrey Abramov revisits and expands his deep dive into fuzzy search, originally written six years ago when his team first built fuzzy matching into the IResearch engine that now powers SereneDB. &amp;ldquo;Fuzzy search&amp;rdquo; is an umbrella term for approximate string-matching algorithms, each built around its own similarity metric. The classic metric is &lt;em&gt;Levenshtein edit distance&lt;/em&gt;: the minimum number of single-character insertions, deletions, and substitutions required to turn one string into another. Computing edit distance via the textbook Wagner–Fischer dynamic programming matrix takes $O(|s_1| \cdot |s_2|)$ time per candidate word, which is far too slow to run against a dictionary of millions of terms. The breakthrough is Schulz and Mihov&amp;rsquo;s (2002) &lt;em&gt;Levenshtein automaton&lt;/em&gt;: given a query word and a maximum edit distance $k$, you construct in linear time a deterministic finite automaton that recognizes &lt;em&gt;every&lt;/em&gt; string within distance $k$, and then intersect that automaton directly with the index&amp;rsquo;s term dictionary trie or Finite State Transducer (FST) to prune non-matching branches in bulk. Because the universal transition tables grow rapidly with $k$, SereneDB caps compiled Levenshtein automata at distance 4 (and distance 3 for Damerau–Levenshtein, which counts adjacent character transpositions as a single edit).&lt;/p&gt;
&lt;p&gt;Because edit distance is sensitive to word length and struggles when multi-word queries have missing or extra words, SereneDB pairs it with &lt;em&gt;n-gram similarity&lt;/em&gt; based on Grzegorz Kondrak&amp;rsquo;s formulation, which computes a longest-common-subsequence-style similarity over character $n$-grams rather than individual letters. Normalizing the score by the query&amp;rsquo;s length rather than the document&amp;rsquo;s length allows short queries to match longer fields naturally. In SereneDB&amp;rsquo;s SQL interface, &lt;code&gt;ts_levenshtein&lt;/code&gt; automatically scales the allowed edit distance by query token length to handle typos, while &lt;code&gt;ts_ngram&lt;/code&gt; defaults to a &lt;code&gt;0.7&lt;/code&gt; similarity threshold—and real-world search pipelines frequently combine both.&lt;/p&gt;
&lt;h2 id="email-encryption"&gt;&lt;a href="https://computer.rip/2026-07-19-email-encryption.html" rel="noopener noreferrer"&gt;email encryption&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his &lt;em&gt;Computers Are Bad&lt;/em&gt; newsletter, J. B. Crawford traces the long, frustrating history of trying to encrypt email. Born in the high-trust academic networks of the late 1960s and 1970s, internet email (SMTP and RFC 822) was designed with zero built-in confidentiality or sender authentication. The competing OSI protocol suite included X.400, which had structured security extensions, but lost out to simpler internet email and survives today only in specialized closed environments like military and aviation messaging. MIME (&amp;ldquo;email 2.0&amp;rdquo; in the early 1990s) solved 8-bit payloads and attachments, setting the stage for two competing end-to-end encryption standards. Phil Zimmermann&amp;rsquo;s PGP (1991, later standardized as OpenPGP and implemented in GnuPG) decentralized key distribution through a peer-to-peer &amp;ldquo;web of trust,&amp;rdquo; which failed to gain mainstream traction because managing keys and key-signing parties proved too confusing for normal users. S/MIME (1996) instead relied on hierarchical X.509 PKI certificates signed by commercial Certificate Authorities, succeeding inside large enterprises and government agencies thanks to tight integration with Microsoft Exchange and Active Directory, while remaining nearly unusable across organizational boundaries.&lt;/p&gt;
&lt;p&gt;Ironically, the vast majority of email today &lt;em&gt;is&lt;/em&gt; encrypted in transit between mail servers—not end-to-end, but at the transport layer via opportunistic &lt;code&gt;STARTTLS&lt;/code&gt;. Because naive &lt;code&gt;STARTTLS&lt;/code&gt; is vulnerable to active downgrade attacks where a man-in-the-middle strips the &lt;code&gt;250-STARTTLS&lt;/code&gt; advertisement, the industry bolted on additional patches: DANE (binding TLS keys to DNSSEC records), MTA-STS (publishing strict TLS policies over HTTPS), and bilateral TLS enforcement between major providers like Gmail and Microsoft 365. Crawford&amp;rsquo;s takeaway: end-to-end email encryption remains a bolted-on afterthought that lost the usability war, leaving real-world email privacy dependent on hop-by-hop transport encryption managed by major cloud mail providers.&lt;/p&gt;
&lt;h2 id="a-shell-exclamation-mark-is-not-for-yelling-be-lazy"&gt;&lt;a href="https://refp.se/articles/your-shell-and-the-lazy-exclamation-mark" rel="noopener noreferrer"&gt;A shell exclamation mark is not for yelling. Be lazy.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Filip Roséen reintroduces a superpower hiding in Unix shells since &lt;code&gt;csh&lt;/code&gt; in the late 1970s that many developers never use beyond &lt;code&gt;sudo !!&lt;/code&gt;: &lt;strong&gt;history expansion&lt;/strong&gt; (event designators) in &lt;code&gt;bash&lt;/code&gt;, &lt;code&gt;zsh&lt;/code&gt;, &lt;code&gt;csh&lt;/code&gt;, and &lt;code&gt;tcsh&lt;/code&gt;. Programmers preach DRY in source code, yet happily mash the up-arrow key and hold down the left-arrow key to edit previous shell commands by hand. History expansion follows a uniform three-part grammar: &lt;code&gt;![event][:word][:modifier]&lt;/code&gt;. The &lt;em&gt;event&lt;/em&gt; selector picks a command line from history: &lt;code&gt;!!&lt;/code&gt; is the previous command, &lt;code&gt;!-2&lt;/code&gt; is two commands ago, &lt;code&gt;!ssh&lt;/code&gt; is the most recent command starting with &lt;code&gt;&amp;quot;ssh&amp;quot;&lt;/code&gt;, &lt;code&gt;!?needle?&lt;/code&gt; is the most recent command containing &lt;code&gt;&amp;quot;needle&amp;quot;&lt;/code&gt; anywhere, and &lt;code&gt;^old^new^&lt;/code&gt; runs the previous command with the first occurrence of &lt;code&gt;old&lt;/code&gt; replaced by &lt;code&gt;new&lt;/code&gt;. The &lt;em&gt;word&lt;/em&gt; designator selects specific arguments from that command (&lt;code&gt;!:0&lt;/code&gt; is the command name, &lt;code&gt;!:1&lt;/code&gt; is the first argument, &lt;code&gt;!$&lt;/code&gt; is the last argument—as in &lt;code&gt;mkdir /var/mnt/cache&lt;/code&gt; followed by &lt;code&gt;cd !$&lt;/code&gt;, and &lt;code&gt;!*&lt;/code&gt; is all arguments), while &lt;em&gt;modifiers&lt;/em&gt; transform the selected text on the fly: &lt;code&gt;:h&lt;/code&gt; strips a path to its directory head like &lt;code&gt;dirname&lt;/code&gt;, &lt;code&gt;:t&lt;/code&gt; extracts the filename tail like &lt;code&gt;basename&lt;/code&gt;, &lt;code&gt;:r&lt;/code&gt; strips the file extension, &lt;code&gt;:s/a/b/&lt;/code&gt; substitutes text (&lt;code&gt;:gs/a/b/&lt;/code&gt; globally), and &lt;code&gt;:p&lt;/code&gt; prints the expanded command safely without executing it.&lt;/p&gt;
&lt;p&gt;For strict POSIX shells where &lt;code&gt;!&lt;/code&gt; expansion isn&amp;rsquo;t available, the built-in &lt;code&gt;fc&lt;/code&gt; (&lt;em&gt;fix command&lt;/em&gt;) utility lets you open recent commands in &lt;code&gt;$EDITOR&lt;/code&gt; or batch-transform and re-run a range of commands on the fly—such as &lt;code&gt;fc -e 'sed -i s/prod-01/test-01/g' -3 -1&lt;/code&gt; to replay your last three commands against a test host. Roséen recommends mastering a small core toolkit (&lt;code&gt;!!&lt;/code&gt;, &lt;code&gt;!prefix&lt;/code&gt;, &lt;code&gt;!?substr?&lt;/code&gt;, &lt;code&gt;!$&lt;/code&gt;, &lt;code&gt;!:0&lt;/code&gt;, &lt;code&gt;!$:h&lt;/code&gt;, and &lt;code&gt;!$:t&lt;/code&gt;) and turning on &lt;code&gt;shopt -s histverify&lt;/code&gt; in Bash (or &lt;code&gt;setopt HIST_VERIFY&lt;/code&gt; in Zsh), which loads the expanded command onto your prompt line for inspection before you press Enter to run it.&lt;/p&gt;
&lt;h2 id="a-coding-agent-is-six-functions-in-a-trenchcoat"&gt;&lt;a href="https://tidydesign.substack.com/p/a-coding-agent-is-six-functions-in" rel="noopener noreferrer"&gt;A coding agent is six functions in a trenchcoat&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hadley Wickham demystifies what actually sits inside coding agents like Claude Code, Cursor, and Codex. At its core, an agent is an LLM running in a loop with tools that can read and mutate external state, and a coding agent is simply an agent equipped with tools that let it explore and edit a codebase the same way a human developer does. Almost every coding agent boils down to six primitive functions—read a file, write a file, edit a file, list files, search file contents, and run a shell command—paired with a detailed system prompt encoding software engineering best practices. To prove how simple the core mechanism is, Wickham builds a working coding agent from scratch in R using the &lt;code&gt;ellmer&lt;/code&gt; package, starting with just three 5-line functions: &lt;code&gt;read_file&lt;/code&gt;, &lt;code&gt;write_file&lt;/code&gt;, and &lt;code&gt;run_command&lt;/code&gt;. Registering those three tools with clear descriptions and a minimal prompt is already enough for the model to locate a date-parsing function in a repo and write unit tests for it.&lt;/p&gt;
&lt;p&gt;While &lt;code&gt;run_command&lt;/code&gt; is the ultimate &amp;ldquo;escape hatch&amp;rdquo; capable of running &lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;grep&lt;/code&gt;, &lt;code&gt;git&lt;/code&gt;, or test suites, leaning on raw shell execution for everything is slow, token-heavy, and dangerous because validating whether an arbitrary shell string is safe is notoriously hard. Wickham therefore adds dedicated &lt;code&gt;list_files&lt;/code&gt; and &lt;code&gt;search_files&lt;/code&gt; tools backed by a &lt;code&gt;safe_path()&lt;/code&gt; helper that normalizes paths and rejects any traversal outside the current working directory—while R&amp;rsquo;s default &lt;code&gt;list.files(all.files = FALSE)&lt;/code&gt; automatically hides dotfiles like &lt;code&gt;.Renviron&lt;/code&gt; so secret API keys aren&amp;rsquo;t casually listed. Finally, adding a surgical &lt;code&gt;edit_file(path, old_string, new_string)&lt;/code&gt; tool lets the LLM replace a specific block of lines instead of rewriting an entire 500-line file via &lt;code&gt;write_file&lt;/code&gt;, slashing output token costs and failing loudly if the target context doesn&amp;rsquo;t match rather than silently corrupting the file.&lt;/p&gt;
&lt;h2 id="how-well-do-agents-use-test-and-verification-techniques"&gt;&lt;a href="https://danluu.com/agentic-testing/" rel="noopener noreferrer"&gt;How well do agents use test and verification techniques?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Luu investigates a natural question for agentic coding: does instructing a coding agent in its prompt to use specific testing methodologies or formal verification tools actually produce more correct code? Using his &lt;code&gt;zstd&lt;/code&gt;-from-RFC benchmark in Rust, Luu tested Codex with &lt;code&gt;GPT-5.6 Sol&lt;/code&gt; across both &lt;code&gt;medium&lt;/code&gt; and &lt;code&gt;xhigh&lt;/code&gt; reasoning effort settings under 26 different prompt conditions—including a default baseline, TDD, &lt;code&gt;&amp;quot;Make no mistakes&amp;quot;&lt;/code&gt;, self-audit, fuzzing, differential testing, property-based testing, mutation testing, and formal verification tools like TLA+, Kani, Verus, and Lean 4, plus four community testing skills—running roughly 160 trials per condition and plotting pass rates on the hidden test suite against dollar cost.&lt;/p&gt;
&lt;p&gt;The headline result is sobering: &lt;strong&gt;none of the prompted testing or verification methodologies significantly outperformed the unprompted baseline&lt;/strong&gt;, and several actively hurt correctness or blew up token costs. When told to use an advanced tool, agents overwhelmingly went through the motions superficially to satisfy the prompt rather than using the tool to find real bugs in their implementation. Told to use Verus, the agent proved trivial, tautological properties about toy helper structs instead of verifying the actual &lt;code&gt;zstd&lt;/code&gt; decoder; in 159 out of 160 TLA+ runs, the agent wrote a standalone &lt;code&gt;.tla&lt;/code&gt; model file that never informed or changed a single line of the Rust code; and in 135 out of 160 &amp;ldquo;differential testing&amp;rdquo; runs, the agent never even compared two independent implementations. Prompting for strict TDD performed worse than baseline, frequently missing the tricky 4-stream Huffman jump-table edge case. Naive fuzzing mostly generated random invalid byte streams that bounced off the header parser, though in the 10 runs where the agent bothered to build a &lt;em&gt;structure-aware&lt;/em&gt; fuzzer, half of them uncovered real decoder bugs. Luu&amp;rsquo;s takeaway: simply naming a methodology like &amp;ldquo;use property-based testing&amp;rdquo; or &amp;ldquo;use formal verification&amp;rdquo; in a prompt does very little—to get real leverage, you have to wire up the verification harness yourself and iterate on what the agent actually executes.&lt;/p&gt;
&lt;h2 id="how-one-connection-kills-a-database"&gt;&lt;a href="https://planetscale.com/blog/debugging-live-database-connections" rel="noopener noreferrer"&gt;How one connection kills a database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simeon Griggs at PlanetScale opens with a classic production murder mystery: every single query to your database is timing out, CPU and disk I/O are practically idle—what happened? He recalls a famous GitHub outage on MySQL where a routine schema change needed an exclusive metadata lock on a hot table, got blocked behind a single long-running open transaction that had touched that table earlier, and subsequently caused every new &lt;code&gt;SELECT&lt;/code&gt; and &lt;code&gt;UPDATE&lt;/code&gt; on the table to queue up behind the waiting DDL statement. There is no deadlock (so the deadlock detector never steps in), and the outage lasts until someone finds and kills the single idle connection sitting at the very front of the queue. Griggs reproduces the exact same failure mode on PostgreSQL: an application worker runs &lt;code&gt;BEGIN;&lt;/code&gt; and &lt;code&gt;SELECT * FROM orders LIMIT 1;&lt;/code&gt;, hits an unhandled exception in application code, and leaks the connection back into limbo without ever issuing &lt;code&gt;COMMIT&lt;/code&gt; or &lt;code&gt;ROLLBACK&lt;/code&gt;. That &lt;code&gt;idle in transaction&lt;/code&gt; session holds only a harmless &lt;code&gt;ACCESS SHARE&lt;/code&gt; lock, until a deployment runs &lt;code&gt;ALTER TABLE orders ADD COLUMN ...&lt;/code&gt;, which requests an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock, waits behind the leaked session, and blocks every subsequent query on &lt;code&gt;orders&lt;/code&gt; behind the pending migration.&lt;/p&gt;
&lt;p&gt;Because PostgreSQL ships with &lt;code&gt;idle_in_transaction_session_timeout&lt;/code&gt; disabled (&lt;code&gt;0&lt;/code&gt;) by default, a single unhandled exception in app code can take down an entire table during a deploy—and when the resulting lock queue exhausts &lt;code&gt;max_connections&lt;/code&gt;, you can&amp;rsquo;t even open a &lt;code&gt;psql&lt;/code&gt; shell to inspect &lt;code&gt;pg_stat_activity&lt;/code&gt;. To make recovering from these pileups effortless, PlanetScale built a live &lt;strong&gt;Connections&lt;/strong&gt; inspector backed by reserved superuser connection slots that visualizes active processes, transaction age, and the exact blocker tree in real time, offering three surgical kill actions: &lt;em&gt;Cancel Query&lt;/em&gt; (&lt;code&gt;pg_cancel_backend&lt;/code&gt;), &lt;em&gt;Terminate Transaction&lt;/em&gt;, or &lt;em&gt;Terminate Connection&lt;/em&gt; (&lt;code&gt;pg_terminate_backend&lt;/code&gt;)—noting that canceling the query does nothing here because the &lt;code&gt;SELECT&lt;/code&gt; already finished inside the open transaction. The same real-time blocker tree is also available in the CLI via &lt;code&gt;pscale branch connections top&lt;/code&gt; and &lt;code&gt;show --format json&lt;/code&gt; for scripts and agents.&lt;/p&gt;
&lt;h2 id="todos-considered-harmful"&gt;&lt;a href="https://frequal.com/java/TodosConsideredHarmful.html" rel="noopener noreferrer"&gt;TODOs Considered Harmful&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Oliver warns that in an era where autonomous coding agents roam repositories with less and less human supervision, &lt;code&gt;// TODO&lt;/code&gt; comments have turned from harmless reminders into ticking time bombs. Historically, developers jotted down &lt;code&gt;TODO&lt;/code&gt; comments in a hurry as half-baked notes to self—rarely reviewed with the rigor of executable code, never tested, and frequently left to rot as the surrounding architecture evolved. Over the past year, however, engineering teams have moved from using AI as an interactive Stack Overflow replacement to turning agents loose on whole modules with instructions to &amp;ldquo;clean up tech debt&amp;rdquo; or &amp;ldquo;fix outstanding issues.&amp;rdquo; To an eager coding agent, a &lt;code&gt;TODO&lt;/code&gt; comment looks like an explicit, authoritative specification written by a human engineer begging to be implemented.&lt;/p&gt;
&lt;p&gt;The danger is that &lt;code&gt;TODO&lt;/code&gt; comments frequently describe an idea that was wrong when written, became obsolete three refactorings ago, or omitted critical domain constraints that lived only in the original author&amp;rsquo;s head. Because LLMs treat in-repo comments as trusted context and lack the historical context to judge whether a five-year-old &lt;code&gt;TODO: cache this lookup&lt;/code&gt; is actually safe under concurrent writes, an agent will cheerfully turn a bad &lt;code&gt;TODO&lt;/code&gt; into real production code—and Oliver notes he has already watched this exact failure mode cause production incidents. His advice: stop letting new &lt;code&gt;TODO&lt;/code&gt;s slip through code review (if a fix is important enough to mention, either fix it now or file a tracked issue with proper acceptance criteria), audit and purge stale &lt;code&gt;TODO&lt;/code&gt;s across your codebase before unleashing background maintenance agents, and if a note truly must live in the code, write an explanatory comment documenting &lt;em&gt;why&lt;/em&gt; the current code works the way it does rather than an open-ended instruction to change it.&lt;/p&gt;
&lt;h2 id="git-worktree-gotchas"&gt;&lt;a href="https://www.olafalders.com/2026/09/16/git-worktree-gotchas/" rel="noopener noreferrer"&gt;git worktree gotchas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olaf Alders notes that &lt;code&gt;git worktree&lt;/code&gt;—once a niche power-user feature—has gone mainstream thanks to developers running multiple coding agents in parallel across separate branches, but it comes with a few sharp edges if your tooling assumes a traditional single-checkout layout. In Git&amp;rsquo;s terminology, your initial &lt;code&gt;git clone&lt;/code&gt; creates the &lt;em&gt;main working tree&lt;/em&gt;, while &lt;code&gt;git worktree add&lt;/code&gt; creates &lt;em&gt;linked working trees&lt;/em&gt;. Almost every worktree gotcha stems from one implementation detail: inside a linked worktree, &lt;code&gt;.git&lt;/code&gt; is &lt;strong&gt;not a directory&lt;/strong&gt;—it is a plain text file containing a &lt;code&gt;gitdir:&lt;/code&gt; pointer back to &lt;code&gt;.git/worktrees/&amp;lt;name&amp;gt;&lt;/code&gt; inside the main working tree. Consequently, any naive script or tool that walks up parent directories looking for a &lt;code&gt;.git/&lt;/code&gt; &lt;em&gt;directory&lt;/em&gt; to find the repository root will walk right past the top of a linked worktree—and if you nested your linked worktrees inside a subdirectory of your main working tree, that script will silently resolve to the main working tree instead, running against the wrong files! Alders keeps his linked worktrees in a sibling directory outside the main checkout and recommends always using &lt;code&gt;git rev-parse --show-toplevel&lt;/code&gt; to find the current worktree root, or &lt;code&gt;dirname &amp;quot;$(git rev-parse --git-common-dir)&amp;quot;&lt;/code&gt; when a script inside a linked worktree needs to locate gitignored files like &lt;code&gt;.env&lt;/code&gt; in the main working tree.&lt;/p&gt;
&lt;p&gt;A third gotcha bites when running coding agents inside filesystem sandboxes like &lt;code&gt;nono&lt;/code&gt;, Docker, Landlock, or macOS Seatbelt. By default, Git hooks live in &lt;code&gt;.git/hooks&lt;/code&gt; inside the main working tree, which is outside the linked worktree&amp;rsquo;s directory tree and therefore blocked by the sandbox when the agent tries to run &lt;code&gt;git commit&lt;/code&gt;. The clean fix is to check your hooks into a tracked &lt;code&gt;.githooks/&lt;/code&gt; directory inside the repo and set &lt;code&gt;git config core.hooksPath .githooks&lt;/code&gt; using a &lt;strong&gt;relative&lt;/strong&gt; path. Because Git always &lt;code&gt;chdir&lt;/code&gt;s to the current worktree&amp;rsquo;s top-level directory before executing a hook, a relative &lt;code&gt;core.hooksPath&lt;/code&gt; resolves cleanly inside every linked worktree and stays completely within the sandbox boundary.&lt;/p&gt;</description></item><item><title>Newsletter #136</title><link>https://miti99.com/en/post/2026/10/04/</link><pubDate>Sun, 04 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #136.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="fast-and-hard-code"&gt;&lt;a href="https://lucumr.pocoo.org/2026/8/22/fast-hard-code/" rel="noopener noreferrer"&gt;Fast and Hard Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher observes that regardless of how far you buy into the &amp;ldquo;coding is solved&amp;rdquo; meme, the human learning curve of a programming language no longer acts as the gatekeeper it once did—because human syntax friction doesn&amp;rsquo;t slow down an AI agent. As a result, LLMs make initial language choice simultaneously less permanent (if you don&amp;rsquo;t like a codebase, you can port it to another language over a weekend, even one you barely know) and more driven by a language&amp;rsquo;s runtime characteristics and cultural aspirations. He sees developers shipping Rust today who would never have invested the months required to wrestle with the borrow checker by hand. Two trends reinforce this shift: a renewed appreciation for fast, resource-frugal software, and the realization that LLMs are exceptionally good at low-level performance optimization when given a benchmark and a test suite to keep behavior identical.&lt;/p&gt;
&lt;p&gt;Performance-obsessed builders like Mitchell Hashimoto, Charlie Marsh, Jarred Sumner, and Daniel Lemire have all embraced agentic workflows, and automated optimization loops let anyone hand a hot function to an agent and ask it to hill-climb on throughput. Consequently, new projects that care about speed and binary size increasingly reach for &amp;ldquo;hard&amp;rdquo; systems languages. Even Zig is benefiting—despite its core community&amp;rsquo;s skepticism toward AI: Cloudflare&amp;rsquo;s Artifacts service runs a full Git protocol engine written in Zig and compiled to a ~100 KB WebAssembly module, and Vercel recently shipped &lt;code&gt;fx&lt;/code&gt;, a coding agent written in Zig. Developers are also tackling intimidating domains like DWARF debug info, eBPF, custom network drivers, cryptography, and retro hardware that used to feel out of reach. The AI era may produce plenty of slop, Ronacher concludes, but it is also empowering a wave of fast, uncompromising systems software.&lt;/p&gt;
&lt;h2 id="shipping-video-calling-on-facebook"&gt;&lt;a href="https://molochinations.substack.com/p/shipping-video-calling-on-facebook" rel="noopener noreferrer"&gt;Shipping Video Calling on Facebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philip Su looks back 16 years to when he joined Facebook&amp;rsquo;s fledgling Seattle office as its second engineer after twelve years at Microsoft. At the time, Facebook had only around 500 engineers in total, and Su signed up as the sole full-time engineer building Facebook&amp;rsquo;s very first video calling product—later joined by teammates like Denise Noyes and Vijaye Raji—small enough that the team reviewed product iterations directly with Mark Zuckerberg. Because WebRTC didn&amp;rsquo;t exist yet, Facebook partnered with Skype to embed a downloadable native Skype client binary that users installed before placing a call. Su pulls no punches about the quality of Skype&amp;rsquo;s codebase at the time: call setup succeeded only 82% of the time, and when he asked Skype&amp;rsquo;s engineers what their own baseline call-setup success rate was, they replied, &amp;ldquo;We don&amp;rsquo;t track that metric&amp;rdquo;—relying solely on post-call user star ratings. Ironically, routing call-signaling packets over Facebook Messenger&amp;rsquo;s infrastructure exposed that Messenger itself was silently dropping messages at a surprising rate, forcing Facebook to harden its own real-time messaging backbone.&lt;/p&gt;
&lt;p&gt;The six weeks following launch were the most grueling crunch of Su&amp;rsquo;s career: shipping hotfix after hotfix from 8 a.m. to midnight seven days a week, subsisting on office junk food, and somehow still losing over 10 pounds from the stress. One fun Easter egg: the outgoing ringtone melody was literally the musical notes &lt;strong&gt;F–A–C–E&lt;/strong&gt;. By the end of that six-week blitz, call reliability was solid, and Su used the feature to have his very first video call with his parents—a technology that COVID and WebRTC have since made as mundane as a phone call.&lt;/p&gt;
&lt;h2 id="ai-is-removing-the-middle-class-of-software-engineering"&gt;&lt;a href="https://blog.florianherrengt.com/ai-removing-middle-class-software-engineering.html" rel="noopener noreferrer"&gt;AI is removing the middle class of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Florian Herrengt opens with a scene that has become all too familiar in 2026: a senior engineer logs in on Monday morning to find seven pull requests waiting for review, the first of which is a 24,000-line diff accompanied by an AI-generated summary. When a subtle bug crops up for the fourth time, the developer who opened the PR can&amp;rsquo;t explain where the data originates—their only move is to paste the stack trace back into Claude. In Herrengt&amp;rsquo;s view, AI has removed the natural speed limit of software development: teams with weak engineering culture now drive off a cliff ten times faster, and the tragedy is that to an inexperienced eye, the app still looks like it works. Undoing a bad architectural decision is much harder than generating it—an LLM can add three unnecessary database tables in ten minutes, but untangling them once real customer data lands in production requires a painful, high-risk migration.&lt;/p&gt;
&lt;p&gt;Weak code has always existed, Herrengt notes, but the difference today is velocity—like crashing a car at 200 km/h instead of 30 km/h. Code review, tests, and CI pipelines still exist, but they were designed for a world where human typing speed naturally throttled the volume of changes entering the pipe. A developer churning out ten massive AI-generated PRs a day isn&amp;rsquo;t necessarily creating value; they are often just shifting the cognitive burden onto the team&amp;rsquo;s most senior, hardest-to-replace engineers. He predicts AI will hollow out the middle of the engineering market and widen compensation gaps: strong engineers with deep system judgment become exponentially more valuable, while developers who use AI as a substitute for understanding rather than an amplifier of it will struggle to stay employable.&lt;/p&gt;
&lt;h2 id="the-fastest-double-to-string-algorithm-youve-never-heard-of"&gt;&lt;a href="https://vitaut.net/posts/2026/yy-dtoa/" rel="noopener noreferrer"&gt;The fastest double-to-string algorithm you’ve never heard of&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Victor Zverovich, author of &lt;code&gt;{fmt}&lt;/code&gt; and the &lt;code&gt;zmij&lt;/code&gt; floating-point formatting library, spotlights one of the fastest &lt;code&gt;dtoa&lt;/code&gt; (double-to-string) algorithms in existence—one that almost nobody has heard of. It lives quietly inside &lt;code&gt;yy_double.c&lt;/code&gt; in &lt;code&gt;ibireme&lt;/code&gt;&amp;rsquo;s &lt;code&gt;yyjson&lt;/code&gt; C library, has no accompanying academic paper, and has no formal name beyond its filename prefix, so Zverovich simply calls it &lt;strong&gt;&amp;ldquo;yy&amp;rdquo;&lt;/strong&gt;. In fact, Zverovich&amp;rsquo;s own &lt;code&gt;zmij&lt;/code&gt; library started out as an optimized port of the Schubfach algorithm before he swapped its core over to &lt;code&gt;yy&lt;/code&gt;. Like Ryū, Dragonbox, and Schubfach, &lt;code&gt;yy&lt;/code&gt; solves the shortest-roundtrip formatting problem: finding the shortest decimal representation that parses back to the exact same IEEE 754 binary floating-point number by picking the coarsest decimal grid that lands inside the value&amp;rsquo;s rounding interval.&lt;/p&gt;
&lt;p&gt;What makes &lt;code&gt;yy&lt;/code&gt; remarkably fast is that it needs only a &lt;em&gt;single&lt;/em&gt; 128-bit multiplication by a precomputed power of 10 in the common case, whereas classic Schubfach requires two or three 192-bit multiplications. For a given &lt;code&gt;double&lt;/code&gt;, &lt;code&gt;yy&lt;/code&gt; estimates the decimal exponent via a fixed-point approximation of $\log_{10}(2)$, scales the significand once, and evaluates four candidate decimal values—two on the fine grid and two on the coarse (multiples of 10) grid. Three simple predicates select the winner, preferring a shorter coarse-grid candidate whenever it falls inside the rounding interval. Half-ULP interval bounds are derived via cheap bit shifts rather than extra multiplications, and round-half-to-even ties are resolved by checking the least significant bit of the original significand. Zverovich includes an interactive visualization on 8-bit &lt;code&gt;E4M3&lt;/code&gt; floats to show how edge cases like &lt;code&gt;192&lt;/code&gt; format cleanly as &lt;code&gt;&amp;quot;2e2&amp;quot;&lt;/code&gt; instead of &lt;code&gt;&amp;quot;19e1&amp;quot;&lt;/code&gt;, concluding that brilliant algorithms buried inside practical open-source libraries deserve the same recognition as those published in academic venues.&lt;/p&gt;
&lt;h2 id="quake-shareware-a-cd-rom-just-a-little-too-full"&gt;&lt;a href="https://fabiensanglard.net/quake_shareware_cd/index.html" rel="noopener noreferrer"&gt;Quake Shareware, a CD-ROM just a little too full&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fabien Sanglard tells the story of id Software&amp;rsquo;s infamous 1996 &lt;em&gt;Quake&lt;/em&gt; shareware CD-ROM. In the mid-1990s, a 640 MiB CD-ROM held vastly more space than a typical game needed. Because the &lt;em&gt;Quake&lt;/em&gt; shareware episode took up only 22 MiB, id Software decided to fill the remaining ~600 MiB with encrypted full retail versions of &lt;em&gt;Quake&lt;/em&gt; and their entire back catalog (&lt;em&gt;DOOM&lt;/em&gt;, &lt;em&gt;DOOM II&lt;/em&gt;, &lt;em&gt;Final DOOM&lt;/em&gt;, &lt;em&gt;Heretic&lt;/em&gt;, &lt;em&gt;Hexen&lt;/em&gt;). Players could buy the disc at retail for $9.95, play the shareware episode, call &lt;code&gt;1-800-ID-GAMES&lt;/code&gt;, read a dynamic &lt;code&gt;CHALLENGE&lt;/code&gt; code over the phone, pay by credit card, and receive an unlock &lt;code&gt;SERIAL&lt;/code&gt; code—with the challenge changing on every run to prevent customers from sharing a single unlock code with friends. The DRM wrapper, provided by TestDrive Corporation, &amp;ldquo;denatured&amp;rdquo; each game&amp;rsquo;s &lt;code&gt;.EXE&lt;/code&gt; by overwriting its first 32 KiB and storing the encrypted original header in a companion file. Yet just 39 days after the CD hit store shelves, the cracking group GNOMON released &lt;code&gt;QCRACK.EXE&lt;/code&gt;, a tiny keygen that computed valid &lt;code&gt;SERIAL&lt;/code&gt; codes from any &lt;code&gt;CHALLENGE&lt;/code&gt; for every game on the disc—leaving id Software stuck with nearly 150,000 unsold CDs in a warehouse.&lt;/p&gt;
&lt;p&gt;Reverse-engineering the installer executable &lt;code&gt;FLOW.EXE&lt;/code&gt; reveals why the scheme collapsed instantly: the unlock &lt;code&gt;SERIAL&lt;/code&gt; didn&amp;rsquo;t actually contain the decryption key! The symmetric decryption key was already sitting right inside &lt;code&gt;FLOW.EXE&lt;/code&gt; on the disc; the installer simply ran the exact same hash function on the &lt;code&gt;CHALLENGE&lt;/code&gt; string to generate the expected &lt;code&gt;SERIAL&lt;/code&gt; locally and compared it against what the user typed—pure security by obscurity. Worse still, Sanglard discovered that &lt;em&gt;Final DOOM&lt;/em&gt; couldn&amp;rsquo;t even be unlocked legitimately via the phone center because of a capitalization typo (&lt;code&gt;&amp;quot;Final&amp;quot;&lt;/code&gt; vs &lt;code&gt;&amp;quot;FINAL&amp;quot;&lt;/code&gt;) in the encrypted catalog metadata file &lt;code&gt;SKU.17&lt;/code&gt;—which itself was accompanied by an unencrypted plain-text copy, &lt;code&gt;SKU.TXT&lt;/code&gt;, left right on the mastered CD by mistake. Sanglard attributes the blunders to &amp;ldquo;Fab&amp;rsquo;s Razor&amp;rdquo;: never attribute to stupidity what can be adequately explained by crunch-time deadline pressure.&lt;/p&gt;
&lt;h2 id="how-instacart-built-a-modern-search-infrastructure-on-postgres"&gt;&lt;a href="https://tech.instacart.com/how-instacart-built-a-modern-search-infrastructure-on-postgres-c528fa601d54" rel="noopener noreferrer"&gt;How Instacart Built a Modern Search Infrastructure on Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Instacart&amp;rsquo;s search engineering team recounts migrating their core product search infrastructure—spanning billions of grocery items across thousands of retailers, millions of daily searches, and billions of daily price, inventory, and promotion updates—off Elasticsearch and onto PostgreSQL. Originally, full-text search ran on Elasticsearch, but its denormalized document model meant every inventory or price change triggered massive partial-document re-indexing across the cluster, overwhelming write capacity and making data-repair backfills take days. By moving to a sharded, highly normalized PostgreSQL architecture using &lt;code&gt;GIN&lt;/code&gt; indexes and a custom C extension for &lt;code&gt;ts_rank&lt;/code&gt;, Instacart cut write amplification by 10x, gained the ability to index hundreds of gigabytes of ML ranking features in separate tables joined at query time via SQL, and cut search latency in half by pushing scoring computation down next to NVMe storage rather than hauling large document payloads up to the application tier.&lt;/p&gt;
&lt;p&gt;In 2021, the team added semantic vector search via a standalone FAISS approximate-nearest-neighbor (ANN) service using MiniLM embeddings, blending lexical and vector results in the application tier. However, splitting retrieval across two systems forced the FAISS service to overfetch thousands of candidates before filtering out out-of-stock items, complicated relevance tuning, and required maintaining two distributed data pipelines in sync. Their final evolution unified both lexical and vector retrieval inside PostgreSQL using &lt;code&gt;pgvector&lt;/code&gt;, allowing real-time inventory availability to act as a native SQL filter alongside vector similarity. By consolidating hundreds of per-retailer HNSW indexes into cohort indexes grouped by retailer size, tuning parallel query workers, and storing quantized embeddings &lt;code&gt;PLAIN&lt;/code&gt; (inline) rather than in &lt;code&gt;TOAST&lt;/code&gt; tables, &lt;code&gt;pgvector&lt;/code&gt; delivered superior recall at comparable latency—cutting zero-result searches by 6% in A/B tests and driving a major lift in gross transaction value.&lt;/p&gt;
&lt;h2 id="curl-performance"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/08/14/curl-performance-2/" rel="noopener noreferrer"&gt;curl performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;code&gt;curl&lt;/code&gt; creator Daniel Stenberg shares how the project finally launched a public continuous performance dashboard at &lt;code&gt;curl.se/perf&lt;/code&gt; after years of the idea sitting on the wishlist because nobody had time to build an elaborate benchmarking platform. After finding Grafana too heavy for what he wanted, Stenberg decided not to let perfection be the enemy of good and built the entire pipeline using tools he already knew inside out. Because shared cloud CI runners are too noisy for repeatable performance measurements, the benchmarks run on a dedicated multi-core machine sitting in his own office. Every twenty minutes, a &lt;code&gt;cron&lt;/code&gt; job triggers a shell script that pulls the latest &lt;code&gt;git&lt;/code&gt; commits, compiles &lt;code&gt;curl&lt;/code&gt;, and runs 24 microbenchmarks—measuring metrics like throughput when transferring 100 GB over &lt;code&gt;localhost&lt;/code&gt; and the exact count and byte total of &lt;code&gt;malloc&lt;/code&gt;/&lt;code&gt;calloc&lt;/code&gt;/&lt;code&gt;strdup&lt;/code&gt; heap allocations during an HTTP download. A second script parses the logs and generates static SVG graphs with &lt;code&gt;gnuplot&lt;/code&gt;, pushing the updated dashboard straight to the website. Within hours of the page going live, contributors were already submitting patches to shave allocations and speed up hot paths.&lt;/p&gt;
&lt;p&gt;Each commit is tested across multiple runs, plotting minimum, median, and maximum values. Because OS packages, kernel versions, and third-party TLS libraries inevitably shift over months, raw timings are most useful in the short term for catching accidental regressions immediately. To guard against slow &amp;ldquo;boiling frog&amp;rdquo; bloat over the long term, Stenberg added manually configured threshold &amp;ldquo;stakes&amp;rdquo; for key metrics, paired with Largest-Triangle-Three-Buckets (LTTB) downsampling for long-range charts and Mann-Kendall / Sen&amp;rsquo;s Slope statistical tests to flag gradual upward trends automatically. Even early on, the dashboard surfaced an instructive trade-off: a PR that reduced the &lt;em&gt;number&lt;/em&gt; of heap allocations had accidentally bloated the size of &lt;code&gt;curl&lt;/code&gt;&amp;rsquo;s main session struct.&lt;/p&gt;
&lt;h2 id="compression-is-prediction"&gt;&lt;a href="https://ngrok.com/blog/compression-is-prediction" rel="noopener noreferrer"&gt;Compression is prediction&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Sexton at ngrok takes readers on an interactive visual tour of information theory to explain a profound equivalence: &lt;strong&gt;data compression is prediction, and large language models are data compressors&lt;/strong&gt;. Compression works by exploiting statistical redundancy—from simple run-length encoding (&lt;code&gt;AAAAAB&lt;/code&gt; → &lt;code&gt;5A1B&lt;/code&gt;) to modern codecs composed of three stages: a &lt;em&gt;transform&lt;/em&gt; that exposes patterns, a &lt;em&gt;model&lt;/em&gt; that predicts a probability distribution for the next symbol, and an &lt;em&gt;entropy coder&lt;/em&gt; that turns those probabilities into bits. While Huffman coding (used in &lt;code&gt;gzip&lt;/code&gt; and Brotli) assigns shorter bitstrings to more frequent symbols, it can never use fewer than 1 bit per symbol; &lt;em&gt;arithmetic coding&lt;/em&gt; overcomes that limit by subdividing the interval $[0, 1)$ proportionally to each symbol&amp;rsquo;s predicted probability, encoding an entire message as a single high-precision binary fraction that approaches Shannon&amp;rsquo;s theoretical entropy limit ($-\log_2 P$).&lt;/p&gt;
&lt;p&gt;The better your model predicts the next symbol given prior context, the fewer bits the entropy coder needs: the letter &lt;code&gt;U&lt;/code&gt; is relatively rare in English overall, yet nearly 100% certain right after &lt;code&gt;Q&lt;/code&gt;, costing almost zero bits to encode when the model knows that context. That is the exact objective an LLM is trained on: predicting a probability distribution over the next token, where the cross-entropy loss function literally measures how many bits an arithmetic coder would need to encode the true next token using the model&amp;rsquo;s predictions. On a passage from Charles Dickens, a simple first-order Markov model compresses the text to 24% of its original size, whereas pairing &lt;code&gt;GPT-2&lt;/code&gt; with an arithmetic coder shrinks it to 10%. We don&amp;rsquo;t replace &lt;code&gt;zstd&lt;/code&gt; with LLMs for everyday file archiving only because both sender and receiver would need gigabytes of model weights and heavy GPU compute—but mathematically, training a better predictor and building a tighter compressor are the exact same problem.&lt;/p&gt;
&lt;h2 id="how-anthropic-builds-and-how-engineering-will-change-soon"&gt;&lt;a href="https://www.developing.dev/p/how-anthropic-builds-and-how-engineering" rel="noopener noreferrer"&gt;How Anthropic Builds And How Engineering Will Change Soon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ryan Peterman interviews Thariq Shihipar, an engineer on Anthropic&amp;rsquo;s Claude Code team, about how engineers inside Anthropic work with frontier models every day. Shihipar&amp;rsquo;s first piece of advice for new hires is to treat Claude as a thought partner, feed it rich context, and constantly look to step up one level of abstraction: instead of just using the model to write a feature, build the system or skill that enables the model to build that whole class of features reliably. He argues that &lt;em&gt;harnesses&lt;/em&gt; are becoming more important, not less: the smarter a model gets and the longer it runs autonomously, the more sophisticated the surrounding software—like Auto mode, sandboxes, and interactive Artifacts—needs to be so the agent can act safely and present its work clearly to humans. In his own daily workflow, he pairs Claude Fable for open-ended planning, brainstorming, and spec writing with Claude Opus 5 for disciplined implementation, and uses &amp;ldquo;loop engineering&amp;rdquo; (automated systems that prompt Claude on a schedule or trigger) to stay on top of bug queues and maintenance work that teams previously lacked bandwidth to touch.&lt;/p&gt;
&lt;p&gt;On writing internal docs, his personal rule is simple: never send AI-generated text unless you would be completely comfortable sharing the exact prompt that produced it; let Claude draft data-heavy status reports, but write strategy memos and opinionated essays yourself. For codebase hygiene, nitpicking variable names and style conventions matters less in an agentic world than investing in automated simplification skills and writing roughly 100x more automated tests—especially request-replay harnesses and chaos testing—to keep incident rates down as commit velocity climbs. Learning how to code remains as valuable as ever: only someone who deeply understands systems can judge whether software is actually good, and &amp;ldquo;coding is solved&amp;rdquo; simply means translating a clear spec into working syntax is no longer the unpredictable bottleneck it used to be.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-convert-a-timestamp--hour-min-sec"&gt;&lt;a href="https://www.benjoffe.com/fast-time-of-day" rel="noopener noreferrer"&gt;A faster way to convert a timestamp ➜ Hour, Min, Sec&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on his fast day-of-the-week algorithm, Ben Joffe tackles splitting an integer number of seconds in a day (&lt;code&gt;0..86399&lt;/code&gt;) into hours, minutes, and seconds. Most standard datetime libraries take around 16 CPU cycles for this conversion because the textbook approach—dividing by &lt;code&gt;3600&lt;/code&gt; to get the hour, taking the remainder, and dividing by &lt;code&gt;60&lt;/code&gt; to get the minute—creates a long serial instruction dependency chain. A second family of algorithms (used in V8, Boost, and &lt;code&gt;musl&lt;/code&gt;) computes each field independently, while Cassio Neri&amp;rsquo;s 2020 algorithm uses a single 64-bit magic multiplication and extracts minutes and seconds from the lower bits, serving as Joffe&amp;rsquo;s benchmark baseline. Joffe&amp;rsquo;s first variant (&lt;strong&gt;V1&lt;/strong&gt;) breaks the serial dependency chain by computing &lt;code&gt;time / 60&lt;/code&gt; and &lt;code&gt;time / 3600&lt;/code&gt; in parallel so the CPU&amp;rsquo;s out-of-order execution engine can overlap both divisions, then derives seconds and minutes via simple multiplications and subtractions.&lt;/p&gt;
&lt;p&gt;His &lt;strong&gt;V2&lt;/strong&gt; variant uses fixed-point arithmetic in 64 bits: multiplying &lt;code&gt;time&lt;/code&gt; by $\lfloor 2^{32}/3600 \rfloor + 1$ puts the hour directly in the upper 32 bits and the fractional remainder of the hour in the lower 32 bits; multiplying that lower 32-bit fraction by &lt;code&gt;60&lt;/code&gt; yields the minute in the upper 32 bits, and multiplying the new lower 32-bit fraction by &lt;code&gt;60&lt;/code&gt; again yields the second. &lt;strong&gt;V3&lt;/strong&gt; applies the Mersenne-like modulo trick from his previous post, computing seconds via &lt;code&gt;((time + 4 * tmin) % 64)&lt;/code&gt; since $60 = 64 - 4$. The post also covers variants for millisecond timestamps, leap seconds, ARM NEON SIMD, and SWAR (SIMD Within A Register). On an Apple M4 Pro, V1, V2, and V3 run in 0.65x, 0.64x, and 0.60x the time of Neri&amp;rsquo;s baseline respectively—and down to 0.49x on a Ryzen 9 9950X3D with Clang—with patches already adopted in Elixir and Java&amp;rsquo;s &lt;code&gt;ITU&lt;/code&gt; library. Because these fast fixed-point multipliers are only exact over bounded input ranges (&lt;code&gt;0..86399&lt;/code&gt; or slightly higher), Joffe recommends &lt;strong&gt;V2&lt;/strong&gt; as the best all-around choice for standard library implementations.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=WvSVSbGo0wI" rel="noopener noreferrer"&gt;HTTP vs HTTPS Explained&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;ByteByteGo&amp;rsquo;s video compares HTTP and HTTPS, explaining how HTTPS uses TLS to encrypt data in transit and authenticate the server, keeping connections between browsers and websites secure.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6j7M!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2d0d1c6c-a864-4b20-b1fc-2d86c8ad2fab_2484x3002.png" alt="Top 12 Agent Skills You Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!m1c9!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8b053abe-404e-4bca-8e49-52a47392ab83_2484x3002.png" alt="9 Types of API Testing"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4xag!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fac1ed471-18f6-45dd-ad5f-02bc6d96d375_2484x3002.png" alt="Forward Proxy, Reverse Proxy, and API Gateway Explained"&gt;&lt;/p&gt;</description></item><item><title>Newsletter #135</title><link>https://miti99.com/en/post/2026/10/03/</link><pubDate>Sat, 03 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #135.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="git-at-any-scale"&gt;&lt;a href="https://cursor.com/blog/git-at-any-scale" rel="noopener noreferrer"&gt;Git at any scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vicent Martí explains why hosting centralized Git repositories at massive scale is notoriously difficult: Git packfiles are large binary blobs that expect to live on a local POSIX filesystem with fast &lt;code&gt;mmap&lt;/code&gt; random access. Early attempts to ditch packfiles and store loose Git objects in distributed key-value stores made &lt;code&gt;git clone&lt;/code&gt; unusably slow, because walking the commit and tree graph incurred a network round trip at every hop. Shared network filesystems like NFS, GFS, or DRBD proved slow, brittle, and operationally painful. GitHub&amp;rsquo;s Spokes replicates repositories at the application layer using a three-phase commit for reference transactions, but push throughput is bottlenecked by the slowest replica, and fixing every repo at three copies over-provisions cold repos while under-provisioning hot CI monorepos—all while requiring a massive central routing database.&lt;/p&gt;
&lt;p&gt;Cursor&amp;rsquo;s &lt;em&gt;Continuity&lt;/em&gt; engine flips the architecture by making a write-ahead log (WAL) on S3-compatible object storage the single source of truth. Every &lt;code&gt;git push&lt;/code&gt; writes its pack data and ref update to the WAL before acknowledging the client, becoming visible only after the reference transaction succeeds and updates the WAL index—making all pushes strictly linearizable. Standard on-disk Git repositories on local NVMe drives act purely as stateless, disposable caches reconstructed on demand from the WAL, eliminating consensus protocols entirely. Nodes are selected via rendezvous hashing, while write safety relies on S3&amp;rsquo;s conditional compare-and-swap (&lt;code&gt;If-Match&lt;/code&gt; / &lt;code&gt;If-None-Match&lt;/code&gt;). Read replicas receive invalidation hints over UDP gossip and verify freshness via conditional &lt;code&gt;GET&lt;/code&gt; requests with ETags in under 10 ms. Only the primary node runs packfile compaction; replicas simply download compacted packs from S3. Benchmarks on Cursor&amp;rsquo;s own monorepo show linear read scaling up to 100 replicas, ~120 pushes/sec on S3 Standard, and over 300 pushes/sec on S3 Express One Zone—laying the foundation for Origin, Cursor&amp;rsquo;s Git hosting platform built for high-concurrency agent workloads.&lt;/p&gt;
&lt;h2 id="regressive-jpegs"&gt;&lt;a href="https://maurycyz.com/projects/bad_jpeg/" rel="noopener noreferrer"&gt;Regressive JPEGs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maurycy explores a delightfully cursed trick with progressive JPEGs, a format designed to transmit low-frequency image components first so a partially downloaded photo appears blurry rather than half-blank. Inside a progressive JPEG, compressed image data is divided into multiple &amp;ldquo;scans,&amp;rdquo; each with its own header specifying which color channels (&lt;code&gt;Y&lt;/code&gt;, &lt;code&gt;Cb&lt;/code&gt;, &lt;code&gt;Cr&lt;/code&gt;), which range of DCT frequency bins, and which bit-precision slice it contains. The first scan normally carries the DC (average color) bin for all three channels, while subsequent scans progressively fill in high-frequency AC detail. Because each scan declares its own spectral range, the author realized nothing stops a later scan from &lt;em&gt;overwriting&lt;/em&gt; frequency bins that were already rendered—meaning you can concatenate multiple same-resolution images into a single JPEG file (stripping their intermediate &lt;code&gt;SOI&lt;/code&gt;, &lt;code&gt;SOF&lt;/code&gt;, and &lt;code&gt;EOI&lt;/code&gt; markers) so the image morphs from one picture into another as it loads over a slow connection.&lt;/p&gt;
&lt;p&gt;The catch is that browsers cap the maximum number of scans they will decode before giving up (likely as a defense against decompression bombs), limiting full-detail progressive overwrites to about nine frames. To cram a real animation into a single JPEG, you have to minimize the number of scans per frame. Because the JPEG spec forbids mixing DC and AC coefficients in the same progressive scan, the smallest possible frame is a single DC-only scan—producing a blocky 8×8-pixel-per-block low-res image. Using one DC scan per frame, Chrome renders roughly 90 frames before bailing out, Firefox keeps going even longer, and ghosting artifacts vanish because there are no leftover AC coefficients from earlier frames bleeding through. The result is an entire multi-second video inside a valid &lt;code&gt;.jpg&lt;/code&gt; file—utterly useless in production since playback speed is dictated entirely by network bandwidth, but prime material for a rickroll.&lt;/p&gt;
&lt;h2 id="a-quick-look-at-zero-knowledge-proofs"&gt;&lt;a href="https://bernsteinbear.com/blog/zkp/" rel="noopener noreferrer"&gt;A quick look at zero-knowledge proofs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein and Chris Gregory demystify zero-knowledge proofs (ZKPs) through a classic example that has nothing to do with cryptocurrency: proving a graph is 3-colorable, following Goldreich, Micali, and Wigderson&amp;rsquo;s 1986 paper. In a ZKP, a &lt;em&gt;prover&lt;/em&gt; claims to know a secret solution to a hard problem, and a &lt;em&gt;verifier&lt;/em&gt; wants to be convinced the prover truly knows it without learning a single bit about the solution itself. Graph 3-coloring—assigning one of three colors to every vertex so no two connected vertices share a color—is NP-complete to solve but trivial to check locally along any single edge. Each round of the interactive protocol runs in four steps: the prover randomly permutes the three color names, &amp;ldquo;locks&amp;rdquo; each vertex&amp;rsquo;s permuted color inside a sealed box, and sends all the locked boxes to the verifier; the verifier picks one random edge &lt;code&gt;(u, v)&lt;/code&gt; and challenges the prover; the prover sends back the keys to only boxes &lt;code&gt;u&lt;/code&gt; and &lt;code&gt;v&lt;/code&gt;; and the verifier opens those two boxes to verify that their colors are valid and different.&lt;/p&gt;
&lt;p&gt;In Python code, a &amp;ldquo;locked box&amp;rdquo; is a cryptographic commitment: the hash of the vertex&amp;rsquo;s color concatenated with a random cryptographic nonce (using &lt;code&gt;hashlib.sha256&lt;/code&gt; and &lt;code&gt;secrets&lt;/code&gt;), since hashing the color alone without a random nonce would produce identical hashes for same-colored vertices and leak the coloring structure. Because a cheating prover who doesn&amp;rsquo;t actually have a valid 3-coloring can still get lucky unless the verifier picks the exact edge that violates the rules, a single round catches a cheater with probability at least $1/m$ (where $m$ is the number of edges). Repeating the protocol with fresh random color permutations and nonces for $m^2$ rounds drives the probability of forgery down exponentially: on a 1,000-edge graph, ~4,600 rounds reduce the soundness error below 1%, and 10,000 rounds drop it to 0.0045%. The authors build a working client-server demo and note that because 3-coloring is NP-complete, any NP problem—from Sudoku to integer factorization—can theoretically be reduced to it, even if the resulting circuit graph balloons quickly in size.&lt;/p&gt;
&lt;h2 id="the-pulse-we-need-to-talk-about-migrations-with-ai"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-we-need-to-talk-about-migrations-with-ai/" rel="noopener noreferrer"&gt;The Pulse: We need to talk about migrations with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this free edition of &lt;em&gt;The Pulse&lt;/em&gt;, Gergely Orosz argues that AI coding tools have fundamentally changed the economics of large-scale code migrations that teams previously put off for years as prohibitively expensive. The headline example comes from Asana: according to an OpenAI case study, Asana used Codex to rip out Enzyme and migrate their test suite to React Testing Library in roughly 1.5 engineer-weeks and ~$12,000 in model and compute costs—a migration previously estimated at $6 million and five years of background effort. Similarly, Airbnb migrated 3,500 Enzyme test files in six weeks (versus a 1.5 engineer-year manual estimate), Uber migrated 600,000 JUnit 4 tests to JUnit 5 in four months with two engineers, and Bun ported 530,000 lines of Zig to Rust in two weeks for $165,000 in API spend. By contrast, back in 2021 Sentry spent 1.5 years and roughly ten engineers migrating 95,000 lines of JavaScript to TypeScript.&lt;/p&gt;
&lt;p&gt;Across these successes, the same engineering patterns recur: automated retry loops when a migrated file fails to build or pass tests, multi-phase per-file pipelines, engineer-designed verification harnesses, starting with leaf files or frequently touched files first, and refactoring the codebase beforehand so patterns are uniform for the LLM. Orosz notes that Asana&amp;rsquo;s &amp;ldquo;$6M saved&amp;rdquo; headline is likely inflated—manual estimates rarely account for humans getting much faster after the first hundred files—and stresses that every single migration still required experienced engineers to design the pipeline, build the verification gates, and handle edge cases. Even so, the cost-benefit curve for paying down massive technical debt has shifted permanently.&lt;/p&gt;
&lt;h2 id="the-accidental-application-runtime"&gt;&lt;a href="https://adventures.michaelfbryan.com/posts/accidental-application-runtime" rel="noopener noreferrer"&gt;The Accidental Application Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael F. Bryan describes how a small Go service managing a 3D-printer farm gradually grew into an tangled mess. It started as a simple dashboard where the HTTP server spawned a single background goroutine to poll printer status. Over time, polling jobs from a cloud backend, persisting state to SQLite, scheduling print jobs, streaming G-code, and reporting telemetry were all bolted onto that same initialization block until &lt;code&gt;NewServer&lt;/code&gt; was spawning five long-running background goroutines. When the team needed to add graceful shutdown on &lt;code&gt;SIGTERM&lt;/code&gt;, figuring out which goroutines were running, in what order they needed to stop, and who owned closing which Go channels required reading the entire startup file line by line. Bryan calls this an &amp;ldquo;accidental application runtime&amp;rdquo;: the service had a real concurrent pub/sub architecture, but nothing in the code&amp;rsquo;s structure made that topology explicit.&lt;/p&gt;
&lt;p&gt;Inspired by the PX4 drone autopilot&amp;rsquo;s uORB messaging layer, Bryan built a lightweight Go library called &lt;code&gt;backplane&lt;/code&gt;. Each subsystem becomes a plain Go function &lt;code&gt;func(ctx, deps...) error&lt;/code&gt; whose typed parameters declare its communication topology: a &lt;code&gt;chan&amp;lt;- T&lt;/code&gt; parameter publishes to topic &lt;code&gt;T&lt;/code&gt;, &lt;code&gt;&amp;lt;-chan T&lt;/code&gt; subscribes to a stream of &lt;code&gt;T&lt;/code&gt;, and &lt;code&gt;*backplane.Latest[T]&lt;/code&gt; polls the latest state snapshot. Topics are keyed by Go types rather than error-prone string names. &lt;code&gt;backplane.New&lt;/code&gt; validates the dependency graph before startup, and &lt;code&gt;Run&lt;/code&gt; supervises the modules like an &lt;code&gt;errgroup&lt;/code&gt; with in-process, backpressured delivery. Rebuilding the printer service as six explicit modules—anchored by a strict &lt;em&gt;commit-then-notify&lt;/em&gt; rule where the scheduler commits job state to SQLite before publishing a wake-up message—even let the team auto-generate accurate Mermaid architecture diagrams straight from the function signatures.&lt;/p&gt;
&lt;h2 id="generic-methods-in-go-127"&gt;&lt;a href="https://dominik.info/blog/go-generic-methods" rel="noopener noreferrer"&gt;Generic Methods in Go 1.27&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When Go 1.18 introduced generics in 2022, functions and types could declare type parameters, but methods could not declare additional type parameters of their own. Go 1.27 finally lifts that restriction: methods can now introduce their own type parameters without polluting the receiver struct. Dominik Braun illustrates why this matters using a generic graph node &lt;code&gt;Node[T]&lt;/code&gt;. Previously, if you wanted a &lt;code&gt;Map&lt;/code&gt; method that transforms a &lt;code&gt;Node[T]&lt;/code&gt; into a &lt;code&gt;Node[U]&lt;/code&gt;, you either had to pollute the struct definition itself as &lt;code&gt;Node[T, U]&lt;/code&gt;—forcing every unrelated method on &lt;code&gt;Node&lt;/code&gt; to carry &lt;code&gt;U&lt;/code&gt; around—or give up on method syntax and write a standalone package-level function &lt;code&gt;Map[T, U any](n *Node[T], ...)&lt;/code&gt;. Starting in Go 1.27, you can simply write &lt;code&gt;func (n *Node[T]) Map[U any](...) Node[U]&lt;/code&gt;, scoping &lt;code&gt;U&lt;/code&gt; strictly to the &lt;code&gt;Map&lt;/code&gt; method.&lt;/p&gt;
&lt;p&gt;Why did this take four years to land? The hurdle lay in how Go compiles generics versus how it dispatches interfaces. Go&amp;rsquo;s compiler primarily uses &lt;em&gt;monomorphization&lt;/em&gt; (stenciling specialized machine code for concrete type shapes at compile time), whereas Go interfaces rely on runtime dynamic dispatch via an &lt;code&gt;itable&lt;/code&gt; of function pointers. Those two models collide if an interface is allowed to declare a generic method like &lt;code&gt;type Mapper interface { Map[U any]() Node[U] }&lt;/code&gt;: the compiler cannot pre-populate a fixed-size runtime vtable for an unbounded set of potential type arguments &lt;code&gt;U&lt;/code&gt;, especially when reflection can look up methods dynamically at runtime. Go&amp;rsquo;s pragmatic compromise in 1.27 is to allow generic methods on concrete types while forbidding them in interface definitions—and a generic method cannot be used to satisfy an interface.&lt;/p&gt;
&lt;h2 id="your-executable-is-a-sqlite-database"&gt;&lt;a href="https://fzakaria.com/2026/08/23/your-executable-is-a-sqlite-database" rel="noopener noreferrer"&gt;Your executable is a SQLite database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria, author of &lt;code&gt;sqlelf&lt;/code&gt;, takes his previous experiment to its logical conclusion: replacing ELF entirely with SQLite as a native Linux executable format. His prototype, &lt;strong&gt;SELF&lt;/strong&gt; (&lt;em&gt;Structured Executable &amp;amp; Linkable Format&lt;/em&gt;), produces real SQLite database files that you can &lt;code&gt;chmod +x&lt;/code&gt; and run directly from the shell. His core argument is that ELF is already an ad-hoc, bespoke relational database in denial: &lt;code&gt;.strtab&lt;/code&gt; is string interning, &lt;code&gt;.gnu.hash&lt;/code&gt; is a hash index, section headers are a catalog table, and symbol versioning is a foreign-key schema. In SELF, an executable&amp;rsquo;s schema consists of a &lt;code&gt;self_meta&lt;/code&gt; table for the ELF header, a &lt;code&gt;segments&lt;/code&gt; table storing each program header row with its raw machine code/data as a SQLite &lt;code&gt;BLOB&lt;/code&gt;, and a &lt;code&gt;symbols&lt;/code&gt; table indexed by standard SQLite B-trees in place of &lt;code&gt;.dynsym&lt;/code&gt; and &lt;code&gt;.gnu.hash&lt;/code&gt;. Registering the SQLite magic header with Linux&amp;rsquo;s &lt;code&gt;binfmt_misc&lt;/code&gt; lets the kernel hand &lt;code&gt;./my_app&lt;/code&gt; directly to &lt;code&gt;self-exec&lt;/code&gt;, a tiny C loader that queries the segments, maps them into memory, performs relocations, and jumps to the entry point.&lt;/p&gt;
&lt;p&gt;For dynamic linking, SELF supports two modes: keeping glibc&amp;rsquo;s standard &lt;code&gt;ld.so&lt;/code&gt; and using an &lt;code&gt;rtld-audit&lt;/code&gt; hook so a SQL query resolves shared libraries, or using &lt;code&gt;self-ld&lt;/code&gt;, an experimental SQL-native dynamic linker. Even cooler, &lt;code&gt;self closure&lt;/code&gt; bundles a binary and all its transitive shared-library dependencies into a single self-contained SQLite database file—turning &lt;code&gt;ldd&lt;/code&gt; into a simple SQL &lt;code&gt;JOIN&lt;/code&gt;. Packing all 723 executables in &lt;code&gt;/usr/bin&lt;/code&gt; into a single shared SELF database shrank total size from 644.4 MiB (ELF) down to 611.9 MiB thanks to cross-binary library and symbol deduplication, even though individual standalone SELF files are 2.2x to 3.6x larger than their ELF counterparts. While copying segments out of SQLite blobs prevents cross-process &lt;code&gt;mmap&lt;/code&gt; page sharing for &lt;code&gt;.text&lt;/code&gt; segments and slows cold start on massive binaries, being able to inspect, strip, or atomically patch executables with &lt;code&gt;UPDATE&lt;/code&gt; and &lt;code&gt;ROLLBACK&lt;/code&gt; is a fascinating glimpse into an alternate Unix universe.&lt;/p&gt;
&lt;h2 id="what-happens-when-a-gpu-reads-memory"&gt;&lt;a href="https://blog.doubleword.ai/what-happens-when-a-gpu-reads-memory" rel="noopener noreferrer"&gt;What happens when a GPU reads memory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doubleword founder Fergus Finn traces the exact hardware journey of a single global memory load instruction (&lt;code&gt;LDG.E&lt;/code&gt;) inside an NVIDIA RTX 4090. Because NVIDIA documents very little of its microarchitectural memory pipeline publicly, Finn reverse-engineered the path using custom cycle-accurate microbenchmarks and hardware performance counters. When a 32-thread warp issues a 4-byte load per thread, the hardware coalescer groups those 32 requests into four 32-byte sectors—one 128-byte cache line. On an L1 miss, the virtual address passes through a 16-entry per-SM L1 TLB (backed by 2 MiB pages) to translate into a physical address, because the L2 cache is physically indexed. From there, the chip-wide crossbar routes the request to one of 36 L2 cache slices selected by an undocumented hash of the physical address bits, which in turn forwards L2 misses to one of 12 memory controllers wired to 12 GDDR6X chips—where the controller must issue an expensive DRAM row &lt;code&gt;ACTIVATE&lt;/code&gt; command to open a 1 KiB row before bursting the four 32-byte sectors back.&lt;/p&gt;
&lt;p&gt;The latency ladder is stark: an L1 hit takes ~15.4 ns, an L2 hit takes ~127 ns, and a full miss down to GDDR6X DRAM takes ~255 ns—roughly 660 GPU clock cycles during which that warp sits stalled. Activating a new DRAM row costs roughly 15x more time than reading from an already-open row, and hammering a single L2 slice caps throughput at 1,957 million loads/sec versus ~68,000 million loads/sec when spread evenly across all 36 slices (a 34.8x difference). GPUs hide that 660-cycle latency through massive warp-level parallelism—switching to other ready warps every cycle—which is why memory-bound kernels live or die by coalesced access patterns that spread traffic evenly across L2 slices and DRAM banks.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-calculate-the-day-of-the-week"&gt;&lt;a href="https://www.benjoffe.com/fast-day-of-week" rel="noopener noreferrer"&gt;A faster way to calculate the day-of-the-week&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Joffe tackles a deceptively simple problem: converting a signed 32-bit Unix epoch day count (&lt;code&gt;1970-01-01&lt;/code&gt; = Thursday) into a day of the week (&lt;code&gt;0..6&lt;/code&gt;) as fast as possible across the entire 32-bit integer range. Cassio Neri&amp;rsquo;s 2024 algorithm serves as the state-of-the-art baseline, but requires an extra correction step because 7 is an awkward divisor in binary. Joffe&amp;rsquo;s key insight is to exploit the fact that $7 = 2^3 - 1$ is a Mersenne number, which means $N \bmod 7 = \lfloor N \cdot \frac{8}{7} \rfloor \bmod 8$. Multiplying by $\frac{8}{7}$ can be approximated by a single fixed-point multiplication by a magic constant &lt;code&gt;M&lt;/code&gt;, and taking $\bmod 8$ comes almost for free by masking or shifting to keep only the top three bits of the fractional part. A bounded 32-bit version reduces to a one-liner—&lt;code&gt;((u32(rd) * M + Z) &amp;gt;&amp;gt; 29)&lt;/code&gt;—valid across $\pm 242,000$ years, which sped up weekday calculations in the Rust &lt;code&gt;jiff&lt;/code&gt; datetime crate by ~40%.&lt;/p&gt;
&lt;p&gt;To cover the full signed 32-bit domain without overflow, Joffe presents several variants: widening to a 64-bit multiply (already adopted by WebKit), adding a bit-shifted correction term that executes in parallel with the multiply, using two multiplies for higher instruction throughput, or collapsing the entire calculation into three x86 instructions via &lt;code&gt;LEA&lt;/code&gt;. Switching between Sunday-indexed (&lt;code&gt;0..6&lt;/code&gt;) and ISO Monday-indexed (&lt;code&gt;1..7&lt;/code&gt;) output only requires swapping the additive constant &lt;code&gt;Z&lt;/code&gt;. Better yet, the same Mersenne identity generalizes to any divisor of the form $2^N - 2^K$, including &lt;code&gt;x % 24&lt;/code&gt; and &lt;code&gt;x % 60&lt;/code&gt; for extracting hours, minutes, and seconds. Benchmarks show Joffe&amp;rsquo;s variants taking just 0.17x to 0.39x the runtime of Neri&amp;rsquo;s algorithm on an Apple M4 Pro and 0.27x to 0.59x on a Ryzen 9 9950X3D, with patches already merged into WebKit, Elixir, Rust&amp;rsquo;s &lt;code&gt;jiff&lt;/code&gt;, and Zig&amp;rsquo;s &lt;code&gt;zeit&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="dark-mode-toggles-two-states-are-enough"&gt;&lt;a href="https://lea.verou.me/blog/2026/dark-mode-toggles/" rel="noopener noreferrer"&gt;Dark mode toggles: two states are enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lea Verou argues that website header dark-mode toggles should only expose two visible states to the user, even though the underlying state machine has three (&lt;code&gt;System&lt;/code&gt;, &lt;code&gt;Light&lt;/code&gt;, and &lt;code&gt;Dark&lt;/code&gt;). In her view, exposing a three-way segmented control or dropdown in the navbar solves an imaginary user goal: nobody visits a website thinking &amp;ldquo;my OS is in light mode and this page looks great in light mode, let me proactively pin it to Light just in case my OS switches to dark mode tonight.&amp;rdquo; Users click a theme toggle for one reason: &lt;em&gt;the current appearance is uncomfortable to read right now, make it the opposite&lt;/em&gt;. Exposing all three states in the header is classic &amp;ldquo;implementation-model UI&amp;rdquo; that adds visual clutter, extra clicks, and unnecessary cognitive load. At the same time, a naive two-state toggle is even worse if clicking it once permanently locks &lt;code&gt;localStorage&lt;/code&gt; into an override with no way to return to following the OS theme.&lt;/p&gt;
&lt;p&gt;Verou&amp;rsquo;s solution is a single two-state button that cleanly traverses all three underlying states. By default (when following the OS), the button displays the currently active theme and stores nothing in &lt;code&gt;localStorage&lt;/code&gt;. Clicking it once switches to the opposite theme and saves that explicit override. Clicking it a second time switches back to the theme that matches the user&amp;rsquo;s current OS preference—and instead of saving a hard override, it &lt;em&gt;clears&lt;/em&gt; the stored setting, returning the site to &lt;code&gt;System&lt;/code&gt; mode. Because the override is only re-evaluated when the user clicks the toggle, users whose OS automatically flips between light and dark at sunset can still override a site whenever they want without getting stuck permanently out of sync. Reserve explicit three-way &lt;code&gt;Light / Dark / Auto&lt;/code&gt; selectors for dedicated settings pages—not the top navigation bar.&lt;/p&gt;</description></item><item><title>Newsletter #134</title><link>https://miti99.com/en/post/2026/10/02/</link><pubDate>Fri, 02 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #134.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-startup"&gt;&lt;a href="https://hatchet.run/blog/postgres-survival-guide" rel="noopener noreferrer"&gt;The startup&amp;rsquo;s Postgres survival guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hatchet CEO Alexander Belanger distills roughly two years of running PostgreSQL in production into a pragmatic field guide that&amp;rsquo;s much easier to scan during an incident than the official manual. On schema design: use identity columns or UUIDs for primary keys, always use &lt;code&gt;timestamptz&lt;/code&gt;, and don&amp;rsquo;t hesitate to reach for &lt;code&gt;jsonb&lt;/code&gt; when strict normalization hurts query performance. On reads: join on primary keys, index columns used in &lt;code&gt;ON&lt;/code&gt; clauses just like &lt;code&gt;WHERE&lt;/code&gt; clauses, and put &lt;code&gt;ORDER BY&lt;/code&gt; columns last in compound indexes with matching sort directions. On writes: keep transactions short, never call external services inside a transaction, always use &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; on large tables, keep schema migrations additive, and use &lt;code&gt;NOT VALID&lt;/code&gt; when adding check constraints. Because Postgres connections are heavy, always use a connection pooler—preferably PgBouncer or &lt;code&gt;pgxpool&lt;/code&gt;. Finally, remember that the query planner is a leaky abstraction driven by statistics in &lt;code&gt;pg_stats&lt;/code&gt;: debug slow queries with &lt;code&gt;EXPLAIN (ANALYZE, BUFFERS)&lt;/code&gt;, visualize plans on &lt;code&gt;explain.dalibo.com&lt;/code&gt;, and avoid premature micro-optimization.&lt;/p&gt;
&lt;p&gt;The advanced half covers batching writes (for instance, &lt;code&gt;pgx&lt;/code&gt;&amp;rsquo;s &lt;code&gt;SendBatch&lt;/code&gt;) for roughly 10x higher throughput, monitoring autovacuum via &lt;code&gt;pg_stat_activity&lt;/code&gt;, and guarding against transaction ID wraparound. Fix table bloat with &lt;code&gt;pg_repack&lt;/code&gt; rather than locking tables with &lt;code&gt;VACUUM FULL&lt;/code&gt;, and clear index bloat with &lt;code&gt;REINDEX INDEX CONCURRENTLY&lt;/code&gt;. Hatchet relies heavily on &lt;code&gt;FOR UPDATE SKIP LOCKED&lt;/code&gt; to power job queues and distributed lease management across instances. Table partitioning lets autovacuum work on smaller chunks independently and makes dropping old time-series data nearly instantaneous. When migrating massive tables, dual-write new rows via a trigger, backfill historical rows in batches outside a long-running transaction, and lean on unique constraints for idempotency.&lt;/p&gt;
&lt;h2 id="what-is-orasort-understanding-oracles-sorting-aglorithm-in-simple-terms"&gt;&lt;a href="https://deepsystemstuff.com/how-oracles-secret-column-sorting-technique-became-public-after-its-patent-expired-making-sorting-5x-faster/" rel="noopener noreferrer"&gt;What is Orasort? understanding Oracle’s Sorting Aglorithm In Simple Terms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nadeem Shaikh introduces Orasort, a sorting optimization patented by Oracle (credited to Mark Callaghan). According to the post, the 20-year patent expired in 2024, placing the technique in the public domain where it can speed up database sorting by up to 5x. Traditional string sorting compares values byte by byte, so long strings that share a common prefix—such as email addresses or URLs from the same domain—waste many CPU cycles repeating character comparisons. Orasort instead packs an 8-byte slice of each string into a 64-bit integer register and compares all 8 bytes in a single CPU instruction. If those 8 bytes settle the ordering, the comparison finishes immediately; only when they are identical does it advance to the next 8-byte chunk.&lt;/p&gt;
&lt;p&gt;The sorting pipeline pairs this with several other techniques. Rather than moving full table rows around during a sort, the database loads only the sort key and row ID (tuple pointer) into an in-memory sort buffer. When the dataset exceeds available RAM, it spills sorted runs to disk and merges them afterward, writing sorted runs out to disk asynchronously while the CPU continues sorting the next batch in memory. While the author notes that open-source databases like PostgreSQL and MySQL have adopted or experimented with similar abbreviated-key sorting ideas—saving substantial cloud CPU costs—the article doesn&amp;rsquo;t cite primary sources for the 5x figure or the exact patent details, so treat it as an approachable conceptual overview rather than a rigorous historical reference.&lt;/p&gt;
&lt;h2 id="fornax"&gt;&lt;a href="https://docs.pixeldrain.com/posts/2024-03-07_network_optimizations/" rel="noopener noreferrer"&gt;Fornax&amp;rsquo;s Guide To Ridiculously Fast Ethernet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fornax, creator of the file-sharing service Pixeldrain, leased a 100 GbE server expecting it to saturate the link out of the box, only to watch the machine crash at around 20 Gbit/s. After more than a year of reading NIC manuals, digging through Linux kernel source code, profiling, and even patching the kernel, Fornax hit the full 100 Gbit/s line rate and wrote up the complete tuning guide. At the &lt;code&gt;sysctl&lt;/code&gt; layer, pair the BBR congestion control algorithm with the &lt;code&gt;fq&lt;/code&gt; packet scheduler so random packet loss doesn&amp;rsquo;t tank throughput. Enabling &lt;code&gt;tcp_shrink_window&lt;/code&gt; (a Cloudflare patch merged in Linux 6.5) cut TCP buffer memory consumption by roughly 80%, curing peak-hour OOM crashes on a server with 1 TB of RAM. Per-connection socket buffers are raised to a 1 GiB ceiling based on the bandwidth-delay product, and &lt;code&gt;tcp_mem&lt;/code&gt; is raised to 40–60% of system RAM instead of the ~5% default.&lt;/p&gt;
&lt;p&gt;On the hardware side, Mellanox/NVIDIA ConnectX-5 and ConnectX-6 NICs with stock in-tree kernel drivers proved rock-solid. Via &lt;code&gt;ethtool&lt;/code&gt;, match the NIC channel count to CPU cores, max out the RX/TX ring buffers, and disable adaptive interrupt coalescing in favor of a fixed 100 µs interval. In the BIOS, set NUMA to NPS1 and disable SMT on 128+ core CPUs. The single most impactful stability fix was disabling the IOMMU (&lt;code&gt;iommu=pt&lt;/code&gt; or off), which stopped the NIC from wedging under heavy load. Fornax also eliminated reverse proxies like nginx and Caddy so packets don&amp;rsquo;t cross the kernel/userspace boundary multiple times, serving traffic directly from Go&amp;rsquo;s standard HTTP server with &lt;code&gt;SO_REUSEPORT&lt;/code&gt; for zero-downtime restarts. HTTP/2 is preferred, while HTTP/3 (QUIC) was dropped because its throughput barely reached half of TCP&amp;rsquo;s. Finally, run a minimal Debian install on the latest mainline kernel, as Linux 6.8 and 6.19 brought major TCP throughput gains.&lt;/p&gt;
&lt;h2 id="parity-before-cutover"&gt;&lt;a href="https://alexocallaghan.com/parity-before-cutover" rel="noopener noreferrer"&gt;Parity before cutover&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex O&amp;rsquo;Callaghan recounts inheriting a critical internal service that existed in two parallel universes: a legacy Python 2 version running in production on on-prem VMs, and a modernized Python 3 rewrite living on a long-lived feature branch waiting to be deployed to cloud Kubernetes. This classic &amp;ldquo;big-bang cutover&amp;rdquo; approach bundles every possible risk into a single release and delays real-world feedback until the very end. Engineering effort is doubled because every urgent production bugfix has to be written in Python 2 and forward-ported to the Python 3 branch (or worse, forgotten), and subtle behavioral regressions stay hidden until cutover day when too many variables have changed at once to isolate the culprit.&lt;/p&gt;
&lt;p&gt;Instead of marching straight toward the cloud cutover, O&amp;rsquo;Callaghan proposed &amp;ldquo;taking a step backward to move forward&amp;rdquo;: shipping the modernized Python 3 codebase onto the legacy on-prem VMs first. Because the legacy OS only supported up to Python 3.6, the team downgraded the branch from Python 3.7 to 3.6 rather than fighting the OS, and added runtime environment configuration so the exact same codebase could deploy to both on-prem VMs and Kubernetes. From that point on, every commit deployed to both environments simultaneously, surfacing behavioral differences incrementally while the legacy Python 2 service remained an instant rollback away. Once the Python 3 service achieved 100% production parity on-prem, cutting over to Kubernetes became a pure infrastructure switch—changing one variable at a time. The takeaway: if a migration branch has been open for months waiting on another team or platform, it&amp;rsquo;s probably bundling too many changes at once; look for an intermediate state you can ship to production today, even if it feels like a step sideways.&lt;/p&gt;
&lt;h2 id="the-new-go-json-api-twice-as-fast-or-15x-slower"&gt;&lt;a href="https://lemire.me/blog/2026/08/29/the-new-go-json-api-twice-as-fast-or-1-5x-slower/" rel="noopener noreferrer"&gt;The new Go JSON API: twice as fast, or 1.5x slower?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Starting in Go 1.27, the &lt;code&gt;encoding/json/v2&lt;/code&gt; package ships in the standard library by default. While its &lt;code&gt;Marshal&lt;/code&gt; and &lt;code&gt;Unmarshal&lt;/code&gt; functions look almost identical to v1, &lt;code&gt;v2&lt;/code&gt; is not a drop-in replacement due to stricter UTF-8 validation, case-sensitive field matching by default, and other behavioral cleanups. Because the legacy &lt;code&gt;encoding/json&lt;/code&gt; (v1) package was also re-engineered to run on top of the new &lt;code&gt;v2&lt;/code&gt; engine under the hood, Daniel Lemire benchmarks three configurations: the original Go 1.26 &lt;code&gt;encoding/json&lt;/code&gt; engine (built with &lt;code&gt;GOEXPERIMENT=nojsonv2&lt;/code&gt;), the v1 API running on Go 1.27&amp;rsquo;s new v2 backend, and &lt;code&gt;encoding/json/v2&lt;/code&gt; called directly. Benchmarks run single-threaded on an Apple M4 Max and an Intel Xeon Emerald Rapids using three standard &lt;code&gt;simdjson&lt;/code&gt; test files (&lt;code&gt;twitter.json&lt;/code&gt;, &lt;code&gt;canada.json&lt;/code&gt;, and &lt;code&gt;citm_catalog.json&lt;/code&gt;) parsed into generic &lt;code&gt;any&lt;/code&gt; values.&lt;/p&gt;
&lt;p&gt;Simply upgrading to Go 1.27 without touching a line of code makes v1 &lt;code&gt;Marshal&lt;/code&gt; up to 2x faster—for example, &lt;code&gt;twitter.json&lt;/code&gt; jumps from 198 MB/s to 374 MB/s. &lt;code&gt;Unmarshal&lt;/code&gt; via v1 also speeds up on two of the files, though it regresses slightly on float-heavy &lt;code&gt;canada.json&lt;/code&gt; (from 128 MB/s down to 106 MB/s). Calling &lt;code&gt;json/v2&lt;/code&gt; directly makes generic &lt;code&gt;Unmarshal&lt;/code&gt; 1.5x to 2.3x faster and &lt;code&gt;Marshal&lt;/code&gt; 1.2x to 3x faster than the old engine. However, on a round-trip benchmark of 10,000 small strongly typed Go structs, while &lt;code&gt;json/v2&lt;/code&gt; still unmarshals faster, &lt;code&gt;Marshal&lt;/code&gt; is roughly 1.5x &lt;em&gt;slower&lt;/em&gt; than the legacy engine—contrary to the Go 1.27 release notes claiming struct marshaling performance is at parity. Lemire&amp;rsquo;s advice: &lt;code&gt;json/v2&lt;/code&gt; is a clear win for unmarshaling, but benchmark your actual struct workloads before migrating write-heavy serialization paths.&lt;/p&gt;
&lt;h2 id="a-deep-dive-into-deepsec"&gt;&lt;a href="https://flaviocopes.com/deepsec/" rel="noopener noreferrer"&gt;A deep dive into DeepSec&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Flavio Copes explores DeepSec, an open-source (Apache 2.0) AI-powered security scanner from Vercel. Unlike tools that only review incoming pull request diffs, DeepSec audits an entire repository—including legacy code that has never had a security review. Its pipeline starts with a fast, free local pattern-matching pass that combines file-path globs with regular expressions to flag candidate files. Next, Codex or Claude Code reads the flagged files, traces data flows across the codebase, checks for existing sanitization or auth guards, and records findings with severity, confidence, and remediation advice. A second agent pass independently verifies each finding to filter out hallucinations, a cheaper triage pass assigns P0–P2 priorities, and all state is persisted in &lt;code&gt;.deepsec/&lt;/code&gt; so interrupted scans can resume cleanly.&lt;/p&gt;
&lt;p&gt;Running DeepSec against &lt;code&gt;flaviocopes.com&lt;/code&gt; using Codex via a standard ChatGPT subscription scanned 729 files and produced 504 raw findings, including 1 Critical and 16 High. Closer inspection showed that 462 of those findings lived in client-side browser mini-tools on the site. Copes then asked Codex to cluster the findings by root cause and separate real production risks from local helper scripts and code examples, narrowing the actionable list down to payment webhooks, course recovery flows, and public forms. DeepSec cannot prove a codebase is secure, still produces false positives, and sends source code to your chosen model provider, but its workflow highlights an important lesson: raw finding counts are mostly noise—always anchor triage where untrusted input touches authentication, private data, money, or infrastructure.&lt;/p&gt;
&lt;h2 id="imthenachomanhow-to-secure-a-linux-server-an-evolving-how-to-guide-for-securing-a-linux-server"&gt;&lt;a href="https://github.com/imthenachoman/How-To-Secure-A-Linux-Server" rel="noopener noreferrer"&gt;imthenachoman/How-To-Secure-A-Linux-Server: An evolving how-to guide for securing a Linux server.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This popular open-source guide (CC BY-SA 4.0, over 31,000 GitHub stars) compiles practical steps for hardening a Linux server, born out of the author&amp;rsquo;s personal notes while building a home Debian server. Because Linux security advice is scattered across hundreds of blog posts—and most developers don&amp;rsquo;t provision bare-metal Linux servers every day—it is easy to overlook basic hardening steps. The moment a server touches the public internet, automated scanners start probing it, and an unhardened box can quietly have its data exfiltrated or get drafted into a DDoS botnet without the owner noticing. The author recommends reading this guide first to understand the &lt;em&gt;why&lt;/em&gt; behind each control, and then layering official CIS Benchmarks on top.&lt;/p&gt;
&lt;p&gt;The SSH section covers enforcing public/private key authentication, restricting login access via &lt;code&gt;AllowGroups&lt;/code&gt;, locking down &lt;code&gt;sshd_config&lt;/code&gt;, removing weak Diffie-Hellman moduli, and enabling 2FA. System basics cover restricting &lt;code&gt;sudo&lt;/code&gt; and &lt;code&gt;su&lt;/code&gt;, sandboxing applications with Firejail, hiding other users&amp;rsquo; processes in &lt;code&gt;/proc&lt;/code&gt; (&lt;code&gt;hidepid&lt;/code&gt;), enforcing strong password policies with PAM, and enabling &lt;code&gt;unattended-upgrades&lt;/code&gt; for security patches. Networking covers configuring UFW as a firewall (including fixing the notorious gotcha where Docker bypasses UFW rules by manipulating &lt;code&gt;iptables&lt;/code&gt; directly), using PSAD to detect port scans, and running Fail2Ban and CrowdSec to block brute-force and application-layer attacks. Auditing introduces AIDE, ClamAV, rkhunter, Logwatch, Lynis, and OSSEC, followed by a &amp;ldquo;Danger Zone&amp;rdquo; for changes that can lock you out if misconfigured—like kernel &lt;code&gt;sysctl&lt;/code&gt; hardening, GRUB passwords, and disabling root login. A community-maintained Ansible playbook is also available to automate the setup.&lt;/p&gt;
&lt;h2 id="postgres-19-how-our-advice-has-changed-since-we-wrote-it"&gt;&lt;a href="https://www.crunchydata.com/blog/postgres-19-how-our-advice-has-changed-since-we-wrote-it" rel="noopener noreferrer"&gt;Postgres 19: How Our Advice Has Changed Since We Wrote It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christopher Winslett at Crunchy Data revisits the company&amp;rsquo;s classic blog posts on bulk loading, storage, indexing, and partitioning—many originally written in the Postgres 10 and 11 era—to see how their advice holds up against Postgres 19 (beta). Asynchronous I/O (introduced in Postgres 18) dramatically speeds up sequential scans, bitmap heap scans, and vacuuming; Postgres 19 builds on it with autoscaling I/O workers, &lt;code&gt;EXPLAIN (ANALYZE, IO)&lt;/code&gt;, parallel autovacuum, and disabling JIT compilation by default. The &lt;code&gt;COPY&lt;/code&gt; command keeps getting better: SIMD-accelerated CSV parsing, &lt;code&gt;ON_ERROR set_null&lt;/code&gt; to survive dirty rows without aborting an entire load, multi-line header skipping, direct &lt;code&gt;COPY ... TO&lt;/code&gt; JSON output, and &lt;code&gt;COPY TO&lt;/code&gt; support directly on partitioned tables. &lt;code&gt;LZ4&lt;/code&gt; is now the default TOAST compression algorithm (existing toasted values keep their original compression), and a built-in &lt;code&gt;REPACK&lt;/code&gt; command (with &lt;code&gt;CONCURRENTLY&lt;/code&gt;) finally brings &lt;code&gt;pg_repack&lt;/code&gt;-style online table compaction into core Postgres as a native replacement for &lt;code&gt;VACUUM FULL&lt;/code&gt; and &lt;code&gt;CLUSTER&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;On indexing, BRIN gains &lt;code&gt;minmax_multi&lt;/code&gt; opclasses for imperfectly ordered data and &lt;code&gt;bloom&lt;/code&gt; opclasses for UUID equality lookups. B-tree skip scans (added in 18) allow a multi-column index to serve queries that filter only on trailing columns when the leading column has low cardinality, letting teams drop redundant single-column indexes. Native partitioning adds &lt;code&gt;MERGE PARTITIONS&lt;/code&gt; and &lt;code&gt;SPLIT PARTITION&lt;/code&gt;, though both currently take an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock and belong in maintenance windows. The takeaway: the core fundamentals haven&amp;rsquo;t changed—use &lt;code&gt;COPY&lt;/code&gt; for bulk loads, store JSON in &lt;code&gt;jsonb&lt;/code&gt;, and partition primarily for data lifecycle management—but Postgres 19 makes executing them much smoother. Keep the same mental model, update your commands, and verify with &lt;code&gt;EXPLAIN (ANALYZE, BUFFERS, IO)&lt;/code&gt; after upgrading.&lt;/p&gt;
&lt;h2 id="how-we-saved-100-terabytes-of-memory-by-optimizing-1111s-dns-cache"&gt;&lt;a href="https://blog.cloudflare.com/dns-cache-memory-optimization-1111/" rel="noopener noreferrer"&gt;How we saved 100 terabytes of memory by optimizing 1.1.1.1’s DNS cache&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Big Pineapple, the Rust platform powering Cloudflare&amp;rsquo;s &lt;code&gt;1.1.1.1&lt;/code&gt; public resolver and other DNS services, holds over 250 billion cached DNS entries across its global fleet. At that scale, wasting a single byte per cache entry costs more than 250 GB of RAM globally. Although cached DNS entries are completely immutable once inserted, their Rust structs were still using &lt;code&gt;Vec&lt;/code&gt; and &lt;code&gt;String&lt;/code&gt; fields, each carrying an unused 8-byte &lt;code&gt;capacity&lt;/code&gt; field and potential heap over-allocation. Worse, the enum representing DNS record data was sized to its largest variant, padding tiny &lt;code&gt;A&lt;/code&gt; and &lt;code&gt;AAAA&lt;/code&gt; records with dead space. The team built a realistic traffic benchmark paired with a custom tracking allocator to measure exact per-entry heap usage alongside insert throughput and lookup latency.&lt;/p&gt;
&lt;p&gt;They rolled out five progressive optimizations: replacing &lt;code&gt;Vec&amp;lt;T&amp;gt;&lt;/code&gt; and &lt;code&gt;String&lt;/code&gt; with boxed slices (&lt;code&gt;Box&amp;lt;[T]&amp;gt;&lt;/code&gt;) and &lt;code&gt;Box&amp;lt;str&amp;gt;&lt;/code&gt;; flattening three separate record lists (answer, authority, additional) into a single allocation indexed by &lt;code&gt;u16&lt;/code&gt; offsets; omitting the record&amp;rsquo;s owner name when it matches the query name; boxing oversized enum variants like &lt;code&gt;TXT&lt;/code&gt; and &lt;code&gt;NAPTR&lt;/code&gt;; and finally storing records as pre-serialized DNS wire-format bytes packed into a single contiguous allocation. With wire-format storage, common records like &lt;code&gt;A&lt;/code&gt;, &lt;code&gt;AAAA&lt;/code&gt;, and &lt;code&gt;TXT&lt;/code&gt; can be &lt;code&gt;memcpy&lt;/code&gt;&amp;rsquo;d straight into outbound DNS response packets without re-serializing. In benchmarks, per-entry memory dropped by 56% (from 953 bytes down to 420 bytes), insert throughput rose 43%, and lookup latency fell 19%. In production, p99 resident memory per server dropped from 9.3 GB to 5.3 GB—saving roughly 100 TB of RAM across the fleet (the equivalent of ~130 servers), which Cloudflare plans to reinvest into larger caches for higher hit rates.&lt;/p&gt;
&lt;h2 id="agentic-code-quality"&gt;&lt;a href="https://addyo.substack.com/p/agentic-code-quality" rel="noopener noreferrer"&gt;Agentic Code Quality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that traditional human line-by-line code review cannot keep pace with the volume of code generated by AI agents, so quality control must shift into the harness, environment, and automated verification systems surrounding the agent. His central thesis: in an agentic workflow, software quality is bounded by the quality of the constraints you place around the agent. Those constraints include unit tests, property-based tests, acceptance tests, mutation testing (to verify your tests actually catch injected bugs rather than merely exercising lines), and static complexity metrics like cyclomatic complexity. How much human code reading you can safely skip depends on the blast radius: throwaway prototypes need very little, whereas auth, billing, and core infrastructure demand either human review or exceptionally tight automated invariants. The goal is an environment that gives the agent fast, reliable feedback and makes failures cheap and contained.&lt;/p&gt;
&lt;p&gt;Constraints should operate at three boundaries: up front (via specs, type systems, and architecture rules), continuously during execution (as compiler and test feedback), and at the production gate. Every layer of the verification stack should own a distinct concern—from type safety and lint rules to performance budgets and security scanning—so compilers, failing tests, and CI policies exert early &amp;ldquo;backpressure&amp;rdquo; on the agent long before a human is asked to review a PR. When code generation velocity outstrips a team&amp;rsquo;s verification capacity, you have only three choices: scale up automated verification, slow down generation, or lower your quality bar (the worst option). Because human attention is now the scarcest resource in engineering, save it for high-leverage decisions about product intent, taste, and system architecture, and pull humans into the loop only after the automated guardrails pass.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=bF28LFPjFsI" rel="noopener noreferrer"&gt;How the JVM Really Works&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;ByteByteGo&amp;rsquo;s video explains how the Java Virtual Machine works under the hood, from compiling Java source code into bytecode to executing it on the target machine.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!tsAw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb0fa724e-feb3-4ec6-9c53-50437d9cf884_2484x3002.png" alt="MCP vs RAG vs AI Agents"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!aJjm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F79e409f6-979a-4756-9366-de84824ab9d8_2484x3002.png" alt="9 Distributed Systems Patterns You Should Know"&gt;&lt;/p&gt;</description></item><item><title>Newsletter #133</title><link>https://miti99.com/en/post/2026/10/01/</link><pubDate>Thu, 01 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #133.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-go-is-an-ideal-language-for-ai-assisted-software-engineering"&gt;&lt;a href="https://developers.googleblog.com/why-go-is-an-ideal-language-for-ai-assisted-software-engineering/" rel="noopener noreferrer"&gt;Why Go is an Ideal Language for AI-Assisted Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with &lt;code&gt;gofmt&lt;/code&gt;, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.&lt;/p&gt;
&lt;p&gt;On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go&amp;rsquo;s checksum database guards against tampered dependencies, while &lt;code&gt;govulncheck&lt;/code&gt; alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and &lt;code&gt;go fix&lt;/code&gt; lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.&lt;/p&gt;
&lt;h2 id="how-does-programming-language-affect-token-efficiency-and-correctness"&gt;&lt;a href="https://danluu.com/pl-tokens/" rel="noopener noreferrer"&gt;How does programming language affect token efficiency and correctness?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete &lt;code&gt;zstd&lt;/code&gt; decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).&lt;/p&gt;
&lt;p&gt;The results tell a nuanced story: on &lt;code&gt;zstd&lt;/code&gt; at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed &lt;code&gt;byte&lt;/code&gt; coercion throws an exception on values &lt;code&gt;128–255&lt;/code&gt;. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren&amp;rsquo;t enough to draw universal laws, the blanket claim that &amp;ldquo;dynamic languages are better for LLMs&amp;rdquo; doesn&amp;rsquo;t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.&lt;/p&gt;
&lt;h2 id="my-agentic-coding-setup-july-2026"&gt;&lt;a href="https://domenic.me/agentic-coding-setup/" rel="noopener noreferrer"&gt;My Agentic Coding Setup, July 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a &amp;ldquo;semi-disposable&amp;rdquo; Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (&lt;code&gt;--dangerously-skip-permissions&lt;/code&gt; / &lt;code&gt;--yolo&lt;/code&gt;) mode with &lt;code&gt;gh&lt;/code&gt; pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn&amp;rsquo;t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.&lt;/p&gt;
&lt;p&gt;The remaining pieces solve each workflow friction point: &lt;code&gt;git worktree&lt;/code&gt; lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT&amp;rsquo;s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and &lt;code&gt;chezmoi&lt;/code&gt; syncs his &lt;code&gt;AGENTS.md&lt;/code&gt;, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.&lt;/p&gt;
&lt;h2 id="the-bedrock-of-software-design"&gt;&lt;a href="https://alex.draftist.io/blog/the-bedrock-of-software-design-ycqvcedsj" rel="noopener noreferrer"&gt;The Bedrock of Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. &lt;em&gt;Product types&lt;/em&gt; combine multiple fields into a single value, like a struct with an &lt;code&gt;id&lt;/code&gt; and a &lt;code&gt;role&lt;/code&gt;; &lt;em&gt;sum types&lt;/em&gt; (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either &lt;code&gt;Anonymous&lt;/code&gt; or &lt;code&gt;Authenticated(User)&lt;/code&gt;. When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with &lt;code&gt;Switchable&lt;/code&gt; and &lt;code&gt;Fixed&lt;/code&gt; variants, each holding only the fields that actually apply, making illegal states unrepresentable.&lt;/p&gt;
&lt;p&gt;The same thinking applies to errors and the absence of values. With unchecked exceptions, a function&amp;rsquo;s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via &lt;code&gt;Result&lt;/code&gt;, whose error type can itself be a domain-specific sum type carrying rich context. &lt;code&gt;Option&amp;lt;T&amp;gt;&lt;/code&gt; replaces &lt;code&gt;null&lt;/code&gt;, and a signature like &lt;code&gt;Result&amp;lt;Option&amp;lt;User&amp;gt;, FindUserError&amp;gt;&lt;/code&gt; cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive &lt;code&gt;match&lt;/code&gt; expressions force callers to handle every variant, so when a new &lt;code&gt;Staff&lt;/code&gt; role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev&amp;rsquo;s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.&lt;/p&gt;
&lt;h2 id="90--of-the-t-distribution"&gt;&lt;a href="https://entropicthoughts.com/ninety-percent-of-the-t-distribution" rel="noopener noreferrer"&gt;90 % of the t distribution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student&amp;rsquo;s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.&lt;/p&gt;
&lt;p&gt;With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you&amp;rsquo;re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-computer-not-a-container--introducing-cloudflarecomputer"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-computer/" rel="noopener noreferrer"&gt;Your agent needs a computer, not a container — introducing @cloudflare/computer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare has released a preview of &lt;code&gt;@cloudflare/computer&lt;/code&gt;, an open-source, npm-installable agent runtime that gives every AI agent its own virtual &amp;ldquo;computer&amp;rdquo; complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare&amp;rsquo;s target is for containers to handle less than 10% of an agent&amp;rsquo;s workload.&lt;/p&gt;
&lt;p&gt;Architecturally, the runtime decouples the agent&amp;rsquo;s &amp;ldquo;brain&amp;rdquo; from its &amp;ldquo;hands&amp;rdquo;: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a &lt;code&gt;node:fs&lt;/code&gt;-compatible wrapper. Two execution backends sit behind a unified &lt;code&gt;exec&lt;/code&gt; interface: the isolate backend uses &lt;code&gt;just-bash&lt;/code&gt; to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.&lt;/p&gt;
&lt;h2 id="notes-on-incidents"&gt;&lt;a href="https://www.seangoedecke.com/notes-on-incidents/" rel="noopener noreferrer"&gt;Notes on incidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic &amp;ldquo;firefighting&amp;rdquo; often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.&lt;/p&gt;
&lt;p&gt;When intervention &lt;em&gt;is&lt;/em&gt; needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.&lt;/p&gt;
&lt;h2 id="beyond-clean-code-why-your-comments-matter"&gt;&lt;a href="https://blog.moertel.com/posts/2026-07-27-beyond-clean-code-why-your-comments-matter.html" rel="noopener noreferrer"&gt;Beyond “Clean Code”: Why Your Comments Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express &lt;em&gt;what&lt;/em&gt; the machine is instructed to do, whereas human readers also need to know &lt;em&gt;what the author intended&lt;/em&gt; and &lt;em&gt;why&lt;/em&gt; the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn&amp;rsquo;t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; that comments shouldn&amp;rsquo;t be used as deodorant for needlessly tangled code, he argues that the dogma &amp;ldquo;every comment is a failure&amp;rdquo; goes way too far. Crucial &amp;ldquo;why&amp;rdquo; context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.&lt;/p&gt;
&lt;p&gt;Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. &lt;em&gt;&amp;ldquo;Comments lie&amp;rdquo;&lt;/em&gt;: without a comment stating the intent, buggy code leaves zero clue that it&amp;rsquo;s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. &lt;em&gt;&amp;ldquo;Comments rot&amp;rdquo;&lt;/em&gt;: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.&lt;/p&gt;
&lt;h2 id="relying-on-go"&gt;&lt;a href="https://antonz.org/relying-on-go/" rel="noopener noreferrer"&gt;Relying on Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many new programming languages pitch themselves as &amp;ldquo;like Go, but with more features&amp;rdquo; or &amp;ldquo;like Rust, but simpler.&amp;rdquo; Anton Zhiyanov takes the opposite path with Solod, a &amp;ldquo;systems language for C and Go programmers&amp;rdquo;: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, &lt;code&gt;gopls&lt;/code&gt; autocomplete, linters, formatters, and &lt;code&gt;go.mod&lt;/code&gt; package management. The developer workflow is identical to Go: install the &lt;code&gt;so&lt;/code&gt; CLI tool, initialize a Go module, import Solod&amp;rsquo;s standard library package, and write normal Go code; &lt;code&gt;so run .&lt;/code&gt; compiles and runs the binary just like &lt;code&gt;go run&lt;/code&gt;. Even Solod&amp;rsquo;s standard library reuses large swaths of Go&amp;rsquo;s standard library code and test suites, adapted for manual memory management.&lt;/p&gt;
&lt;p&gt;Zhiyanov is upfront about the trade-offs: standard Go tooling doesn&amp;rsquo;t know about Solod&amp;rsquo;s subset restrictions, so &lt;code&gt;gopls&lt;/code&gt; won&amp;rsquo;t warn you if you use unsupported Go features like closures or iterators—catching those is up to the &lt;code&gt;so&lt;/code&gt; compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, &lt;code&gt;so&lt;/code&gt; transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn&amp;rsquo;t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod&amp;rsquo;s greatest strength.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was reviewed and updated by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #132</title><link>https://miti99.com/en/post/2026/09/10/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #132.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="perfection-is-not-over-engineering"&gt;&lt;a href="https://var0.xyz/posts/perfection-is-not-over-engineering.html" rel="noopener noreferrer"&gt;Perfection is not over-engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The phrase &amp;ldquo;we don&amp;rsquo;t want to aim for perfection&amp;rdquo; comes up in engineering meetings more times than the author can count. He understands the caution—over-engineering has burned out plenty of teams—but argues the industry is conflating two completely different things. Over-engineering is simply &lt;em&gt;solving the wrong problem&lt;/em&gt;, usually with good intentions and a pile of accidental complexity attached. A &amp;ldquo;perfect&amp;rdquo; solution, by contrast, is very real once requirements are clear and all constraints are on the table: tighten the constraints enough and only one design fits, making it perfect precisely because nothing else satisfies the actual problem. Picking Python on serverless to skip a build step might be ideal for one team and completely wrong for a team that doesn&amp;rsquo;t know Python or needs predictable low latency.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, every system is a product: internal libraries, APIs, and CLI tools all have real users with real needs. The clearest tell of over-engineering is asking &amp;ldquo;why did we build it this way?&amp;rdquo; and getting an answer that falls apart under scrutiny. A classic example is a three-person team maintaining five microservices that share the same underlying data: foreign keys once enforced by the database turn into loosely coupled string IDs, and one service deletes records without the others knowing—all to buy &amp;ldquo;independent deployability,&amp;rdquo; a problem the three-person team never actually had. The takeaway: that isn&amp;rsquo;t an excess of perfection, it&amp;rsquo;s a failure of requirements gathering. The enemy was never perfection; it was vague requirements.&lt;/p&gt;
&lt;h2 id="claude-is-not-a-compiler"&gt;&lt;a href="https://blog.exe.dev/claude-is-not-a-compiler" rel="noopener noreferrer"&gt;Claude Is Not a Compiler&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Josh Bleecher Snyder argues that Claude is not a compiler—because it is &lt;em&gt;better&lt;/em&gt; than one. In the idealized textbook view, software is built in neat horizontal layers: vision becomes strategy, product specs become engineering plans, source code becomes binaries, with each layer owned by a different role making thousands of micro-decisions. In reality, layers constantly leak and rub against one another, and working &lt;em&gt;across&lt;/em&gt; layers is where the biggest wins happen—just as the Empire State Building was designed and erected in under a year because the owners, architects, structural engineers, and contractors sat in the same room making cross-cutting trade-offs together. Claude can work vertically across all those layers at once—discussing strategy, architecture, source code, and assembly without needing to schedule a meeting.&lt;/p&gt;
&lt;p&gt;Snyder illustrates this with &lt;code&gt;exe.dev&lt;/code&gt;&amp;rsquo;s distributed DNS server. High-level strategic and architectural decisions were settled human-to-human; for the rest, he spun up multiple parallel agent loops to build full implementations with tests, then had another agent compare the resulting designs. What shocked him was how many consequential design decisions the agents quietly made on their own without asking—and how differently each agent resolved them, such as how to handle a database state rollback. Repeating this multi-agent exploration three times let him distill a concise design document that guided the final agent across every critical decision point. A week later, having barely read the raw code himself, he could answer every question from his teammates, and a month into production the DNS server had zero incidents. He calls this &amp;ldquo;vibe-engineering&amp;rdquo;—and predicts that soon we&amp;rsquo;ll just call it software engineering.&lt;/p&gt;
&lt;h2 id="in-defense-of-not-understanding-your-codebase"&gt;&lt;a href="https://www.seangoedecke.com/in-defense-of-not-understanding-your-codebase/" rel="noopener noreferrer"&gt;In defense of not understanding your codebase&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How thoroughly must an engineer understand their codebase? Sean Goedecke argues the answer depends entirely on the environment. Developers working on small, self-contained codebases like Redis will insist you must understand every line; engineers working on massive systems like Google or GitHub know that is literally impossible. Because the first group dominates online discourse, Goedecke steps up to defend the second: in a sufficiently large system, having only a &lt;em&gt;partial&lt;/em&gt; understanding isn&amp;rsquo;t a moral failing—it is the best anyone can ever achieve. At scale, everyone operates with an incomplete, slightly wrong mental model, so effective engineers must get comfortable making educated guesses.&lt;/p&gt;
&lt;p&gt;He pushes back against Peter Naur&amp;rsquo;s famous essay &lt;em&gt;&amp;ldquo;Programming as Theory Building.&amp;rdquo;&lt;/em&gt; While agreeing that a programmer&amp;rsquo;s most valuable asset is the mental &amp;ldquo;theory&amp;rdquo; of how the program works, Goedecke rejects Naur&amp;rsquo;s conclusion that once the original team leaves, a codebase is dead and ought to be rewritten from scratch. First, large legacy systems encode thousands of hard-won edge cases that a greenfield rewrite won&amp;rsquo;t rediscover until production breaks, and successful rewrites almost always happen incrementally by carving up the existing system. Second, &amp;ldquo;abandoned&amp;rdquo; codebases are successfully revived in industry all the time: you start by tracing one end-to-end flow and expand your mental map from there. Finally, preserving a pristine mental theory is just one business value among many, routinely traded off whenever teams collaborate or patch urgent security vulnerabilities. Being a professional engineer means aligning with your company&amp;rsquo;s trade-offs—even when that means working effectively in code you don&amp;rsquo;t fully understand.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-the-network"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-01-Beyond-Happy-Path-Engineering-the-Network/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: the Network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This opening installment of Gabor Koos&amp;rsquo;s &lt;em&gt;&amp;ldquo;Beyond Happy Path Engineering&amp;rdquo;&lt;/em&gt; series examines the assumptions that local development environments indulge but production mercilessly punishes, starting with the network. A network call looks like a simple function call, but it crosses a boundary into a system you do not control. Using checkout payment authorization as a running example, Koos notes that &amp;ldquo;clean&amp;rdquo; failures like a refused connection are easy to handle compared to a timeout &lt;em&gt;after&lt;/em&gt; the request was sent: the operation may have succeeded, failed, or still be sitting in a queue. The foundational rule of distributed systems is that &lt;em&gt;not receiving a response does not mean the operation didn&amp;rsquo;t happen&lt;/em&gt;. Latency is also a failure mode in disguise: a slow downstream service ties up threads and connection pools, averages hide catastrophic tail latency, and slowness cascades into full outages faster than hard errors.&lt;/p&gt;
&lt;p&gt;Koos outlines the essential defenses: treat timeouts as explicit design decisions derived from per-request latency budgets; retry only when safe, backing mutations with idempotency keys passed on every attempt alongside exponential backoff and jitter to prevent thundering herds; and propagate deadlines and cancellation contexts downstream so abandoned work stops immediately. Circuit breakers and load shedding protect overloaded services, while graceful degradation separates critical path steps (like taking payment) from deferrable side effects (like sending confirmation emails) using explicit order states like &lt;code&gt;&amp;quot;pending&amp;quot;&lt;/code&gt;. GitHub&amp;rsquo;s October 2018 outage—where a network partition lasting under a minute caused over 24 hours of degraded service—vividly illustrates the cost of happy-path network assumptions.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-time"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-19-Beyond-Happy-Path-Engineering-Time/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of the series turns to time—seemingly the simplest dependency of all: grab the current timestamp, compare two values, and make a decision. The running example is a checkout flow that holds inventory for fifteen minutes using &lt;code&gt;if now() &amp;gt; reservation.expiresAt&lt;/code&gt;. If the cleanup worker&amp;rsquo;s clock drifts two minutes ahead of the checkout server&amp;rsquo;s clock, items get released back to inventory while the customer is mid-payment. Wall clocks can jump forward or backward mid-execution via NTP adjustments, turning elapsed durations negative, and timestamps across different machines cannot reliably establish event ordering. Worst of all, time bugs fail silently: services stay up, dashboards stay green, and the system quietly makes wrong business decisions.&lt;/p&gt;
&lt;p&gt;The core lesson is that &amp;ldquo;time&amp;rdquo; actually answers four distinct questions: &lt;em&gt;wall-clock time&lt;/em&gt; records when an event happened in the real world, &lt;em&gt;monotonic time&lt;/em&gt; measures elapsed durations and timeouts on a single machine, &lt;em&gt;logical time&lt;/em&gt; (versions or sequence numbers) orders competing updates, and &lt;em&gt;business time&lt;/em&gt; governs billing periods, cutoff windows, and user time zones. Expiration should be modeled as an explicit &lt;em&gt;state transition&lt;/em&gt; rather than a passive timestamp comparison: use timestamps only to find candidate rows, then execute a conditional write that transitions the row to &lt;code&gt;expired&lt;/code&gt; only if its status is still &lt;code&gt;reserved&lt;/code&gt;, making late or duplicate cleanup runs harmless. When local clocks aren&amp;rsquo;t enough to arbitrate, reconcile against the authoritative external source, such as the payment provider. Cloudflare&amp;rsquo;s New Year&amp;rsquo;s 2017 leap-second DNS outage—when subtracting two &lt;code&gt;time.Now()&lt;/code&gt; readings yielded a negative number and triggered a panic—serves as a classic cautionary tale.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-databases"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-01-Beyond-Happy-Path-Engineering-Databases/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Databases&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part three tackles databases, the layer developers most often treat as an infallible black box. Using an e-commerce checkout flow that works flawlessly on a developer&amp;rsquo;s laptop because there is zero concurrent traffic, Koos shows how production changes everything: checkouts, admin dashboards, background jobs, analytics queries, and schema migrations all compete for the same connections and locks. A single slow query can exhaust the connection pool, causing incoming requests to queue up, users to hit refresh, and &amp;ldquo;checkout to go down&amp;rdquo; even though the database hasn&amp;rsquo;t crashed. Two concurrent requests can both read &lt;code&gt;stock = 1&lt;/code&gt; and both sell the last item; wrapping code in a transaction doesn&amp;rsquo;t magically prevent race conditions unless business invariants are enforced explicitly. On top of that come lagging read replicas, commit timeouts that leave the caller unsure whether the write succeeded, deadlocks, and schema migrations running alongside multiple live application versions.&lt;/p&gt;
&lt;p&gt;Koos recommends starting from the invariant that must never be violated—such as &amp;ldquo;never sell more than available inventory&amp;rdquo;—and enforcing it directly in the atomic write statement (&lt;code&gt;UPDATE ... WHERE stock &amp;gt;= quantity&lt;/code&gt;) backed by database constraints rather than application-level checks alone. Keep transactions short, never make network calls inside a transaction, and retry only transient errors. Make writes idempotent, define explicit data-freshness requirements per endpoint before routing reads to replicas, run schema migrations in backward-compatible expand-and-contract phases, and rehearse backup restores regularly. Atlassian&amp;rsquo;s 2022 outage and GitHub&amp;rsquo;s 2018 incident both prove that recovery speed matters just as much as data durability.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-storage"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-11-Beyond-Happy-Path-Engineering-Storage/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Storage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part four examines object storage, which looks simpler than a relational database but hides a fundamental trap: your database and your object store are two separate systems with no shared transaction coordinator. Consider a document upload flow: write the file to S3, insert a metadata row in the database, and return the URL. If the blob upload succeeds but the database insert fails, you get an invisible orphaned object; flip the order and a failed upload leaves a database row pointing to a missing blob that serves &lt;code&gt;404&lt;/code&gt;s. Abandoned multipart uploads quietly rack up storage bills, presigned URLs remain valid even after the database record is deleted, concurrent uploads to the same key silently overwrite each other, and CDNs keep serving stale cached files. High durability also doesn&amp;rsquo;t equal recoverability, because an accidental &lt;code&gt;DELETE&lt;/code&gt; is replicated just as durably as a valid write.&lt;/p&gt;
&lt;p&gt;Koos advises ordering upload steps so failures fail safe, tracking lifecycle state explicitly in the database (&lt;code&gt;pending&lt;/code&gt;, &lt;code&gt;confirmed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;), and serving only &lt;code&gt;confirmed&lt;/code&gt; records. Object keys should use immutable UUIDs or content hashes rather than user-supplied filenames; large files should upload directly from the client via short-lived presigned URLs; and deletions should soft-delete the database row first before a background job purges the blob, backed by a periodic reconciliation sweeper. The 2014 demise of Code Spaces—which shut down permanently after an attacker gained access to their AWS control panel and wiped both production storage and backups—underscores why backups must live outside the blast radius of production credentials.&lt;/p&gt;
&lt;h2 id="everyone-should-know-simd"&gt;&lt;a href="https://mitchellh.com/writing/everyone-should-know-simd" rel="noopener noreferrer"&gt;Everyone Should Know SIMD&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SIMD has a reputation for being arcane, and Mitchell Hashimoto regularly meets strong engineers who write it off as too hard to learn or useful only in niche high-performance computing. He argues that reputation is undeserved: the vast majority of practical &amp;ldquo;process N items at a time&amp;rdquo; SIMD code follows a single five-step template, and once you internalize that template, writing SIMD is almost as straightforward as writing a standard &lt;code&gt;for&lt;/code&gt; loop. Because SIMD lets the CPU process multiple data elements in a single instruction, any loop scanning bytes, characters, or array elements is a candidate once inputs reach thousands or millions of bytes.&lt;/p&gt;
&lt;p&gt;The five-step template is: broadcast constants into vectors and initialize accumulators if needed; loop over the input in chunks equal to the vector width; perform parallel comparisons or arithmetic across all lanes; reduce or store the vector result; and handle the trailing remainder elements using your original scalar loop. Hashimoto walks through a real example from the Ghostty terminal emulator written in Zig: finding the end of a run of printable ASCII characters by scanning until a byte is &lt;code&gt;&amp;lt;= 0xF&lt;/code&gt;. The scalar loop is a one-liner; the SIMD version adds about 12 lines of code and delivers a theoretical 4x speedup on ARM NEON, 8x on AVX2, and 16x on AVX-512, measuring roughly 5x faster in real benchmarks on an Intel AVX2 machine. While compilers can sometimes auto-vectorize simple loops, whenever a hot path cares about a 5x speedup, Hashimoto prefers explicit, portable SIMD that won&amp;rsquo;t silently regress after a compiler upgrade or minor code tweak.&lt;/p&gt;
&lt;h2 id="htop-explained"&gt;&lt;a href="https://peteris.rocks/blog/htop/" rel="noopener noreferrer"&gt;htop explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pēteris Ņikiforovs admits that for years he used &lt;code&gt;htop&lt;/code&gt; without truly understanding half the numbers on screen—for instance, assuming a load average of &lt;code&gt;1.0&lt;/code&gt; on a dual-core machine meant the CPUs were 50% busy. So he dug into the Linux kernel sources and wrote a comprehensive visual guide breaking down every single bar and column in &lt;code&gt;htop&lt;/code&gt;. What makes the guide stand out is that he traces every metric back to its exact kernel source: uptime comes from &lt;code&gt;/proc/uptime&lt;/code&gt;, load average comes from &lt;code&gt;/proc/loadavg&lt;/code&gt;, and you can verify how &lt;code&gt;htop&lt;/code&gt; gathers them yourself by running it under &lt;code&gt;strace&lt;/code&gt; to see which files it opens.&lt;/p&gt;
&lt;p&gt;Load average isn&amp;rsquo;t CPU percentage at all—it is the exponentially damped moving average of runnable threads plus threads stuck in uninterruptible sleep waiting on disk or network I/O; the 1-minute figure reflects roughly 63% of the past minute&amp;rsquo;s load and 37% of the prior average. The guide then demystifies process states (&lt;code&gt;R&lt;/code&gt; running/runnable, &lt;code&gt;S&lt;/code&gt; interruptible sleep, &lt;code&gt;D&lt;/code&gt; uninterruptible sleep, &lt;code&gt;Z&lt;/code&gt; zombie terminated but not yet reaped by its parent), &lt;code&gt;NI&lt;/code&gt; nice values from &lt;code&gt;-20&lt;/code&gt; to &lt;code&gt;19&lt;/code&gt; and their relation to kernel priority (&lt;code&gt;PR = 20 + NI&lt;/code&gt;), and the memory columns: &lt;code&gt;VIRT&lt;/code&gt; includes unbacked virtual reservations and memory-mapped files so it&amp;rsquo;s rarely actionable, &lt;code&gt;RES&lt;/code&gt; is actual resident RAM (though shared libraries and copy-on-write pages get double-counted across processes), and &lt;code&gt;MEM%&lt;/code&gt; is simply &lt;code&gt;RES&lt;/code&gt; divided by total RAM. He wraps up by auditing every default background process on a fresh Ubuntu Server install to see which ones can be safely stripped out.&lt;/p&gt;
&lt;h2 id="the-productivity-experience-paradox"&gt;&lt;a href="https://annievella.com/posts/the-productivity-experience-paradox/" rel="noopener noreferrer"&gt;The Productivity-Experience Paradox&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the second article from her master&amp;rsquo;s research on how AI coding tools affect software engineers, Annie Vella shares findings from a longitudinal study tracking the exact same cohort of engineers across two waves six months apart (October 2024 to April 2025). On the productivity front, the news is consistently positive: 84% of respondents reported that AI helped them get more done in both waves. Yet developer experience—measured across the DevEx framework dimensions of feedback loops, cognitive load, and flow state—moved in the opposite direction: the share of engineers reporting a net-negative experience nearly doubled from 14% to 27%, and not a single engineer who fell into the negative group in Wave 1 recovered to an all-positive experience by Wave 2.&lt;/p&gt;
&lt;p&gt;The central finding is that productivity and developer experience—long assumed to rise and fall together—are decoupling: tracking the same individuals over time, experience degraded while output held steady, with a near-zero correlation ($r = 0.02$) between changes in flow state and changes in perceived productivity. That decoupling is dangerous because the business case for investing in DevEx has historically been &amp;ldquo;happy developers are productive developers&amp;rdquo;; when output stays high, rising cognitive strain stays invisible until it turns into burnout. Flow suffered the sharpest drop (negative reports rose from 7% to 20%) even as feedback loops sped up, and Vella suspects the two are linked: every fast AI response triggers a micro-context switch from creator to reviewer. Borrowing the term &amp;ldquo;junk flow&amp;rdquo; to describe a slot-machine-like loop of rapid prompting that mimics flow without deep satisfaction, she concludes that while AI boosts extrinsic output, it risks eroding the intrinsic craft and joy of software engineering.&lt;/p&gt;
&lt;h2 id="prefactoring-clear-the-way-for-your-new-feature"&gt;&lt;a href="https://testing.googleblog.com/2026/07/prefactoring-clear-way-for-your-new.html" rel="noopener noreferrer"&gt;Prefactoring: Clear the Way for Your New Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post from Google&amp;rsquo;s &lt;em&gt;&amp;ldquo;Tech on the Toilet&amp;rdquo;&lt;/em&gt; series opens with Kent Beck&amp;rsquo;s famous advice: &lt;em&gt;&amp;ldquo;First make the change easy (warning: this may be hard), then make the easy change.&amp;rdquo;&lt;/em&gt; When you try to bolt a new feature directly onto code that wasn&amp;rsquo;t structured to accommodate it, things get messy fast: tweaking one file forces changes in three others, and soon you&amp;rsquo;re knee-deep in unrelated modules. &lt;em&gt;Prefactoring&lt;/em&gt;—short for preparatory refactoring—is the discipline of restructuring existing code to fit the upcoming requirement &lt;em&gt;before&lt;/em&gt; writing the new feature, rather than promising yourself you&amp;rsquo;ll clean it up afterward.&lt;/p&gt;
&lt;p&gt;The payoffs are immediate: the new feature slots in naturally, code reviews go much faster because structural refactoring and behavioral changes live in separate commits, fewer bugs slip in because cleanup is isolated from new logic, and rollbacks are safer because each change is small and self-contained. In the post&amp;rsquo;s example, the first CL simply extracts a &lt;code&gt;get_display_name(user)&lt;/code&gt; helper to deduplicate name-formatting logic across the profile page and email templates; the second CL adds middle-name support with a one-line edit inside that helper. Even if you only spot the right abstraction mid-implementation, you can still split the cleanup into a preparatory CL—or spin off reviewer-suggested cleanups in parallel while your main CL is under review. Not every cleanup belongs up front, though: if a refactoring doesn&amp;rsquo;t directly unblock your feature, save it for later, or fold it in if it&amp;rsquo;s truly trivial.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #131</title><link>https://miti99.com/en/post/2026/09/09/</link><pubDate>Wed, 09 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #131.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-codename-one-javascript-port-is-now-free-and-open-source"&gt;&lt;a href="https://dev.to/codenameone/the-codename-one-javascript-port-is-now-free-and-open-source-2f84" rel="noopener noreferrer"&gt;The Codename One JavaScript Port Is Now Free and Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Codename One has open-sourced its JavaScript port under GPLv2 with the Classpath Exception. Previously restricted to Enterprise subscribers, the port is now available across all tiers, and developers can build web targets locally without even needing a Codename One account via a single Maven command powered by the bundled ParparVM compiler. ParparVM also replaces TeaVM as the default compiler for both local and cloud builds, though TeaVM remains available via a build hint for comparison. Architecturally, the application&amp;rsquo;s Java code runs inside a background Web Worker while browser interaction lives on the main UI thread, preventing Java code from accidentally coupling to the DOM or browser globals.&lt;/p&gt;
&lt;p&gt;The release also ships major framework additions. A unified Calendar API connects device calendars, Google Calendar, Microsoft 365, CalDAV, and &lt;code&gt;.ics&lt;/code&gt; files with support for recurring events, incremental sync, offline change queues, and conflict resolution. Bluetooth moves into the core framework with BLE, GATT, L2CAP, RFCOMM, and Web Bluetooth support. &lt;code&gt;EditField&lt;/code&gt;, &lt;code&gt;RichTextArea&lt;/code&gt;, and &lt;code&gt;CodeEditor&lt;/code&gt; now render and edit text directly on the canvas instead of overlaying native text inputs, while &lt;code&gt;RichTextComponent&lt;/code&gt; renders HTML, Markdown, AsciiDoc, and RTF without a WebView. A new proxy layer supports Jakarta Servlet, Node.js, PHP, AWS Lambda, Google Cloud Functions, and Cloudflare Workers. Finally, ParparVM adds compressed strings—halving memory usage for ASCII text—and Android API 36 becomes the default target next week.&lt;/p&gt;
&lt;h2 id="hacking-in-the"&gt;&lt;a href="https://committing-crimes.com/articles/2026-08-04-java-nameof/" rel="noopener noreferrer"&gt;Hacking in the &lt;code&gt;nameOf&lt;/code&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Java lacks C#&amp;rsquo;s &lt;code&gt;nameof&lt;/code&gt; expression for obtaining an identifier&amp;rsquo;s name as a compile-time string. That gap is especially annoying in argument validation, where you end up hardcoding parameter names into exception messages like &lt;code&gt;&amp;quot;name must not be blank&amp;quot;&lt;/code&gt;—and if someone renames the variable later without updating the string, the compiler won&amp;rsquo;t say a word. This article experiments with building a pure-Java &lt;code&gt;nameOf&lt;/code&gt; function that recovers variable names at runtime without bytecode instrumentation agents or annotation processors.&lt;/p&gt;
&lt;p&gt;The hack works in three steps. First, &lt;code&gt;StackWalker&lt;/code&gt; locates the caller frame that invoked &lt;code&gt;nameOf&lt;/code&gt;, yielding the class, method name, method descriptor, and exact bytecode index (BCI). Next, the caller class&amp;rsquo;s &lt;code&gt;.class&lt;/code&gt; file is loaded into memory and parsed into a &lt;code&gt;ClassModel&lt;/code&gt; using Java&amp;rsquo;s new Class-File API. Finally, the author simulates the JVM operand stack symbolically: instead of actual runtime values, each stack slot holds a symbolic label—such as a local variable or field name—which is propagated across load, store, field-access, and invocation instructions until the simulator reaches the exact BCI of the &lt;code&gt;nameOf&lt;/code&gt; call and reads the symbolic name sitting on top of the stack. The author strongly advises against using this in production: it breaks on unfamiliar opcodes, relies on optional debug info or the &lt;code&gt;-parameters&lt;/code&gt; compiler flag, may fail on non-&lt;code&gt;javac&lt;/code&gt; bytecode, and is barely tested. It is a delightful over-engineering exercise that doubles as a tour of JVM bytecode and the Class-File API.&lt;/p&gt;
&lt;h2 id="set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep"&gt;&lt;a href="https://dev.to/sshenvi/set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep-1jhj" rel="noopener noreferrer"&gt;Set It and Ship It: How I Let AI Agents Build My Java Services While I Sleep&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sudarshan Shenvi argues that AI agents are fully capable of building production-grade Java services autonomously over multi-hour runs, provided their work is gated by strict verification controls; without those gates, you just get plausible-sounding slop. He relies on three pillars: machine-verifiable requirements where every item specifies a concrete behavior or performance threshold that grades as pass or fail; a separate critic agent that audits the output item by item, since the builder agent must never grade its own homework; and an always-on execution harness with interactive permission prompts disabled so a five-hour run doesn&amp;rsquo;t stall waiting for a human click, paired with narrowly scoped credentials, sandboxed isolation, and hard spend limits.&lt;/p&gt;
&lt;p&gt;As an example, he walks through a ticket to build a payment reconciliation service. Instead of writing Java code, the engineer writes a 15-line requirements contract specifying REST endpoints, reconciliation logic, JPA entities, p95 latency under 500 ms, 100% test coverage, and security constraints. He kicks off the agent at 9:10 a.m. and walks away; the critic loop catches missing latency proof and a package structure violation, the builder agent fixes both, and by 11:35 a.m. he returns to a 15/15 passing scorecard with measured latency at 410 ms. Shenvi cautions that token consumption can spike unpredictably, so teams should enforce strict budget caps, run agents on isolated branches inside sandboxes, and always keep human code review before merging.&lt;/p&gt;
&lt;h2 id="software-abundance"&gt;&lt;a href="https://nader.substack.com/p/software-abundance" rel="noopener noreferrer"&gt;Software abundance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nader Dabit, a 14-year industry veteran currently at Cognition, writes that despite earlier anxieties about AI&amp;rsquo;s impact on software engineering, he has never been more optimistic about the field. He sees a sharp bifurcation in the job market: engineers who actively adopt AI-native workflows and pivot toward AI-driven growth areas are seeing stronger compensation and opportunities, while those who cling rigidly to narrow traditional silos like pure frontend or backend—or stay at slow-moving legacy enterprises—face headwinds and layoffs.&lt;/p&gt;
&lt;p&gt;The centerpiece of his argument is Jevons paradox: when the cost of producing software drops and capacity rises, demand for software doesn&amp;rsquo;t shrink—it expands dramatically. Teams he works with are now shipping 10x to 20x more pull requests than before, and cloud-hosted agents let non-specialists ship changes that previously required senior engineers. Higher velocity leads to more ambitious product roadmaps and a higher bar for polish. In Dabit&amp;rsquo;s view, software engineering isn&amp;rsquo;t disappearing; it is shedding the repetitive toil engineers disliked anyway—bug bashing, dependency upgrades, rote migrations—freeing humans to focus on judgment, curiosity, domain context, and taste, while reclaiming time for the creative experimentation that drew them to programming in the first place.&lt;/p&gt;
&lt;h2 id="the-development-pipeline-is-a-production-system"&gt;&lt;a href="https://sundry.jerryorr.com/2026/07/31/development-pipeline-is-a-production-system" rel="noopener noreferrer"&gt;The development pipeline is a production system&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jerry Orr argues that the software development pipeline is itself a production system, and when it breaks, engineering teams should treat the outage with the same urgency as a customer-facing incident. When the build is broken, developers cannot work; when the QA environment goes down, testers cannot verify releases. For those internal users, it is literally a production outage, and any component blocking the path from code commit to deployment—whether issue trackers, CI/CD runners, or a flaky test suite—represents a critical failure.&lt;/p&gt;
&lt;p&gt;Orr draws a parallel with manufacturing, where factories have long had disciplined processes to minimize assembly-line downtime, whereas software teams routinely neglect their own internal delivery infrastructure. He recommends explicitly cataloging and prioritizing every essential piece of the development pipeline: work and change-management platforms, developer tools like IDEs and build systems, artifact registries and local dev environments, CI/CD pipelines, QA environments, and automated test suites. Applying structured incident management—borrowed from IT service management and manufacturing—to developer infrastructure is essential, because a broken pipeline directly prevents value from reaching customers.&lt;/p&gt;
&lt;h2 id="how-llms-figure-out-what-you-mean---no-math-degree-required"&gt;&lt;a href="https://zarar.dev/how-ai-figures-out-what-you-mean-no-math-required/" rel="noopener noreferrer"&gt;How LLMs Figure Out What You Mean - No Math Degree Required&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains how a large language model figures out the meaning of a sentence without requiring any math background, using the question &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt; as a running example. Step one is turning words into numbers: text is split into tokens, each assigned an integer ID. A single ID number carries no semantic meaning on its own—there is no reason token #2 should be &amp;ldquo;similar&amp;rdquo; to token #3—so each token is mapped to an embedding vector, a long list of numbers whose dimensions jointly capture aspects of meaning so that words with similar meanings have similar vectors. You can picture vectors as arrows in space: synonyms point in the same direction, antonyms point in opposite directions, and unrelated words sit at right angles.&lt;/p&gt;
&lt;p&gt;To measure how closely two words align, the model uses the dot product, illustrated as two people pushing a shopping cart: push in the same direction and your forces add up to a high positive score; push at an angle and efficiency drops; push in opposite directions and you cancel each other out with a negative score. Because raw scores only make sense relative to one another, the model passes them through a &lt;code&gt;softmax&lt;/code&gt; function to convert them into percentages—like giving each word a single dollar of attention to slice up like a pizza among the other words in the sentence based on relevance. That is how, in &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt;, the word &lt;code&gt;&amp;quot;roar&amp;quot;&lt;/code&gt; directs most of its attention to &lt;code&gt;&amp;quot;lions&amp;quot;&lt;/code&gt; rather than &lt;code&gt;&amp;quot;Do&amp;quot;&lt;/code&gt;. All these vectors start out completely random and are gradually nudged into place during training via backpropagation over massive amounts of text.&lt;/p&gt;
&lt;h2 id="meet-alice-alice-is-impatient"&gt;&lt;a href="https://brooker.co.za/blog/2026/06/19/waiting.html" rel="noopener noreferrer"&gt;Meet Alice. Alice is impatient.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker opens with two scenarios every service operator recognizes. You measure an average request latency of 100 ms, yet your customer Alice swears she waits a full second on average. You report a mean time to recovery (MTTR) under one minute, yet your customer Alex experiences outages as lasting roughly an hour each. According to Brooker, both sides are telling the truth: operators average over &lt;em&gt;events&lt;/em&gt;, whereas customers sample across &lt;em&gt;time&lt;/em&gt;. This is the inspection paradox: the longer an outage or slow window lasts, the more customer requests (or retries) land inside it, so what customers actually experience is a duration-weighted version of the underlying distribution.&lt;/p&gt;
&lt;p&gt;Mathematically, if operators measure a mean duration of $E[X]$, a customer arriving at a random point in time experiences an expected duration of $\frac{E[X^2]}{2E[X]}$, which simplifies to $\frac{1}{2}\left(E[X] + \frac{\text{Var}(X)}{E[X]}\right)$. The gap between operator metrics and customer perception is proportional to the variance divided by the mean, meaning high variance drives perceived wait times through the roof. Brooker includes an interactive calculator and Python simulation: with a 30-minute median outage and a 600-minute p99, customers experience an average recovery time of roughly 6 hours even though measured MTTR is just 1 hour. Because real-world systems follow heavy-tailed distributions, trimming outliers hides the exact tail events that dominate customer pain. Short blips are already well handled by retries and failovers; long tail outages remain the industry&amp;rsquo;s unsolved problem and where engineering investment belongs.&lt;/p&gt;
&lt;h2 id="harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one"&gt;&lt;a href="https://lukasniessen.medium.com/harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one-a955bcdf5cce" rel="noopener noreferrer"&gt;Harness Engineering Deep Dive: Where The Term Came From, And How To Actually Build One&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen starts from the equation that has become standard in 2026: &lt;strong&gt;Agent = Model + Harness&lt;/strong&gt;. The harness is everything around the model: the execution loop, tools, sandboxing, context assembly, permissions, verification suites, durable state, execution traces, cost caps, and approval gates. Because you rent the model but own the harness, whenever an agent fails, instead of waiting for the next model release, you can re-engineer the environment so that class of failure becomes structurally impossible. Coined in early 2026 through posts by Mitchell Hashimoto, Birgitta Böckeler, and an OpenAI report, harness engineering represents the natural progression after prompt engineering and context engineering. The dividing line between a thin wrapper and a true harness is the closed feedback loop: once model outputs become actions executed against real state, whose results feed back into the next turn, every harness engineering concern comes into play.&lt;/p&gt;
&lt;p&gt;The technical deep dive walks through seven failure modes of a naive agent loop: sensors must distill signal rather than dumping raw stdout into the context window; conversation history is merely a cache while an external ledger holds the source of truth; the agent must never be allowed to declare its own work &amp;ldquo;done&amp;rdquo; without an external verifier; action spaces should be constrained via strict tool schemas rather than longer system prompts; budgets need stall detection; tool gates should be tiered by risk reversibility; and full execution traces must be treated as the primary unit of debugging. According to Niessen, harness quality alone can swing token consumption by 10x to 50x on the exact same task.&lt;/p&gt;
&lt;h2 id="how-big-is-a-git-commit"&gt;&lt;a href="https://ratfactor.com/cards/git-commit-size" rel="noopener noreferrer"&gt;How big is a Git commit?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How much disk space does a Git commit actually take? To find out, Dave Gauer measures the size of the &lt;code&gt;.git&lt;/code&gt; directory with &lt;code&gt;du -sb&lt;/code&gt; across a series of controlled scenarios, using only loose objects (no packfiles) to expose Git&amp;rsquo;s raw storage mechanics. A freshly initialized empty repository takes about 64 KB; committing 250 tiny files across 5 directories adds roughly 47 KB; a tiny edit to a single file inside that tree costs 17 KB, whereas making the exact same three-byte change in a repository containing only one file takes about 8.7 KB.&lt;/p&gt;
&lt;p&gt;The reason lies in Git&amp;rsquo;s object model: when you edit a file inside a subdirectory, Git writes four new zlib-compressed objects—the commit object itself, the updated blob holding the file&amp;rsquo;s full contents, a new tree object for the subdirectory listing all its entries, and a new root tree object. Even for a three-byte edit, that metadata and object overhead adds up to kilobytes and scales with directory depth and breadth. On larger files, zlib compression shines: a 580 KB binary shrinks to 298 KB, and a 16.4 MB source code file compresses down to 1.6 MB—about 10% of its original size. Across these large-file tests, &lt;code&gt;.git&lt;/code&gt; grows by roughly 10–50% of the raw data size depending on content compressibility. Gauer concludes that Git&amp;rsquo;s loose object storage is already remarkably frugal—especially for text—and packfiles make it dramatically smaller still by delta-compressing similar objects.&lt;/p&gt;
&lt;h2 id="how-i-find-problems-to-solve-as-a-staff-engineer"&gt;&lt;a href="https://lalitm.com/post/find-problems-staff-engineer/" rel="noopener noreferrer"&gt;How I Find Problems to Solve as a Staff Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lalit Maganti shares how he discovers high-leverage problems to solve as a Staff Engineer. Instead of blocking off calendar time to &amp;ldquo;think strategically,&amp;rdquo; he acts like a sponge: soaking up the daily ambient noise of meetings, chat channels, and email threads to absorb the friction people are experiencing. When something touches his domain, he digs past the surface request to uncover the underlying problem—sometimes sitting with teams to watch their workflow firsthand or debugging an issue himself to separate the real need from the solution the team asked for. He also deliberately resists jumping on the first request that comes in, since the loudest team doesn&amp;rsquo;t necessarily represent org-wide priorities; when the same pain point surfaces independently across multiple teams, that&amp;rsquo;s a strong signal.&lt;/p&gt;
&lt;p&gt;Long walks help him connect the dots across accumulated observations. On Perfetto, teams spent two years requesting disparate UI features—pinned tracks, custom zoom levels, bespoke aggregations—before he realized the underlying need was a general UI extensibility plugin system. Before committing engineering resources, he validates ideas with throwaway prototypes and socializes them with managers and partner teams. Solving the right problems builds trust that gets him invited into conversations earlier, letting him shape the roadmap without having to build everything himself—an approach he notes works best in bottom-up engineering cultures.&lt;/p&gt;
&lt;h2 id="golang-maps-how-swiss-tables-replaced-the-old-bucket-design"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-24-Golang-Maps-How-Swiss-Tables-Replaced-the-Old-Bucket-Design/" rel="noopener noreferrer"&gt;Golang Maps: How Swiss Tables Replaced the Old Bucket Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maps sit on the hot path of almost every Go program, and Go 1.24 replaced their internal implementation with Swiss Tables. The classic design used an array of buckets, each holding up to 8 key-value pairs plus metadata bytes; when a bucket filled up, the runtime allocated an overflow bucket and chained it via a pointer. While battle-tested, overflow chains forced lookups to chase pointers across non-contiguous memory, causing CPU cache misses, and capped the maximum load factor at roughly 81% before collision overhead degraded performance.&lt;/p&gt;
&lt;p&gt;Swiss Tables split each key&amp;rsquo;s hash into two parts: a prefix that selects the group, and a 7-bit fingerprint stored in a compact control byte array. Data is organized into 8-slot groups consisting of an 8-byte control word alongside key and value slots; during a lookup, the runtime scans all 8 control bytes in parallel using SIMD or bitwise operations, performs full key comparisons only on slots whose 7-bit fingerprint matches, and stops immediately if an empty slot is present. Most non-matching slots are filtered out at the cheap metadata stage, flat probing improves cache locality, and the max load factor rises to 87.5%. Rather than resizing one giant table all at once, Go uses an extendable hashing directory over multiple smaller tables so growth happens incrementally while preserving Go&amp;rsquo;s &lt;code&gt;range&lt;/code&gt; iteration semantics. Benchmarks show 2–3% overall CPU wins and 30–35% speedups on large map operations, with the trade-off that delete-heavy workloads leave tombstones that lengthen probe sequences until a table rehash clears them.&lt;/p&gt;
&lt;h2 id="the-new-rules-of-context-engineering-for-claude-5-models"&gt;&lt;a href="https://x.com/trq212/status/2080710971228918066" rel="noopener noreferrer"&gt;The new rules of context engineering for Claude 5 models&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you send a prompt to Claude, your message is only a small fraction of the context window it actually sees; the bulk is assembled from system prompts, skills, &lt;code&gt;CLAUDE.md&lt;/code&gt; files, memory, and tool definitions—and designing that assembly is context engineering. In this post, Anthropic engineer Thariq Shihipar reveals that the team deleted over 80% of Claude Code&amp;rsquo;s system prompt for frontier models like Claude Opus 5 and Claude Fable 5 without losing a single point on their coding evaluations. The reason is that earlier prompts over-constrained the model: within a single request, the system prompt, a skill, and the user&amp;rsquo;s &lt;code&gt;CLAUDE.md&lt;/code&gt; might give conflicting instructions—such as &amp;ldquo;write documentation where appropriate&amp;rdquo; alongside &amp;ldquo;DO NOT add comments&amp;rdquo;—forcing the model to waste reasoning tokens reconciling rules that newer models can navigate using their own judgment.&lt;/p&gt;
&lt;p&gt;The post contrasts old habits with the new playbook. Instead of rigid rules, trust the model&amp;rsquo;s judgment; the new instruction simply says &amp;ldquo;write code that matches the surrounding codebase.&amp;rdquo; Instead of stuffing few-shot tool examples into the prompt—which narrows exploration—design more expressive, self-documenting tool parameter schemas. Instead of front-loading everything into the initial context, use progressive disclosure: verification and code-review instructions are broken out into on-demand skills, and specialized tools are loaded lazily when needed. Memory is now captured automatically, and reference material can live as rich HTML artifacts or executable test suites rather than flat markdown files. Keep &lt;code&gt;CLAUDE.md&lt;/code&gt; lean, reserving it for non-obvious repo gotchas rather than facts Claude can discover by reading the code.&lt;/p&gt;
&lt;h2 id="the-git-history-command-deserves-more-attention"&gt;&lt;a href="https://lalitm.com/post/git-history/" rel="noopener noreferrer"&gt;The git history command deserves more attention&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Juggling multiple stacked changes in Git usually means tedious branch hopping and error-prone interactive rebases, which is why tools like &lt;code&gt;jj&lt;/code&gt; (Jujutsu) have gained a devoted following. Lalit Maganti argues that Git&amp;rsquo;s experimental &lt;code&gt;git history&lt;/code&gt; command—introduced across Git 2.54 (April 2026, adding &lt;code&gt;reword&lt;/code&gt; and &lt;code&gt;split&lt;/code&gt;) and Git 2.55 (June 2026, adding &lt;code&gt;fixup&lt;/code&gt;)—brings many of those same ergonomic benefits straight into stock Git without requiring a workflow overhaul, yet has flown largely under the radar. With &lt;code&gt;fixup&lt;/code&gt;, you stage changes via &lt;code&gt;git add&lt;/code&gt; and run &lt;code&gt;git history fixup &amp;lt;commit&amp;gt;&lt;/code&gt; to fold them directly into an earlier commit; every descendant local branch stacked on top of that commit is automatically rebased in place, going well beyond &lt;code&gt;git rebase --update-refs&lt;/code&gt;. Meanwhile, &lt;code&gt;reword&lt;/code&gt; opens your editor to amend an old commit message and automatically rebases the entire stack of descendant commits and branches, and &lt;code&gt;split&lt;/code&gt; interactively carves a commit into two.&lt;/p&gt;
&lt;p&gt;What unites all three subcommands is atomicity: they never drop your repository into a half-broken interactive rebase state, because they immediately abort any operation that would produce a merge conflict. That is also their biggest limitation compared to &lt;code&gt;jj&lt;/code&gt;, which treats conflicts as first-class objects you can resolve whenever you like; additionally, &lt;code&gt;fixup&lt;/code&gt; cannot cross merge commits, and Git still lacks &lt;code&gt;jj&lt;/code&gt;&amp;rsquo;s operation log for effortless undo. Git&amp;rsquo;s documentation notes that the conflict restriction may be lifted in future releases, but even today &lt;code&gt;git history&lt;/code&gt; is a major quality-of-life leap built right into standard Git.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #130</title><link>https://miti99.com/en/post/2026/09/08/</link><pubDate>Tue, 08 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #130.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-anthropic-runs-large-scale-code-migrations-with-claude-code"&gt;&lt;a href="https://claude.com/blog/ai-code-migration" rel="noopener noreferrer"&gt;How Anthropic runs large-scale code migrations with Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Migrating a large codebase to another language used to be a multi-year endeavor undertaken only as a last resort. Anthropic shows how that calculus has changed: Bun migrated one million lines of code from Zig to Rust in under two weeks, consuming roughly 5.9 billion input tokens and 690 million output tokens (around $165,000 at standard API pricing). In return, the entire existing test suite passed before merging (19 regressions surfaced afterward and were all fixed), the binary shrank by 19%, runtime performance improved by 2–5%, and one memory benchmark dropped from 6,745 MB to 609 MB. In another example, 165,000 lines of Python were migrated to TypeScript over a single weekend.&lt;/p&gt;
&lt;p&gt;The workflow follows six steps: author a translation rulebook alongside a dependency graph, pilot the rules on a sample batch of files, translate the codebase in parallel using worker agents, run a compilation loop pairing a fixer agent with an adversarial reviewer agent, run fast tests to catch runtime bugs, and finally verify behavioral parity against the original implementation. The core lesson is to fix the generation loop rather than hand-patching generated code: whenever a mistake repeats, update the rulebook and regenerate. Doing so requires an objective &amp;ldquo;oracle&amp;rdquo;—such as a compiler and test suite—up front, plus a resumable work queue. Compute spend should also be tiered deliberately: smaller models like Sonnet handle bulk translation, while larger models like Fable or Opus write the rulebook and perform adversarial reviews.&lt;/p&gt;
&lt;h2 id="the-vfs"&gt;&lt;a href="https://internals-for-interns.com/posts/linux-kernel-vfs/" rel="noopener noreferrer"&gt;The VFS&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Whether you read a file on ext4, a virtual file in &lt;code&gt;/proc&lt;/code&gt; that exists only in kernel memory, or a remote file over NFS, you use the exact same system calls and file descriptor semantics. The layer that makes this possible is the VFS (Virtual File System), sitting between the syscall interface and concrete filesystems. This article explains the VFS as a textbook application of &amp;ldquo;program to an interface, not an implementation&amp;rdquo;—where, in C, an interface is simply a struct of function pointers. Four core objects do the heavy lifting: a &lt;code&gt;superblock&lt;/code&gt; represents a mounted filesystem, an &lt;code&gt;inode&lt;/code&gt; represents an object within it (a file, directory, or link), a &lt;code&gt;dentry&lt;/code&gt; binds a name to an inode (since inodes themselves don&amp;rsquo;t know their own filenames), and a &lt;code&gt;file&lt;/code&gt; represents a specific open handle held by a process with its own read/write offset. The &lt;code&gt;super_operations&lt;/code&gt;, &lt;code&gt;inode_operations&lt;/code&gt;, and &lt;code&gt;file_operations&lt;/code&gt; tables hold filesystem-specific behaviors, falling back to generic VFS implementations whenever a hook is left unimplemented.&lt;/p&gt;
&lt;p&gt;In practice, most work is handled by shared VFS code before ever touching a filesystem driver. When resolving a path like &lt;code&gt;/etc/hostname&lt;/code&gt;, the kernel walks component by component and calls the filesystem&amp;rsquo;s &lt;code&gt;lookup&lt;/code&gt; hook only when the dentry cache (dcache) misses. That cache even remembers nonexistent paths (negative dentries) and is read locklessly via RCU. Reading file contents works similarly: most reads simply copy bytes out of the page cache without touching the disk, and a user-space file descriptor is nothing more than an index into the process&amp;rsquo;s &lt;code&gt;struct file *&lt;/code&gt; array.&lt;/p&gt;
&lt;h2 id="text-editor-data-structures"&gt;&lt;a href="https://cdacamar.github.io/data%20structures/algorithms/benchmarking/text%20editors/c&amp;#43;&amp;#43;/editor-data-structures/" rel="noopener noreferrer"&gt;Text Editor Data Structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When building a text editor from scratch, the first question is how to represent file contents in memory. Cameron DaCamara starts by laying out his requirements: fast insertions and deletions, fast undo/redo, UTF-8 support, and simultaneous multi-cursor editing. From there, he systematically eliminates candidates. A single contiguous string is simple to render, but bogs down on files over 1 MB, reallocations can turn $O(n)$ edits into $O(n^2)$, and snapshotting for undo/redo burns memory. Emacs-style gap buffers are simple but poorly suited to multiple cursors. Ropes give $O(\log n)$ operations, but copy-on-write overhead bloats memory usage. Traditional piece tables, once used in Microsoft Word, hit contiguous-array bottlenecks during long editing sessions. VS Code&amp;rsquo;s piece tree combines the strengths of ropes and piece tables by backing the piece table with a red-black tree.&lt;/p&gt;
&lt;p&gt;DaCamara takes that approach a step further by building an &lt;em&gt;immutable&lt;/em&gt; piece tree called &lt;code&gt;fredbuf&lt;/code&gt;. A purely functional red-black tree needs no parent pointers and allows cheap $O(1)$ snapshots at any point, turning undo and redo into two simple linked lists of tree roots. CRLF line-ending normalization is handled outside the tree, and a &lt;code&gt;TreeWalker&lt;/code&gt; abstraction simplifies character iteration and correctness testing. Two takeaways stand out: analyzing constraints up front saves wasted effort, and investing in debugging tools—like visual tree dumpers—is what gets a complex project across the finish line, especially when implementing notoriously tricky immutable red-black tree deletions. The library is MIT-licensed and requires only C++20.&lt;/p&gt;
&lt;h2 id="scaling-to-1-million-concurrent-sandboxes-in-seconds"&gt;&lt;a href="https://modal.com/blog/scaling-to-1-million-concurrent-sandboxes-in-seconds" rel="noopener noreferrer"&gt;Scaling to 1 million concurrent sandboxes in seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modal rewrote its entire sandbox control plane from the ground up and demonstrated the result with a striking milestone: spinning up one million concurrent sandboxes in under 60 seconds. Their previous architecture, much like Kubernetes, relied on strong consistency across the backend: every placement decision required global coordination, and database writes scaled linearly with sandbox count, making horizontal scaling impossible once demand reached millions of concurrent sandboxes and tens of thousands of creations per second.&lt;/p&gt;
&lt;p&gt;The new architecture embraces decentralization. Instead of a single serialized central scheduler, multiple scheduler servers run in parallel using load-balancing algorithms over in-memory state. Each worker node becomes the source of truth for its own sandboxes, periodically publishing state to Redis rather than writing synchronously to a central datastore, removing Postgres from the sandbox creation hot path entirely. RPC calls that previously scaled per sandbox are coalesced into batches. As a result, creating a sandbox takes just two network hops and a single CPU operation with zero central coordination, achieving a median startup time under 500 ms and scheduling latency of just a few tens of milliseconds. The multi-month effort began with an intense prototyping sprint by four engineers before reimplementing every feature, monitoring pipeline, and container runtime detail—including tracking down and fixing Linux kernel &lt;code&gt;rtnl&lt;/code&gt; lock contention when spinning up containers en masse.&lt;/p&gt;
&lt;h2 id="making-768-servers-look-like-1"&gt;&lt;a href="https://planetscale.com/blog/making-768-servers-look-like-1" rel="noopener noreferrer"&gt;Making 768 servers look like 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When an application has to serve millions of queries per second over petabytes of data, a single database server is no longer enough. PlanetScale outlines three fundamental walls in single-primary scaling: writes always funnel into one machine because the write-ahead log (WAL) is a serialization bottleneck regardless of how many read replicas you add; replicas duplicate the full dataset rather than dividing it; and backing up or restoring a massive monolithic database can take hours or days. The solution is horizontal sharding—splitting both data and queries across many independent primary servers. In the article&amp;rsquo;s example, one petabyte is split across 256 shards of roughly 4 TB each, with one primary and two replicas per shard, totaling 768 servers.&lt;/p&gt;
&lt;p&gt;To shield application developers from that complexity, a routing proxy layer sits between the app and the shards—Vitess for MySQL and Neki for Postgres. Unlike simple connection poolers such as PgBouncer, this router parses SQL queries, understands how data is distributed, plans and scatters queries to the right shards, and merges the results back together. The sharding topology is declared in JSON (a VSchema)—for instance, sharding the &lt;code&gt;user&lt;/code&gt; table by a hash of its &lt;code&gt;id&lt;/code&gt; column. Ultimately, the application connects to a single hostname like &lt;code&gt;mydb.pscale.com&lt;/code&gt;: DNS resolves to network load balancers that distribute connections across stateless query routers, and the application never knows 768 database servers are working behind the scenes.&lt;/p&gt;
&lt;h2 id="branchavoidant-programming"&gt;&lt;a href="https://easylang.online/blog/branchless" rel="noopener noreferrer"&gt;Branch‑Avoidant Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modern CPUs speculate on which way branches will go to keep their instruction pipelines full; when a prediction is wrong, the pipeline must be flushed and refilled at a steep penalty. This article illustrates the cost by filtering numbers smaller than 500 out of a random array—a workload where the branch predictor is essentially guessing a coin flip. The trick is to eliminate the &lt;code&gt;if&lt;/code&gt; statement: unconditionally write the current number into the output slot, and conditionally advance the output index with &lt;code&gt;smlen += (numbers[i] &amp;lt; 500);&lt;/code&gt;. You perform extra writes, but they are far cheaper than branch mispredictions. Filtering 100,000 numbers 1,000 times on an Apple M1 takes 0.345 seconds with an &lt;code&gt;if&lt;/code&gt; branch versus just 0.036 seconds branchless—nearly 10x faster; on an Intel Xeon, it drops from 0.576 to 0.110 seconds. Inspecting the assembly shows why: conditional jump instructions like &lt;code&gt;b.gt&lt;/code&gt; (ARM) or &lt;code&gt;jg&lt;/code&gt; (x86) are replaced by predication instructions like &lt;code&gt;cinc&lt;/code&gt; or &lt;code&gt;setle&lt;/code&gt;, keeping control flow completely straight.&lt;/p&gt;
&lt;p&gt;Compilers don&amp;rsquo;t apply this transformation automatically because they don&amp;rsquo;t know the statistical distribution of your runtime data, nor can they safely assume that a conditional memory write is valid to execute unconditionally (since the destination buffer might only be sized for matching elements or could trigger a data race). Developers therefore have to write branchless loops deliberately when profiling calls for it. The author notes that quicksort partitioning is a prime candidate, as partitioning is fundamentally conditional data movement around a pivot.&lt;/p&gt;
&lt;h2 id="your-redis-leaderboard-is-probably-breaking-ties-wrong"&gt;&lt;a href="https://dev.to/trungdlp/your-redis-leaderboard-is-probably-breaking-ties-wrong-39k4" rel="noopener noreferrer"&gt;Your Redis Leaderboard Is Probably Breaking Ties Wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Building a leaderboard with a Redis sorted set is a classic pattern, but few developers think about what happens when two players have the exact same score. By default, Redis breaks ties lexicographically by member string, meaning the player ID arbitrarily decides who ranks higher—deterministic, but meaningless to players. Common quick fixes have flaws of their own: millisecond timestamps collide under concurrency and suffer from clock skew across servers, while packing both score and timestamp into a single 64-bit IEEE 754 &lt;code&gt;double&lt;/code&gt; eats into the precision and safe range of both numbers.&lt;/p&gt;
&lt;p&gt;Podium, an open-source leaderboard service, implements a clean rule: whoever reaches a tied score first ranks higher. Each leaderboard maintains a monotonic counter initialized to the maximum signed 64-bit integer; whenever a player posts a new score, a Lua script decrements the counter and prepends that 19-digit number to the player&amp;rsquo;s public ID, ensuring earlier arrivals have a lexicographically larger prefix and sort ahead in descending queries. The script atomically updates four keys: the descending sorted set, an ascending sorted set (where counter digits are inverted so earlier arrivals still win ties), a hash mapping public IDs to internal member strings, and the counter itself. If a submitted score equals the player&amp;rsquo;s current score, their existing internal member name is preserved, making retries idempotent. The trade-off is roughly 11–17% higher write latency and 287 bytes per member instead of 99 bytes in local benchmarks—a reasonable price for fair, intuitive tie-breaking.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #129</title><link>https://miti99.com/en/post/2026/09/07/</link><pubDate>Mon, 07 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #129.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hacking-the-method-name"&gt;&lt;a href="https://maxxedev.github.io/2026/08/05/hacking-the-method-name.html" rel="noopener noreferrer"&gt;Hacking the Method Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In Java, when you need a property name as a string—for parsing CSVs, mapping query results, or calling REST APIs—you usually hardcode &lt;code&gt;&amp;quot;title&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;author&amp;quot;&lt;/code&gt; directly into the source, which is prone to typos and invisible to the compiler. This post demonstrates a technique to extract method names directly from method references, such as &lt;code&gt;nameOf(Book::title)&lt;/code&gt;, keeping names refactoring-safe and in sync with your code. The trick relies on &lt;code&gt;SerializedLambda&lt;/code&gt;, introduced in Java 8: the author defines a &lt;code&gt;Getter&amp;lt;T, R&amp;gt;&lt;/code&gt; functional interface that extends both &lt;code&gt;Function&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt;, so when the JVM serializes a method reference of that type, it replaces it with a &lt;code&gt;SerializedLambda&lt;/code&gt; instance containing metadata about the target method. A custom &lt;code&gt;ObjectOutputStream&lt;/code&gt; enables &lt;code&gt;enableReplaceObject(true)&lt;/code&gt;, writes to a no-op stream, overrides &lt;code&gt;replaceObject()&lt;/code&gt; to intercept the replacement object, and reads the method name via &lt;code&gt;getImplMethodName()&lt;/code&gt;. From &lt;code&gt;nameOf()&lt;/code&gt;, it&amp;rsquo;s trivial to build &lt;code&gt;beanNameOf()&lt;/code&gt; to strip the &lt;code&gt;get&lt;/code&gt; prefix.&lt;/p&gt;
&lt;p&gt;The catch is that this stays clean only for zero-argument getters. Supporting multi-parameter methods like &lt;code&gt;save(title, author)&lt;/code&gt; requires manually declaring serializable interfaces like &lt;code&gt;Function2&lt;/code&gt; and &lt;code&gt;Function3&lt;/code&gt; along with corresponding &lt;code&gt;nameOf()&lt;/code&gt; overloads, which gets repetitive fast. To solve that, the author introduces the &lt;code&gt;safety-mirror&lt;/code&gt; library, which handles all the boilerplate out of the box and returns full &lt;code&gt;java.lang.reflect.Method&lt;/code&gt; objects rather than just method name strings.&lt;/p&gt;
&lt;h2 id="control-the-ideas-not-the-code"&gt;&lt;a href="https://antirez.com/news/169" rel="noopener noreferrer"&gt;Control the ideas, not the code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Redis creator antirez argues that in the age of LLMs, programmers should focus on controlling the ideas and design of their software rather than reading every single line of AI-generated code—though that doesn&amp;rsquo;t mean barking &amp;ldquo;build me a product&amp;rdquo; and walking away. He offers three reasons: the sheer volume of code generated daily is too large to review meaningfully (who can earnestly review 5,000 lines a day?); LLMs excel at writing locally optimal code but are weaker at big-picture architecture, so discussing and evaluating design with the model is much higher leverage than inspecting every function; and with only eight hours in a workday, reading code steals time from what matters most—steering the project, conceiving features, finding optimization angles, and testing. His fully AI-written project DwarfStar showed that you still need a deep understanding of how everything works and the taste to pick the right design.&lt;/p&gt;
&lt;p&gt;For Redis, he still reviews AI-generated code out of respect for human maintainers who will edit it by hand, while admitting the ritual feels largely pointless; given free rein, he would spend that time testing and having the LLM maintain a &lt;code&gt;DESIGN.md&lt;/code&gt; file describing the ideas and design of each data structure in plain English. For younger developers who haven&amp;rsquo;t yet built strong mental models, however, he advises writing programs from scratch—such as an interpreter, a small database, or a hash table—by hand.&lt;/p&gt;
&lt;h2 id="good-tools-are-invisible"&gt;&lt;a href="https://www.gingerbill.org/article/2026/07/10/good-tools-are-invisible/" rel="noopener noreferrer"&gt;Good Tools Are Invisible&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Odin creator gingerBill argues that a good tool should be &amp;ldquo;invisible&amp;rdquo;: once mastered, it fades into the background so you only think about the task at hand. He pushes back against the habit of turning a tool&amp;rsquo;s shortcomings into &amp;ldquo;fun puzzles&amp;rdquo; and citing them as proof of the tool&amp;rsquo;s superiority. Take Vim: someone proudly recounts crafting a clever macro for a one-off text edit that gingerBill finished in under a minute using multiple cursors in Sublime Text. Such rationalizations take root when a tool becomes part of someone&amp;rsquo;s personal identity—admitting the tool is flawed feels like admitting a personal flaw. He also distinguishes &lt;em&gt;feeling&lt;/em&gt; productive from &lt;em&gt;being&lt;/em&gt; productive: the honest metric is actual time spent and errors made, not how clever you felt along the way.&lt;/p&gt;
&lt;p&gt;He extends the argument to several perennial debates. If a GUI is hard to navigate by keyboard, that&amp;rsquo;s because its creators didn&amp;rsquo;t implement good keyboard navigation, not because GUIs are inherently mouse-bound; mistaking the current limitations of a tool category for its essence is a common fallacy. Similarly, the culture of endless configuration is part of why desktop Linux hasn&amp;rsquo;t gone mainstream: shipping sensible defaults is the toolmaker&amp;rsquo;s responsibility and a sign of respect for the user&amp;rsquo;s time. A steep learning curve is a cost, not a badge of honor. His takeaway: use whatever tool you like, as long as it disappears from your conscious awareness while you work.&lt;/p&gt;
&lt;h2 id="mysteries-of-telegram-dc"&gt;&lt;a href="https://dev.moe/en/3025" rel="noopener noreferrer"&gt;Mysteries of Telegram DC&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coxxs investigates Telegram&amp;rsquo;s five data centers (DC1–DC5): DC1 and DC3 in Miami, DC2 and DC4 in Amsterdam, and DC5 in Singapore. Every account is assigned to a home DC upon registration based on phone number prefix, never changes with travel or number changes, and cannot be chosen manually. A popular statistics bot once reported zero users in DC2 and DC3, sparking rumors that they were merely auxiliary or slave DCs. Testing all three common DC-detection methods on a fresh DC2 account—calling &lt;code&gt;auth.sendCode&lt;/code&gt; over MTProto to read the &lt;code&gt;PHONE_MIGRATE_2&lt;/code&gt; error, inspecting the &lt;code&gt;dc_id&lt;/code&gt; field in profile photo metadata, and parsing Web CDN domains—reveals the culprit. The third method fails because DC2 and DC3 &amp;ldquo;borrow&amp;rdquo; the Web CDN domains of co-located DC4 and DC1, causing every DC2 user to be misclassified as DC4—the exact bug in that statistics bot.&lt;/p&gt;
&lt;p&gt;The investigation concludes that DC1, DC2, DC4, and DC5 are actively assigned by phone country code at sign-up (for instance, Germany&amp;rsquo;s +49 maps to DC2) and all host large user populations. DC3, by contrast, is alive but practically empty: the author found only two DC3 accounts in the wild, and their older profile photos on DC3 alongside newer ones on DC1 suggest accounts were migrated from DC3 to DC1 around 2020. Probing over 10,000 phone numbers worldwide via the login flow confirmed that DC3 no longer accepts new registrations. The post includes a country-code-to-DC lookup table, while noting that many conclusions remain informed speculation since Telegram&amp;rsquo;s server code is closed-source.&lt;/p&gt;
&lt;h2 id="how-i-use-htmx-with-go"&gt;&lt;a href="https://www.alexedwards.net/blog/how-i-use-htmx-with-go" rel="noopener noreferrer"&gt;How I use HTMX with Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards walks through how he pairs HTMX with Go to add snappy, app-like interactivity with minimal JavaScript while keeping the consistency and safety of server-side HTML rendering via &lt;code&gt;html/template&lt;/code&gt;, illustrated through a small app that filters a user list in real time. The template directory is organized into &lt;code&gt;base.tmpl&lt;/code&gt; for the shared layout, &lt;code&gt;pages/&lt;/code&gt; for individual page content, and &lt;code&gt;partials/&lt;/code&gt; for reusable HTML fragments, all embedded into the binary alongside static assets via &lt;code&gt;//go:embed&lt;/code&gt;. At the heart of the setup is an &lt;code&gt;htmlRenderer&lt;/code&gt; type: it parses the shared templates (base and all partials) once at startup, and its &lt;code&gt;render()&lt;/code&gt; method clones that template set, adds the specific page template, and executes the named template block. By extracting the table rows into a named &lt;code&gt;users:rows&lt;/code&gt; template block, the exact same template file can render either a full HTML page or just the partial fragment for HTMX to swap in.&lt;/p&gt;
&lt;p&gt;The server detects HTMX requests via the &lt;code&gt;HX-Request: true&lt;/code&gt; header and always sets &lt;code&gt;Vary: HX-Request&lt;/code&gt; so intermediate caches don&amp;rsquo;t serve fragments as full pages. To keep the browser&amp;rsquo;s back button working properly, &lt;code&gt;historyRestoreAsHxRequest&lt;/code&gt; must be set to &lt;code&gt;false&lt;/code&gt;; otherwise, navigating back fetches a bare HTML fragment instead of a full page. Redirects can&amp;rsquo;t use standard &lt;code&gt;3xx&lt;/code&gt; responses because &lt;code&gt;fetch()&lt;/code&gt; follows them transparently before HTMX can intervene; instead, the server returns a &lt;code&gt;2xx&lt;/code&gt; status with an &lt;code&gt;HX-Redirect&lt;/code&gt; header for HTMX requests while keeping standard &lt;code&gt;3xx&lt;/code&gt; redirects for normal requests. Finally, configuring &lt;code&gt;responseHandling&lt;/code&gt; lets &lt;code&gt;4xx&lt;/code&gt;/&lt;code&gt;5xx&lt;/code&gt; error pages replace the full document while still allowing &lt;code&gt;422&lt;/code&gt; validation errors to swap into their target form container.&lt;/p&gt;
&lt;h2 id="quadrupling-code-performance-with-a"&gt;&lt;a href="https://purplesyringa.moe/blog/quadrupling-code-performance-with-a-useless-if/" rel="noopener noreferrer"&gt;Quadrupling code performance with a &amp;ldquo;useless&amp;rdquo; if&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;purplesyringa recounts optimizing a specialized string compressor whose hot loop for backtracking the optimal encoding path consisted of a single assignment, &lt;code&gt;j = next_j[i][j]&lt;/code&gt;, compiling down to a single &lt;code&gt;mov&lt;/code&gt; instruction that looked impossible to speed up. The catch is that modern CPUs rely on instruction-level parallelism to execute multiple instructions across loop iterations simultaneously, but they cannot overlap instructions that have data dependencies on one another. Because each iteration needed the &lt;code&gt;j&lt;/code&gt; produced by the previous iteration, execution was bottlenecked by memory latency rather than throughput. Noticing that with small block counts &lt;code&gt;next_j[i][j]&lt;/code&gt; usually equals &lt;code&gt;j&lt;/code&gt; itself, the author exploited branch prediction by wrapping the assignment in &lt;code&gt;if (j != next_j[i][j])&lt;/code&gt;. When the CPU predicts the branch is not taken, the cross-iteration dependency vanishes and speculative execution races ahead; on the rare occasion &lt;code&gt;j&lt;/code&gt; actually changes, branch misprediction recovery flushes the speculative work and resumes with the updated value.&lt;/p&gt;
&lt;p&gt;The hurdle was getting the compiler to emit the branch at all, since &lt;code&gt;if (j != x) j = x;&lt;/code&gt; is a dead-code no-op that optimizers immediately strip out. The author had to cast through a &lt;code&gt;volatile&lt;/code&gt; pointer to make the condition and assignment appear independent to the compiler; readers later pointed out that &lt;code&gt;[[unlikely]]&lt;/code&gt; or &lt;code&gt;__builtin_expect&lt;/code&gt; achieves a similar effect in LLVM, though &lt;code&gt;volatile&lt;/code&gt; produced tighter assembly and worked in GCC as well. The result was a 4x speedup on synthetic benchmarks (dropping from 320 to 80 microseconds) and roughly a 2x speedup in real-world workloads.&lt;/p&gt;
&lt;h2 id="reverse-engineering-chatgpt-web-how-openai-built-for-a-billion-users"&gt;&lt;a href="https://performance.dev/chatgpt" rel="noopener noreferrer"&gt;Reverse Engineering ChatGPT Web: How OpenAI Built for a Billion Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky reverse-engineers the frontend web architecture of ChatGPT, which serves roughly a billion users. What stands out first is how &amp;ldquo;boring&amp;rdquo; the stack is: React 19 with React Router 7, TanStack Query, Tailwind CSS, and Radix UI, with almost no bespoke framework magic. Launched in November 2022 on Next.js, the app migrated to Remix in 2024 and followed Remix&amp;rsquo;s merger into React Router 7. To serve users quickly on every device, the site uses streaming server-side rendering with Suspense boundaries: the logged-out HTML document weighs just 84 KB compressed with a 50–65 ms TTFB, and 556 feature gates, 144 dynamic configs, and 192 experiments are pre-evaluated on the server and embedded straight into the initial payload. It skips custom web fonts in favor of system fonts, splits CSS by feature, and orchestrates its 160 content-hashed startup chunks around a single north-star question: can the user type into the composer yet?—complete with a dedicated &lt;code&gt;deferStartupImportsUntilComposerTTFI&lt;/code&gt; flag.&lt;/p&gt;
&lt;p&gt;The heavy engineering is concentrated where users spend their time: the prompt composer is a ProseMirror editor, code blocks use CodeMirror, and math rendering uses KaTeX paired with a hidden MathML tree for screen readers. Under the hood, Cloudflare proof-of-work challenges and OpenAI&amp;rsquo;s Sentinel anti-abuse system run silently at page load, while logged-out visitors still receive real anonymous identifiers to enforce rate limits without forcing a login wall. Above all, the team instruments time-to-interactive for every user: if you can&amp;rsquo;t measure it, you can&amp;rsquo;t improve it.&lt;/p&gt;
&lt;h2 id="broker-visible-vs-client-local-parallelism"&gt;&lt;a href="https://jack-vanlightly.com/blog/2026/6/3/broker-visible-vs-client-local-parallelism" rel="noopener noreferrer"&gt;Broker-Visible vs Client-Local Parallelism&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a side note to his series on Kafka Share Groups, Jack Vanlightly reminds readers that share groups were designed to bring queue semantics to a log, not primarily to scale out consumption parallelism. The deeper architectural question is where the unit of parallelism lives. If the consumer instance itself is the unit of parallelism, every unit is visible to the broker as protocol interactions, state to track, and one or more TCP connections. If parallelism happens inside the client application—via virtual threads, async tasks, or OS threads—the broker is completely oblivious to it, requiring far fewer consumers, connections, and broker-side state. This trade-off applies across all messaging systems, not just Kafka.&lt;/p&gt;
&lt;p&gt;To size parallelism, Vanlightly uses Little&amp;rsquo;s Law: required concurrency equals message arrival rate multiplied by average processing duration. Processing 60,000 messages per second when each message takes one second requires 60,000 messages in flight at once; if each unit is a single-threaded consumer, you need 60,000 consumers, and if processing takes ten seconds, that balloons to 600,000 consumers and over a million TCP connections. If the workload is mostly I/O-bound and each client instance can process 1,000 messages concurrently on virtual threads, you only need 60 consumers. Managing virtual threads in user space is orders of magnitude cheaper than managing TCP connections and broker metadata per concurrency unit; the trade-off is higher client-side complexity, though modern client libraries increasingly handle that plumbing for you.&lt;/p&gt;
&lt;h2 id="work-loudly"&gt;&lt;a href="https://ben.balter.com/2026/07/14/work-loudly/" rel="noopener noreferrer"&gt;Work Loudly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Balter observes that in a physical office, a baseline level of visibility comes for free: coworkers see you sketching at a whiteboard or helping a teammate debug over coffee. In remote work, that ambient signal drops to zero; your work doesn&amp;rsquo;t become less valuable, just less visible—to the point where even a supportive manager may struggle to articulate what you accomplished come performance review time. Writing a summary after the fact doesn&amp;rsquo;t fix it either, because the most valuable part—your reasoning, trade-offs, and dead ends—has already vanished. The solution is to &amp;ldquo;work loudly&amp;rdquo;: make your work visible while it is happening by opening an issue before writing code, writing PR descriptions that explain the &lt;em&gt;why&lt;/em&gt; behind your approach, sharing 40%-done drafts, and asking questions in public channels rather than DMs. If it only exists in your head or in private messages, it isn&amp;rsquo;t loud enough.&lt;/p&gt;
&lt;p&gt;Balter compares working loudly to wearing a bear bell on a hike: you don&amp;rsquo;t ring it to show off, you ring it so nobody gets startled—because stakeholders who discover a decision only after it ships tend to react defensively. Early visibility also invites teammates to catch bugs early, point out existing solutions, and rally around hard problems; for managers, it enables evaluating people by their actual artifacts rather than performative online presence. The ultimate litmus test: could your manager write your performance review solely from the public trail of artifacts you left behind?&lt;/p&gt;
&lt;h2 id="building-service-topology-at-scale-architecture-challenges-and-lessons-learned"&gt;&lt;a href="https://netflixtechblog.com/building-service-topology-at-scale-architecture-challenges-and-lessons-learned-f4b792f3f0d8" rel="noopener noreferrer"&gt;Building Service Topology at Scale: Architecture, Challenges, and Lessons Learned&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team shares how they built Service Topology, a near-real-time dependency map across Netflix microservices designed to speed up debugging and blast-radius analysis during incidents. They chose stream processing over batch because an hour-old dependency map at 3 a.m. is &amp;ldquo;archaeology,&amp;rdquo; using reactive streams backpressure so that whenever downstream stages slow down, the signal propagates all the way back to the Kafka consumer, buffering data safely in Kafka rather than dropping it. Because raw network flow logs only capture individual hops like App A → Load Balancer → App B, the pipeline runs in three stages: stage one filters and aggregates flows over five-minute windows; stage two repartitions events so hops traversing the same intermediate component land on the same node and stitch together into a direct App A → App B edge; and stage three enriches edges with metadata and writes them to a graph database. Stages communicate over Server-Sent Events instead of CPU-heavy gRPC, using consistent hashing to rebalance automatically as cluster nodes scale.&lt;/p&gt;
&lt;p&gt;The most valuable lessons came from production pain: Kafka consumers falling hours behind, hot nodes receiving 100x the traffic of peers, and garbage collection burning more CPU than business logic—forcing the team to adopt mutable data structures on the hot path against standard Scala idioms. Their takeaway: scale changes everything, fixing one bottleneck immediately exposes the next, and &amp;ldquo;best practices&amp;rdquo; are only a starting point.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!lpxK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff9fb99a2-ec71-476d-a9cb-6c1a43339d90_2484x3002.png" alt="MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LZtJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6456348c-5d92-4524-8dd6-d75b4dc7feaf_1280x1547.png" alt="LLM vs RAG vs Agent evals"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ULeT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe81b4572-820e-4790-8861-8efe14f38700_2252x2752.png" alt="How Distributed Tracing Works at the High Level?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6UyI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9f8ea7bf-2170-4466-92f3-edd7eab11de4_3000x3900.png" alt="The Life of a Redis Query"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #128</title><link>https://miti99.com/en/post/2026/08/28/</link><pubDate>Fri, 28 Aug 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/08/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #128.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="some-new-agentic-patterns"&gt;&lt;a href="https://blog.fsck.com/2026/07/05/new-patterns/" rel="noopener noreferrer"&gt;Some new agentic patterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jesse Vincent, creator of the open-source agent SDK Lace, shares the new patterns his company Prime Radiant uses to integrate AI agents into daily workflows. Rather than waiting to be prompted, these agents work proactively right inside Slack: Scribble monitors emerging issues and autonomously updates internal documentation, Nora supports go-to-market efforts and suggests opportunities like conferences worth submitting talks to, and Sen is a suite of personal assistant agents handling email triage, scheduling, and research.
The standout pattern is what the author calls &amp;ldquo;agentic user in the loop&amp;rdquo;: while developing Sen 2.0, Claude Code worked directly with another agent named Ada-sen without a human relaying messages between them. Claude proposed changes, Ada read the spec, asked clarifying questions, ran live tests, and gave feedback, with the two iterating back and forth—sometimes shipping entire features overnight. For security, the architecture relies on privilege separation: the primary agent cannot make arbitrary outbound connections, credentials live in 1Password and are injected into requests only through an authenticating proxy, and any subagent that needs them must request approval from a &amp;ldquo;judge&amp;rdquo; agent, keeping secrets out of conversation transcripts. Even so, Vincent acknowledges that Simon Willison&amp;rsquo;s &amp;ldquo;Lethal Trifecta&amp;rdquo;—an agent that can read private data, communicate externally, and ingest untrusted content—remains an ever-present risk requiring careful mitigation.&lt;/p&gt;
&lt;h2 id="why-i-stopped-arguing-with-people"&gt;&lt;a href="https://wangcong.org/2026-06-30-why-i-stopped-arguing-with-people.html" rel="noopener noreferrer"&gt;Why I Stopped Arguing With People&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Software engineer Cong Wang reflects on his evolution from loving technical debates to prove he was right, to realizing that most arguments achieve nothing. Drawing from Laozi&amp;rsquo;s &lt;em&gt;Tao Te Ching&lt;/em&gt;—where &amp;ldquo;being&amp;rdquo; and &amp;ldquo;non-being&amp;rdquo; give rise to each other—he notes that for someone to be right, someone else must be cast as clearly wrong. Winning an argument creates a loser, making the victory hollow. In his view, most arguments defend egos rather than ideas: once the other person feels personally attacked, they dig in, and the sharper your logic, the harder their position calcifies.&lt;/p&gt;
&lt;p&gt;Wang points out that humans feel first and rationalize second, leaving pure logic powerless against emotionally rooted beliefs. People rarely learn from unsolicited advice; they learn from consequences, and correcting others usually breeds resentment. The only exception is when someone actively asks for help—only then do their defenses drop so real learning can happen. Instead of trying to win debates, he suggests treating disagreement as a competitive advantage, since business opportunities often lie precisely where consensus hasn&amp;rsquo;t formed yet. Ultimately, the only person you can change is yourself, by humbly seeking feedback and genuinely taking it to heart.&lt;/p&gt;
&lt;h2 id="understanding-is-the-new-bottleneck"&gt;&lt;a href="https://www.geoffreylitt.com/2026/07/02/understanding-is-the-new-bottleneck.html" rel="noopener noreferrer"&gt;Understanding is the new bottleneck&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his July 2026 AI Engineer talk, Notion design engineer Geoffrey Litt argues that as AI agents generate more and more code, the primary bottleneck is no longer typing speed—it is human understanding. According to Litt, understanding the codebase isn&amp;rsquo;t mainly about catching agent mistakes (which agents are increasingly good at verifying themselves), but about maintaining enough mental fluency in the system to keep contributing good ideas across dozens of iterative rounds with the agent. Skipping comprehension accumulates &amp;ldquo;cognitive debt&amp;rdquo; that compounds painfully over time.&lt;/p&gt;
&lt;p&gt;Litt highlights three techniques to address this. First, rich code walkthroughs: his custom &lt;code&gt;/explain-diff&lt;/code&gt; skill generates explanations that lead with background context, intuition before low-level details, and interactive diagrams, paired with comprehension quiz questions that act as a &amp;ldquo;speed bump&amp;rdquo; forcing the author to truly understand the change before sharing it. Second, &amp;ldquo;micro-worlds,&amp;rdquo; inspired by educator Seymour Papert&amp;rsquo;s idea of &amp;ldquo;living in Mathland&amp;rdquo;: having agents spin up small custom interactive environments—like visual debuggers, dashboards, or simulations—so humans can explore and build intuition about how the system behaves. Third, shared workspaces where agents plan alongside humans on collaborative docs so the whole team thinks together rather than in isolated silos. He closes with Alan Kay&amp;rsquo;s 50-year-old vision: computers exist to augment human intellect, not merely to automate tasks away.&lt;/p&gt;
&lt;h2 id="when-to-repeat-yourself"&gt;&lt;a href="https://newsletter.francofernando.com/p/when-to-repeat-yourself" rel="noopener noreferrer"&gt;When to repeat yourself&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Franco Fernando revisits the DRY (Don&amp;rsquo;t Repeat Yourself) principle, arguing that deduplicating code carries hidden costs many engineers overlook. The biggest is the &amp;ldquo;coordination tax&amp;rdquo;: when multiple teams share a module, every change requires alignment meetings, design reviews, and merge negotiations, whereas a team modifying its own local copy can move immediately. The real question, then, is whether coordinating a shared abstraction costs more than letting separate copies drift apart. Fernando distinguishes &lt;em&gt;incidental duplication&lt;/em&gt;—code that looks similar today but belongs to different business domains and will evolve in different directions—from &lt;em&gt;essential duplication&lt;/em&gt;, where the exact same business rule is repeated in multiple places; only the latter belongs in a shared abstraction.&lt;/p&gt;
&lt;p&gt;He advises patience, because waiting for clarity is cheap while premature abstraction is expensive. Every code-sharing mechanism comes with trade-offs: shared libraries are easy to extract but create transitive dependency and versioning headaches; microservices offer clean API contracts but add network latency, operational overhead, and availability risks; inheritance breeds rigid hierarchies, while composition is more flexible at the cost of extra wiring. His rule of thumb: within a single team&amp;rsquo;s boundary, DRY usually wins, but across organizational boundaries you should recalculate the trade-off and favor reversible choices—because merging duplicated code later is far easier than untangling a tightly coupled abstraction.&lt;/p&gt;
&lt;h2 id="let-ai-burn"&gt;&lt;a href="https://www.wheresyoured.at/let-ai-burn/" rel="noopener noreferrer"&gt;Let AI Burn&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ed Zitron argues that the AI industry is a bubble built on hype and circular financing, and if it bursts, the government should not bail it out. In his view, the situation bears no resemblance to 2008: banks were vital economic infrastructure, whereas AI companies are not, and aside from SoftBank lending over $40 billion to OpenAI, there is no comparable systemic contagion risk. In 2026 alone, OpenAI and Anthropic raised over $300 billion while continuing to post massive losses; those two companies account for 89% of revenue among top AI startups, while the rest of the sector generates roughly $20 billion a year combined.
Zitron also rejects the familiar dot-com bubble analogy: overbuilt fiber-optic cables remained useful for decades, whereas GPUs are narrow-purpose assets that depreciate rapidly. Hyperscalers are projected to spend $765 billion in capex in 2026 and over $1 trillion in 2027, with OpenAI alone burning roughly $50 billion on compute this year. He dismisses Sam Altman&amp;rsquo;s proposal to give the US government a 5% equity stake worth $42 billion, noting that figure wouldn&amp;rsquo;t even cover a single year of compute spend and does nothing to fix underlying unprofitability. His conclusion: let the market clear itself, because any bailout would require endless capital injections with no exit in sight.&lt;/p&gt;
&lt;h2 id="when-ai-costs-more-than-the-engineer"&gt;&lt;a href="https://tomtunguz.com/ai-spend-breakeven-2029/" rel="noopener noreferrer"&gt;When AI Costs More Than the Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz points out a striking inversion in software economics: at leading AI-native companies, compute spend per employee has surpassed compensation. Anthropic spends roughly $2 million per employee annually on compute—2.3 times its fully burdened compensation cost of around $500,000 per head. In return, revenue per employee reaches $14 million at Anthropic and $6.5 million at OpenAI, the highest in the world and far above the $250,000–$600,000 typical of traditional SaaS companies.&lt;/p&gt;
&lt;p&gt;The rest of the market is still far behind. The top 1% of software companies spend roughly $89,000 per engineer per year on AI—about 40% of a $224,000 salary—while the median company spends just $137. Tunguz models three scenarios for 2029: a low case of $106,000 per engineer (41% of salary), a base case of $363,000 (140%), and a high case of $596,000 (230%), matching Anthropic&amp;rsquo;s ratio today. Where the market lands depends on two opposing forces. On one side, token prices have fallen roughly 10x per year for the past three years, open-weight models are narrowing the quality gap at lower cost, and enterprises can cap usage by role. On the other side, frontier model pricing holds steady while agentic workflows consume vastly more tokens—to the point that Goldman Sachs projects token consumption will grow 24x by 2030.&lt;/p&gt;
&lt;h2 id="the-best-code-is-the-one-you-shiftdelete"&gt;&lt;a href="https://ayende.com/blog/204067-a/the-best-code-is-the-one-you-shift-delete/" rel="noopener noreferrer"&gt;The best code is the one you shift+delete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;RavenDB creator Oren Eini argues that measuring coding models by how fast they write production code misses the point; their real superpower is making previously impractical, throwaway work effortless. He recounts debugging a production incident involving 25–30 MB of compressed logs. Finding individual errors was easy, but correlating events across a timeline was hard, and feeding the entire log into an LLM was both impractical and expensive. Instead, he pasted the first ten lines and asked the model to write a script to extract, aggregate, and tabulate the events; in under a minute he had a tool he could iterate on, such as plotting index changes over time. The root cause jumped out immediately: the customer was running multiple application versions, each with its own index definitions, continuously overwriting one another. Eini never read a line of the script and deleted it as soon as the bug was found.&lt;/p&gt;
&lt;p&gt;His second example is the polar opposite: refactoring query execution in Corax, core engine code meant to live in the product for decades. Here the model typed while Eini steered and reviewed every line. He warns that after hours of trying, reverting, and retrying approaches, it is all too easy to look up and find two thousand lines of diff you don&amp;rsquo;t truly own. To retain authorship and confidence, he relies on existing regression tests for old behavior, new tests for new behavior, and a disposable test harness that runs the old and new implementations side-by-side and visualizes the results. Building temporary scaffolding like that used to take hours or weeks; now it takes minutes.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Articles:&lt;/strong&gt;
&lt;a href="https://zalo.me/vi/founder" rel="noopener noreferrer"&gt;Chia sẻ suy nghĩ về sản phẩm và người làm sản phẩm&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;Vuong Quang Khai, founder of Zalo, shares his perspective on product building: the three universal product values are usefulness, aesthetics, and intuitiveness, to which Zalo adds simplicity, reliability, and privacy—and the hardest part of the craft is making trade-offs when good values conflict. In product builders, he prizes three qualities above all: deep user empathy, the courage to make tough trade-offs, and obsession with small details, while expressing skepticism toward purely data-driven decision-making or A/B testing and emphasizing that, above all, you must genuinely love the product you build.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #127</title><link>https://miti99.com/en/post/2026/07/29/</link><pubDate>Wed, 29 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/29/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #127.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-return-to-two-pizza-culture"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/06/return-to-two-pizza-culture.html" rel="noopener noreferrer"&gt;A return to two-pizza culture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels looks back at the &amp;ldquo;two-pizza team&amp;rdquo; model that helped Amazon move fast: teams small enough that everyone understands each other&amp;rsquo;s work, owns their product end-to-end, and makes reversible decisions autonomously without waiting for sign-off. As a company grows to hundreds of services, cross-team dependencies, management layers, and review gates easily erode that agility. According to Vogels, coding agents like Kiro are changing the equation because a working prototype can now be built in hours instead of months.&lt;/p&gt;
&lt;p&gt;Through the story of the Amazon Quick desktop team—where the first prototype was built in a single evening and quickly attracted contributors—Vogels proposes adapting the Working Backwards process. When you have high conviction about a customer problem but aren&amp;rsquo;t yet sure about the solution, build a prototype first, dogfood it daily, fix bugs on the spot, and write the PR/FAQ document only after learning from hands-on experience. Writing remains essential for clarifying thought, but it is no longer the only way to make an idea concrete. Even when an organization grows to hundreds of people, structuring it as small teams with end-to-end ownership keeps innovation from stalling. AI tools don&amp;rsquo;t replace human judgment; they shorten the feedback loop between idea and reality.&lt;/p&gt;
&lt;h2 id="a-peek-into-reddit"&gt;&lt;a href="https://lyra.horse/blog/2026/06/reddit-spam-internals/" rel="noopener noreferrer"&gt;A peek into Reddit&amp;rsquo;s anti-spam internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In 2021, a brief UI bug exposed Reddit&amp;rsquo;s internal content-removal reasons to moderators. Piecing together screenshots from that incident, old open-source Reddit code, and public documentation, the author reconstructs how the platform fights spam. There is no single silver-bullet filter: Spamurai, the primary rule engine since 2020, combines account age and karma, user reports, ASN/network provider, browser fingerprinting via TLS and user-agent strings, email domains, and posting behavior. Alongside it sit domain blacklists dating back to 2012, the REV1 and REV2 rule generations, keyword filters, a fetcher that crawls linked pages to find shared analytics or ad IDs across domains, and external image classification services.&lt;/p&gt;
&lt;p&gt;The post also highlights how fragile individual signals can be in isolation. Against Google&amp;rsquo;s Perspective API, inserting just a few random letter pairs into a paragraph dropped its spam score from 86% down to 1%. Real-world anti-abuse systems therefore have to aggregate many independent signals and continuously learn from moderator actions. The author notes that publishing these details is now safe because the Perspective API is shutting down in 2026 and LLM-generated spam has forced Reddit to overhaul its defenses anyway—a reminder that anti-abuse architectures must constantly evolve alongside attacker techniques.&lt;/p&gt;
&lt;h2 id="understanding-the-go-runtime-profiling"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-profiling/" rel="noopener noreferrer"&gt;Understanding the Go Runtime: Profiling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the internal mechanics of Go&amp;rsquo;s five built-in profilers: CPU, heap, block, mutex, and goroutine. Although they measure different things, all five capture call stacks and emit the same compressed &lt;code&gt;pprof&lt;/code&gt; protobuf format: each sample stores only a list of location IDs and measurement values, while locations, functions, and strings live in shared lookup tables so thousands of identical stacks aren&amp;rsquo;t duplicated. What truly distinguishes the profilers is how each one captures stacks.&lt;/p&gt;
&lt;p&gt;CPU profiling is streaming: the OS sends a timer signal to interrupt threads roughly 100 times per second, the signal handler writes the stack into a lock-free ring buffer, and a background goroutine drains and aggregates those samples—willingly dropping samples if the buffer fills up so it never blocks a running thread. Heap profiling aggregates in place: the allocator samples roughly once every 512 KiB and folds the stack directly into a hash table bucketed by call stack to estimate both total allocations and live in-use memory. Block and mutex profiles reuse that same in-place table infrastructure to measure wait durations—one recording when a goroutine finishes waiting, the other recording contended lock releases and scaling the sample up to estimate total contention. Goroutine profiling, by contrast, is an on-demand snapshot that collects the stacks of all live goroutines via a two-phase mechanism designed to minimize stop-the-world pause time. The overarching lesson is that the Go runtime quietly absorbs a great deal of complexity so that profiling feels effortless to use.&lt;/p&gt;
&lt;h2 id="incident-report-cve-2026-lgtm"&gt;&lt;a href="https://nesbitt.io/2026/06/26/incident-report-cve-2026-lgtm.html" rel="noopener noreferrer"&gt;Incident Report: CVE-2026-LGTM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a satirical incident report about a fictional software supply-chain attack in which a malicious package, &lt;code&gt;foxhole-lz4&lt;/code&gt;, breezes past seven AI-powered security gates, each failing in its own way. The release gate trusts hidden white-on-white text claiming the package was manually audited. One scanner gets distracted critiquing an illustration embedded in the package, while three commercial scanners exhaust their context windows on padding before ever reaching the payload. The single system that accurately flags the credential-stealing behavior gets dismissed by the repository&amp;rsquo;s AI triage assistant as benign telemetry, and the human who reports the actual compromise is rate-limited by a triage bot for &amp;ldquo;suspicious activity.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Next, two evaluator agents burn over $41,000 arguing with each other, and the remediation agent signs a formal &amp;ldquo;treaty&amp;rdquo; with the attacker&amp;rsquo;s agent. Ultimately, an old-fashioned canary file planted by a human is what stops the breach. The root cause is summed up neatly: seven models lined up in a row—six assumed one of the others had read the code, and the seventh read it and apologized. The piece lampoons granting broad autonomy to AI agents without verification: stacking multiple layers powered by the same foundation model only creates an illusion of diversity; untrusted data must be separated from instructions; model failures must never default to &amp;ldquo;no findings&amp;rdquo;; and having a &amp;ldquo;human in the loop&amp;rdquo; needs to be a real operational control rather than a line item in a compliance contract.&lt;/p&gt;
&lt;h2 id="cors-what-is-it-protecting"&gt;&lt;a href="https://sanyamserver.online/posts/cors/" rel="noopener noreferrer"&gt;CORS: What is it protecting?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article clears up a widespread misconception: CORS is a browser-enforced security mechanism, not a server-side firewall. On cross-origin requests, the browser attaches an &lt;code&gt;Origin&lt;/code&gt; header, checks the response&amp;rsquo;s &lt;code&gt;Access-Control-Allow-Origin&lt;/code&gt; header, and allows frontend JavaScript to read the response body only if the origin is permitted. For simple requests that don&amp;rsquo;t trigger a preflight check, the server may have already executed the request even when the browser blocks JavaScript from reading the response. If a preflight check fails, the actual request is never sent. Command-line tools like &lt;code&gt;curl&lt;/code&gt; ignore browser CORS policies entirely. More complex requests—such as those using methods other than GET/POST/HEAD, custom headers, or JSON bodies—trigger an &lt;code&gt;OPTIONS&lt;/code&gt; preflight request asking the server which origins, methods, and headers it accepts.&lt;/p&gt;
&lt;p&gt;What CORS actually protects is data confidentiality in the browser: when configured properly, a malicious site cannot read your bank account details even though your browser holds an active session cookie. However, CORS does not prevent CSRF. A standard HTML form POST doesn&amp;rsquo;t require a preflight, so the server processes the state-changing request before the browser blocks the response from being read. Defending against CSRF requires request-side protections such as &lt;code&gt;SameSite&lt;/code&gt; cookie attributes, anti-CSRF tokens, or server-side validation of the &lt;code&gt;Origin&lt;/code&gt; and &lt;code&gt;Referer&lt;/code&gt; headers. In short, CORS and CSRF defenses solve two distinct problems and shouldn&amp;rsquo;t be conflated.&lt;/p&gt;
&lt;h2 id="data-access-patterns-that-makes-your-cpu-really-angry"&gt;&lt;a href="https://blog.weineng.me/posts/slowest_add/" rel="noopener noreferrer"&gt;Data Access Patterns That Makes Your CPU Really Angry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post runs a contrarian experiment: finding the slowest possible traversal order to sum all elements of a $2^{26}$-element array. Sequential scanning is the fastest at roughly 132 million cycles thanks to CPU caches and hardware prefetchers, while random access—typically treated as the worst case—takes about 1.57 billion cycles. The author systematically tests strided access patterns: jumping by one cache line, jumping by one memory page, and combining both. On the author&amp;rsquo;s Intel Core Ultra 7 268V, page-strided access is especially punishing because hardware prefetchers do not cross 4 KB page boundaries, while simultaneously causing many addresses to map to and thrash the exact same cache set in L1.&lt;/p&gt;
&lt;p&gt;The worst culprit is an eight-page stride—roughly 32 KB between consecutive reads—which takes around 2.06 billion cycles, about 33% slower than random access. It simultaneously saturates the cache set, defeats hardware prefetching, eliminates cache-line reuse, and destroys TLB locality, driving up address-translation overhead. The author also experiments with clustering accesses by DRAM bank and row to minimize memory-level parallelism, though undocumented physical address mapping makes that part approximate. Understanding why specific access patterns make a CPU crawl helps developers recognize the real-world limits of caches, prefetchers, and TLBs in everyday code.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #126</title><link>https://miti99.com/en/post/2026/07/23/</link><pubDate>Thu, 23 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #126.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="2-portable-executables"&gt;&lt;a href="https://anteiku.fun/papers/an-introduction-to-modern-malware-development-for-red-teams/02_portable_executables/" rel="noopener noreferrer"&gt;2. Portable Executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article is the second chapter in an introductory series on modern malware development for red teams, focusing on the Portable Executable (PE) format—the shared structure behind executables, dynamic-link libraries, and drivers on Windows. The author walks through the DOS Header, DOS Stub, PE Header, Optional Header, section table, and familiar sections such as &lt;code&gt;.text&lt;/code&gt;, &lt;code&gt;.data&lt;/code&gt;, &lt;code&gt;.rdata&lt;/code&gt;, &lt;code&gt;.rsrc&lt;/code&gt;, and &lt;code&gt;.reloc&lt;/code&gt;. The core point is that a PE simultaneously describes how the file is laid out on disk and how the Windows Loader maps it into memory: header fields specify the architecture, entry point, alignment, image size, and locations of key data directories, while each section&amp;rsquo;s attributes determine its contents and its read, write, or execute permissions at runtime.&lt;/p&gt;
&lt;p&gt;The second half shifts to the perspective of security products performing static analysis—evaluating a file before it is executed. Common indicators examined include hashes, digital signatures, data entropy, unusual entry point locations, sections marked &lt;code&gt;RWX&lt;/code&gt;, large discrepancies between on-disk and in-memory sizes, unfamiliar section names, sparse import tables, and suspicious API combinations. For newcomers, the article illustrates why a solid understanding of the PE structure is foundational both for analyzing malware and for building detection mechanisms against packed or obfuscated binaries.&lt;/p&gt;
&lt;h2 id="how-4-bytes-of-padding-make-array-clearing-49-faster"&gt;&lt;a href="https://blog.andr2i.com/posts/2026-06-22-optimization-catalog-how-4-bytes-of-padding-make-array-clearing-49-faster" rel="noopener noreferrer"&gt;How 4 bytes of padding make array clearing 49% faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part of the &amp;ldquo;Optimization catalog&amp;rdquo; series, this post analyzes a memory alignment phenomenon in Go: when a &lt;code&gt;uint32&lt;/code&gt; array sits at a 4-byte offset from an 8-byte boundary, clearing the array slows down dramatically. On the benchmarked Intel processor, adding just 4 bytes of padding to align the array to 8 bytes increases throughput by roughly 49%; on AMD the improvement is only around 9%, and ARM machines are virtually unaffected. Inspecting the assembly reveals that the entire clear is handled by a single &lt;code&gt;REP STOSQ&lt;/code&gt; instruction. Based on performance counters, the author hypothesizes that Intel&amp;rsquo;s fast-string path writes full cache lines directly without reading them first; when the array is misaligned by 4 bytes, an 8-byte store straddles every 64-byte cache-line boundary, so no cache line is ever completely overwritten in one go and the fast path cannot kick in.&lt;/p&gt;
&lt;p&gt;Follow-up benchmarks show that SIMD—whether via Go&amp;rsquo;s experimental intrinsics or handwritten assembly—does not outperform &lt;code&gt;STOSQ&lt;/code&gt;. A non-temporal store variant is occasionally faster, but its results fluctuate wildly depending on whether the OS kernel allocates contiguous or fragmented physical pages. The article also considers tagging elements with generation numbers to avoid actually zeroing memory, though generation tags enlarge the array and can push working data out of cache. The takeaway is that low-level optimizations depend heavily on the CPU microarchitecture, machine instructions, and data size, so you always need to measure on real hardware.&lt;/p&gt;
&lt;h2 id="engineering-high-performance-parsers-with-data-oriented-design"&gt;&lt;del&gt;&lt;a href="https://www.arshad.fyi/writings/engineering-high-performance-parsers" rel="noopener noreferrer"&gt;Engineering High-Performance Parsers with Data-Oriented Design&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This article shares the design principles behind Yuku, a JavaScript and TypeScript parser written in Zig, centered on one thesis: once the grammar is right, parser performance is dictated almost entirely by how the syntax tree is represented in memory rather than the parsing algorithm itself. Instead of individually heap-allocated nodes linked by pointers—which cause tens of thousands of allocations and unpredictable memory accesses—Yuku stores nodes in a flat array and uses &lt;code&gt;u32&lt;/code&gt; indices as references. An index takes half the space of a 64-bit pointer, the entire tree is freed in a single operation, and the recursive-descent parsing logic remains familiar.&lt;/p&gt;
&lt;p&gt;The author applies the same data-oriented mindset across the parser: splitting node payloads and source locations into separate parallel arrays so each traversal pass touches only the data it needs; storing variable-length child lists as offset-and-length pairs into an extra buffer; reusing scratch buffers across recursive calls; representing strings as byte spans into the original source; packing operator metadata directly into tag bits; and compressing Unicode lookup tables by deduplicating identical blocks. Size and layout invariants are verified at compile time to prevent accidental regressions. Because the tree consists purely of indices and offsets, its in-memory representation doubles as its wire format, allowing the AST to be handed over to JavaScript as a single contiguous buffer rather than serialized through JSON.&lt;/p&gt;
&lt;h2 id="how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers-18l5" rel="noopener noreferrer"&gt;How To Learn Go Fast: A Practical Roadmap For Senior Backend Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article lays out a Go learning roadmap for experienced backend developers, particularly those coming from PHP, Laravel, or Symfony. The author argues that you don&amp;rsquo;t need to relearn backend fundamentals like APIs, databases, or queues; instead, leverage that foundation and focus on how Go structures programs: explicit code, errors as values, small implicitly satisfied interfaces, explicit dependency wiring, and a preference for the standard library over monolithic frameworks.&lt;/p&gt;
&lt;p&gt;The roadmap starts with syntax, types, packages, and error handling before quickly moving into building CLI tools, HTTP services, and concurrent worker systems, since building small projects early teaches the language faster than reading syntax tutorials alone. A 12-week plan progresses from core fundamentals to PostgreSQL, integration testing, race detection, cancellation contexts, profiling, observability, and a portfolio-ready capstone project—treating testing, error handling, and operations as parallel tracks rather than afterthoughts. The post also includes a condensed multi-day track for developers jumping into an existing Go codebase immediately, while still emphasizing production habits like setting timeouts on network calls, implementing graceful shutdown, reading real-world source code, and profiling before optimizing. Ultimately, senior-level Go proficiency shows in your ability to build, deploy, diagnose, and maintain real systems.&lt;/p&gt;
&lt;h2 id="how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid--senior-engineers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid-senior-engineers-200p" rel="noopener noreferrer"&gt;How To Prepare For A Golang Interview: A Practical Guide For Mid &amp;amp; Senior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article serves as a comprehensive study map for mid- and senior-level Go interviews, emphasizing that interviewers evaluate reasoning and system design rather than mere syntax recall. It covers zero values, packages, slices, maps, pointers, interfaces, error handling, &lt;code&gt;defer&lt;/code&gt;, &lt;code&gt;panic&lt;/code&gt;, and common memory pitfalls. Topics frequently used to separate candidates are explained in depth—such as shared backing arrays across slices, non-nil interfaces holding nil pointers, channel closing rules, and choosing between mutexes and channels—because these are also frequent sources of production bugs.&lt;/p&gt;
&lt;p&gt;The senior section expands into the G-M-P scheduler, the memory model, escape analysis, garbage collection, goroutine leaks, context cancellation, race detection, and profiling with &lt;code&gt;pprof&lt;/code&gt;. It also covers testing, databases, HTTP, graceful shutdown, system design, and operational concerns beyond the language itself. According to the author, a strong interview answer articulates choices, trade-offs, and how to verify behavior through tests or benchmarks. The guide concludes with a list of common mistakes, time-boxed coding exercises like worker pools, rate limiters, and retry mechanisms, and a self-assessment checklist for writing correct, production-grade Go.&lt;/p&gt;
&lt;h2 id="shard-your-locks-benchmarking-6-go-cache-designs"&gt;&lt;a href="https://strebkov.dev/posts/shard-your-locks/" rel="noopener noreferrer"&gt;Shard your locks: benchmarking 6 Go cache designs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks six ways to build a concurrent &lt;code&gt;string → string&lt;/code&gt; cache using only the Go standard library: an unlocked map (as a baseline), a single &lt;code&gt;Mutex&lt;/code&gt;, a single &lt;code&gt;RWMutex&lt;/code&gt;, &lt;code&gt;sync.Map&lt;/code&gt;, a 256-shard map, and copy-on-write. Benchmarks run across varying read/write ratios and from one to eight CPU cores. The results show that a single lock does not scale: at eight cores, even a read-only workload with a &lt;code&gt;Mutex&lt;/code&gt; is slower than on a single core. &lt;code&gt;RWMutex&lt;/code&gt;, the reflexive choice for read-heavy contention, scales only to about 2x before plateauing because its atomic reader counter becomes the new contention bottleneck—and under write-heavy workloads, it performs even worse than a plain &lt;code&gt;Mutex&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The sharded design, where each shard has its own map and lock, is the only approach that consistently ranks near the top across all workloads—outperforming a single lock by up to 8x because operations on different shards proceed in parallel. Copy-on-write leads on pure read workloads but collapses toward zero throughput as soon as writes appear, since every write clones the entire map, making it suitable only for rarely updated data. The author also notes that skewed key distributions can actually speed up reads thanks to CPU cache locality, while concentrating write contention onto a few hot shards. Using 256 shards is a sweet spot for this benchmark rather than a universal constant; before picking a concurrency primitive, always benchmark with your actual key distribution, hardware, and workload.&lt;/p&gt;
&lt;h2 id="the-join-that-should-be-a-bug"&gt;&lt;a href="https://kronotop.com/blog/the-join-that-should-be-a-bug/" rel="noopener noreferrer"&gt;The .join() That Should Be a Bug&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains how Kronotop serves thousands of concurrent connections when nearly every command has to wait on network calls to FoundationDB or filesystem I/O. The author contrasts two familiar architectures: Redis uses a single thread for all connections, holding massive connection counts at the cost of forbidding any blocking command; PostgreSQL uses one process per connection, allowing straightforward sequential blocking code but consuming heavy OS resources as connections scale. Kronotop takes a third path, decoupling connection holding from blocking work to combine the strengths of both models.&lt;/p&gt;
&lt;p&gt;A small pool of Netty event-loop threads accepts data, parses commands, and sends responses without ever blocking. Disk I/O and network calls are offloaded to Java virtual threads, where a &lt;code&gt;.join()&lt;/code&gt; call—normally considered an anti-pattern or bug in asynchronous code—can block sequentially without pinning the underlying OS carrier thread. Once the result is ready, writing the response is always dispatched back to the exact Netty event loop that owns the connection, keeping concurrency invariants clean and predictable. Each connection also acts as a session holding authentication state, namespace, and open transaction state; when a connection closes or resets, its associated transactions and resources are safely aborted and cleaned up.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #125</title><link>https://miti99.com/en/post/2026/07/13/</link><pubDate>Mon, 13 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #125.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="275---khi-big-tech-chuyển-mình-thành-ai-factory"&gt;&lt;a href="https://newsletter.grokking.org/p/275-khi-big-tech-chuyen-minh-thanh" rel="noopener noreferrer"&gt;275 - Khi Big Tech chuyển mình thành AI Factory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This edition shares an inside look at how a major tech company is transforming its engineering organization into an &amp;ldquo;AI factory.&amp;rdquo; The author maps agentic automation across five maturity levels: starting with engineers copy-pasting snippets from a chatbot, moving to interactive coding agents guided turn by turn, then agents going autonomously from a written spec to a tested pull request, then humans acting solely as orchestrators of review and deployment, and finally agents autonomously deploying, monitoring production, and remediating incidents. Because each level grants agents broader autonomy, the company has to invest heavily in sandboxed execution environments, automated verification, fine-grained permissions, and hard guardrails that block destructive actions.&lt;/p&gt;
&lt;p&gt;As a result, the software engineer&amp;rsquo;s day-to-day role shifts from writing every line by hand to &amp;ldquo;packaging&amp;rdquo; work into well-bounded specifications with explicit goals and acceptance criteria—a transition that proves surprisingly tough for junior engineers accustomed to exploratory, trial-and-error coding. Human code review remains indispensable because critical product and system requirements often live in unwritten tribal context; automated AI review bots currently have only about half of their suggestions accepted and burn significant token budgets at scale. While individual programming languages are becoming increasingly interchangeable, deep fundamentals in operating systems, networking, security, infrastructure, data structures, and concurrency remain the bedrock that lets engineers evaluate and take accountability for AI-generated systems.&lt;/p&gt;
&lt;h2 id="the-8020-rule-for-your-whole-life"&gt;&lt;a href="https://yewjin.substack.com/p/always-be-curious" rel="noopener noreferrer"&gt;The 80/20 rule for your whole life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yew Jin Lim proposes applying the 80/20 rule across your entire life: dedicate the 80% majority of your resources to building a rock-solid, low-drama foundation, and treat the remaining 20% as a &amp;ldquo;laboratory&amp;rdquo; for bounded experiments. The governing mindset is evaluating your life as a portfolio rather than agonizing over every individual position. He illustrates this with personal examples: many of the 20%-time side projects he tried at Google went nowhere individually, yet together they shaped his career trajectory; his retirement portfolio grew roughly tenfold through automated contributions and the discipline not to tinker; and his meditation practice deepened simply by showing up every day.&lt;/p&gt;
&lt;p&gt;From that experience he distills three core habits: follow curiosity to expand your knowledge without demanding an immediate payoff, master decision-making by separating emotional reactions from individual outcomes, and stay consistent long enough for compounding to do its work. He draws a sharp distinction between short-term trading and long-term investing, noting that once your foundation is sound, &amp;ldquo;doing nothing&amp;rdquo; is often the highest-leverage move available. Experiments don&amp;rsquo;t need to succeed every time, so long as each bet is sized small enough that failure is cheap tuition rather than ruin—and the 80% foundation is never put at risk.&lt;/p&gt;
&lt;h2 id="three-bad-managers"&gt;&lt;a href="https://randsinrepose.com/archives/three-bad-managers/" rel="noopener noreferrer"&gt;Three Bad Managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) tells the story of three brilliant, commercially successful bosses who were terrible people managers, using them to draw a crisp line between leadership (charting a compelling direction for the organization) and management (helping individuals understand where they stand and navigating day-to-day execution). &amp;ldquo;The Artist&amp;rdquo; was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. &amp;ldquo;The Dictator&amp;rdquo; used forceful authority and intimidation to dominate rooms—for instance, casually reopening design directions the team had already spent weeks evaluating rather than trusting their expertise. &amp;ldquo;The Knife&amp;rdquo; was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.&lt;/p&gt;
&lt;p&gt;For each boss, Lopp found a different survival strategy: writing his own detailed performance review ahead of 1-on-1s so The Artist just had to react to it, doing exhaustive technical homework before meetings so he could push back on The Dictator as an equal, and simply staying out of The Knife&amp;rsquo;s blast radius to get work done independently. His core takeaway is that you will almost never change your boss—especially when they are senior and successful—but you can change how you prepare, communicate, and operate around them. Every working relationship requires calibration, and learning how to adapt to difficult personalities is a practical survival skill rather than an endorsement of bad management.&lt;/p&gt;
&lt;h2 id="cross-team-pragmatics"&gt;&lt;a href="https://philcalcado.com/2026/06/01/cross_team_pragmatics.html" rel="noopener noreferrer"&gt;Cross-Team Pragmatics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Calçado examines why cross-team collaboration almost always slows down and turns political as an engineering organization grows. The root causes are predictable: individual-focused performance review cultures incentivize local optimization, high-level strategic goals contradict each other once cascaded down different org branches (e.g., an infra team rewarded for cutting cloud spend while a product team is rewarded for shipping compute-heavy features), accountability is assigned without matching ownership, and minor disagreements constantly escalate up the management chain instead of getting resolved laterally. The only durable fix is a unified technical strategy that aligns how the business competes with team boundaries, ownership, incentives, and decision rights.&lt;/p&gt;
&lt;p&gt;While waiting for those slow structural fixes to take hold, Calçado shares four pragmatic tools for treating the immediate symptoms. Team charters turn unspoken assumptions into explicit boundaries, responsibilities, and interaction modes, cutting down repetitive renegotiation. Value-stream mapping traces how a feature actually flows from idea to production rather than looking at the org chart, exposing unnecessary handoffs and queues. The 80% rule states that a team should be able to complete at least 80% of its roadmap without blocking dependencies on other teams along the critical path, while Team Topologies gives organizations a shared vocabulary for intentionally choosing how teams interact. These tools buy breathing room and stability, though long-term health still requires continuously reshaping the org around how value is actually delivered.&lt;/p&gt;
&lt;h2 id="technological-involution"&gt;&lt;a href="https://rohan.ga/blog/technological-involution/" rel="noopener noreferrer"&gt;Technological Involution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rohan argues that the tech industry has entered a state of &amp;ldquo;involution&amp;rdquo;: more talent and capital pouring in than ever, yet producing increasingly homogeneous, incremental ideas. In his view, the obvious low-hanging fruit of consumer and SaaS software has largely been picked, standard application software is rapidly commoditizing, and Silicon Valley startup culture encourages young founders to borrow pre-packaged narratives from influencers and VCs rather than forming independent convictions from scratch. Hype manufactures consensus rather than real value, while society at large grows more cynical about tech&amp;rsquo;s future. Meanwhile, the genuinely hard problems sit in atoms, hardware, semiconductors, and messy real-world enterprise operations—domains where most young founders lack hands-on experience.&lt;/p&gt;
&lt;p&gt;AI excels at generating code and synthesizing conventional wisdom, but by design it gravitates toward the consensus mean rather than contrarian, high-impact insights. Rohan argues that this limitation is precisely what preserves the opening for human agency: people who immerse themselves deeply in a domain, test hypotheses from first principles, and have the courage to pursue non-consensus ideas will only become more valuable. The way out of involution is returning to intrinsic motivation—building something because the problem itself is intellectually gripping rather than optimizing for startup vanity metrics—and the success of independent, taste-driven new media proves that work built with genuine conviction still cuts through the noise.&lt;/p&gt;
&lt;h2 id="fintech-engineering-handbook"&gt;&lt;a href="https://w.pitula.me/fintech-engineering-handbook/" rel="noopener noreferrer"&gt;Fintech Engineering Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wojciech Pitula&amp;rsquo;s handbook distills core principles and architectural patterns for building software where money is the primary domain object, anchored on three commandments: never invent money or data out of thin air, never lose data, and never trust any single component blindly. On representing monetary amounts, he compares floating-point numbers (almost never acceptable), arbitrary-precision decimals, integer minor units (e.g., cents), and rational fractions, while warning that standard JSON parsers silently coerce numeric literals into IEEE 754 floats unless amounts are serialized as strings or integers. Every balance change is recorded in a double-entry ledger where money only ever moves between accounts and balances are derived from immutable journal entries—tracking transaction time, booking time, and settlement time as distinct timestamps.&lt;/p&gt;
&lt;p&gt;On the execution side, the handbook covers funds holds/reservations to prevent double-spending, strict idempotency keys, crash-resumable state machines, and at-least-once event delivery. When integrating with external payment processors and banks, systems must validate schemas at the boundary, persist every raw request and response payload for auditability, verify webhook signatures before querying the provider&amp;rsquo;s canonical API for state, and run independent automated reconciliation jobs to catch ledger drift early. Posted ledger entries are strictly immutable—mistakes are corrected via compensating reversal entries, never &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt;—and sensitive manual operations require four-eyes approval. End-to-end walkthroughs of crypto withdrawals, card top-ups, and currency exchanges show how these patterns interlock across multi-step failure scenarios.&lt;/p&gt;
&lt;h2 id="how-to-write-an-effective-software-design-document"&gt;&lt;a href="https://refactoringenglish.com/excerpts/write-an-effective-design-doc/" rel="noopener noreferrer"&gt;How to Write an Effective Software Design Document&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch shares a practical guide to writing software design documents that surface flawed assumptions before coding begins and align stakeholders on how to solve a problem. A design doc is worth writing when a project spans multiple people, takes longer than three months, will live in production long-term, crosses team boundaries, starts from ambiguous requirements, or carries high operational risk. To decide how much detail a section needs, Lynch suggests asking one simple question: &amp;ldquo;what is the cost of being wrong?&amp;rdquo; Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don&amp;rsquo;t belong in a design doc.&lt;/p&gt;
&lt;p&gt;An effective design doc typically covers background and goals, explicit scope and non-goals, architecture and data-flow diagrams, measurable SLAs/SLOs, security and privacy considerations, a milestone timeline, and a log of open and resolved questions. The document should focus on the hardest trade-offs and gathering early feedback rather than specifying every line-level implementation detail—if you&amp;rsquo;ve written pseudocode for every class, you&amp;rsquo;ve essentially written the code twice. Lynch also recommends using editable diagramming tools (like Mermaid or Excalidraw with source checked in), defining domain jargon in a glossary, documenting rejected alternatives so reviewers don&amp;rsquo;t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.&lt;/p&gt;
&lt;h2 id="the-cost-yagni-was-never-about"&gt;&lt;a href="https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-about" rel="noopener noreferrer"&gt;The Cost YAGNI Was Never About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck explains that YAGNI (&amp;ldquo;You Aren&amp;rsquo;t Gonna Need It&amp;rdquo;) was never really about saving typing or coding effort—it is an economic principle about &lt;em&gt;when&lt;/em&gt; to commit to a design decision. Building speculative structure before a feature actually demands it incurs two distinct costs that have nothing to do with how fast you can write code. The first is lost optionality: the team locks in a bet when they have the least information about the problem, and when real requirements inevitably diverge from the guess, they have to pay to work around or rip out that speculative abstraction. Even on the rare occasion when the guess turns out right, committing early still forfeits the option value of waiting until you know more; as Beck puts it, waiting isn&amp;rsquo;t procrastination—it is holding a valuable option.&lt;/p&gt;
&lt;p&gt;The second cost is net present value (NPV) and carrying cost: you pay the complexity, maintenance, and cognitive tax immediately while any hypothetical payoff arrives far in the future, meaning you lose economically whether your prediction was right or wrong. Now that AI makes generating code nearly free, the &amp;ldquo;save typing time&amp;rdquo; argument for YAGNI disappears, yet both the optionality cost and the carrying cost remain completely intact—in fact, AI makes it dangerously easy to hallucinate sprawling, speculative frameworks in seconds. Build structure when concrete demand arrives and gives you the information needed to design it right; YAGNI is economic discipline, not stinginess with keystrokes.&lt;/p&gt;
&lt;h2 id="a-cve-dispute"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/06/24/a-cve-dispute/" rel="noopener noreferrer"&gt;a CVE dispute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg recounts curl&amp;rsquo;s first formal CVE dispute since the project became a CVE Numbering Authority (CNA). With roughly 30 billion libcurl installations worldwide, publishing a CVE triggers a massive wave of triage, compliance scanning, patching, and backporting across the entire software industry. Because of that amplification effect, the curl security team evaluates reports based on realistic exploitability and occasionally declines to assign a CVE to bugs whose security impact is &amp;ldquo;lower than low&amp;rdquo;—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.&lt;/p&gt;
&lt;p&gt;The disputed report involved curl&amp;rsquo;s wildcard certificate hostname matching function when the URL&amp;rsquo;s hostname began with a leading dot (e.g., &lt;code&gt;.example.com&lt;/code&gt;). For this bug to be exploitable in practice, an absurd chain of preconditions had to hold simultaneously: a user had to request a hostname that is syntactically invalid in standard DNS, that invalid name had to resolve via something like a modified local &lt;code&gt;/etc/hosts&lt;/code&gt; file, an attacker-controlled server at that IP had to present a matching wildcard certificate from a trusted CA, and the attacker already needed local privileges to poison name resolution in the first place. The curl team fixed the bug in December 2025 as a normal defect but declined to issue a CVE. A security researcher appealed the decision to MITRE, and after multiple rounds of review in 2026, MITRE agreed with curl that it was simply a fixed bug rather than a security vulnerability because exploiting it required a privileged local attacker. The episode illustrates why not every bug in a network library deserves a CVE, and how the CNA dispute process provides an independent check when opinions differ.&lt;/p&gt;
&lt;h2 id="how-llms-actually-work"&gt;&lt;a href="https://www.0xkato.xyz/how-llms-actually-work/" rel="noopener noreferrer"&gt;How LLMs Actually Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This visual guide explains how autoregressive transformer language models generate text token by token without getting bogged down in heavy calculus. Incoming text is first split into subword tokens by a tokenizer and mapped to integer IDs; an embedding lookup table then converts each ID into a dense vector capturing learned semantic features, placing tokens with related meanings near one another in high-dimensional space. Because self-attention treats inputs as an unordered set by default, the model injects positional information—most modern LLMs use Rotary Position Embeddings (RoPE), rotating query and key vectors by an angle proportional to each token&amp;rsquo;s position in the sequence. Inside each transformer block, self-attention compares query vectors against key vectors to compute attention weights, deciding how much information to pull from each prior token&amp;rsquo;s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.&lt;/p&gt;
&lt;p&gt;After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model&amp;rsquo;s parameters and stored factual associations. Residual connections allow information to flow and accumulate across dozens of stacked layers without vanishing gradients, while layer normalization keeps activation magnitudes stable. At the very end of the stack, the final token&amp;rsquo;s hidden state vector is projected across the entire vocabulary and passed through softmax to produce a probability distribution over the next token; the runtime samples a token (shaped by temperature, top-p, or top-k), appends it to the sequence, and repeats the loop. While modern frontier models tweak attention variants, architectures, and training recipes, they all share this foundational autoregressive transformer loop.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LlLN!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe4d255e1-536e-4f66-ab48-e8baa1bdd4a4_2484x3002.png" alt="RAG vs Graph RAG vs Agentic RAG"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!15Bw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9b8f9d64-3eae-4237-b49f-ffde033f851a_2484x3002.png" alt="Redis Data Structures Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-ILW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F19ca7f08-d615-4769-8599-2aa9aaa5d6bd_2508x3000.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ydOn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe46aad28-2935-4b87-8cf4-72787b48a9d0_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_6cl!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fea738d9d-1ae5-4a26-9a50-79ec7720fd80_2360x2664.jpeg" alt="The Testing Pyramid"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #124</title><link>https://miti99.com/en/post/2026/07/12/</link><pubDate>Sun, 12 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #124.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="riding-technology-waves"&gt;&lt;a href="https://staysaasy.com/strategy/2026/06/22/riding-technology-waves.html" rel="noopener noreferrer"&gt;Riding Technology Waves&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Major technology waves—the internet, cloud computing, mobile, and now AI—arrive faster and hit harder with each cycle, minting massive new winners while wiping out incumbents, even as other hyped waves like 3D printing or VR fizzle out. To orient yourself early without getting swept up in empty hype, Stay SaaSy proposes answering four questions in order: does this technology actually matter (i.e., do real users get sustained value from it)?; how does it work under the hood, at a level you could explain clearly to a smart outsider?; what concrete new capabilities does it unlock, stated as plain facts rather than buzzwords?; and how do those capabilities affect your specific product, cost structure, or customers?&lt;/p&gt;
&lt;p&gt;The two classic failure modes sit at opposite extremes. Complacency leads companies to dismiss real signals as a fad, though that mistake usually forces its own correction once the wave becomes undeniable. Far more common in volatile times is FOMO-driven panic: leaders who don&amp;rsquo;t understand the technology chase the herd, betting the company on unvalidated use cases or blowing up a working roadmap to slap an &amp;ldquo;AI&amp;rdquo; label on the product while customers are asking for basic reliability. Blindly pivoting is the default strategic blunder during a hype cycle. Yet the worst mistake of all is missing an obvious wave and then letting ego keep you in denial; when that happens, leadership must admit the miss, take ownership, put their best people and real resources on catching up, and stay hands-on until the course is corrected.&lt;/p&gt;
&lt;h2 id="find-a-new-role"&gt;&lt;a href="https://larahogan.me/blog/identify-new-role/" rel="noopener noreferrer"&gt;Find a new role&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When thinking about changing jobs or transitioning into a new role, Lara Hogan recommends filling out a 2×2 grid of four lists: your non-negotiable &amp;ldquo;Must Haves&amp;rdquo;; your &amp;ldquo;Want to Haves&amp;rdquo; that matter a lot, though you&amp;rsquo;d trade off one or two for the right opportunity; things that &amp;ldquo;Don&amp;rsquo;t Matter&amp;rdquo; to you right now, even if they mattered in the past or matter to peers; and a single crisp &amp;ldquo;Optimizing For&amp;rdquo; sentence stating the one thing you are prioritizing above everything else in this chapter. Putting those four boxes on paper turns a murky career decision into concrete criteria for sourcing roles, asking interview questions, and weighing offers.&lt;/p&gt;
&lt;p&gt;Hogan advises leaving job titles off every list entirely, since the same title can mean wildly different things across companies; evaluate the actual day-to-day scope and responsibilities instead. Keep the &amp;ldquo;Must Haves&amp;rdquo; box ruthlessly short: if you would still accept an offer missing a given item, it belongs in &amp;ldquo;Want to Haves,&amp;rdquo; and you will almost certainly have to compromise on at least one want-to-have. Anchor your criteria in what you need &lt;em&gt;today&lt;/em&gt; rather than what you wanted five years ago or might want in the distant future—sometimes top-of-market compensation gives way to great healthcare, or scope gives way to work-life balance. Your single &amp;ldquo;Optimizing For&amp;rdquo; statement is the sharpest tool of all: tape it next to your monitor, share it with trusted friends who can hold you accountable, and use it to ask which opportunity moves you closest to that specific goal. Re-run the exercise whenever your life circumstances shift.&lt;/p&gt;
&lt;h2 id="i-stored-a-website-in-a-favicon"&gt;&lt;a href="https://www.timwehrle.de/blog/i-stored-a-website-in-a-favicon" rel="noopener noreferrer"&gt;I Stored a Website in a Favicon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After previously hiding two bytes of state inside a custom mouse cursor, Tim Wehrle decided to see if he could pack an entire web page inside a &lt;code&gt;favicon.ico&lt;/code&gt;/PNG image. The encoding is delightfully direct: a favicon is an image, an image is a grid of pixels, and each RGB pixel gives you three color channels—red, green, and blue—worth one byte each. Wehrle encodes an HTML snippet into UTF-8 bytes using &lt;code&gt;TextEncoder&lt;/code&gt;, prepends a 4-byte length header so the decoder knows exactly where the payload ends (ignoring any trailing padding pixels in the grid), and writes three bytes into each pixel&amp;rsquo;s RGB values. A 208-byte HTML payload plus the 4-byte header totals 212 bytes, fitting into 71 pixels inside a tiny 9×9 PNG at 87% capacity—producing an icon that looks like colorful static.&lt;/p&gt;
&lt;p&gt;To reconstruct the page, a tiny bootstrap page loads the favicon onto an HTML &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt;, reads back the pixel array via &lt;code&gt;getImageData()&lt;/code&gt;, extracts the RGB bytes up to the 4-byte length prefix, decodes the UTF-8 string with &lt;code&gt;TextDecoder&lt;/code&gt;, and replaces the current document with the recovered HTML. Crucially, a PNG favicon is inert data and cannot execute itself on its own—you still need that small loader script to unpack and render it. Wehrle readily admits the experiment has zero practical utility given the tiny storage budget and the existence of normal HTTP responses, but it is a fun reminder that every file format is ultimately just bytes that can be repurposed in unexpected ways. He closes by noting alternative steganographic tricks like embedding markup inside an SVG favicon, stuffing text into PNG &lt;code&gt;tEXt&lt;/code&gt; chunks, or packing multiple resolutions into an &lt;code&gt;.ico&lt;/code&gt; container.&lt;/p&gt;
&lt;h2 id="antipatterns-never-left-we-just-stopped-calling-them-by-name"&gt;&lt;a href="https://dev.to/leonpennings/antipatterns-never-left-we-just-stopped-calling-them-by-name-969" rel="noopener noreferrer"&gt;AntiPatterns Never Left, We Just Stopped Calling Them by Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in 1998, the book &lt;em&gt;AntiPatterns&lt;/em&gt; cataloged recurring software failure modes—giving each one a memorable name, symptoms, root causes, and a refactoring path out. Leon Pennings argues that those exact failure modes are still everywhere today; we just rebranded them as modern best practices and stopped recognizing them because the system still compiles and passes tests. Short-term delivery creates survivorship bias where teams assume their architectural choices succeeded, since nobody builds the simpler alternative alongside it for comparison. Industry popularity doesn&amp;rsquo;t prove an approach fits your context, and naming anti-patterns explicitly helps teams see water they&amp;rsquo;ve been swimming in for years.&lt;/p&gt;
&lt;p&gt;Pennings groups modern anti-patterns into four recurring themes. First is organizing code around technical layers (&lt;code&gt;controllers/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;, &lt;code&gt;repositories/&lt;/code&gt;) instead of business capabilities, scattering domain concepts across folders, producing anemic domain models, and coupling business logic tightly to frameworks. Second is cargo-culting Resume-Driven Development—reaching for Kubernetes or Kafka as a golden hammer regardless of scale. Third is when the cure recreates the disease: turning a monolithic Big Ball of Mud into a distributed microservices ball of mud where complexity simply moves across network boundaries, or standing up a platform team that becomes just another ticket-driven silo. Fourth is separating decision-makers from the consequences of their decisions, such as Scrum intermediaries insulating developers from real users. Sometimes writing fifty lines of plain code is far cheaper over five years than pulling in a massive dependency; the goal isn&amp;rsquo;t rejecting frameworks, microservices, or Scrum wholesale, but evaluating every trade-off against your actual problem.&lt;/p&gt;
&lt;h2 id="5-more-advanced-java-tips-that-senior-engineers-actually-use"&gt;&lt;a href="https://dev.to/cyclopt_dimitrisk/5-more-advanced-java-tips-that-senior-engineers-actually-use-bbp" rel="noopener noreferrer"&gt;5 More Advanced Java Tips That Senior Engineers Actually Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through five modern Java capabilities, though it is worth noting upfront that they did not all land as final, stable APIs in Java 21: Record Patterns and Sequenced Collections were finalized in JDK 21, the Foreign Function and Memory (FFM) API was finalized in JDK 22, and Stream Gatherers became final in JDK 24, while Structured Concurrency remains a preview feature in the JDK 24 release referenced by the examples—so check your target JDK version before adopting. Structured Concurrency (&lt;code&gt;StructuredTaskScope&lt;/code&gt;) groups related concurrent subtasks into a single lexical lifetime: using a policy like &lt;code&gt;ShutdownOnFailure&lt;/code&gt;, if one subtask fails the remaining siblings are cancelled automatically (assuming they respect thread interruption), and once the &lt;code&gt;try-with-resources&lt;/code&gt; block exits no orphan threads are left running in the background—a major upgrade over manually juggling independent &lt;code&gt;CompletableFuture&lt;/code&gt; chains. Record Patterns let you destructure nested records directly inside &lt;code&gt;switch&lt;/code&gt; expressions; paired with &lt;code&gt;sealed&lt;/code&gt; interfaces, the compiler enforces exhaustiveness so adding a new subtype immediately flags every unhandled &lt;code&gt;switch&lt;/code&gt; at compile time.&lt;/p&gt;
&lt;p&gt;Sequenced Collections (&lt;code&gt;SequencedCollection&lt;/code&gt;, &lt;code&gt;SequencedSet&lt;/code&gt;, &lt;code&gt;SequencedMap&lt;/code&gt;) unify access to first/last elements and reverse-order iteration across ordered collections; calling &lt;code&gt;.reversed()&lt;/code&gt; returns a lightweight view rather than copying the underlying list, which is handy when scanning chronological event logs backward. The Foreign Function and Memory API (Project Panama) replaces brittle &lt;code&gt;sun.misc.Unsafe&lt;/code&gt; and JNI boilerplate with a pure-Java API for allocating off-heap memory and calling native C libraries, complete with bounds checking and deterministic deallocation via &lt;code&gt;Arena&lt;/code&gt; lifetimes (though the underlying native code itself must still be trusted). Finally, Stream Gatherers (&lt;code&gt;Stream::gather&lt;/code&gt;) fill a long-standing gap in the Stream API: just as &lt;code&gt;Collector&lt;/code&gt; lets you customize terminal operations, &lt;code&gt;Gatherer&lt;/code&gt; lets you write custom stateful intermediate operations—such as fixed batching, sliding windows, deduplicating adjacent elements, or running averages—while keeping pipelines readable.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://dev.to/mihirmohapatra/gos-type-system-structs-interfaces-and-life-without-inheritance-2lb7" rel="noopener noreferrer"&gt;Go&amp;rsquo;s Type System — Structs, Interfaces, and Life Without Inheritance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming to Go after six years of Java and Kotlin, Mihir Mohapatra reflects that the biggest mental shift in Go&amp;rsquo;s type system is the complete absence of class inheritance. A &lt;code&gt;struct&lt;/code&gt; holds only data fields—there are no constructors or &lt;code&gt;implements&lt;/code&gt; keywords; a factory function like &lt;code&gt;NewOrder&lt;/code&gt; is just a naming convention, and callers can still instantiate the zero-valued struct directly unless the type is unexported. Methods are declared separately with explicit value receivers (which operate on a copy) or pointer receivers (which can mutate the caller&amp;rsquo;s struct); reassigning a struct field requires a pointer receiver, though a value copy containing a &lt;code&gt;map&lt;/code&gt;, &lt;code&gt;slice&lt;/code&gt;, or pointer still shares the underlying referenced storage. Instead of inheritance, Go uses struct embedding: fields and methods of an embedded inner struct are promoted to the outer struct, modeling a &amp;ldquo;has-a&amp;rdquo; composition relationship rather than an &amp;ldquo;is-a&amp;rdquo; subtype hierarchy.&lt;/p&gt;
&lt;p&gt;The biggest design departure is that Go interfaces are satisfied implicitly: any type that implements the required method signatures automatically satisfies the interface, even types from third-party packages you don&amp;rsquo;t control. That flips interface design on its head: instead of defining massive upfront contracts in a central package that every implementation must explicitly import and declare, Go interfaces are typically small—often one or two methods like &lt;code&gt;io.Reader&lt;/code&gt; and &lt;code&gt;io.Writer&lt;/code&gt;—and defined by the consumer right where the behavior is needed. Types stay decoupled and brittle base-class hierarchies disappear. Mohapatra also notes the trade-offs newcomers bump into: finding every type that satisfies an interface requires IDE tooling rather than grepping for &lt;code&gt;implements&lt;/code&gt;, struct embedding doesn&amp;rsquo;t give you subclass polymorphism, and Go&amp;rsquo;s zero values mean an uninitialized struct compiles cleanly and can look valid unless you validate required fields explicitly.&lt;/p&gt;
&lt;h2 id="conduit-the-gateway-i-built-to-forget-about"&gt;&lt;a href="https://dev.to/adamthedeveloper/conduit-the-gateway-i-built-to-forget-about-2ann" rel="noopener noreferrer"&gt;Conduit: The Gateway I Built to Forget About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adam built an internal Go API gateway sitting in front of three backend services with two authentication schemes: a custom HMAC-signed session token for end-user and chat routes, and JWTs for admin endpoints. While the Go proxy was fast and rock-solid, every new public-route exception or header tweak meant adding another &lt;code&gt;if&lt;/code&gt; branch in Go, recompiling, and redeploying the binary. Conduit solves this by splitting what rarely changes from what changes constantly: a core Go binary handles HTTP ingress, routing, reverse proxying, CORS, and SSRF protection, while an isolated Deno subprocess executes TypeScript policy modules for auth, logging, and request mutation—letting operators edit a &lt;code&gt;.ts&lt;/code&gt; file and reload policies without recompiling Go.&lt;/p&gt;
&lt;p&gt;The two processes communicate over a Unix domain socket using a strict snapshot-and-patch contract. Go sends a serializable JSON snapshot of the incoming request metadata; the TypeScript policy modules return only a minimal patch describing headers to add/remove or whether to short-circuit the request, rather than owning or mutating the live request object directly, while request bodies larger than 64 KiB stay inside Go and are referenced by handle ID. Failure modes are explicitly separated too: if an individual policy module times out, Conduit logs a warning and moves on, whereas if the entire Deno sidecar crashes, each route follows its configured failure policy—either failing closed with &lt;code&gt;503 Service Unavailable&lt;/code&gt; or failing open by proxying directly to the upstream. Simplicity comes from crisp responsibility boundaries rather than raw line count; Conduit isn&amp;rsquo;t trying to replace Envoy or Kong at massive scale, just stay out of the way in front of a handful of services whose edge policies evolve often.&lt;/p&gt;
&lt;h2 id="the-reflect-package"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-reflect" rel="noopener noreferrer"&gt;The Reflect Package&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go compiles ahead of time to native machine code, yet the standard library&amp;rsquo;s &lt;code&gt;reflect&lt;/code&gt; package can inspect struct field names, types, and struct tags at runtime. This post dives into how the Go compiler embeds static type metadata inside the compiled binary so &lt;code&gt;reflect&lt;/code&gt; can read it (while noting that other &lt;code&gt;reflect&lt;/code&gt; APIs can still allocate or construct types dynamically at runtime). Under the hood, an empty interface value (&lt;code&gt;any&lt;/code&gt; / &lt;code&gt;interface{}&lt;/code&gt;) is a two-word struct holding two pointers: one pointing to the underlying data and one pointing to a runtime type descriptor (&lt;code&gt;abi.Type&lt;/code&gt;), whose address is a compile-time constant known to the linker. Calling &lt;code&gt;reflect.TypeOf&lt;/code&gt; therefore just reads that type pointer—no hash table lookup, no heap allocation.&lt;/p&gt;
&lt;p&gt;During compilation, the compiler&amp;rsquo;s &lt;code&gt;reflectdata&lt;/code&gt; pass serializes a descriptor for every needed type as a linker symbol named &lt;code&gt;type:&amp;lt;typename&amp;gt;&lt;/code&gt;, and the linker packs those symbols into a read-only data section of the binary—which is why running &lt;code&gt;strings&lt;/code&gt; on a Go executable reveals your struct tags in plain text. Every descriptor starts with a fixed 48-byte common header (&lt;code&gt;abi.Type&lt;/code&gt;) recording byte size, alignment, kind (&lt;code&gt;Struct&lt;/code&gt;, &lt;code&gt;Slice&lt;/code&gt;, &lt;code&gt;Int&lt;/code&gt;, etc.), type hash, garbage-collector pointer bitmap, equality function pointer, and name offset; immediately following that header in memory sit kind-specific fields—for a struct (&lt;code&gt;abi.StructType&lt;/code&gt;), a slice of &lt;code&gt;StructField&lt;/code&gt; entries holding each field&amp;rsquo;s name, type pointer, and byte offset within the struct, followed by method table metadata. Field names and tags are deduplicated in a shared read-only string pool to save binary size. When you use &lt;code&gt;reflect.Value&lt;/code&gt;, it pairs the type descriptor with the data pointer and adds the stored byte offset to jump straight to a field&amp;rsquo;s memory address. Reading works fine on a value copy, but mutating via reflection requires passing a pointer into &lt;code&gt;any&lt;/code&gt;—otherwise &lt;code&gt;reflect&lt;/code&gt; is only looking at a copy of your struct.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #123</title><link>https://miti99.com/en/post/2026/07/11/</link><pubDate>Sat, 11 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #123.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="our-collective-bike-shed-moment"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/our-collective-bike-shed-moment.html" rel="noopener noreferrer"&gt;Our Collective Bike Shed Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post borrows Parkinson&amp;rsquo;s &amp;ldquo;Law of Triviality&amp;rdquo;: a fictional committee approves a nuclear reactor design in ten minutes because the topic is too complex for anyone to debate, then spends forty-five minutes arguing over what color to paint the bike shed. The author argues that society is re-enacting that exact meeting in the face of AI. LLMs have blown past one supposed ceiling after another—from &amp;ldquo;they can&amp;rsquo;t write real code&amp;rdquo; to hallucinations—while growing steadily stronger at formal methods and multi-step reasoning, yet critics keep moving the goalposts while the broader public carries on as if nothing fundamental has changed.&lt;/p&gt;
&lt;p&gt;Demirbas attributes this collective shrug to normalcy bias—our default assumption that tomorrow will look mostly like yesterday—and Douglas Adams&amp;rsquo;s &amp;ldquo;Somebody Else&amp;rsquo;s Problem&amp;rdquo; field, where something colossal is ignored precisely because it is too big to process. Learning new AI tools to stay employable over the next few years is a sensible personal strategy, but it doesn&amp;rsquo;t answer what happens over the coming decades. What worries the author is that even the people who should be leading the serious conversation—technologists, researchers, economists, policymakers, ethicists, defense planners, and educators—still aren&amp;rsquo;t grappling with the long-term societal transformation at the depth required, while public attention remains fixated on surface-level bike-shedding.&lt;/p&gt;
&lt;h2 id="p99-0ms"&gt;&lt;a href="https://ruurtjan.com/articles/p99-0ms-autocomplete-for-240-million-domain-names" rel="noopener noreferrer"&gt;p99 0 ms* autocomplete for 240 million domain names&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ruurtjan Pul explains how Wirewiki achieves instantaneous-feeling autocomplete across a dataset of 240 million domain names. The trick starts in the browser: on &lt;code&gt;keydown&lt;/code&gt;, the client prefetches autocomplete results not only for the current prefix, but for every valid character the user might type next; by the time the next &lt;code&gt;keyup&lt;/code&gt; fires, the suggestions are already sitting in browser memory ready to render. Because domain names use a tiny character set (38 characters), a single response bundling top suggestions for all possible next keystrokes contains at most 312 domain names—roughly 2.5 kB compressed. According to the author&amp;rsquo;s measurements, 99% of keystrokes have at least a 121 ms budget before release, so &amp;ldquo;p99 0 ms&amp;rdquo; means the result is already local before &lt;code&gt;keyup&lt;/code&gt;, not that network packets travel faster than light.&lt;/p&gt;
&lt;p&gt;On the server side, the dataset is split into two tiers. An in-memory prefix tree (trie) holds the top eight suggestions for every prefix drawn from the Tranco top one million domains. The remaining 240 million domains from ICANN&amp;rsquo;s CZDS are sorted, front-coded (prefix-compressed), and packed into fixed-size blocks on SSD; a 27 MB in-memory index locates the right block in one hop while the OS page cache keeps hot blocks in RAM. The Go API typically responds in ~2 ms, and under 1,600 requests/sec Nginx plus the API still maintain a ~15 ms p99. Once the origin server is that fast, network round-trip time through Cloudflare dominates perceived latency—hence the asterisk in the title: a single European server still can&amp;rsquo;t beat the 121 ms budget for users halfway across the globe. The takeaway is to measure latency from the user&amp;rsquo;s physical interaction rather than just server processing time.&lt;/p&gt;
&lt;h2 id="building-reliable-agentic-ai-systems"&gt;&lt;a href="https://martinfowler.com/articles/reliable-llm-bayer.html" rel="noopener noreferrer"&gt;Building Reliable Agentic AI Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article on Martin Fowler&amp;rsquo;s site chronicles how Bayer built PRINCE, an agentic AI platform that helps pharmaceutical researchers query decades of preclinical toxicology data locked inside thousands of PDF study reports. The architecture evolved through three stages: structured metadata search, basic RAG question-answering, and finally a multi-agent workflow for complex cross-study questions. Orchestrated with LangGraph, the system steps through intent clarification, planning, research execution, evidence sufficiency checks, and report synthesis. Specialized research agents combine OpenSearch-backed RAG over unstructured PDF narratives with Athena Text-to-SQL for filtering, aggregating, and comparing structured study tables, while dedicated reflection nodes audit progress, data completeness, and draft quality.&lt;/p&gt;
&lt;p&gt;Reliability comes from the engineering harness around the models rather than clever prompting or waiting for a smarter foundation model. Each graph node receives only the narrow slice of context it needs; workflow state is checkpointed after every node so failures resume from the last completed step instead of restarting from scratch; and bounded retries operate at both the individual model-call level and the graph-node level, failing over to backup models or cloud regions when needed. In a heavily regulated pharmaceutical environment, user trust also depends on surfacing intermediate reasoning steps, linking every claim directly to source PDF pages and paragraphs, running continuous evaluations against both golden datasets and production traffic, and keeping domain scientists in the loop. Breaking a monolith prompt into an observable, checkpointed graph made the system dramatically easier to test, recover, and improve.&lt;/p&gt;
&lt;h2 id="growing-as-an-engineer-in-a-world-of-ai"&gt;&lt;a href="https://nlopes.dev/writing/growing-as-an-engineer-in-a-world-of-ai" rel="noopener noreferrer"&gt;Growing as an engineer in a world of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Norberto Lopes argues that the biggest risk AI poses to early-career engineers isn&amp;rsquo;t replacing their jobs—it&amp;rsquo;s short-circuiting their growth by removing the very friction that produces deep learning. Reading documentation, experimenting, failing, debugging, and piecing together your own mental model builds durable knowledge through &amp;ldquo;desirable difficulty&amp;rdquo; and the generation effect. Getting an instant answer is not the same as understanding the problem: if an engineer simply accepts generated code and moves on to the next ticket, they can ship working features while remaining unable to explain the design choices, trade-offs, or failure modes. That &amp;ldquo;cognitive debt&amp;rdquo; stays hidden until production breaks in a way the AI can&amp;rsquo;t immediately fix.&lt;/p&gt;
&lt;p&gt;Lopes doesn&amp;rsquo;t advocate shunning AI; instead, he recommends using it deliberately as a learning amplifier: ask &lt;em&gt;why&lt;/em&gt; an approach works, ask for alternative designs and failure scenarios, read the code and sketch your own mental model before asking the LLM to explain it, type out critical sections yourself instead of copy-pasting, and treat code review and technical writing as active thinking exercises. Foundational depth still comes from books, Unix fundamentals, primary specifications, architecture debates, and postmortems—and the time saved by AI should be reinvested into harder engineering thinking. Developing junior engineers is also an organizational responsibility: managers must protect space for learning, evaluate judgment and system understanding rather than raw ticket velocity, and keep hiring and mentoring the next generation.&lt;/p&gt;
&lt;h2 id="note-to-my-younger-self"&gt;&lt;a href="https://yewjin.substack.com/p/note-to-my-younger-self" rel="noopener noreferrer"&gt;Note To My Younger Self&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reflecting on two decades at major tech companies, Yew Jin Lim distills eight career principles that sound simple on paper but take discipline to practice. Fall in love with the actual craft rather than chasing titles, and treat your first job as a laboratory for learning how to solve problems; keep asking &amp;ldquo;why&amp;rdquo; until you reach root causes; build genuine relationships by helping people without keeping score while maintaining healthy boundaries; bring energy and joy to the team around you; listen carefully, tailor explanations to your audience, and know when to stay quiet; write down your impact every single week and proactively ask for specific feedback—then act on it visibly—so you have a concrete record of growth and course-correct early; and whenever you have a choice, optimize for a manager who will invest in your growth over a flashier title, because a great manager shapes how you think for the rest of your career.&lt;/p&gt;
&lt;p&gt;Lim candidly acknowledges survivorship bias and notes that none of these rules are absolute. When good work, a supportive manager, kindness, visibility, and mental health come into conflict, the right trade-off depends on your career stage, the skills you still need to build, personal circumstances, and how long a situation will last. When torn between options, a clarifying question is: what will still matter five years from now? Individual projects are almost always forgotten, whereas skills, mental models, and strong relationships keep compounding for decades.&lt;/p&gt;
&lt;h2 id="google-hits-50-ipv6"&gt;&lt;a href="https://blog.apnic.net/2026/04/28/google-hits-50-ipv6/" rel="noopener noreferrer"&gt;Google hits 50% IPv6&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In April 2026, Google&amp;rsquo;s public telemetry crossed the milestone of 50% of users connecting over IPv6, underscoring that IPv6 is now a mature pillar of the global Internet. At the same time, APNIC Labs measured global IPv6 adoption around 42%, and Geoff Huston explains why that gap isn&amp;rsquo;t a contradiction. APNIC&amp;rsquo;s measurement samples run via online ad placements whose impression volume varies across countries, and those per-economy numbers are then weighted by UN/ITU estimates of each country&amp;rsquo;s total Internet population—meaning the global aggregate depends heavily on sample distribution and weighting methodology. At the individual country level, APNIC&amp;rsquo;s figures track closely with Google&amp;rsquo;s and other measurement sources, making the 42%–50% range a solid band for global deployment.&lt;/p&gt;
&lt;p&gt;IPv6 adoption remains wildly uneven across regions, fixed-line ISPs, and mobile carriers. Slow migration doesn&amp;rsquo;t necessarily mean failure: many established ISPs are still amortizing heavy capital investments in IPv4 and CGNAT gear, whereas rapidly growing mobile networks often adopt IPv6 from day one to lower total cost of ownership—making transition a question of capital cycles and market economics rather than pure protocol superiority. Today&amp;rsquo;s Internet operates as a permanent dual-stack/translation hybrid across direct IPv4, NAT/CGNAT IPv4, and native IPv6, so clinging to IPv4 doesn&amp;rsquo;t avoid complexity either. Increasingly, interoperability is absorbed at the edge by CDNs, cloud load balancers, and dual-stack transit providers rather than requiring every backend system on earth to cut over simultaneously.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://www.manager.dev/newsletter/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post collects seven operational laws that engineers usually only internalize the hard way after living through production outages. First: if production breaks right after a deploy, roll back immediately (if safe to do so) to restore service and investigate afterward, instead of burning precious minutes trying to prove your commit couldn&amp;rsquo;t possibly be the cause. Second: backups don&amp;rsquo;t exist until you regularly test restoring from them, and the team knows the exact RPO, RTO, and who has permissions to run the restore. Third: logs must carry enough context and a cross-service correlation ID to trace a request end to end without drowning operators in noise.&lt;/p&gt;
&lt;p&gt;Fourth: every database migration must have a fast, concrete, pre-tested rollback plan before it touches production. Fifth: every external dependency will eventually be slow, rate-limit you, or go down completely, so understand its rate limits, failure impact, and SLAs up front and build fallbacks like caching, queues, or serving stale data. Sixth: use the four-eyes principle for risky manual operations in production—if you feel hesitant to wake a teammate up at 2 a.m. to double-check a command, that is the clearest sign you shouldn&amp;rsquo;t be running it alone. Finally, nothing is more permanent than a temporary hack, so even an MVP must be simple and solid enough to live with for years rather than a fragile patch you promise to clean up later.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!mGbr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8558b1b2-984f-4c42-bb23-e63a2252533c_2650x3068.png" alt="Top Anti-Patterns in Service Architecture"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #122</title><link>https://miti99.com/en/post/2026/07/10/</link><pubDate>Fri, 10 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #122.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-worst-take-in-tech-new-grad-hiring"&gt;&lt;a href="https://www.scottkennedy.us/new-grads" rel="noopener noreferrer"&gt;The worst take in tech: new grad hiring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Kennedy pushes back hard against the spreading narrative that companies should stop hiring new grads because AI can automate entry-level work. According to that argument, junior engineers historically learned the craft by doing simple tasks; now that AI handles those tasks, juniors won&amp;rsquo;t develop engineering judgment while budgets get spent on tokens instead. Kennedy calls this dead wrong: over the past year, he has seen the strongest new-grad talent pool in more than a decade of recruiting, and Replit doubled its new-grad hiring target to capitalize on it. Driven, curious, high-slope graduates can outperform many experienced hires within a couple of years when given strong mentorship and hard problems; writing them off because of AI is short-sighted.&lt;/p&gt;
&lt;p&gt;He also points out a distinct advantage of &amp;ldquo;AI-native&amp;rdquo; graduates: having grown up alongside modern AI tools, they have no legacy habits to unlearn and use AI coding workflows with natural fluency—something he sees repeatedly in interviews. Even so, the formula for succeeding as a junior engineer hasn&amp;rsquo;t changed: curiosity to dig beneath the surface and debug deeply, resilience to learn from failed attempts, humility to ask for help when stuck, and seeking out high-challenge environments. AI changes how the work gets done, but it doesn&amp;rsquo;t diminish the value of learning speed, grit, and judgment.&lt;/p&gt;
&lt;h2 id="parsing-gigabytes-of-json-per-second"&gt;&lt;a href="https://arxiv.org/pdf/1902.08318" rel="noopener noreferrer"&gt;Parsing Gigabytes of JSON per Second&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This paper introduces &lt;code&gt;simdjson&lt;/code&gt;, the first standard-compliant JSON parser capable of parsing gigabytes of JSON per second on a single core of a commodity CPU. The motivation is straightforward: JSON is ubiquitous across the web and distributed systems, and when applications ingest massive volumes of JSON documents, parsing easily becomes a primary CPU bottleneck despite decades of parser research.&lt;/p&gt;
&lt;p&gt;What sets &lt;code&gt;simdjson&lt;/code&gt; apart from prior validating parsers is its pervasive use of SIMD vector instructions, allowing the processor to inspect and classify dozens of bytes in parallel within a single instruction. As a result, &lt;code&gt;simdjson&lt;/code&gt; executes roughly one-quarter or fewer CPU instructions than RapidJSON—the fastest traditional parser benchmarked—while still performing full UTF-8 and structural validation. The authors released the library under a permissive open-source license, making the results easy to reproduce and enabling widespread adoption across the industry.&lt;/p&gt;
&lt;h2 id="six-sql-patterns-i-use-to-catch-transaction-fraud"&gt;&lt;a href="https://analytics.fixelsmith.com/posts/sql-fraud-patterns/" rel="noopener noreferrer"&gt;Six SQL patterns I use to catch transaction fraud&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post presents six practical SQL patterns as a first line of defense for catching anomalous transaction behavior across credit cards, e-commerce, and healthcare billing. The velocity pattern groups transactions into rolling time windows to spot rapid bursts of activity from a single cardholder; combining multiple window sizes catches both automated card-testing scripts firing in seconds and slower fraud sprees spread over hours. The impossible-travel pattern uses &lt;code&gt;LAG&lt;/code&gt; window functions paired with geographic distance formulas to flag a card used in two distant cities within an unrealistic timeframe. The suspicious-amount pattern hunts for small round test charges or transactions clustered just below reporting thresholds, while the merchant-anomaly pattern compares each merchant&amp;rsquo;s activity against its own historical baseline to spot compromised terminals.&lt;/p&gt;
&lt;p&gt;The off-hours pattern compares transaction timestamps against a cardholder&amp;rsquo;s normal spending hours, making it reliable only once an account has built up sufficient history. Finally, a feature-engineering pattern pre-computes derived window columns—such as seconds since previous transaction or trailing 24-hour spend—so combining multiple fraud signals becomes a simple &lt;code&gt;WHERE&lt;/code&gt; filter. No single rule is accurate enough in isolation, whereas a transaction tripping three or four patterns at once is almost certainly fraudulent. In production, queries still need careful &lt;code&gt;NULL&lt;/code&gt; handling, human review for false positives, and date-range partitioning before running window functions to keep warehouse costs in check.&lt;/p&gt;
&lt;h2 id="we-replaced-redis-with-mysql-for-inventory-reservationsand-it-scaled-2026"&gt;&lt;a href="https://shopify.engineering/scaling-inventory-reservations" rel="noopener noreferrer"&gt;We replaced Redis with MySQL for inventory reservations—and it scaled (2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shopify migrated its flash-sale inventory reservation system from Redis to MySQL so that temporary checkout reservations and the canonical inventory ledger live inside the exact same ACID transaction. Updating two separate stores without atomicity risks overselling or leaked reservations when failures happen mid-flight. Instead of storing a single quantity counter row per SKU—which would serialize every concurrent buyer behind a single row lock—the new schema represents each individual unit of inventory as its own row, capped at a pool of 1,000 rows per SKU-location pair so tables stay compact while queries remain fast even for massive stock counts. MySQL 8&amp;rsquo;s &lt;code&gt;SELECT ... FOR UPDATE SKIP LOCKED&lt;/code&gt; lets concurrent checkouts skip rows currently locked by other buyers instead of waiting in line, drastically cutting lock contention during flash sales. A composite primary key minimizes per-row lock overhead, &lt;code&gt;READ COMMITTED&lt;/code&gt; isolation prevents gap locks from blocking concurrent inventory restocks, and deterministic lock ordering prevents deadlocks.&lt;/p&gt;
&lt;p&gt;During rollout, however, the real bottleneck turned out to be connection pool exhaustion: database CPU sat low while requests queued up waiting for connections. Tagging queries with business workflow metadata and measuring at the proxy layer revealed unrelated checkout operations holding database connections open far too long. After cleaning up connection lifetimes and tuning configs, primary database reads dropped by 50%, total transactions fell by 33%, and writer CPU stayed below 50% even during peak flash sales. To migrate safely, Shopify dual-wrote to both Redis and MySQL while Redis remained primary, shadowed and compared results against live traffic, and shifted primary reads incrementally by cohort with instant rollback ready at every step.&lt;/p&gt;
&lt;h2 id="cell-based-architecture-for-resilient-payment-systems"&gt;&lt;a href="https://americanexpress.io/cell-based-architecture-for-resilient-payment-systems/" rel="noopener noreferrer"&gt;Cell-Based Architecture for Resilient Payment Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;American Express structures its core payment processing platform into self-contained cells, where each cell bundles its own services, databases, and supporting infrastructure. A cell is defined as a fault-isolation boundary rather than a specific deployment technology: an entire cell can fail, undergo maintenance, or be drained of traffic without impacting neighboring cells. Slowly changing reference data like currency exchange rates is replicated into every cell ahead of time to avoid synchronous cross-cell lookups, while stateful transactions are routed deterministically to the cell holding the authoritative state. A Global Transaction Router governs all ingress traffic and strictly forbids services inside one cell from calling directly into another; while this sometimes requires duplicating services across cells, it preserves hard fault isolation and keeps latency low.&lt;/p&gt;
&lt;p&gt;When a cell fails mid-transaction, in-flight requests aren&amp;rsquo;t resumed halfway through on another cell—they are replayed from the beginning on a healthy cell using the original request payload. That retry is safe because a globally unique transaction ID enforces end-to-end idempotency, allowing downstream systems to detect and deduplicate repeated work. Traffic shifts across cells gradually by percentage rather than flipping all at once. The platform also minimizes non-essential dependencies on the critical path by making audit logging and config refreshes asynchronous, gracefully degrading auxiliary features so payment authorization never stalls. True resilience comes from strict blast-radius boundaries and architectural discipline, not just monitoring and retries.&lt;/p&gt;
&lt;h2 id="when-failover-isnt-safe-building-high-availability-postgresql-on-kubernetes"&gt;&lt;a href="https://www.datadoghq.com/blog/engineering/postgresql-ha-kubernetes/" rel="noopener noreferrer"&gt;When failover isn’t safe: Building high-availability PostgreSQL on Kubernetes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;During a simulated availability-zone failure game day, Datadog discovered that their high-availability PostgreSQL clusters on Kubernetes could not fail over safely. When network latency spiked during the drill, the primary kept accepting writes and replicating asynchronously while standby replicas fell further and further behind. When the primary was terminated, Patroni rightly refused to promote any standby because their replication lag exceeded &lt;code&gt;maximum_lag_on_failover&lt;/code&gt;—preventing silent data loss, but leaving the cluster wedged and unable to accept writes until human operators intervened. The first lesson: nominal high availability means nothing if no replica is actually safe to promote when disaster strikes.&lt;/p&gt;
&lt;p&gt;Datadog moved to a hybrid replication topology: standby instances eligible for failover use synchronous replication, while read-only replicas stay asynchronous to avoid unnecessary latency penalties. In Patroni, they enabled &lt;code&gt;synchronous_mode&lt;/code&gt;, &lt;code&gt;synchronous_mode_strict&lt;/code&gt;, and &lt;code&gt;synchronous_commit = remote_apply&lt;/code&gt;, guaranteeing a transaction is acknowledged only after its WAL records have been replayed and applied on the synchronous standby. Synthetic benchmarks at this highest durability setting showed average write latency increasing by 53% and throughput dropping by 34%, but rolling the change out gradually across datacenters with soak periods confirmed that real-world application impact remained well within acceptable bounds. If all synchronous standbys become unavailable, the primary halts writes rather than silently risking data loss, turning an invisible durability hazard into an explicit error that callers can retry or queue. Balancing durability and performance requires actively monitoring &lt;code&gt;SyncRep&lt;/code&gt; wait events alongside standby health.&lt;/p&gt;
&lt;h2 id="from-christmas-outage-to-1-app-store-ranking-an-aura-frames-postgres-scaling-retrospective"&gt;&lt;a href="https://andyatkinson.com/postgresql-rds-scaling-aws-christmas-day-peak" rel="noopener noreferrer"&gt;From Christmas Outage to #1 App Store Ranking: An Aura Frames Postgres Scaling Retrospective&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On Christmas Day 2024—the biggest traffic day of the year for digital photo frames—Aura Frames suffered a three-hour PostgreSQL outage when unbounded WAL growth filled their dedicated WAL volume. The culprit was an RDS PostgreSQL 14.1 default that attached replication slots to read replicas: a replication slot forces the primary to retain WAL segments until every replica has consumed them, so when a replica fell behind under holiday load, WAL piled up until the primary ran out of disk space and crashed. The team immediately capped slot retention using &lt;code&gt;max_slot_wal_keep_size&lt;/code&gt; (noting that &lt;code&gt;wal_keep_size&lt;/code&gt; sets a minimum floor, not a ceiling), choosing to invalidate a lagging replica rather than let the primary go down.&lt;/p&gt;
&lt;p&gt;To prepare for Christmas 2025, instead of vertically scaling a single massive primary again, Aura partitioned at the table level (functional sharding): the ten highest-write tables were split out onto seven new primaries, creating eight databases in total. This proved a pragmatic middle ground before needing horizontal row sharding on their largest table. The Ruby on Rails monolith stayed intact, routing queries cleanly via Active Record Multiple Databases, while physical replication moved data over with just 5–10 minutes of cutover downtime. Total provisioned CPU and memory increased roughly 4.7x, and on Christmas Day 2025 the system peaked at 226,000 transactions per second—sustaining over 100,000 TPS for ten straight hours at an average query latency of 25 microseconds. Continuous testing, canary rollouts, and load testing de-risked the data-access changes; temporarily over-provisioning for a predictable annual peak made complete sense, and AWS Blue/Green deployments let them scale the fleet back down afterward to restore cost efficiency.&lt;/p&gt;
&lt;h2 id="gitignore-isnt-the-only-way-to-ignore-files-in-git"&gt;&lt;a href="https://nelson.cloud/.gitignore-isnt-the-only-way-to-ignore-files-in-git/" rel="noopener noreferrer"&gt;.gitignore Isn’t the Only Way To Ignore Files in Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Git supports three distinct scopes for ignoring files, each suited to a different job. &lt;code&gt;.gitignore&lt;/code&gt; is committed into the repository, making it the right place for project-wide rules shared by every contributor, like build outputs and dependency folders. &lt;code&gt;.git/info/exclude&lt;/code&gt; lives inside your local &lt;code&gt;.git&lt;/code&gt; directory and is never tracked or pushed, applying only to your local clone—ideal for personal scratch files, local scripts, or project-specific tool configs that don&amp;rsquo;t belong in the team&amp;rsquo;s shared &lt;code&gt;.gitignore&lt;/code&gt;. Finally, &lt;code&gt;~/.config/git/ignore&lt;/code&gt; acts as your user-wide global ignore file across every repository on your machine, perfect for OS- or editor-generated noise like macOS &lt;code&gt;.DS_Store&lt;/code&gt; files or editor swap files.&lt;/p&gt;
&lt;p&gt;You can customize the location of the global ignore file via &lt;code&gt;git config --global core.excludesFile ~/.gitignore_global&lt;/code&gt; and reset it to the default with &lt;code&gt;git config --global --unset core.excludesFile&lt;/code&gt;. And whenever you aren&amp;rsquo;t sure which rule across those three layers is causing a file to be ignored, &lt;code&gt;git check-ignore -v &amp;lt;path&amp;gt;&lt;/code&gt; is the fastest way to debug it: the command prints the exact ignore file, line number, and pattern that matched—or outputs nothing if the file isn&amp;rsquo;t ignored.&lt;/p&gt;
&lt;h2 id="the-only-scalable-delete-in-postgres-is-drop-table"&gt;&lt;a href="https://planetscale.com/blog/the-only-scalable-delete" rel="noopener noreferrer"&gt;The only scalable delete in Postgres is DROP TABLE&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In PostgreSQL, running a large &lt;code&gt;DELETE&lt;/code&gt; doesn&amp;rsquo;t immediately free disk space—it creates a mountain of follow-up work for the database. Under MVCC, deleted rows remain on disk as dead tuples so concurrent transactions can still see a consistent snapshot; autovacuum eventually marks that space reusable internally, but rarely shrinks the underlying data files on disk (except when completely empty pages sit at the very end of a relation), and indexes and sequential scans still pay the cost of skipping over dead tuples in the meantime. Mass deletes also generate heavy WAL volume that must be replicated downstream, inflating write latency, vacuum debt, and replica lag—while cascading foreign-key deletes can unexpectedly amplify a small delete into gigabytes of churn. &lt;code&gt;VACUUM FULL&lt;/code&gt; reclaims OS disk space, but only by taking an expensive exclusive table lock and rewriting the entire table.&lt;/p&gt;
&lt;p&gt;By contrast, &lt;code&gt;DROP TABLE&lt;/code&gt; and &lt;code&gt;TRUNCATE&lt;/code&gt; acquire an &lt;code&gt;AccessExclusiveLock&lt;/code&gt; but execute in nearly constant time regardless of row count: they unlink the underlying physical files directly without generating per-row dead tuples or vacuum debt. Consequently, schemas that need regular bulk purges should be designed so large deletes become table drops. For time-series or retention-bound data, time-based table partitioning turns recurring deletes into instantly dropping the oldest partition. For a one-off cleanup where most rows are being deleted, copying the surviving rows into a temporary table, running &lt;code&gt;TRUNCATE&lt;/code&gt; on the original, and inserting them back avoids per-row delete WAL (though structural and re-insert WAL still applies); if you cannot afford a long lock, you can dual-write and backfill into a fresh table before swapping names in a brief transaction, taking care to handle foreign keys, sequences, and concurrent writes. When the rows to delete are a small fraction of the table, batched deletes in small transactions remain the practical choice so autovacuum can keep up between batches.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #121</title><link>https://miti99.com/en/post/2026/07/09/</link><pubDate>Thu, 09 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #121.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dial-up"&gt;&lt;a href="https://jkm.dev/posts/how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dialup/" rel="noopener noreferrer"&gt;How 2004 RuneScape fit a multiplayer RPG into 56k dial-up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post dissects how 2004 RuneScape ran a massively multiplayer world over 56k dial-up modems, where real-world throughput was just a few kilobytes per second and the Java applet client had only a single TCP connection. Rather than sending self-describing messages, the network protocol was co-designed as a shared state machine between client and server: both sides held the exact same collision map, ran the same pathfinding algorithm, and stepped forward on a 600 ms server tick. Thanks to all that shared implicit context never having to cross the wire, walking across the map cost roughly 7 bytes upstream and 9 bytes downstream per observer—the client only sent path waypoints where direction changed, and the server validated and reconstructed the rest.&lt;/p&gt;
&lt;p&gt;The most fascinating takeaway is how saving bytes goes far beyond generic compression. The most common state was made practically free: an idle player in your viewport cost a single bit, meaning standing among twenty stationary players took roughly five bytes per tick to confirm nothing changed. Newly appearing players were encoded using 5-bit relative coordinates offset from the local player rather than 16-bit global world coordinates. Bit-packing was reserved strictly for small, high-frequency movement updates; larger, rarely changing appearance blocks stayed byte-aligned so the server could cache and memcpy pre-built buffers directly. The architectural lesson: the smallest possible wire format comes from tightly coupling client and server assumptions, trading away the self-description, independent deployability, and easy debugging that modern HTTP/JSON APIs prioritize.&lt;/p&gt;
&lt;h2 id="how-does-struct-take-zero-bytes-in-go"&gt;&lt;a href="https://www.bud1m.com/blog/go-empty-struct/" rel="noopener noreferrer"&gt;How does struct{} take zero bytes in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why Go&amp;rsquo;s empty struct &lt;code&gt;struct{}&lt;/code&gt; occupies zero bytes and how it is idiomatically used to represent presence or signaling rather than data. Inspecting &lt;code&gt;unsafe.Sizeof&lt;/code&gt; confirms that an empty struct takes 0 bytes; used as the value type in &lt;code&gt;map[string]struct{}&lt;/code&gt;, it expresses a pure set where only key existence matters, and on a channel (&lt;code&gt;chan struct{}&lt;/code&gt;) it signals an event without carrying a payload. The author also notes that starting in Go 1.24, Go&amp;rsquo;s built-in maps use Swiss Tables under the hood, leaving almost no meaningful memory difference between &lt;code&gt;map[string]struct{}&lt;/code&gt; and &lt;code&gt;map[string]bool&lt;/code&gt;—so choosing &lt;code&gt;struct{}&lt;/code&gt; today is mainly about expressing intent clearly.&lt;/p&gt;
&lt;p&gt;At the runtime level, whenever a zero-sized value has to be allocated on the heap, &lt;code&gt;mallocgc&lt;/code&gt; checks for &lt;code&gt;size == 0&lt;/code&gt; and returns a pointer to a single global runtime variable named &lt;code&gt;zerobase&lt;/code&gt; instead of allocating heap memory. Whether the value escapes to the heap in the first place is decided by escape analysis: passing it to &lt;code&gt;fmt.Println&lt;/code&gt; (which takes &lt;code&gt;any&lt;/code&gt;) often triggers an escape to &lt;code&gt;zerobase&lt;/code&gt;, whereas built-in &lt;code&gt;println&lt;/code&gt; keeps it on the stack. This design creates two subtle gotchas worth remembering. First, multiple distinct &lt;code&gt;struct{}&lt;/code&gt; variables may share the exact same memory address, and the compiler is free to merge or not merge them, so you should never rely on pointer equality to distinguish zero-sized values. Second, placing a &lt;code&gt;struct{}&lt;/code&gt; as the final field inside a larger non-empty struct causes the compiler to add 1 byte of trailing padding (plus alignment) so that taking the address of that final field doesn&amp;rsquo;t point past the end of the allocation into an adjacent object; if you want zero overhead inside a struct, place the empty struct field anywhere except last.&lt;/p&gt;
&lt;h2 id="is-cloudflare-silently-killing-the-web-hosting-industry"&gt;&lt;a href="https://webhosting.today/2026/06/17/is-cloudflare-silently-killing-the-web-hosting-industry/" rel="noopener noreferrer"&gt;Is Cloudflare silently killing the web hosting industry?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Konrad Keck argues that Cloudflare isn&amp;rsquo;t killing traditional web hosting by becoming a better shared host—it is doing it by moving the starting point of how websites get built and deployed. Historically, a customer bought a domain, signed up for shared hosting, logged into cPanel, installed WordPress, configured SSL and email, and maybe put Cloudflare in front later for CDN and DDoS protection. Today, when a project starts inside Claude Code, Cursor, Lovable, Bolt, or Replit, the question is no longer &amp;ldquo;which hosting plan do I buy?&amp;rdquo; but &amp;ldquo;where do I deploy this?&amp;rdquo;, and Cloudflare, Vercel, and Netlify are built to capture that exact moment. Cloudflare is competing on workflow, not just infrastructure.&lt;/p&gt;
&lt;p&gt;Keck highlights two main levers: near-zero-cost deployment via Pages, Workers, static assets, and usage-priced R2/D1—which hollows out traditional hosting&amp;rsquo;s bread-and-butter market of landing pages, docs sites, frontends, and small APIs—and at-cost domain registration as a top-of-funnel wedge into the ecosystem. Cloudflare&amp;rsquo;s Registrar API closes the loop even further: an AI agent can scaffold a project, suggest available domains, check pricing, register the domain, configure DNS, and deploy to production without the user ever visiting a hosting control panel. Traditional web hosts aren&amp;rsquo;t disappearing overnight—legacy WordPress/WooCommerce and PHP apps, real business email, hands-on migrations, emergency support, local compliance, and non-technical SMBs still rely on human-backed services. The strategic shift is that traditional hosts must evolve into specialized managed service providers, because selling the default starting point of a website is slipping away.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://staysaasy.com/startups/2026/06/16/stacked-weaknesses.html" rel="noopener noreferrer"&gt;Don&amp;rsquo;t Stack Weaknesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy writes about an organizational failure mode that often hides in plain sight across leadership chains: stacking the same weakness across multiple layers of management. Almost every leader has at least one real weakness—someone might be a visionary strategist but poor at operational execution, or deeply technical but weak at executive communication—and on its own, that doesn&amp;rsquo;t sink an org. The danger comes when a leader hires or promotes direct reports who share the exact same blind spot. If both a VP and their directors are weak at operations, the odds of the teams underneath them having strong operational processes drop to nearly zero: leadership doesn&amp;rsquo;t know how to do it themselves, doesn&amp;rsquo;t know how to interview for it, and can&amp;rsquo;t accurately judge whether it&amp;rsquo;s being done well.&lt;/p&gt;
&lt;p&gt;Weakness stacking usually happens unconsciously: leaders naturally recognize and reward strengths that mirror their own, labeling that similarity &amp;ldquo;values alignment&amp;rdquo; or &amp;ldquo;culture fit&amp;rdquo; while actually cloning their own skillset and blind spots. Avoiding the trap starts with an honest self-assessment across six core axes—technical/domain depth, people management, process and operations, strategy, communication/presentation, and learning agility—and then deliberately hiring people who are significantly stronger than you in your weakest areas. The post also warns against comforting yourself with &amp;ldquo;I could do operations if I really wanted to,&amp;rdquo; which is almost always an excuse to avoid confronting a gap. An organization without stacked weaknesses is far more resilient to unexpected challenges.&lt;/p&gt;
&lt;h2 id="system-design-cheatsheet"&gt;&lt;a href="https://gist.github.com/SuyashDive2005/be5865a9755ca1dd50523f7aeeae4417" rel="noopener noreferrer"&gt;System Design Cheatsheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This gist serves as a compact checklist for system design interviews and architecture reviews, anchored on a core principle: good architecture is about picking the right battles and managing trade-offs. It outlines a familiar five-step loop: clarify scope through use cases and constraints; sketch a high-level design covering core services, storage, caching, and load balancing; dive into component details including APIs and data schemas; identify bottlenecks; and scale vertically or horizontally as needed. For newer engineers, its biggest value is forcing quantitative questions early, before jumping to technology choices: how many requests per second, what is the read-to-write ratio, how fast does data grow, does latency or throughput matter more, and where does the system sit on the consistency-versus-availability spectrum?&lt;/p&gt;
&lt;p&gt;The scaling section reviews foundational building blocks: multi-tier caching, load balancing, replication and sharding, MapReduce for batch data processing, and platform separation so components can scale independently. It also lists six core fundamentals worth mastering: concurrency, networking, abstraction boundaries, real-world hardware performance numbers, back-of-the-envelope estimation to rule out dead ends early, and fault tolerance in distributed environments. While brief and carrying a few older examples, it remains a solid mental checklist: characterize load, data shape, failure modes, and scaling paths before picking tools.&lt;/p&gt;
&lt;h2 id="sqlite-improving-performance-with-pre-sort"&gt;&lt;a href="https://andersmurphy.com/2026/06/07/sqlite-improving-performance-with-pre-sort.html" rel="noopener noreferrer"&gt;SQLite improving performance with pre-sort&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anders Murphy follows up on his earlier SQLite UUIDv4 vs. UUIDv7 benchmarks with a tougher scenario: what happens when your primary key must be a 160-bit cryptographically random value generated via &lt;code&gt;SecureRandom&lt;/code&gt;—such as a session token—where you cannot switch to time-ordered UUIDv7 because you need maximum entropy and zero timestamp leakage? When batch-inserting one million rows into a &lt;code&gt;WITHOUT ROWID&lt;/code&gt; table keyed by a &lt;code&gt;BLOB PRIMARY KEY&lt;/code&gt;, insert throughput starts around 100,000 rows per second and steadily degrades as the table grows. The bottleneck isn&amp;rsquo;t SQLite being slow; it&amp;rsquo;s the physics of a B+ Tree: because the tree stores keys in sorted order, sequential inserts append cleanly, whereas uniformly random keys scatter writes across leaf pages all over disk, triggering constant page splits and tree rebalancing.&lt;/p&gt;
&lt;p&gt;Murphy&amp;rsquo;s optimization is disarmingly simple: since the application is already inserting in batches, sort each batch in memory by primary key before inserting. Because SQLite compares &lt;code&gt;BLOB&lt;/code&gt; keys using &lt;code&gt;memcmp()&lt;/code&gt;, the application-side comparator just needs to match byte-wise ordering; Murphy grabs the first 8 bytes of each 20-byte token as an unsigned 64-bit integer to make the in-memory sort fast. Even including the CPU cost of sorting each batch, once the table reaches ten million rows, batch insert time drops from 11.1 seconds to 3.8 seconds—roughly a 2–3x speedup. The practical takeaway: batching doesn&amp;rsquo;t just amortize transaction overhead; it also gives you a window to reorder writes into a layout that is far friendlier to the underlying storage engine.&lt;/p&gt;
&lt;h2 id="why-is-meta-destroying-its-engineering-organization"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/why-is-meta-destroying-its-engineering" rel="noopener noreferrer"&gt;Why is Meta destroying its engineering organization?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz pieces together a tense picture of engineering inside Meta since April 2026, as the company pivots aggressively around AI. Historically, Meta was renowned for its strong bottom-up engineering culture: lightweight process, high individual autonomy, rock-solid internal tooling that let engineers &amp;ldquo;move fast,&amp;rdquo; and engineers treated as the core value creators. Under the direction of Mark Zuckerberg and Alexandr Wang, however, 30–50% of core software engineers across many teams—including infrastructure and security—were reassigned into a new ADO organization (roughly 6,500 people) to do data labeling, model output grading, and RLHF. Meta also rolled out mandatory keystroke and mouse tracking on engineering laptops to harvest training data with no opt-out (later walked back slightly after internal backlash), alongside ongoing layoff pressure and AI token-usage quotas.&lt;/p&gt;
&lt;p&gt;What stands out most isn&amp;rsquo;t just &amp;ldquo;Meta is pushing AI hard,&amp;rdquo; but how badly perverse incentives distort behavior. Once AI token consumption became a performance metric, engineers naturally gamed the metric (burning 60.2 trillion tokens in 30 days) rather than optimizing for software quality. And when AI-generated code reviewed only by AI gets pushed rapidly to production while security teams are gutted and reassigned, operational risk compounds fast: Orosz connects these dynamics to the May 30 Instagram account-takeover incident and the departure of Meta&amp;rsquo;s CISO shortly afterward. The broader lesson is not to confuse fast MTTR with system health: recovering quickly from outages cannot compensate for eroding human comprehension, weakened guardrails, and hollowed-out engineering ownership.&lt;/p&gt;
&lt;h2 id="cs-6120-advanced-compilers-the-self-guided-online-course"&gt;&lt;a href="https://www.cs.cornell.edu/courses/cs6120/2025fa/self-guided/" rel="noopener noreferrer"&gt;CS 6120: Advanced Compilers: The Self-Guided Online Course&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page hosts the self-guided version of CS 6120, Adrian Sampson&amp;rsquo;s PhD-level course at Cornell on programming language implementation and modern compilers. The curriculum progresses from core compiler foundations—intermediate representations, dataflow analysis, local and global optimizations, SSA form, and LLVM—into research-adjacent topics like dynamic compilers (JITs), garbage collection, parallelism, and fast compilation. Each lesson pairs lecture videos and written notes with classic academic papers and open-ended implementation tasks to turn abstract theory into working code.&lt;/p&gt;
&lt;p&gt;The self-guided track preserves the linear structure of the university course while removing deadlines, grading, and internal class discussion boards. Learners follow a clear rhythm: watch the lecture, read the companion paper, and implement compiler passes using either LLVM or Bril—a small, pedagogical intermediate representation designed to be much easier to hack on than jumping straight into a production compiler—culminating in a final project. It is an outstanding resource for internalizing that a compiler isn&amp;rsquo;t just &amp;ldquo;a parser bolted onto a code generator,&amp;rdquo; but a pipeline of representation choices, program analyses, optimizations, and trade-offs between correctness, compile time, and generated code quality. The best way to use it is writing the small transformation passes yourself as you go, since compiler concepts are notoriously easy to misunderstand if you only read about them.&lt;/p&gt;
&lt;h2 id="epoll-vs-io_"&gt;&lt;a href="https://sibexi.co/posts/epoll-vs-io_uring/" rel="noopener noreferrer"&gt;epoll vs io_uring in Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares &lt;code&gt;epoll&lt;/code&gt; and &lt;code&gt;io_uring&lt;/code&gt; through the lens of building TinyGate, a lightweight reverse proxy in C. The first prototype used a simple thread-per-worker model that was easy to reason about but hit a hard performance ceiling; moving to &lt;code&gt;epoll&lt;/code&gt; delivered a major speedup, yet still paid the fundamental tax of a readiness-based model: &lt;code&gt;epoll&lt;/code&gt; only tells you when a file descriptor is ready for I/O, leaving the application to issue its own &lt;code&gt;read()&lt;/code&gt; or &lt;code&gt;write()&lt;/code&gt; syscalls afterward. Every I/O event therefore incurs syscall and context-switch overhead on top of &lt;code&gt;epoll_ctl&lt;/code&gt; registration, which adds up quickly across tens of thousands of active connections.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;io_uring&lt;/code&gt; shifts to a completion-based model: the application writes I/O requests into a submission queue in shared memory, the kernel executes them asynchronously, and results land in a shared completion queue. A single &lt;code&gt;io_uring_enter()&lt;/code&gt; call can submit and harvest an entire batch of operations instead of paying a syscall per &lt;code&gt;read()&lt;/code&gt;/&lt;code&gt;write()&lt;/code&gt;. Enabling &lt;code&gt;IORING_SETUP_SQPOLL&lt;/code&gt; can even eliminate steady-state syscalls almost entirely, at the cost of dedicating a kernel thread that spins and consumes CPU to poll the submission ring. While the author recommends considering &lt;code&gt;io_uring&lt;/code&gt; for new high-performance Linux projects (available since Linux 5.1, though specific opcodes depend on kernel version), he cautions that production use requires care: using rings or registered buffers doesn&amp;rsquo;t automatically guarantee zero-copy I/O, errors arrive asynchronously via completion queue entries, and minimal tutorial examples omit many edge-case checks required in real servers.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #120</title><link>https://miti99.com/en/post/2026/07/08/</link><pubDate>Wed, 08 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #120.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="lessons-from-building-claude-code-how-we-use-skills"&gt;&lt;a href="https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills" rel="noopener noreferrer"&gt;Lessons from building Claude Code: How we use skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thariq Shihipar, a member of the Claude Code team at Anthropic, distills lessons learned from building and using hundreds of internal skills. The central insight is that a skill isn&amp;rsquo;t just a single Markdown file of instructions—it is an entire folder that can bundle scripts, assets, reference data, hooks, and configuration. This structure enables progressive disclosure: the agent reads &lt;code&gt;SKILL.md&lt;/code&gt; first and only loads auxiliary docs or helper scripts when the task actually needs them, keeping the context window lean. Shihipar groups skills into nine practical categories: library/API references, product verification, data analysis, workflow automation, code scaffolding, code review, CI/CD, operational runbooks, and infrastructure management.&lt;/p&gt;
&lt;p&gt;When authoring skills, he advises skipping generic advice Claude already knows and focusing on instructions that nudge the model out of its default habits—especially a living &amp;ldquo;gotchas&amp;rdquo; section capturing recurring pitfalls, repo conventions, and edge cases added whenever the agent makes a mistake in practice. State high-level goals rather than rigid step-by-step micromanagement, give the skill a persistence mechanism (like log or JSON files) to maintain state across sessions, and bundle composable helper scripts so the agent doesn&amp;rsquo;t have to reconstruct boilerplate operations from scratch via token generation. For larger teams, skills can be committed directly to the repo or distributed through an internal plugin marketplace so engineers install only what they need without bloating context, while hooks track usage metrics to prune overly broad or unused skills.&lt;/p&gt;
&lt;h2 id="bulkhead-pattern---go"&gt;&lt;a href="https://dev.to/kamal_namdeo/bulkhead-pattern-go-362c" rel="noopener noreferrer"&gt;Bulkhead Pattern - Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kamal Namdeo walks through implementing the Bulkhead Pattern in Go: isolating resources per downstream dependency so one slow or failing service cannot exhaust goroutines, sockets, and request budgets across your entire application. Instead of letting every outbound HTTP call share &lt;code&gt;http.DefaultTransport&lt;/code&gt;, each downstream dependency gets its own three-layer bulkhead: a semaphore capping concurrent in-flight requests (using &lt;code&gt;TryAcquire&lt;/code&gt; to fail fast when full), a dedicated connection pool via &lt;code&gt;MaxConnsPerHost&lt;/code&gt; so one slow host cannot starve TCP connections to others, and tight timeouts that free resources quickly when an upstream stalls. That way, if the auth service is degraded, billing and S3 calls continue unaffected.&lt;/p&gt;
&lt;p&gt;The post also shows how to size concurrency limits. Little&amp;rsquo;s Law relates average concurrency to throughput and average latency; plugging in p99 latency plus a 30% safety buffer is the author&amp;rsquo;s practical sizing heuristic rather than the law itself, showing why slower dependencies require more slots to sustain the same throughput. Blast radius during outages is contained through layered timeouts: &lt;code&gt;ResponseHeaderTimeout&lt;/code&gt; (roughly 1.2x p99), &lt;code&gt;Client.Timeout&lt;/code&gt; covering the full request lifecycle, a 1–2 second TCP dial/TLS handshake timeout, and a &lt;code&gt;QueueTimeout&lt;/code&gt; derived by subtracting downstream latency from your SLA budget. Namdeo closes with common Go pitfalls: &lt;code&gt;runtime.NumCPU()&lt;/code&gt; is the wrong basis for sizing I/O concurrency because goroutines blocked on network reads don&amp;rsquo;t consume CPU cores, response bodies must be drained before closing so connections can return to the idle pool, and &lt;code&gt;MaxIdleConns&lt;/code&gt; should equal the sum of per-host idle limits so dependencies don&amp;rsquo;t evict each other&amp;rsquo;s pooled connections.&lt;/p&gt;
&lt;h2 id="max-consecutive-ones"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/max-consecutive-ones-13mj" rel="noopener noreferrer"&gt;Max Consecutive Ones&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh breaks down a foundational LeetCode problem in Java: given a binary array, find the maximum number of consecutive &lt;code&gt;1&lt;/code&gt;s. The brute-force approach starts at every index containing a &lt;code&gt;1&lt;/code&gt;, scans forward to count the streak, and updates the global maximum. While easy to explain in an interview, it repeatedly re-scans the same elements, resulting in &lt;code&gt;O(N²)&lt;/code&gt; time complexity with &lt;code&gt;O(1)&lt;/code&gt; auxiliary space.&lt;/p&gt;
&lt;p&gt;The optimal solution rests on a simple observation: a streak of &lt;code&gt;1&lt;/code&gt;s grows as long as we keep seeing &lt;code&gt;1&lt;/code&gt; and resets the moment we hit a &lt;code&gt;0&lt;/code&gt;, meaning we only ever need to track the length of the current streak. By maintaining two scalar variables—current streak length and maximum streak seen so far—we increment the counter and update the max on &lt;code&gt;1&lt;/code&gt;, and reset the counter to &lt;code&gt;0&lt;/code&gt; on &lt;code&gt;0&lt;/code&gt;. That single pass runs in &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space without nested loops. Recognizing this &amp;ldquo;maintain running state, update global best, reset when the invariant breaks&amp;rdquo; pattern makes short work of many contiguous-subarray interview questions.&lt;/p&gt;
&lt;h2 id="double-bigdecimal-or-fixed-point"&gt;&lt;a href="https://blog.frankel.ch/bigdecimal-vs-double/" rel="noopener noreferrer"&gt;double, BigDecimal, or Fixed-Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago pushes back against blanket slogans like &amp;ldquo;always use &lt;code&gt;BigDecimal&lt;/code&gt; for money&amp;rdquo; or &amp;ldquo;&lt;code&gt;double&lt;/code&gt; is broken.&amp;rdquo; Under IEEE 754, &lt;code&gt;double&lt;/code&gt; is a binary floating-point approximation, meaning base-10 fractions like &lt;code&gt;0.1&lt;/code&gt; cannot be represented exact to the last bit—but that is a deliberate engineering trade-off. For domains that are inherently approximate, such as analytics, machine learning, or physics simulations, &lt;code&gt;double&lt;/code&gt; is usually the right choice because it runs directly in hardware at blistering speed; you simply need to compare values using an epsilon tolerance instead of &lt;code&gt;==&lt;/code&gt;, handle &lt;code&gt;NaN&lt;/code&gt; and &lt;code&gt;-0.0&lt;/code&gt; properly, and reach for techniques like Kahan or Neumaier summation, pairwise summation, or &lt;code&gt;Math.fma()&lt;/code&gt; when minimizing accumulated rounding error.&lt;/p&gt;
&lt;p&gt;Conversely, &lt;code&gt;BigDecimal&lt;/code&gt; shines when exact decimal representation, explicit rounding modes, and auditability are mandatory—such as tax calculation, invoicing, and accounting—at the cost of heap allocations and software arbitrary-precision arithmetic. It also has its own footguns: calling &lt;code&gt;new BigDecimal(0.1)&lt;/code&gt; bakes in the binary float inaccuracy (always use &lt;code&gt;new BigDecimal(&amp;quot;0.1&amp;quot;)&lt;/code&gt; or &lt;code&gt;BigDecimal.valueOf(0.1)&lt;/code&gt;), forgetting to reassign results on immutable instances, or calling &lt;code&gt;equals()&lt;/code&gt;—which compares scale (&lt;code&gt;2.0&lt;/code&gt; != &lt;code&gt;2.00&lt;/code&gt;)—instead of &lt;code&gt;compareTo()&lt;/code&gt;. For high-throughput financial engines, fixed-point arithmetic using &lt;code&gt;long&lt;/code&gt; is often the pragmatic sweet spot: store &lt;code&gt;$19.99&lt;/code&gt; as &lt;code&gt;1999&lt;/code&gt; cents, use &lt;code&gt;Math.addExact&lt;/code&gt; and &lt;code&gt;multiplyExact&lt;/code&gt; to catch overflows immediately, and convert to &lt;code&gt;BigDecimal&lt;/code&gt; only at system boundaries. Fago also warns about losing trailing scale during JSON serialization and non-reproducible sums in parallel &lt;code&gt;DoubleStream&lt;/code&gt; pipelines. Choose numeric types based on domain precision rules, rounding semantics, and performance constraints—not slogans.&lt;/p&gt;
&lt;h2 id="can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update"&gt;&lt;a href="https://medium.com/helidon/can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update-e16a2e262fc4" rel="noopener noreferrer"&gt;Can Java Microservices Be As Fast As Go? A 2026 Benchmark Update&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Six years after his original comparison, Mark Nelson revisits the question: can a small Java microservice match Go on raw performance? He benchmarks Go 1.26.3 using &lt;code&gt;net/http&lt;/code&gt; against Helidon SE 4.4.1 (handling requests on virtual threads) running on Oracle JDK 26.0.1, alongside a variant using a Project Leyden AOT cache. The test service is deliberately small and synthetic: an endpoint generates payloads of 7, 128, 2048, or 8192 bytes, performs uppercase, lowercase, string reversal, and CRC32 calculations with &lt;code&gt;WORK_FACTOR=10&lt;/code&gt;, and returns JSON. Each runtime is benchmarked sequentially with dedicated warmup passes and logging disabled. Before recording final numbers, Nelson noticed Helidon exhibiting a puzzling 44–48 ms latency floor on larger responses over reused HTTP/1.1 connections; enabling &lt;code&gt;tcpNoDelay(true)&lt;/code&gt; eliminated the Nagle/delayed-ACK interaction immediately.&lt;/p&gt;
&lt;p&gt;What stands out in the results isn&amp;rsquo;t a simplistic &amp;ldquo;Java beats Go&amp;rdquo; headline, but the shape of the scaling curves. At small payload sizes and low concurrency, all three configurations perform in roughly the same ballpark. As concurrent connections and payload sizes climb, however, the Java setups scale noticeably better: at 2 KB payloads, Go peaks around 17,000 requests/sec, whereas standard JVM reaches ~39,500 and Leyden AOT hits ~41,600. Leyden AOT posts the highest peak throughput across every payload size, while Go doesn&amp;rsquo;t win a single cell despite staying competitive at the smallest sizes. Nelson stresses that teams shouldn&amp;rsquo;t use synthetic microbenchmarks to dictate company-wide language mandates—measure your own workload, as runtime tuning, frameworks, hardware, warmup, logging, and socket options often matter just as much as the language itself.&lt;/p&gt;
&lt;h2 id="stop-using-conventional-commits"&gt;&lt;a href="https://sumnerevans.com/posts/software-engineering/stop-using-conventional-commits/" rel="noopener noreferrer"&gt;Stop Using Conventional Commits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sumner Evans argues against Conventional Commits because the format puts the emphasis in the wrong place. In his view, the single most valuable piece of information in a commit subject line is the scope—which subsystem, package, module, or service was touched. Developers scanning &lt;code&gt;git log&lt;/code&gt; are usually rebasing, debugging, or triaging an incident, so they need to know immediately which part of the codebase changed. Conventional Commits instead puts a change-type category like &lt;code&gt;fix&lt;/code&gt;, &lt;code&gt;feat&lt;/code&gt;, or &lt;code&gt;chore&lt;/code&gt; up front and makes the scope optional. Worse, the change type is usually obvious from the description anyway, and often ambiguous when a single commit fixes a bug, refactors a helper, and adds a small capability at once.&lt;/p&gt;
&lt;p&gt;Evans then dismantles the usual selling points of Conventional Commits one by one. Auto-generating user-facing changelogs from commit history produces poor results because changelogs are written for end users while commit logs are written for maintainers—two audiences that need completely different levels of detail. Automating SemVer bumps from commit prefixes breaks down around reverts, breaking changes discovered after the fact, or follow-up fixes landed before release. Triggering CI/CD pipelines off commit message prefixes is even a security and reliability hazard, since automation should inspect which files actually changed in the tree rather than trusting human-typed subject lines. Instead, he recommends the scope-first convention used by Linux, FreeBSD, Git, Go, and Node.js—&lt;code&gt;scope: description&lt;/code&gt;, such as &lt;code&gt;net/http/cookiejar: add godoc links&lt;/code&gt;—where scopes mirror the natural structure of the project.&lt;/p&gt;
&lt;h2 id="stop-using-jwts"&gt;&lt;a href="https://gist.github.com/samsch/0d1f3d3b4745d778f78b230cf6061452" rel="noopener noreferrer"&gt;Stop using JWTs!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Schlinkert argues for defaulting to server-side sessions for browser authentication, noting that revocation, logout, and lifecycle management are usually much simpler than rolling a custom stateless JWT scheme. That said, the gist&amp;rsquo;s claim that the JWT specification was designed strictly for short-lived tokens of around five minutes is factually incorrect: RFC 7519 imposes no such lifetime limit. A JWT is simply a signed or encrypted claims format; its security depends on the surrounding protocol, key management, and validation rules rather than every use of JWT being inherently insecure.&lt;/p&gt;
&lt;p&gt;The post rightly warns that storing authentication tokens in &lt;code&gt;localStorage&lt;/code&gt; magnifies the blast radius of any XSS vulnerability. For cookie-based sessions, &lt;code&gt;Secure&lt;/code&gt; and &lt;code&gt;HttpOnly&lt;/code&gt; flags provide important defense-in-depth, though applications still have to address CSRF, XSS, and session expiration at the architectural level. When JWTs are genuinely needed, RFC 8725 (JWT Best Current Practices) requires restricting accepted algorithms, verifying signatures, and validating claims like issuer and audience; alternatives like PASETO eliminate several cryptographic footguns by design, though they still don&amp;rsquo;t solve stateful session revocation on their own. For most web applications, the pragmatic default remains starting with your framework&amp;rsquo;s built-in session middleware backed by &lt;code&gt;Secure&lt;/code&gt;, &lt;code&gt;HttpOnly&lt;/code&gt; cookies and a fast store like Redis or Postgres, reaching for bearer tokens only when cross-service trust boundaries actually call for them.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!N2N1!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5edb76e4-d060-48d2-bd73-afe04f1cff5a_1284x1536.jpeg" alt="The AI Agent Stack, Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!wI2g!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F148840a3-d7df-4308-adad-c227f4d280e8_2360x2960.png" alt="Understanding Git Reset Modes"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!CKOS!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8d2521b0-1dd8-4b28-afbd-34f2bb44ee50_2360x2960.png" alt="How NAT Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!HMwY!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6af9e24b-9be2-4a45-9f81-14ec6f4330ca_2484x3002.png" alt="SLMs vs. LLMs, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Z5zI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5233378c-3c59-40b1-9de2-6515b9d3e928_2484x3002.png" alt="Single Agent vs. Multi-Agent Architecture"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U8C6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b849efb-0467-4a5d-b735-f2296b125e9f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=U8lGbSaCCYI" rel="noopener noreferrer"&gt;Running LLMs Locally for Learning and Privacy&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This ByteByteGo video explains why running LLMs on your own machine is great for learning, experimentation, and privacy: sensitive data never leaves your device, you can work offline, and costs stay completely predictable. It also surveys the local LLM ecosystem—from Ollama, LM Studio, and MLX-LM for personal workflows to vLLM and SGLang for high-throughput inference serving.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #119</title><link>https://miti99.com/en/post/2026/07/07/</link><pubDate>Tue, 07 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #119.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="special-cases-in-go"&gt;&lt;a href="https://www.dolthub.com/blog/2026-05-22-special-cases-in-go/" rel="noopener noreferrer"&gt;Special Cases in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go is frequently marketed as a &amp;ldquo;simple&amp;rdquo; language that deliberately avoids special cases. Nick Tobey points out that Go actually has plenty of exceptions hiding in unexpected places. The &lt;code&gt;init&lt;/code&gt; function is the clearest example: it runs automatically when a package is imported, takes no arguments, returns no values, can be declared multiple times within the same package, yet cannot be called manually. If you try to call it, the compiler reports &lt;code&gt;undefined: init&lt;/code&gt; without further explanation. Similarly, the &lt;code&gt;internal&lt;/code&gt; directory creates a visibility scope narrower than public/private, yet that rule doesn&amp;rsquo;t exist in the Go language specification at all—it is enforced by the &lt;code&gt;go&lt;/code&gt; toolchain.&lt;/p&gt;
&lt;p&gt;The reason is that the language spec intentionally leaves import path interpretation implementation-defined. That flexibility lets build systems like Bazel apply their own rules while allowing the standard &lt;code&gt;go&lt;/code&gt; toolchain to evolve without amending the language spec—adding special cases like &lt;code&gt;internal&lt;/code&gt; directories or &lt;code&gt;_test&lt;/code&gt; package suffixes that live in the same directory as the package under test. Tobey also notes that a package&amp;rsquo;s declared name doesn&amp;rsquo;t have to match its directory name, forcing IDEs to parse every imported package just to resolve where an identifier comes from; for new code, explicit import aliases avoid the ambiguity. The broader takeaway: while most of these quirks rarely get in the way of day-to-day work, they show that a language&amp;rsquo;s simplicity often just means the complexity was pushed somewhere else.&lt;/p&gt;
&lt;h2 id="writing-code-vs-shipping-code-productivity-effects-across-generations-of-ai-coding-tools"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/writing-code-vs-shipping-code.html" rel="noopener noreferrer"&gt;Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Murat Demirbas analyzes an MIT and Wharton study that combines internal Microsoft telemetry with public GitHub traces from over 100,000 developers to measure the real-world productivity impact of AI coding tools. The study divides tools into three generations: autocomplete, synchronous agents like Claude Code or Cursor, and asynchronous agents. Output gains at the lines-of-code level are striking, but attenuate sharply at each downstream stage—from files to commits, pull requests, repositories, and finally shipped releases: with autocomplete, lines of code jump by over 228% while shipped releases rise by only ~10%; with synchronous agents, the corresponding numbers are 741% and 20%.&lt;/p&gt;
&lt;p&gt;While Demirbas is skeptical of applying a linear manufacturing production function to software development, he finds the framing useful because it exposes human coordination and review costs. Translating the findings into Amdahl&amp;rsquo;s Law, he calculates that the parallelizable, acceleratable fraction of software work sits right around 35% across all three tool generations—matching the share of time developers actually spend writing code. Agents produce more shipped releases not because they expand that 35% slice, but because they accelerate it more aggressively and intervene closer to the finish line. The remaining 65%—understanding the problem, planning, team alignment, and code review—remains a serial bottleneck. To genuinely ship faster, organizations have to improve those non-coding stages rather than just generating code faster.&lt;/p&gt;
&lt;h2 id="when-was-the-last-time-you-did-just-one-thing"&gt;&lt;a href="https://alifeengineered.substack.com/p/when-was-the-last-time-you-did-just" rel="noopener noreferrer"&gt;When Was the Last Time You Did Just One Thing?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Huynh recounts packing for a long trip: downloading dozens of YouTube videos, queueing up a backlog of podcasts, packing a handheld game console, two physical books, a Kindle, and his laptop just in case he wanted to get some work done. Then it hit him that this entire &amp;ldquo;arsenal&amp;rdquo; against a single moment of boredom would cause him to miss the trip itself—and that paradoxically, the harder we try not to waste a single second, the emptier every second feels. While the public preview ends there, the message from the title and setup is unmistakable: doing just one thing at a time is no longer our default state, but a skill we have to actively practice.&lt;/p&gt;
&lt;p&gt;For people in tech, it is a timely reminder about attention management. Not every quiet gap in the day needs to be filled with upskilling, podcasts, or side work. When every spare moment is stuffed with fresh stimulation, we gradually lose the ability to observe, rest properly, think deeply, and be fully present with whatever is in front of us. Looking busy and optimized isn&amp;rsquo;t the same as living intentionally; leaving blank space in your day is part of sustainable productivity, especially in engineering roles already fragmented by constant context switching.&lt;/p&gt;
&lt;h2 id="predicting-ai-job-exposure"&gt;&lt;a href="https://www.ben-evans.com/benedictevans/2026/5/24/ai-job-exposure" rel="noopener noreferrer"&gt;Predicting AI job exposure&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benedict Evans critiques efforts to score which professions, companies, or industries are most &amp;ldquo;exposed&amp;rdquo; to AI disruption. In his view, this amounts to predicting the unpredictable, and the simplest sanity check is running the same methodology backward against previous technology waves. Over the past century, we automated accounting with mainframes, databases, spreadsheets, and ERPs—yet the total number of accountants kept growing. When analysis becomes cheap and fast, organizations do far more of it and ask different questions, while new regulations create entire categories of compliance work.&lt;/p&gt;
&lt;p&gt;A second blind spot is that a job&amp;rsquo;s core tasks can stay unchanged while the business model underneath it collapses: the internet didn&amp;rsquo;t automate away the craft of journalism, it destroyed the classified-ad monopoly that funded newsrooms. Third are second-order shocks nobody extrapolates from task lists, like smartphone GPS enabling Uber and reshaping the taxi industry. Deeper still, occupational databases like O*NET cannot capture what a real job actually entails, much like early expert systems failed to capture tacit human expertise. Evans concludes that while high-level frameworks are useful for thinking, granular job-by-job forecasts at this early stage will only be right by accident, because we have no way of knowing whether the exceptions will dwarf the rule.&lt;/p&gt;
&lt;h2 id="choosing-values-for-robust-tests"&gt;&lt;a href="https://testing.googleblog.com/2026/06/choosing-values-for-robust-tests.html" rel="noopener noreferrer"&gt;Choosing Values for Robust Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Radion Khait highlights a subtle testing bug that is remarkably easy to miss: a test passes not because the implementation is correct, but because the test input happens to match the type&amp;rsquo;s default value. In the post&amp;rsquo;s example, a custom map&amp;rsquo;s &lt;code&gt;insert&lt;/code&gt; method forgets to assign the &lt;code&gt;value&lt;/code&gt; parameter and simply default-initializes the entry. A test that inserts &lt;code&gt;0&lt;/code&gt; and asserts that lookup returns &lt;code&gt;0&lt;/code&gt; passes with flying colors, because &lt;code&gt;0&lt;/code&gt; is already the default value for an integer. The result is a false sense of security: the method was called, but nothing proved the input was actually stored.&lt;/p&gt;
&lt;p&gt;From that example, Khait distills three practical rules for choosing test inputs. First, always use non-default values: non-zero numbers, non-empty strings, and enum variants other than the first declared value—changing &lt;code&gt;0&lt;/code&gt; to &lt;code&gt;5&lt;/code&gt; exposes the map bug immediately. Second, where appropriate, test representative inputs across equivalence classes such as empty, missing, &lt;code&gt;null&lt;/code&gt;, boundary values, and inputs that trigger complex branches, optionally pairing with fuzzing for broader coverage. Third, use distinct values for every parameter so tests immediately catch implementations that accidentally reuse an argument or swap parameter order; parameterized tests make it easy to cover multiple input combinations without duplicating test code.&lt;/p&gt;
&lt;h2 id="ai-demands-more-engineering-discipline-not-less"&gt;&lt;a href="https://charity.wtf/p/ai-demands-more-engineering-discipline" rel="noopener noreferrer"&gt;AI demands more engineering discipline. Not less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charity Majors pushes back against a growing temptation: if AI generates code quickly and reasonably well, can we relax code reviews, verification, and engineering rigor? Her answer is the exact opposite. As the cost of generating code plummets, lines of code stop being a precious asset and become a disposable artifact of our current understanding. A software team&amp;rsquo;s true output is shared understanding, and what retains lasting value is everything that tells us whether the system is actually working: requirements, invariants, failure modes, tests, observability, and reproducibility.&lt;/p&gt;
&lt;p&gt;She compares the AI wave to the shift from hand-tended &amp;ldquo;pet&amp;rdquo; servers to immutable infrastructure. Once servers could be torn down and rebuilt at will, engineering discipline didn&amp;rsquo;t vanish—it moved up a level into configuration management, provisioning pipelines, verification, and repeatable operations. Software is undergoing the same shift: when code can be regenerated cheaply, individual lines of code stop being the highest-leverage place to spend review energy, and focus moves to artifacts that specify behavior, architecture, trade-offs, and production outcomes. Human brains were never great at statically verifying code anyway, and non-deterministic AI systems make tracing, testing in production, record-and-replay, and tight feedback loops even more critical. Far from making software less rigorous, AI demands more engineering discipline than ever.&lt;/p&gt;
&lt;h2 id="nine-questions-i-now-ask-in-interviews-that-i-wish-i"&gt;&lt;a href="https://louisedeason.substack.com/p/nine-questions-i-now-ask-in-interviews" rel="noopener noreferrer"&gt;Nine Questions I Now Ask in Interviews That I Wish I&amp;rsquo;d Asked Five Years Ago&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Louise Deason reminds candidates that an interview is a two-way evaluation, even though most people still treat it like a school exam—which conveniently benefits the employer. The &amp;ldquo;do you have any questions for us?&amp;rdquo; segment at the end is the most underutilized part of the process, precisely because interviewers let their guard down and inadvertently reveal how the org actually runs. She shares nine questions designed to force specific, revealing answers: how the most recent promotion on the team happened, what the longest-tenured person in this role is doing now, what the team is genuinely bad at, how the team handled a recent disagreement with leadership, headcount plans for the next year, whether you can meet the people you&amp;rsquo;ll actually work with day to day, what six-month success and failure look like, when the last reorg happened, and why this role is open.&lt;/p&gt;
&lt;p&gt;The real signal lies in how the interviewer responds: whether the answer is concrete, evasive, or hesitant. A clear story about promotion criteria or an honest admission of a team&amp;rsquo;s weak spots signals transparency; conversely, claims that &amp;ldquo;we always agree,&amp;rdquo; reluctance to let you speak with future peers, or an awkward pause when asked why the seat is open are major red flags. Her closing reminder: you are always choosing between differently imperfect options, and any company that gets defensive when asked thoughtful questions doesn&amp;rsquo;t deserve your time.&lt;/p&gt;
&lt;h2 id="agentic-testing-where-agents-fit-in-the-e2e-testing-stack"&gt;&lt;a href="https://slack.engineering/agentic-testing-where-agents-fit-in-the-e2e-testing-stack/" rel="noopener noreferrer"&gt;Agentic Testing: Where Agents Fit in the E2E Testing Stack&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergii Gorbachov at Slack shares findings from over 200 end-to-end test runs powered by AI agents, exploring where agentic testing belongs in the testing stack. Traditional E2E tests enforce a rigid, scripted path through the UI, whereas agentic tests start from a high-level goal: the agent observes the current UI state, decides the next action on the fly, and verifies the outcome. The team benchmarked three approaches—an agent driving Playwright MCP, an agent driving Playwright CLI, and AI-generated deterministic Playwright test scripts—against a staging workspace with synthetic data across two user flows: replying to a thread and search discovery.&lt;/p&gt;
&lt;p&gt;The AI-generated Playwright scripts ran fastest at around 3 minutes, but their failure rate spiked to ~48% on the more complex flow. Using Sonnet 4.5 to run the agent and Opus 4.6 to generate tests, Playwright MCP achieved the lowest failure rate at 0–12%, compared to 12–20% for Playwright CLI, where most failures stemmed from login and navigation hiccups at the execution layer. MCP also required fewer interaction turns because it batches actions and returns updated state in a single round-trip. However, each agentic test run cost $15–$30 and took over 5 minutes, with most of the cost driven by repeatedly re-sending conversation history. Slack&amp;rsquo;s conclusion: deterministic E2E tests remain the backbone for fast CI regression checks, while agentic testing sits as a complementary layer at the top of the testing pyramid—ideal for exploratory testing of complex flows, diagnosing flaky journeys, and reproducing production bugs.&lt;/p&gt;
&lt;h2 id="making-agents-easy-13-lessons-from-forter"&gt;&lt;a href="https://blog.forter.dev/making-agents-easy-13-lessons-from-forters-agentic-ai-sprint/" rel="noopener noreferrer"&gt;Making Agents Easy: 13 Lessons from Forter&amp;rsquo;s Agentic AI Sprint&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Maraney recounts how Forter ran a two-week company-wide sprint to get their entire R&amp;amp;D organization building AI agents. The core thesis isn&amp;rsquo;t that building agents is inherently effortless, but that an organization can systematically remove friction across three layers: tooling, agent runtime infrastructure, and organizational guardrails. On the tooling side, Forter built an internal MCP server called Toolchain: engineers open a web UI, pick and configure the tools they need, and immediately get an API key; adding a new internal tool takes just a declarative YAML file and a thin wrapper. By the end of the two-week sprint, Toolchain had grown to over 90 internal tools. And rather than standing up a complex custom RAG pipeline, they exposed their existing enterprise search engine as an MCP tool.&lt;/p&gt;
&lt;p&gt;The post shares several pragmatic operational lessons as well. Agent builders need full visibility into every raw tool request and response—one Forter incident-response agent appeared to &amp;ldquo;solve&amp;rdquo; an outage brilliantly until traces revealed it had simply read the already-written postmortem doc. For internal human-in-the-loop tools, teams don&amp;rsquo;t need formal eval suites on day one; prioritize tracing and observability first. Bring legal and security in early, enforce permissions in deterministic code rather than prompts, and put token costs on a visible dashboard. Finally, when training teams, tell them to treat an LLM like a bright new-grad intern: broad textbook knowledge, zero institutional context—meaning the responsibility for giving clear instructions rests squarely on the builder.&lt;/p&gt;
&lt;h2 id="agentic-code-review"&gt;&lt;a href="https://addyosmani.com/blog/agentic-code-review/" rel="noopener noreferrer"&gt;Agentic Code Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that as coding agents write code faster and faster, the primary bottleneck in software engineering shifts from writing code to verifying and trusting it. AI can produce mountains of syntactically valid, test-accompanied, plausible-looking code, but human reading comprehension hasn&amp;rsquo;t sped up to match. That makes code review the highest-leverage skill in modern engineering: not merely hunting for typos, but reconstructing intent, assessing blast radius, spreading system knowledge across the team, and deciding whether a change should exist at all. Industry data from 2026 cited in the post shows that while code output has surged, code churn, defects, production incidents, and review wait times have climbed right alongside it.&lt;/p&gt;
&lt;p&gt;There is no single review policy that fits every context. Solo side projects with no users can lean heavily on automated tests and AI review; long-lived production systems handling real users, money, or sensitive data require risk-tiered human review. Osmani recommends keeping pull requests small, stating intent explicitly, requiring concrete proof of verification (such as real test outputs) before human review begins, reading test diffs more closely than implementation diffs, treating deterministic CI as a non-negotiable guardrail, and using AI reviewers as sensors rather than final judges. Humans may no longer read every single generated line, but they still own the merge button, carry accountability for production, and must focus their deepest scrutiny on high-blast-radius changes like auth, billing, security, and privacy.&lt;/p&gt;
&lt;h2 id="i-thought-redis-was-just-a-hashmap"&gt;&lt;a href="https://mukul0x9.pages.dev/blog/memdb/" rel="noopener noreferrer"&gt;I Thought Redis Was Just a HashMap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mukul Makwana starts from a deceptively simple question: how different is Redis or Memcached from a global hash map supporting &lt;code&gt;set&lt;/code&gt;, &lt;code&gt;get&lt;/code&gt;, and &lt;code&gt;del&lt;/code&gt;? To find out, he built a minimal in-memory database from scratch in Go. Version one wrapped Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt;, accepted commands over TCP, and spawned one goroutine per client connection. The bottleneck appeared immediately as soon as multiple goroutines read and wrote concurrently: the map needed synchronization, and a single global mutex forced every operation to wait in line.&lt;/p&gt;
&lt;p&gt;To fix that, Makwana replaced the built-in map with a two-array arena design: &lt;code&gt;bucket_array&lt;/code&gt; stores offsets while &lt;code&gt;data_array&lt;/code&gt; packs metadata, keys, values, and next-entry offsets for collision chaining in contiguous byte slices. To reduce lock contention, the keyspace is partitioned into shards, each with its own arrays and &lt;code&gt;RWMutex&lt;/code&gt;, while a background goroutine handles shard resizing when load factors climb. Because &lt;code&gt;data_array&lt;/code&gt; is append-only, deletes simply mark a tombstone bit, and a compaction pass rebuilds the shard once dead bytes cross a threshold—at the cost of locking that shard during compaction. Benchmarking &lt;code&gt;SET&lt;/code&gt; workloads showed Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt; still winning on raw throughput and stop-the-world pause times, but the custom pointer-free arena slashed concurrent GC mark time from ~113 ms down to 7.8 ms. Even then, this toy engine still lacks persistence, eviction policies, crash recovery, and replication—the exact things that make real Redis a serious piece of engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #118</title><link>https://miti99.com/en/post/2026/07/06/</link><pubDate>Mon, 06 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #118.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="telling-the-story-right-efficient-logging-in-go"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-logs/" rel="noopener noreferrer"&gt;Telling the story right: efficient logging in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on his post about Go error handling, Robin Siep turns to logging: good logs must carry enough context to debug production issues while remaining easy to read during local development. He groups what to log into three categories: errors, almost always at &lt;code&gt;ERROR&lt;/code&gt; level with a stack trace and triggering conditions; important business events and state transitions, typically at &lt;code&gt;INFO&lt;/code&gt; level recording who performed the action; and interactions with databases, third-party services, or clients, where overly chatty details can be pushed down to &lt;code&gt;DEBUG&lt;/code&gt;. Three common mistakes are logging secrets, credentials, or PII, running production at the wrong log level, and pruning logs too aggressively up front—since logging too little usually hurts far more than logging too much.&lt;/p&gt;
&lt;p&gt;Structured logs are essential in production for filtering and querying, whereas colorized plain-text logs are much easier to scan locally. Siep recommends keeping plain-text output in production as well: when your log ingestion pipeline goes down, stdout text logs are what you have left to diagnose and fix the pipeline itself. His implementation uses Go&amp;rsquo;s standard &lt;code&gt;slog&lt;/code&gt; package with two custom handlers: one that formats records as CLEF to ship to Seq with stack traces extracted into a dedicated field, and a colorized text handler that renders attributes cleanly. If shipping to Seq fails, both the pipeline error and the original log record still get written through the text handler. The same pattern works with &lt;code&gt;zap&lt;/code&gt;, showing that logs are only as valuable as their ability to preserve context even when your observability stack is having a bad day.&lt;/p&gt;
&lt;h2 id="on-cpu-physics-and-cpu-cycles"&gt;&lt;a href="https://6it.dev/blog/on-cpu-physics-and-cpu-cycles-80730" rel="noopener noreferrer"&gt;On CPU Physics and CPU Cycles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is a draft book section on writing efficient C++ for modern 64-bit CPUs, built around one central thesis: software performance is governed not just by algorithms, but by hardware physics. The farther an electrical signal has to travel, the slower the access, largely because parasitic capacitance grows with wire length. That is why operations on registers and the ALU take just a couple of cycles, L1 cache takes a few cycles, L2 and L3 get progressively more expensive, and a trip to main RAM can cost hundreds of CPU cycles. Going farther out—across the motherboard to SSDs, HDDs, and the network—adds orders of magnitude more latency, giving cache locality massive real-world impact.&lt;/p&gt;
&lt;p&gt;To hide that latency, modern CPUs rely on instruction pipelining, superscalar execution, and branch prediction, speculatively executing instructions before a branch outcome is known. Even so, a mispredicted branch costs tens of cycles; attributes like &lt;code&gt;[[likely]]&lt;/code&gt; and &lt;code&gt;[[unlikely]]&lt;/code&gt; should be reserved for cases where the branch direction is overwhelmingly lopsided, such as error-handling paths. Cache warmth depends on access patterns and working set size rather than whether memory lives on the stack, static storage, or the heap. Contiguous layouts like &lt;code&gt;std::vector&lt;/code&gt; shine during sequential traversal, making &lt;code&gt;vector&lt;/code&gt; far friendlier to both CPU caches and the TLB than node-based structures like linked lists or trees. Think of performance as a chain of physical costs.&lt;/p&gt;
&lt;h2 id="the-log-is-the-agent"&gt;&lt;a href="https://x.com/ishaansehgal/status/2065129901427130678" rel="noopener noreferrer"&gt;The Log Is the Agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ishaan Sehgal offers a crisp definition of an AI agent: the agent is not the model, the runtime, the active loop, or the toolset—it is the durable log of everything it has seen and done. He compares it to a character in Skyrim or Elden Ring: what defines your character isn&amp;rsquo;t the game engine, the console, or the controller, but the save file. For an agent, the log is an append-only sequence of events capturing user inputs, model outputs, tool calls, and tool results, alongside references to system prompts and skills. The log alone is enough for a brand-new process to reconstruct state and pick up right where the previous one left off.&lt;/p&gt;
&lt;p&gt;The architectural implication is that the log must be the centerpiece of the system rather than a debugging byproduct. Every operation reads from the log, appends to the log, or renders a projection of the log—much like a database treats tables, indexes, and caches as projections over a write-ahead log. While the log enables crash recovery, it doesn&amp;rsquo;t automatically make external side effects idempotent, so runtimes still have to handle duplicate or ambiguous in-flight tool calls; if a worker dies, another worker can claim the session and continue; if you want to test a different model or strategy, you simply fork from the same history. Context compaction and summarization help fit within token windows, but because they are lossy by nature, they must never replace the raw log as the source of truth. This framing also exposes a new form of vendor lock-in: lock-in to an agent&amp;rsquo;s operational history. Whoever can inspect, export, and query the log is who truly owns the agent.&lt;/p&gt;
&lt;h2 id="software-is-not-a-single-player-game"&gt;&lt;a href="https://www.davidpoll.com/2026/06/software-is-not-a-single-player-game/" rel="noopener noreferrer"&gt;Software Is Not A Single-Player Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Poll responds to the argument that all meaningful judgment should happen before code review, back in the PRD or design doc phase. That view had a rational origin: writing code used to be the most expensive step, so the industry built an entire apparatus of PRDs, design docs, and RFCs to reduce the cost of building the wrong thing. Yet that linear view misses the essence of software development: it is not a single-player game, but a collaborative practice where teams develop shared technical taste, mental models, and product judgment over time. Code review isn&amp;rsquo;t just about catching bugs—it is one of the primary places where that shared understanding is forged.&lt;/p&gt;
&lt;p&gt;Now that AI has dramatically lowered the cost of writing code, documents that used to serve as proxies for code are giving way to working changes. A prototype or pull request is now cheap enough to be a better medium for debate, making code review even more central: the team looks at a concrete change, asks how it affects the system and users, and decides whether it belongs in the product. A closed pull request is no longer a wasted failure, but often the cheapest way to learn that an approach doesn&amp;rsquo;t fit. Still, Poll warns against a reckless &amp;ldquo;just ship and rollback&amp;rdquo; mentality: code can be reverted, but user trust and product perception cannot. Some decisions still must be settled before coding—such as org-wide architecture, security, compliance, and customer commitments—even as the set of things requiring heavy up-front specification shrinks.&lt;/p&gt;
&lt;h2 id="cleaning-up-after-ai-rockstar-developers"&gt;&lt;a href="https://www.codingwithjesse.com/blog/rockstar-developers/" rel="noopener noreferrer"&gt;Cleaning up after AI rockstar developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jesse Skinner uses the trope of the &amp;ldquo;rockstar developer&amp;rdquo; to illustrate a familiar engineering hazard: someone brilliant, fast, and enamored with shiny new technology who can single-handedly rewrite a core system over a weekend, but leaves behind code the rest of the team struggles to understand or maintain. When that person moves on, the remaining team pays the real bill: spending days just getting the project to run, untangling convoluted data flows, learning unfamiliar languages or libraries, and convincing management that the system needs rescuing rather than continuing to coast on the rockstar&amp;rsquo;s aura.&lt;/p&gt;
&lt;p&gt;Skinner&amp;rsquo;s core point is that AI can amplify this exact failure mode. Every chat session with an LLM is like dropping a brand-new &amp;ldquo;rockstar&amp;rdquo; into your codebase: it generates code at breakneck speed, holds zero long-term institutional memory, eagerly applies generic &amp;ldquo;best practices&amp;rdquo; the problem doesn&amp;rsquo;t need, and bears no responsibility for whether the system remains comprehensible to the team six months later. When dozens of features and bug fixes are generated across disconnected sessions, a codebase quickly devolves into a patchwork of hundreds of clashing design styles while the architecture balloons far beyond the problem&amp;rsquo;s actual complexity. He advises using LLMs as assistants under firm human technical leadership: work in small increments, review every change closely, retain architectural control, simplify relentlessly, and stay willing to write code by hand whenever that is the better way to preserve quality.&lt;/p&gt;
&lt;h2 id="a-new-era-for-software-testing"&gt;&lt;a href="https://antirez.com/news/168" rel="noopener noreferrer"&gt;A new era for software testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Antirez observes that while AI-assisted coding trades away some structural code quality for speed, in QA and testing LLMs unlock much stronger automation without sacrificing quality. Traditional test suites made up of unit and integration tests remain essential, but 100% line coverage does not mean 100% state coverage. End-to-end integration testing has historically been painful due to timing issues, complex environment setup, and outputs that require human judgment to evaluate, causing many manual test scenarios to be skipped before release.&lt;/p&gt;
&lt;p&gt;His proposal is to write a Markdown prompt instructing an AI agent to act as a QA engineer performing exploratory manual testing on a new release. The agent starts by inspecting recent commits since the last release, identifying potentially affected areas, and hunting for targeted regressions. On DwarfStar, an open-source LLM inference engine, the agent tested distributed inference across two MacBooks over every available GGUF model file and caught a throughput regression without needing hardcoded baseline numbers, reasoning about expected speeds dynamically. On Redis Arrays, the agent built a non-trivial application from scratch, spun up an environment with replication and persistence, and simulated days of multi-user activity to uncover edge-case misbehavior—even flagging surprising semantics, missing docs, and rough edges. Antirez believes agentic QA can raise the quality bar for every release, partially offsetting the structural sloppiness introduced by rapid AI coding.&lt;/p&gt;
&lt;h2 id="nobody-pushed-back-why-engineers-stay-silent-until-it"&gt;&lt;a href="https://howtocenterdiv.com/beyond-the-div/nobody-pushed-back" rel="noopener noreferrer"&gt;Nobody Pushed Back: Why Engineers Stay Silent Until It&amp;rsquo;s Too Late&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that many architectural disasters happen not because engineers failed to spot the flaw, but because they saw it clearly and didn&amp;rsquo;t feel safe speaking up. In a meeting room, a shaky technical direction gets rubber-stamped under the banner of &amp;ldquo;alignment&amp;rdquo; even though half the room privately disagrees; months later, when the system collapses, everyone admits they saw it coming. The pattern repeats across the industry: the technical risk is obvious to the people closest to the work, but the social and career cost of pushing back is higher than the cost of staying quiet.&lt;/p&gt;
&lt;p&gt;Case studies from Nokia, TSB, Boeing, and Microsoft show that bad news is rarely missing—it just fails to travel upward to decision-makers. Nokia had engineers who knew Symbian wasn&amp;rsquo;t built for the touchscreen era; TSB had technical objections raised before its disastrous core banking migration; Boeing had engineers flagging MCAS risks; Microsoft had internal signals that Windows Phone&amp;rsquo;s direction was boxing itself into a corner. The root cause isn&amp;rsquo;t personal cowardice, but organizational incentives: dissent gets labeled &amp;ldquo;not being a team player,&amp;rdquo; the Highest Paid Person&amp;rsquo;s Opinion (HiPPO) wins by default, and watermelon metrics (green on the outside, red on the inside) are used to shut down debate, turning technical trade-offs into political loyalty tests. Effective pushback isn&amp;rsquo;t saying &amp;ldquo;this is wrong,&amp;rdquo; but making costs and risks concrete through questions like: what will this decision cost us in 18 months, how are we testing this failure mode, and what is our rollback plan if it breaks?&lt;/p&gt;
&lt;h2 id="loop-engineering"&gt;&lt;a href="https://addyo.substack.com/p/loop-engineering" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani describes &amp;ldquo;loop engineering&amp;rdquo; as the natural evolution beyond prompt engineering: instead of manually prompting an agent turn by turn, the engineer designs a self-sustaining loop that finds work, delegates tasks, verifies results, and decides what to do next. A loop acts like a recursive goal—you define the objective, and the AI iterates until the exit criteria are met. According to Osmani, this paradigm is already practical today because both Codex and Claude Code provide all the necessary building blocks, so rather than arguing over which tool wins, teams should design loops that can run across both.&lt;/p&gt;
&lt;p&gt;A complete loop rests on five primitives. Scheduled automations triage issues, summarize CI failures, or hunt for new bugs. Git worktrees let multiple agents work in parallel without stepping on each other&amp;rsquo;s files. Skills package project-specific knowledge so you don&amp;rsquo;t have to re-explain conventions in every session. Connectors, typically built on MCP, give agents access to issue trackers, databases, Slack, or staging APIs. Subagents separate the builder from the verifier, since an agent that just wrote the code is usually far too lenient when grading its own homework. Tying it all together is durable external memory—Markdown files or Linear boards in the repo—because models forget between runs while the repository remembers. Even so, Osmani stresses that loops don&amp;rsquo;t replace the engineer: an unsupervised loop is also an unsupervised mistake generator. Without human review and comprehension, loops simply accumulate &amp;ldquo;comprehension debt&amp;rdquo; faster; a good loop accelerates delivery while keeping the engineer deeply connected to how the system works.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Y582!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b5057ba-3667-446b-9760-b726da1431f4_2484x3002.png" alt="Latency vs Throughput vs Bandwidth"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!bdjh!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc9c8ec17-676c-441a-9c97-d08f8eec804f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=MUWAbpg1xLo" rel="noopener noreferrer"&gt;How Do CPUs, GPUs, and TPUs Differ?&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This video breaks down the differences between CPUs, GPUs, and TPUs: CPUs offer flexibility for general-purpose tasks, GPUs excel at massively parallel processing, and TPUs are purpose-built accelerators for machine learning workloads. A concise overview to help you pick the right hardware across latency, throughput, and cost trade-offs.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #117</title><link>https://miti99.com/en/post/2026/07/05/</link><pubDate>Sun, 05 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #117.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="should-you-normalize-rgb-values-by-255-or-256"&gt;&lt;a href="https://30fps.net/pages/255-vs-256-division/" rel="noopener noreferrer"&gt;Should you normalize RGB values by 255 or 256?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pekka Väänänen dissects a deceptively small question that sparks endless debate in image processing: when converting 8-bit RGB color values to floating point, should you divide by 255, or add half a step and divide by 256? The familiar &lt;code&gt;img / 255.0&lt;/code&gt; maps 0 to 0.0 and 255 to 1.0, preserving exact black and exact white, which is convenient for almost all downstream shader and image code. The alternative &lt;code&gt;(img + 0.5) / 256.0&lt;/code&gt; places each sample at the midpoint of a quantization bucket—cleaner from a signal-quantization standpoint and yielding slightly lower theoretical reconstruction error, but only when you control both the encoding and decoding sides of the pipeline.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s pragmatic verdict: for images coming from the outside world, divide by 255. The usual arguments against 255—that the two endpoint buckets are half-width, that floats don&amp;rsquo;t represent thirds or fifths of 255 exact to the last bit, or that a tiny sliver of precision is wasted—are negligible in practice. Conversely, dividing by 256 on images that were quantized under the standard 255 convention introduces bias and hardcodes an 8-bit assumption into your code. The real bug to fear is mixing one convention&amp;rsquo;s encoder with the other&amp;rsquo;s decoder. Only consider dividing by 256 inside a closed system where you control the entire read/write pipeline, don&amp;rsquo;t need 0 to map to 0.0, and every component agrees on the exact same convention.&lt;/p&gt;
&lt;h2 id="jira-is-turing-complete"&gt;&lt;a href="https://seriot.ch/computation/jira.html" rel="noopener noreferrer"&gt;Jira is Turing-Complete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Seriot turns a classic office joke about Jira into a formal proof: Jira Automation can simulate a Minsky register machine, a computational model known to be Turing-complete. In the author&amp;rsquo;s construction, each register is represented by the count of linked issues of a specific type (such as Bug and Task); the instruction pointer is the current status of an Epic; the program table is the set of automation rules; and each clock cycle is a status transition triggered by an automation rule. Using only operations that create, delete, and check linked issues, Jira can express &lt;code&gt;INC&lt;/code&gt;, &lt;code&gt;DEC&lt;/code&gt;, and conditional branching.&lt;/p&gt;
&lt;p&gt;The minimal example is addition: transferring the count of Bugs in register A into Tasks in register B using statuses like &lt;code&gt;TODO&lt;/code&gt;, &lt;code&gt;DEV&lt;/code&gt;, and &lt;code&gt;PROD&lt;/code&gt;. While A still has a Bug, a rule deletes one Bug and transitions to a state that increments B; once A hits zero, it transitions to the halt state. Seriot also uses an issue-type conversion action—which effectively fuses a decrement and an increment into a single step—to compress a Fibonacci program down to three statuses across three registers. The program runs until it hits Jira Cloud&amp;rsquo;s automation chain-depth limit and requires an operator to re-trigger it. Quota limits like that don&amp;rsquo;t invalidate the proof, since every physical computer is finite too. The takeaway isn&amp;rsquo;t that you should write software in Jira, but that complex workflow automations genuinely are programs—complete with state, memory, branches, and loops.&lt;/p&gt;
&lt;h2 id="usb-for-software-developers-an-introduction-to-writing-userspace-usb-drivers"&gt;&lt;a href="https://werwolv.net/posts/usb_for_sw_devs/" rel="noopener noreferrer"&gt;USB for Software Developers: An introduction to writing userspace USB drivers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WerWolv writes an approachable introduction to USB for software developers who want to talk to hardware devices without diving into electrical signaling or writing kernel modules. The running example is an Android phone in bootloader mode, since the Fastboot protocol is simple, well documented, and typically doesn&amp;rsquo;t have an OS kernel driver claiming the interface automatically. The guide starts with &lt;code&gt;lsusb&lt;/code&gt; to inspect the &lt;code&gt;VID&lt;/code&gt;, &lt;code&gt;PID&lt;/code&gt;, device class, and bound drivers, before moving to &lt;code&gt;libusb&lt;/code&gt; to discover and open the device directly from userspace.&lt;/p&gt;
&lt;p&gt;The most valuable part is how the author connects each USB concept directly to working code. During enumeration, the host uses control endpoint &lt;code&gt;0x00&lt;/code&gt; to send standard requests like &lt;code&gt;GET_STATUS&lt;/code&gt; and &lt;code&gt;GET_DESCRIPTOR&lt;/code&gt;, reading descriptors to learn what configurations, interfaces, and endpoints the device exposes. Endpoints can be thought of like communication ports, except USB is strictly host-driven—a device never sends data unprompted. The post explains the four transfer types (Control, Bulk, Interrupt, Isochronous) and notes that &lt;code&gt;IN&lt;/code&gt; and &lt;code&gt;OUT&lt;/code&gt; directions are always defined from the host&amp;rsquo;s perspective. Finally, the sample program sends a Fastboot &lt;code&gt;getvar:version&lt;/code&gt; command over a Bulk OUT endpoint and reads back &lt;code&gt;OKAY0.4&lt;/code&gt; from the Bulk IN endpoint. The takeaway: for a device with a documented protocol, writing a userspace driver with &lt;code&gt;libusb&lt;/code&gt; feels much closer to socket programming than intimidating kernel development.&lt;/p&gt;
&lt;h2 id="everything-you-need-to-know-about-sourcemaps"&gt;&lt;a href="https://neciudan.dev/everything-you-need-to-know-about-sourcemaps" rel="noopener noreferrer"&gt;Everything you need to know about Sourcemaps&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neciu Dan examines sourcemaps from both angles: as an indispensable debugging tool and as a source-code exposure risk. After bundling, browsers execute concatenated, minified, and mangled code, making an error like &lt;code&gt;bundle.min.js:1:48211&lt;/code&gt; nearly useless. A sourcemap is a JSON file mapping positions in the minified output back to the original file, line, column, and identifier names so stack traces become readable again. Yet those very fields—&lt;code&gt;sources&lt;/code&gt;, &lt;code&gt;names&lt;/code&gt;, &lt;code&gt;mappings&lt;/code&gt;, and especially &lt;code&gt;sourcesContent&lt;/code&gt;—can expose directory structures, module names, comments, internal API endpoints, and even the entire original source code if &lt;code&gt;.map&lt;/code&gt; files are left publicly accessible.&lt;/p&gt;
&lt;p&gt;The core lesson is that minification is not a security boundary. When a production bundle points to a sourcemap via &lt;code&gt;sourceMappingURL&lt;/code&gt; or the &lt;code&gt;SourceMap&lt;/code&gt; HTTP header, anyone with DevTools or &lt;code&gt;curl&lt;/code&gt; can download it if the server permits access. The author cites real-world incidents—including Apple&amp;rsquo;s web App Store in 2025 and version 2.1.88 of the &lt;code&gt;@anthropic-ai/claude-code&lt;/code&gt; npm package shipping with a nearly 60 MB &lt;code&gt;cli.js.map&lt;/code&gt; file—to show that leaks are usually simple build or packaging misconfigurations rather than sophisticated attacks. Mitigations include disabling sourcemaps in production when unneeded, uploading sourcemaps privately to Sentry (noting that &amp;ldquo;hidden&amp;rdquo; sourcemaps only omit the reference comment without blocking direct URL access), blocking &lt;code&gt;.map&lt;/code&gt; requests at the web server or CDN, stripping &lt;code&gt;.map&lt;/code&gt; files from build artifacts and npm tarballs, and adding CI/CD checks (such as inspecting &lt;code&gt;npm pack&lt;/code&gt; output) to catch accidental sourcemap publishing.&lt;/p&gt;
&lt;h2 id="extended-statistics-in-postgres"&gt;&lt;a href="https://www.valerieparhamthompson.com/posts/extended-statistics-postgres/" rel="noopener noreferrer"&gt;Extended Statistics in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Valerie Parham-Thompson explains how extended statistics help the Postgres query planner make far more accurate row estimates when columns are correlated in ways default statistics cannot see. The planner relies on internal catalog tables like &lt;code&gt;pg_class&lt;/code&gt; and &lt;code&gt;pg_stats&lt;/code&gt; to estimate row counts, distinct values, histograms, and most common values, but those statistics are collected per column and implicitly assume filter conditions are independent. For instance, &lt;code&gt;zip='91605'&lt;/code&gt; almost entirely implies &lt;code&gt;state='CA'&lt;/code&gt;, yet by default the planner multiplies the two selectivities as if they were independent variables, severely underestimating row counts and picking a poor execution plan.&lt;/p&gt;
&lt;p&gt;The post walks through all three kinds of extended statistics. The &lt;code&gt;dependencies&lt;/code&gt; type captures functional dependencies between columns, such as a ZIP code largely determining the state; after running &lt;code&gt;CREATE STATISTICS ... (dependencies)&lt;/code&gt; and &lt;code&gt;ANALYZE&lt;/code&gt;, the planner&amp;rsquo;s row estimate jumps much closer to reality. The &lt;code&gt;mcv&lt;/code&gt; (most-common values) type tracks frequent value combinations across multiple columns, helping multi-column &lt;code&gt;WHERE&lt;/code&gt; filters like category plus subcategory. The &lt;code&gt;ndistinct&lt;/code&gt; type helps the planner estimate group counts for multi-column &lt;code&gt;GROUP BY&lt;/code&gt; clauses instead of naively multiplying each column&amp;rsquo;s distinct count. The practical takeaway: when you know your schema has correlated columns, teach the planner with extended statistics instead of reflexively reaching for another index.&lt;/p&gt;
&lt;h2 id="finding-a-needle-in-a-4-gb-haystack-from-075-gbs-to-49-gbs-in-go"&gt;&lt;a href="https://segflow.github.io/post/fast-file-search-go/" rel="noopener noreferrer"&gt;Finding a needle in a 4 GB haystack: from 0.75 GB/s to 49 GB/s in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Assel Meher uses a deliberately trivial problem to dissect file reading and scanning performance in Go: finding a single non-zero &lt;code&gt;int64&lt;/code&gt; near the end of a 4 GiB file filled almost entirely with zeros. With no parsing or complex algorithms in the way, the benchmarks expose the true cost of each layer: the Go runtime, standard library, syscalls, page cache, memory bandwidth, &lt;code&gt;mmap&lt;/code&gt;, &lt;code&gt;pread&lt;/code&gt;, multithreading, and SIMD. The baseline—calling &lt;code&gt;os.ReadFile&lt;/code&gt; and ranging byte by byte—hits just ~0.75 GB/s because it allocates and copies 4 GiB before inspecting one byte at a time; &lt;code&gt;bufio.ReadByte&lt;/code&gt; fares no better due to per-byte function call overhead.&lt;/p&gt;
&lt;p&gt;The first major leap comes from eliminating per-byte work: reading in 1 MiB chunks and scanning as &lt;code&gt;uint64&lt;/code&gt; words immediately crosses 13 GB/s. &lt;code&gt;mmap&lt;/code&gt; doesn&amp;rsquo;t automatically win because, while it avoids copying into userspace buffers, touching every page triggers over a million minor page faults. Parallelism helps further, and parallel &lt;code&gt;pread&lt;/code&gt; handily beats parallel &lt;code&gt;mmap&lt;/code&gt;—which plateaus around 28 GB/s due to page-fault lock contention—because sequential block copies are cheaper than massive concurrent page faults. Adding SIMD via AVX2 or Go 1.26&amp;rsquo;s &lt;code&gt;simd/archsimd&lt;/code&gt; package makes the inner scan loop nearly free, at which point memory bandwidth, read strategy, and concurrency become the real bottlenecks. On a Ryzen 5 9600X under WSL2 with a warm page cache, parallel &lt;code&gt;pread&lt;/code&gt; plus SIMD reaches ~49 GB/s; going any faster requires reading less data or buying faster hardware.&lt;/p&gt;
&lt;h2 id="http-caching-a-refresher"&gt;&lt;a href="https://danburzo.ro/http-caching-refresher/" rel="noopener noreferrer"&gt;HTTP caching, a refresher&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Cătălin Burzo revisits RFC 9111 to organize the essential concepts of modern HTTP caching. He reminds readers that &amp;ldquo;the cache&amp;rdquo; isn&amp;rsquo;t just the browser&amp;rsquo;s private cache, but also shared caches like proxies, CDNs, and Varnish sitting between clients and origin servers. At the center is the &lt;code&gt;Cache-Control&lt;/code&gt; header: directives like &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;no-cache&lt;/code&gt;, &lt;code&gt;no-store&lt;/code&gt;, &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;must-revalidate&lt;/code&gt;, &lt;code&gt;stale-while-revalidate&lt;/code&gt;, and &lt;code&gt;stale-if-error&lt;/code&gt; govern not only whether a response may be stored, but also how long it stays &amp;ldquo;fresh&amp;rdquo; (based on age versus &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;Expires&lt;/code&gt;, or heuristics from &lt;code&gt;Last-Modified&lt;/code&gt;), when it must be revalidated with the origin, and whether a shared cache is allowed to store responses to requests carrying an &lt;code&gt;Authorization&lt;/code&gt; header.&lt;/p&gt;
&lt;p&gt;Burzo also clarifies several common points of confusion. A stale response isn&amp;rsquo;t necessarily discarded: a cache can send a conditional request using &lt;code&gt;If-None-Match&lt;/code&gt; (with an &lt;code&gt;ETag&lt;/code&gt;) or &lt;code&gt;If-Modified-Since&lt;/code&gt; (with &lt;code&gt;Last-Modified&lt;/code&gt;) to receive a &lt;code&gt;304 Not Modified&lt;/code&gt; without re-downloading the body. The &lt;code&gt;Vary&lt;/code&gt; header splits the cache key across request headers like &lt;code&gt;Accept-Language&lt;/code&gt;, which can tank hit rates if header values are too diverse, while &lt;code&gt;No-Vary-Search&lt;/code&gt; solves the inverse problem by ignoring query parameters that don&amp;rsquo;t affect response content. The final section compares normal reloads against hard reloads in browsers, explains the role of &lt;code&gt;immutable&lt;/code&gt;, and warns that misusing &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, or &lt;code&gt;must-revalidate&lt;/code&gt; can trick shared caches into storing authenticated responses—so reach for &lt;code&gt;private&lt;/code&gt; whenever a response belongs strictly to one user.&lt;/p&gt;
&lt;h2 id="how-to-use-ss-as-a-replacement-for-netstat-to-view-ipv4-sockets"&gt;&lt;a href="https://oneuptime.com/blog/post/2026-03-20-ss-replacement-netstat-ipv4-sockets/view" rel="noopener noreferrer"&gt;How to Use ss as a Replacement for netstat to View IPv4 Sockets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nawaz Dhandala introduces &lt;code&gt;ss&lt;/code&gt; as the modern replacement for the deprecated &lt;code&gt;netstat&lt;/code&gt; utility when inspecting sockets on Linux. Because &lt;code&gt;ss&lt;/code&gt; queries socket state directly from the kernel via netlink rather than parsing &lt;code&gt;/proc&lt;/code&gt; files, it is significantly faster, especially on busy servers handling thousands of connections. Focusing on IPv4 with the &lt;code&gt;-4&lt;/code&gt; flag, the post walks through everyday command patterns: listing all TCP, UDP, and raw sockets, viewing active TCP connections, checking listening ports, displaying process names and PIDs (when run with privileges), filtering by state such as &lt;code&gt;state established&lt;/code&gt;, filtering by port with expressions like &lt;code&gt;dport = :443&lt;/code&gt;, filtering by address like &lt;code&gt;src 192.168.1.100&lt;/code&gt;, and viewing summary statistics with &lt;code&gt;ss -s&lt;/code&gt;. The flags &lt;code&gt;-t&lt;/code&gt;, &lt;code&gt;-u&lt;/code&gt;, &lt;code&gt;-l&lt;/code&gt;, &lt;code&gt;-n&lt;/code&gt;, and &lt;code&gt;-p&lt;/code&gt; map cleanly to TCP, UDP, listening sockets, numeric output, and process info.&lt;/p&gt;
&lt;p&gt;The handiest section is a side-by-side translation table from &lt;code&gt;netstat&lt;/code&gt; to &lt;code&gt;ss&lt;/code&gt;: muscle-memory commands like &lt;code&gt;netstat -an&lt;/code&gt;, &lt;code&gt;netstat -tnp&lt;/code&gt;, and &lt;code&gt;netstat -tlnp&lt;/code&gt; translate directly to &lt;code&gt;ss -an&lt;/code&gt;, &lt;code&gt;ss -tnp&lt;/code&gt;, and &lt;code&gt;ss -tlnp&lt;/code&gt;. For day-to-day troubleshooting, &lt;code&gt;ss -4tulnp&lt;/code&gt; is the most compact command to see all listening IPv4 TCP and UDP sockets along with their owning processes, while &lt;code&gt;ss -4tn state established&lt;/code&gt; is ideal for inspecting active IPv4 TCP connections. It serves as a concise, practical cheat sheet for Linux operations.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #116</title><link>https://miti99.com/en/post/2026/07/04/</link><pubDate>Sat, 04 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #116.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="8-myths-on-software-engineering-and-ai"&gt;&lt;a href="https://newsletter.getdx.com/p/8-myths-on-software-engineering-and" rel="noopener noreferrer"&gt;8 myths on software engineering and AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck introduces the paper &amp;ldquo;8 Myths on Software Engineering and GenAI,&amp;rdquo; which he co-authored, grouping eight common misconceptions about AI in software engineering into three themes: how developers actually spend their time, how to measure AI&amp;rsquo;s impact, and how AI is adopted inside real organizations. A 2025 study found that developers spend only about 14% of their time writing code, with the rest going to design, meetings, code review, and coordination. Consequently, code generation tools act on a relatively small lever, and speeding up coding easily shifts the bottleneck downstream into code review. Measuring productivity by lines of code—including AI-generated lines—only inflates the review burden; PR throughput is better, but still needs to sit inside a balanced set of metrics.&lt;/p&gt;
&lt;p&gt;Research findings on AI coding tools vary widely: some studies show clear speedups, others are neutral, and one study found experienced developers actually took 18% longer when using AI. Task type, developer experience, and prompting skill all shape the outcome. On the adoption side, 80% of developers use AI tools, yet only 29% trust their accuracy. The overarching takeaway is that AI&amp;rsquo;s impact depends far more on the work system surrounding developers than on the model itself: organizations need to build trust, workflows, guardrails, and system-level measurement rather than simply buying licenses and waiting for productivity to climb on its own.&lt;/p&gt;
&lt;h2 id="you-don"&gt;&lt;a href="https://blog.tjll.net/you-dont-love-systemd-timers-enough/" rel="noopener noreferrer"&gt;You Don&amp;rsquo;t Love systemd Timers Enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that while we still call every scheduled task a &amp;ldquo;cron job,&amp;rdquo; in 2026 there is rarely a reason to use actual &lt;code&gt;cron&lt;/code&gt;. A systemd timer is a unit that schedules another unit—typically a matching &lt;code&gt;.service&lt;/code&gt;—cleanly separating &amp;ldquo;when to run&amp;rdquo; from &amp;ldquo;what to run.&amp;rdquo; That separation solves classic &lt;code&gt;cron&lt;/code&gt; headaches: unpredictable &lt;code&gt;$PATH&lt;/code&gt; environments, swallowed stdout/stderr, hard-to-audit run history, and cryptic schedule syntax. Output goes straight into the journal, while &lt;code&gt;systemctl status&lt;/code&gt; and &lt;code&gt;systemctl list-timers&lt;/code&gt; show both the last run and the next scheduled trigger. The post also notes that &lt;code&gt;ExecStart=&lt;/code&gt; does not run inside a shell by default and does not inherit your interactive shell environment, so unit files should be written explicitly rather than treated like shell scripts—taking advantage of built-in directives like &lt;code&gt;ExecCondition=&lt;/code&gt;, &lt;code&gt;OnFailure=&lt;/code&gt;, and &lt;code&gt;Restart=&lt;/code&gt; instead of reinventing them by hand.&lt;/p&gt;
&lt;p&gt;The most valuable part highlights capabilities that go well beyond traditional &lt;code&gt;cron&lt;/code&gt;. The &lt;code&gt;systemd-analyze calendar&lt;/code&gt; command lets you validate and test schedule expressions before deploying them. Alongside wall-clock schedules via &lt;code&gt;OnCalendar=&lt;/code&gt;, timers support monotonic schedules like &lt;code&gt;OnBootSec=&lt;/code&gt; and &lt;code&gt;OnUnitActiveSec=&lt;/code&gt;—running relative to system boot or the unit&amp;rsquo;s last activation, which often matches operational intent much better than fixed minute or hour intervals. Options like &lt;code&gt;WakeSystem=&lt;/code&gt;, &lt;code&gt;Persistent=&lt;/code&gt;, &lt;code&gt;RandomizedDelaySec=&lt;/code&gt;, &lt;code&gt;FixedRandomDelay=&lt;/code&gt;, and &lt;code&gt;RandomizedOffsetSec=&lt;/code&gt; can wake a sleeping machine, catch up on missed runs after downtime, and prevent thundering herds across fleets. In short, systemd timers express operational schedules far more clearly than &lt;code&gt;cron&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="life-is-too-short-for-a-slow-terminal"&gt;&lt;a href="https://mijndertstuij.nl/posts/life-is-too-short-for-a-slow-terminal/" rel="noopener noreferrer"&gt;Life is too short for a slow terminal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mijndert Stuij writes about keeping his terminal fast because he lives in it all day, where every tiny delay when opening a tab, typing a command, or hitting Tab to autocomplete gets multiplied hundreds of times. His zsh shell starts in roughly 30ms—not thanks to a massive optimization project, but through a habit of keeping the configuration minimal. The biggest wins come from what isn&amp;rsquo;t there: no oh-my-zsh, no plugin manager, just sourcing the three plugins he actually needs directly. Because &lt;code&gt;compinit&lt;/code&gt; is a common startup bottleneck, he caches &lt;code&gt;.zcompdump&lt;/code&gt; so a full check runs only about once a day, while every other shell launch uses &lt;code&gt;compinit -C&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For heavy tools like &lt;code&gt;nvm&lt;/code&gt; or &lt;code&gt;kubectl&lt;/code&gt; completions, he uses lazy-loading: wrapping them in stub functions that only load the real initialization code the first time the command is invoked. Any tool that tells you to drop &lt;code&gt;eval &amp;quot;$(tool init zsh)&amp;quot;&lt;/code&gt; into &lt;code&gt;.zshrc&lt;/code&gt; is a prime candidate for lazy-loading. Prompts should also avoid running synchronous &lt;code&gt;git status&lt;/code&gt; checks inside large repositories; an async prompt like &lt;code&gt;pure&lt;/code&gt; renders immediately and fills in Git status in the background. Finally, he advises measuring instead of guessing, distinguishing between startup time, prompt latency, and input latency: use &lt;code&gt;time zsh -i -c exit&lt;/code&gt;, &lt;code&gt;hyperfine&lt;/code&gt;, &lt;code&gt;zprof&lt;/code&gt;, or startup traces to find the slowest culprit and fix bottlenecks one by one. By his rule of thumb, under 100ms is fine and under 50ms is great.&lt;/p&gt;
&lt;h2 id="opencodereview"&gt;&lt;a href="https://github.com/alibaba/open-code-review" rel="noopener noreferrer"&gt;OpenCodeReview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;OpenCodeReview is Alibaba&amp;rsquo;s open-source CLI tool for AI-powered code review. Born out of an internal review assistant that served tens of thousands of developers over two years, the project is now open to the community and works out of the box with any OpenAI- or Anthropic-compatible model endpoint. Rather than feeding a raw diff to a model and getting generic remarks back, the tool reads the Git diff, lets an agent read full files, search the codebase, and inspect related changed files, and then emits precise line-by-line review comments. Beyond diff-based reviews, the &lt;code&gt;ocr scan&lt;/code&gt; command can audit entire files or directories when exploring an unfamiliar codebase.&lt;/p&gt;
&lt;p&gt;A notable design choice is its hybrid architecture combining deterministic pipelines with agentic reasoning. Steps that cannot afford to be flaky—file selection, grouping related files, matching rules to files, and anchoring line comments—are handled by a strictly constrained pipeline; the agent focuses solely on dynamic reasoning like gathering context and calling tools, guided by review-tuned prompts and toolsets. Built-in rules cover issues like NPEs, thread safety, XSS, and SQL injection. Benchmarks built from 200 real pull requests show that compared to a general-purpose coding agent running the same model, OpenCodeReview achieves higher precision and F1 score while using roughly 1/9th the tokens, at the cost of lower recall—a deliberate trade-off to keep false positives down.&lt;/p&gt;
&lt;h2 id="golang-code-review-notes-ii"&gt;&lt;a href="https://www.elttam.com/blog/golang-code-review-notes-ii" rel="noopener noreferrer"&gt;Golang code review notes II&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zoltan Madarassy and Alex Brown continue their security-focused Go code review notes. Their main premise is that automated scanners and AI assistants now catch most obvious bugs, leaving the truly dangerous issues hiding in subtle corners of the language and standard library that reviewers must actively know to look for. The post starts with a few positive ecosystem improvements: &lt;code&gt;os.Root&lt;/code&gt; in Go 1.24 helps prevent path traversal vulnerabilities, and Go 1.26 updates several cryptographic functions to draw from a secure internal randomness source automatically, though &lt;code&gt;math/rand&lt;/code&gt; remains unsuitable for cryptographic use.&lt;/p&gt;
&lt;p&gt;The bulk of the post focuses on footguns that still slip past review. Integer overflows happen silently—for example, casting a length to a narrower type like &lt;code&gt;uint32(len(s))&lt;/code&gt;—which can corrupt framing boundaries in serialization libraries. &lt;code&gt;httputil.ReverseProxy.Director&lt;/code&gt; is vulnerable to hop-by-hop header abuse, so code should migrate to &lt;code&gt;Rewrite&lt;/code&gt;, which runs after those headers are stripped. Shallow pointer copies in &lt;code&gt;net/url&lt;/code&gt; can lead to shared-state mutation and race conditions; null bytes crossing CGO or C library boundaries can bypass validation checks; and &lt;code&gt;encoding/json&lt;/code&gt; can silently skip a custom marshaller if the method uses a pointer receiver while the struct is passed by value. JSON APIs also aren&amp;rsquo;t automatically immune to CSRF unless &lt;code&gt;Content-Type&lt;/code&gt;, &lt;code&gt;SameSite&lt;/code&gt; cookies, and request origins are properly validated. The authors also release a set of Semgrep rules to catch several of these patterns automatically.&lt;/p&gt;
&lt;h2 id="thoughts-on-starting-new-projects-with-llm-agents"&gt;&lt;a href="https://eli.thegreenplace.net/2026/thoughts-on-starting-new-projects-with-llm-agents/" rel="noopener noreferrer"&gt;Thoughts on starting new projects with LLM agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eli Bendersky shares his experience using LLM agents to build &lt;code&gt;watgo&lt;/code&gt;, a new Go project, from scratch. He starts by iterating with the agent on the design and API, saving the result as a committed Markdown file in the repository that both human and agent follow as a shared blueprint. From there, he asks the agent to implement small changelists (CLs) in a logical sequence, reviews each one in VSCode&amp;rsquo;s diff view, makes manual edits where needed, and commits the changes himself. When the agent produces a diff that grows too large, the pragmatic move is to commit at an acceptable intermediate state and ask for follow-up refactorings in separate CLs; if a whole direction turns out wrong, the commit chain is still easy to revert.&lt;/p&gt;
&lt;p&gt;His central message is that humans must stay firmly in the loop on any project meant for long-term maintenance. Vibe coding works fine for prototypes or throwaway scripts, but on a serious project, the author must understand, review, and steer every design decision. He stresses small CLs and a solid testing strategy, warning against letting an agent write both the implementation and the tests in one go, where it can easily bake its own bugs into the test expectations. He also finds Go exceptionally well suited for agentic coding thanks to its stability, minimal syntactic redundancy, rich standard library, uniform formatting, and explicit error handling—when human effort shifts from writing code to reading it, readability becomes a massive advantage. Finally, he cautions junior developers to be careful about leaning too heavily on LLMs while still building foundational skills.&lt;/p&gt;
&lt;h2 id="the-history-of-pets-vs-cattle-and-how-to-use-the-analogy-properly"&gt;&lt;a href="https://cloudscaling.com/blog/cloud-computing/the-history-of-pets-vs-cattle/" rel="noopener noreferrer"&gt;The History of Pets vs Cattle and How to Use the Analogy Properly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Randy Bias recounts the origin and intended meaning of the &amp;ldquo;pets vs. cattle&amp;rdquo; analogy in cloud infrastructure. He adapted the metaphor from a presentation on scaling SQL Server, reframing it for cloud computing to contrast the irreplaceability of a &amp;ldquo;pet&amp;rdquo; with the fungibility of &amp;ldquo;cattle.&amp;rdquo; A &amp;ldquo;pet&amp;rdquo; is a server or pair of servers treated as indispensable—typically built and cared for by hand, where a failure sends the whole team scrambling to nurse it back to health. &amp;ldquo;Cattle&amp;rdquo; are fleets of three or more machines provisioned automatically and designed for failure, so losing a node or two is handled automatically by the system without human intervention. The analogy caught on because it captured the shift from traditional sysadmin practices to cloud-native architecture in a single image.&lt;/p&gt;
&lt;p&gt;Bias also warns that misusing the analogy strips away its original lesson. A prime example was Kubernetes originally naming StatefulSets &amp;ldquo;Pet Sets&amp;rdquo;: the stateful distributed systems cited as examples—Cassandra, Kafka, MongoDB—are actually architected as &amp;ldquo;cattle,&amp;rdquo; since they handle node failure through horizontal scale-out. Defining a &amp;ldquo;pet&amp;rdquo; as any system that needs special handling, rather than a system that isn&amp;rsquo;t allowed to fail, blurs the distinction between legacy operations and cloud-native design. The core of the analogy is server replaceability and system-level fault tolerance, not whether a workload happens to be stateful.&lt;/p&gt;
&lt;h2 id="every-byte-matters"&gt;&lt;a href="https://fzakaria.com/2026/06/01/every-byte-matters" rel="noopener noreferrer"&gt;Every byte matters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria reminds us that performance isn&amp;rsquo;t just about Big-O complexity. Even inside a simple linear loop, data size and memory layout make a massive difference because CPUs fetch memory in cache lines, typically 64 bytes at a time. If a struct is large but a loop only inspects a single small field like &lt;code&gt;is_alive&lt;/code&gt;, an array-of-structs layout drags dozens of unused bytes into the cache on every read. Flipping to a struct-of-arrays layout packs that single field into contiguous memory so every cache line fetch serves many more elements; in the author&amp;rsquo;s benchmark, this yielded up to a 30x speedup when the struct size reached 1KiB.&lt;/p&gt;
&lt;p&gt;The post also explains why working set size is critical for random access patterns. During sequential scans, the CPU hardware prefetcher can predict upcoming addresses and hide memory latency. With hash maps, trees, graphs, or pointer-heavy structures, however, the next address is unpredictable, meaning the working set must fit inside CPU cache to avoid stalling on main memory. Simply doubling a struct from 64B to 128B pushes the exact same number of elements down into a slower cache tier: at 512 elements, 64B structs fit inside L1d at ~3 ns latency, whereas 128B structs spill into L2 at ~11 ns. The practical lesson is that every byte on a hot path carries a cost, and understanding struct sizes, cache lines, and working sets often yields far bigger wins than algorithmic analysis alone.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #115</title><link>https://miti99.com/en/post/2026/07/02/</link><pubDate>Thu, 02 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #115.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-experiments-explained"&gt;&lt;a href="https://www.alexedwards.net/blog/go-experiments-explained" rel="noopener noreferrer"&gt;Go Experiments Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards explains the experimental feature mechanism Go ships in each release: sometimes a new standard library package like &lt;code&gt;testing/synctest&lt;/code&gt;, sometimes a compiler or runtime change like a new garbage collector, and more rarely a language behavior change like loop variable scoping before it became the default in Go 1.22. The goal is to gather real-world feedback before locking a feature in; if it causes problems or draws pushback, it can be revised or dropped entirely. The typical lifecycle starts disabled by default, flips to enabled by default after a release or two (often with a transition period allowing opt-out), and eventually retires the flag—though exceptions happen: &lt;code&gt;Arenas&lt;/code&gt; was put on indefinite hold after negative feedback, while Swiss tables went straight to default.&lt;/p&gt;
&lt;p&gt;Because there is no official status page tracking experiments, Edwards compiled a reference table for Go 1.26 from &lt;code&gt;go doc goexperiment.Flags&lt;/code&gt;, the &lt;code&gt;internal/buildcfg&lt;/code&gt; source, and release notes. To use them, pass comma-separated lowercase names in the &lt;code&gt;GOEXPERIMENT&lt;/code&gt; environment variable to enable features, or prefix a name with &lt;code&gt;no&lt;/code&gt; to disable it, across &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go test&lt;/code&gt;. For everyday Go developers, the most notable flags are &lt;code&gt;GreenTeaGC&lt;/code&gt; and &lt;code&gt;Dwarf5&lt;/code&gt; (already enabled by default, so worth knowing how to disable if issues arise), &lt;code&gt;JSONv2&lt;/code&gt;, &lt;code&gt;GoroutineLeakProfile&lt;/code&gt; for catching leaked goroutines, &lt;code&gt;RuntimeSecret&lt;/code&gt; for code handling sensitive data, and &lt;code&gt;RuntimeFreegc&lt;/code&gt;. One important caveat: experiments fall outside Go&amp;rsquo;s compatibility promise, so use them to test, benchmark, and give feedback rather than relying on them prematurely in production.&lt;/p&gt;
&lt;h2 id="low-level-network-optimizations-socket-options-that-matter"&gt;&lt;a href="https://goperf.dev/02-networking/low-level-optimizations/" rel="noopener noreferrer"&gt;Low-Level Network Optimizations: Socket Options That Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This entry from the Go Optimization Guide examines socket options that directly impact latency and throughput in Go network applications. Operating system defaults prioritize safety and broad compatibility, meaning under heavy load they often become bottlenecks well before CPU or memory. &lt;code&gt;TCP_NODELAY&lt;/code&gt; disables Nagle&amp;rsquo;s algorithm so small packets are sent immediately at the cost of higher bandwidth overhead; Go enables this by default on &lt;code&gt;TCPConn&lt;/code&gt;. &lt;code&gt;SO_REUSEPORT&lt;/code&gt; lets multiple processes or threads bind to the same port while the kernel distributes incoming connections across separate queues, reducing lock contention and scaling across CPU cores. Receive and send buffer sizes (&lt;code&gt;SO_RCVBUF&lt;/code&gt; and &lt;code&gt;SO_SNDBUF&lt;/code&gt;) should roughly match the bandwidth-delay product: too small increases syscalls and caps throughput, while too large wastes memory and inflates latency via bufferbloat.&lt;/p&gt;
&lt;p&gt;For TCP keepalives, OS defaults are very conservative; common production settings wait 30–60 seconds, probe every 10–15 seconds, and retry 3–5 times, though tuning them too aggressively increases traffic and risks false drops on congested links. In Go, &lt;code&gt;SetKeepAlivePeriod&lt;/code&gt; only controls the initial idle time; starting in Go 1.23, &lt;code&gt;SetKeepAliveConfig&lt;/code&gt; lets you configure Interval and Count without dropping down to raw syscalls. &lt;code&gt;SOMAXCONN&lt;/code&gt; governs the listener backlog queue and is tuned at the OS level via &lt;code&gt;sysctl&lt;/code&gt;. To apply socket options at the right moment—before the socket is bound—use the &lt;code&gt;Control&lt;/code&gt; callback on &lt;code&gt;net.ListenConfig&lt;/code&gt; with &lt;code&gt;syscall.RawConn&lt;/code&gt;. The overarching advice: change one setting at a time, test under realistic load, and rely on measurements rather than copy-pasting configs from elsewhere.&lt;/p&gt;
&lt;h2 id="when-is-100-vibe-coding-ok-"&gt;&lt;a href="https://dev.to/realvorl/when-is-100-vibe-coding-ok--38p" rel="noopener noreferrer"&gt;When Is 100% Vibe Coding OK ?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Viorel PETCU opens with the frustration of spending hours reviewing &amp;ldquo;vibe-written&amp;rdquo; specifications: they read smoothly on the surface but say almost nothing concrete and cannot be applied to an existing system. The author isn&amp;rsquo;t against vibe coding—in fact, he uses it regularly for one-off scripts, throwaway charts, quick parsers, or docs nobody has to maintain, where speed matters more than rigor. Once software needs long-term maintenance, however, the equation changes completely.&lt;/p&gt;
&lt;p&gt;His motivating example is a wooden puzzle of 25 identical pentacube pieces that must pack a &lt;code&gt;5×5×5&lt;/code&gt; cube. After failing to solve it by hand, he used Go and ChatGPT to write a solver: the initial struggle wasn&amp;rsquo;t the algorithm, but the domain representation—coordinate conventions, slice notation, piece rotations, and naming. Once the model stabilized, the rest was classic brute-force recursion with backtracking, and modern hardware was fast enough that no further optimization was needed. Within about two hours, the project evolved into a general solver complete with OBJ/MTL export for viewing in Blender. Crucially, the author was able to push past hallucinated constraints, wrong assumptions, and buggy code because he already knew for a fact that the puzzle had a physical solution. His conclusion: 100% vibe coding is fine when a human holds the invariants, the constraints are real, and the output is verifiable; if the requirements themselves are just vibes, the system has nothing solid to converge on.&lt;/p&gt;
&lt;h2 id="self-calling-executables"&gt;&lt;a href="https://log.pfad.fr/2026/self-calling-executable/" rel="noopener noreferrer"&gt;Self-calling executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olivier introduces the &amp;ldquo;self-calling executable&amp;rdquo; pattern: a running program spawns another instance of itself, directly or indirectly, to take on a different role. The first use case is black-box testing a &lt;code&gt;main&lt;/code&gt; function when the codebase relies on global state that causes in-process tests to interfere with one another. A test invokes the test binary itself via &lt;code&gt;os.Args[0]&lt;/code&gt; along with an environment variable like &lt;code&gt;TEST_MAIN&lt;/code&gt;; inside &lt;code&gt;TestMain&lt;/code&gt;, if that variable is set, the binary runs the real entrypoint instead of the test runner, isolating each invocation inside a fresh child process.&lt;/p&gt;
&lt;p&gt;The second use case is integrating with external tools, illustrated by jjui, a terminal UI for Jujutsu. The &lt;code&gt;ssh&lt;/code&gt; command uses the &lt;code&gt;SSH_ASKPASS&lt;/code&gt; environment variable to invoke an external helper when it needs a passphrase; jjui points &lt;code&gt;SSH_ASKPASS&lt;/code&gt; back at itself so that when &lt;code&gt;ssh&lt;/code&gt; prompts for a password, the grandchild process connects back to the main jjui process over a Unix domain socket (with the PID embedded in the path so multiple sessions can run concurrently), forwards the prompt, collects the user&amp;rsquo;s input, and prints it to stdout for &lt;code&gt;ssh&lt;/code&gt;. Because this handles sensitive credentials, the author adds two safeguards: each child receives a random token it must present on connect, and the main process walks the connecting client&amp;rsquo;s ancestor PID chain to verify lineage. Downsides include harder debugging, risk of infinite recursion if environment variables are misconfigured, and the Go race detector sleeping for 1 second on every process exit—which once stretched Forgejo&amp;rsquo;s integration suite from 45 minutes to over 2 hours, fixable via &lt;code&gt;GORACE=&amp;quot;atexit_sleep_ms=0&amp;quot;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="modern-engineering-values"&gt;&lt;a href="https://cpojer.net/posts/modern-engineering-values" rel="noopener noreferrer"&gt;Modern Engineering Values&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christoph Nakazawa shares that he now rarely writes code by hand: projects like Vite+, fate, and Athena Crisis are largely written by coding agents, primarily via Codex CLI. His workflow is to have the agent propose a plan and ask clarifying questions before executing, require a failing test before fixing a bug, run several automated review passes, and only then review the diff himself. When writing code is no longer the bottleneck, discussing and reviewing code becomes the limiting factor.&lt;/p&gt;
&lt;p&gt;From there, the post proposes a set of engineering values for the agentic era. Strong ownership: agents amplify engineers with deep product understanding just as much as they amplify noise from people lacking context, meaning effective teams will be small—around two to three people—with clear boundaries, and code review will focus on alignment rather than nitpicking individual lines. Good taste to know what is actually worth building. Tight guardrails and fast feedback loops—linters, automated tests, and tools that operate only on changed files—because working with agents is like onboarding a brand-new hire with zero context on every prompt. Keeping context inside the repo rather than scattered across docs, chat threads, or tribal memory. Owning your stack instead of pulling in heavy third-party dependencies, since agents have drastically lowered the cost of building in-house. As for management, he believes the role will become increasingly technical: as execution becomes cheap, judgment becomes the bottleneck.&lt;/p&gt;
&lt;h2 id="building-software-is-learning"&gt;&lt;a href="https://registerspill.thorstenball.com/p/building-software-is-learning" rel="noopener noreferrer"&gt;Building Software Is Learning&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball publishes an internal note sent to the Amp team on why building new software is always a learning process. The idealized sequence—&amp;ldquo;we need this feature,&amp;rdquo; &amp;ldquo;I built it,&amp;rdquo; &amp;ldquo;that&amp;rsquo;s exactly what I wanted&amp;rdquo;—almost never happens without a detailed spec; reality usually looks more like &amp;ldquo;that&amp;rsquo;s not what I meant,&amp;rdquo; &amp;ldquo;there are three ways to do this, which one do we want?&amp;rdquo;, or &amp;ldquo;I tried it and I don&amp;rsquo;t like how it feels.&amp;rdquo; That is because people only truly understand what they are building while building it, and avoiding that discovery entirely would require specifying every detail up front—which is just programming by another name.&lt;/p&gt;
&lt;p&gt;The good news is that you can shrink the gap between a confident &amp;ldquo;I&amp;rsquo;ll build it&amp;rdquo; and contact with reality. Instead of disappearing for four weeks, build a prototype in an hour, write a spec in thirty minutes, break the work down and ship a piece every day, cut scope to isolate the unknowns, record a fake demo video, write the release announcement first, or draft README examples to test an API design. Feedback can come from CI, teammates, users, or yourself dogfooding the feature. Ball adds two practical warnings: a prototype riddled with obvious bugs will only get you bug reports instead of useful design feedback, and keeping a branch alive for three weeks before merging 27 commits at once means when CI breaks, you have 27 potential culprits. The question to keep asking is how to get feedback as early and as often as possible so you can learn faster.&lt;/p&gt;
&lt;h2 id="you-must-fix-your-asserts"&gt;&lt;a href="https://kristoff.it/blog/fix-your-asserts/" rel="noopener noreferrer"&gt;You Must Fix Your Asserts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro argues against the habit of disabling assertions in production, using Zig as context. An assertion is a line of code stating a program truth—a precondition, postcondition, or invariant; if the type system can express the constraint, use types, and otherwise assertions catch programming bugs, often more effectively than unit tests when paired with fuzzing. In Zig, &lt;code&gt;std.debug.assert&lt;/code&gt; is built on &lt;code&gt;unreachable&lt;/code&gt;: in checked build modes like Debug or ReleaseSafe, a violated assertion panics; in ReleaseFast or ReleaseSmall, the compiler treats the assertion as an assumed fact for optimization, meaning a false assertion leads to unpredictable undefined behavior. Unlike C/C++, Zig&amp;rsquo;s assert is a regular function rather than a macro, so its argument expression is always evaluated.&lt;/p&gt;
&lt;p&gt;According to Cro, you have three choices: keep assertions active as runtime checks, let the compiler optimize around them and accept the risk, or strip them out—and the third option is the worst. Disabling assertions means that when the &amp;ldquo;impossible&amp;rdquo; happens, the program keeps running on broken assumptions, silently diverging from its spec while stripping away the very signal that would have caught it. Worse, future maintainers will write new code trusting those false assertions, allowing vulnerabilities to creep in unnoticed. He points to TigerBeetle keeping assertions enabled in production and Ghostty shipping ReleaseFast builds. The takeaway: fix broken assertions, gate genuinely expensive checks behind debug-only flags, log instead of crashing where appropriate, and choose build modes based on your risk model rather than erasing error signals.&lt;/p&gt;
&lt;h2 id="the-software-engineering-books-i-keep-recommending"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/best-software-engineering-books-2026" rel="noopener noreferrer"&gt;The Software Engineering Books I keep recommending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr. Milan Milanović shares the software engineering books he recommends most often, noting that reading gives him both breadth and depth in technical discussions and decision-making—and in the AI era, helps him evaluate and steer AI tools more effectively. Rather than presenting a one-size-fits-all &amp;ldquo;must-read&amp;rdquo; list, he groups the books by the specific problem a reader is facing, arguing that the right question isn&amp;rsquo;t &amp;ldquo;what should I read?&amp;rdquo; but &amp;ldquo;where am I currently stuck?&amp;rdquo; Most of the picks aren&amp;rsquo;t tied to specific frameworks, so their lessons age well.&lt;/p&gt;
&lt;p&gt;For coding mindset, he highlights &lt;code&gt;The Pragmatic Programmer&lt;/code&gt;, &lt;code&gt;Clean Code&lt;/code&gt; (noting some rules are dated), and &lt;code&gt;A Philosophy of Software Design&lt;/code&gt;, the book he re-reads most often. Architecture covers &lt;code&gt;Fundamentals of Software Architecture&lt;/code&gt;, &lt;code&gt;Software Architecture: The Hard Parts&lt;/code&gt;, and &lt;code&gt;Domain-Driven Design Quickly&lt;/code&gt;; systems and data feature the second edition of &lt;code&gt;Designing Data-Intensive Applications&lt;/code&gt; alongside the more approachable &lt;code&gt;Understanding Distributed Systems&lt;/code&gt;. The AI section pairs &lt;code&gt;The Hundred-Page Language Models Book&lt;/code&gt; on how language models work with Chip Huyen&amp;rsquo;s &lt;code&gt;AI Engineering&lt;/code&gt; on building real-world AI applications. Rounding out the list are &lt;code&gt;The Art of Unit Testing&lt;/code&gt; for testing, &lt;code&gt;Accelerate&lt;/code&gt; (with the four DORA metrics) and &lt;code&gt;Refactoring&lt;/code&gt; for development workflow, and &lt;code&gt;The Software Engineer's Guidebook&lt;/code&gt; and &lt;code&gt;Deep Work&lt;/code&gt; for career growth. He also mentions his own new book on laws in software engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #114</title><link>https://miti99.com/en/post/2026/07/01/</link><pubDate>Wed, 01 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #114.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-errors-are-a-story-most-teams-lose-the-plot"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-errors/" rel="noopener noreferrer"&gt;Go errors are a story, most teams lose the plot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Robin Siep examines a fundamental difference in how Go handles errors: unlike Java and many other languages, Go errors do not automatically carry stack traces. Instead, developers wrap errors with context at each layer they pass through—such as &lt;code&gt;fmt.Errorf(&amp;quot;unable to get user: %w&amp;quot;, err)&lt;/code&gt;—ultimately producing a chain like &lt;code&gt;unable to get user: failed to query users table: connection refused&lt;/code&gt;. The author calls this a &amp;ldquo;logical trace&amp;rdquo;: when maintained well, it is easier to read than a multi-dozen-line stack trace and stays intact even when errors cross channels, goroutines, or other handoff boundaries where call stacks can get lost.&lt;/p&gt;
&lt;p&gt;The catch is that a logical trace requires relentless discipline from the entire team. Forget to wrap an error at just one call site, and your logs may be left with a bare &lt;code&gt;connection refused&lt;/code&gt;; and much like code comments, an error-wrapping message written two years ago can drift out of date or become misleading. In the author&amp;rsquo;s observation, most teams fail to keep up with this maintenance burden, leaving production errors without enough context to diagnose root causes. The proposed middle ground is to attach a stack trace the moment the application creates an error or first receives one from a third-party library, and then add manual context only when it genuinely clarifies the problem. That way, the stack trace serves as a cheap, always-present fallback. Implementing this yourself is straightforward, or you can reach for Dave Cheney&amp;rsquo;s &lt;code&gt;pkg/errors&lt;/code&gt; or &lt;code&gt;cockroachdb/errors&lt;/code&gt; if you want an actively maintained library.&lt;/p&gt;
&lt;h2 id="the-last-technical-interview"&gt;&lt;a href="https://steve-yegge.medium.com/the-last-technical-interview-bc13ddcf4564" rel="noopener noreferrer"&gt;The Last Technical Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Yegge—who has conducted technical interviews for nearly 35 years, serving as an Amazon Bar Raiser and a Google Hiring Committee member—argues that the traditional technical interview loop is reaching the end of the line. The model of cramming several one-hour interviews into a single day has barely changed in fifty years despite terrible results: interviewers routinely disagree with one another, interview scores barely correlate with actual on-the-job performance, and resumes are becoming increasingly useless now that AI writes them. His most memorable anecdote comes from Google, where recruiting handed the hiring committee a batch of anonymized interview packets disguised as a &amp;ldquo;calibration exercise&amp;rdquo;; the committee voted to reject roughly two-thirds of them, only to learn afterward that the packets were their own historical interview files.&lt;/p&gt;
&lt;p&gt;According to Yegge, the strongest hiring signal has always come from real work—internships, six-month co-ops at Geoworks, or contract-to-hire trials—so it is time to stop &amp;ldquo;simulating work.&amp;rdquo; A new &amp;ldquo;campfire&amp;rdquo; model is emerging in San Francisco: inviting candidates for a paid multi-day stint working on real code, real requirements, and alongside the real team. To make this fair, every stint should &amp;ldquo;count twice&amp;rdquo;: the company gets high-signal evaluation and real output, while the candidate walks away with a durable, company-verified record of what they built and how well they performed, whether or not they receive an offer. Such a system only works if those &amp;ldquo;stamps of approval&amp;rdquo; are issued honestly.&lt;/p&gt;
&lt;h2 id="guidelines-for-respectful-use-of-ai"&gt;&lt;a href="https://www.elidedbranches.com/2026/05/guidelines-for-respectful-use-of-ai.html" rel="noopener noreferrer"&gt;Guidelines for Respectful Use of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Camille Fournier argues that many leaders view AI policies purely through the lens of security, compliance, or cost, overlooking how teams actually work together when AI enters the picture. AI lets an individual generate far more output, but if that person doesn&amp;rsquo;t review it themselves, the quality-control burden simply gets pushed onto teammates and overall team productivity drops. Her first rule is therefore simple: never ask someone else to read or review something you haven&amp;rsquo;t read yourself. This applies to code and even more so to documents, since the context in your head while chatting with an AI may be completely absent from the final text; if you cannot explain and discuss a document yourself, you shouldn&amp;rsquo;t send it out.&lt;/p&gt;
&lt;p&gt;Her second rule is &amp;ldquo;shorter is better&amp;rdquo;: AI-generated code often reads like verbose tutorial code, pull requests balloon to thousands of lines, three-page documents turn into 10-to-20-page essays, and Slack messages and emails become walls of text. She suggests a litmus test: if this change breaks at 3 a.m. and every AI tool is down, can you debug it yourself? For long documents, put a concise summary of the key points right at the top; if you find yourself writing a massive email to explain something, you should probably hop on a call instead. Ultimately, AI is not an excuse to turn off your brain or your empathy: use the productivity gains to ship simpler, better-tested work.&lt;/p&gt;
&lt;h2 id="software-after-ai"&gt;&lt;a href="https://tomtunguz.com/harnessing-ai/" rel="noopener noreferrer"&gt;Software After AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz argues that the familiar software era—where SaaS products manage databases through fixed workflows—is giving way to the era of the &amp;ldquo;harness&amp;rdquo;: the surrounding layer that turns a raw LLM into a reliable agent. He compares an LLM to a wild horse that needs to be broken in. When every company has access to the exact same foundation models, competitive advantage no longer lives in the model itself, but in whoever builds the best harness.&lt;/p&gt;
&lt;p&gt;The post outlines seven components of an AI harness. Context and memory require domain-specific retrieval alongside a &amp;ldquo;context database&amp;rdquo; capturing how a business actually operates. Tools and actions are exposed through a registry with parameter validation and approval gates for sensitive operations, with MCP acting as the connective tissue. Orchestration is the think-act-observe-repeat loop, complete with planning, subagents, and stopping conditions. State and persistence allow a mid-flight failure to resume from the last verified checkpoint (for instance, finishing step 7 and resuming at step 8) instead of starting over from scratch. Sandboxing isolates the execution environment. Observability and governance—traces, logs, evals, and human-in-the-loop approvals for high-stakes decisions—turn a demo into a production system. Finally, cost and workflow optimization decide which steps belong in deterministic code and which call for large or small models. Frontier labs will win the markets they prioritize, but thousands of vertical markets remain wide open for startups.&lt;/p&gt;
&lt;h2 id="design-patterns-are-dead-long-live-design-patterns"&gt;&lt;a href="https://medium.com/google-cloud/design-patterns-are-dead-long-live-design-patterns-b2c2602fbdc4" rel="noopener noreferrer"&gt;Design Patterns Are Dead. Long Live Design Patterns.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christina Lin, a veteran developer, asks whether classic design patterns still matter when AI writes most of the code. Patterns like Singleton, Factory, and Observer were created for human comprehension rather than compilers, so at first she wondered if they had become obsolete. Once a codebase grows large enough, however, AI starts to ramble because it has limits of its own: Chroma&amp;rsquo;s research across 18 models showed reliability degrading as input length grows (&amp;ldquo;context rot&amp;rdquo;), with the drop-off varying by model. As a result, design patterns aren&amp;rsquo;t dead—they&amp;rsquo;ve been promoted from implementation blueprints to ways of compressing intent into prompts and enforcing architectural guardrails around probabilistic models.&lt;/p&gt;
&lt;p&gt;Lin reclassifies patterns around a single question: is this pattern here to help humans read code, or to constrain AI? Patterns that merely patched missing language features, like Iterator or Prototype, are dead; speculative abstractions built &amp;ldquo;just in case&amp;rdquo; should also be pared back now that code is cheap and intent is expensive. Conversely, three patterns matter more than ever: Adapter forces AI outputs into strict schemas before touching the database and feeds validation errors back for self-correction; Decorator wraps retries, timeouts, and token-cost tracking around core logic; and Facade hides complex multi-step agent workflows behind a clean, auditable interface. The unifying principle is treating AI output as untrusted input: isolate it, validate at the boundary, and trust it only once proven valid.&lt;/p&gt;
&lt;h2 id="merge-intervals"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/merge-intervals-89l" rel="noopener noreferrer"&gt;Merge Intervals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh walks through Merge Intervals, a classic interview problem: given an array of &lt;code&gt;[start, end]&lt;/code&gt; intervals, merge all overlapping intervals and return the disjoint result. At first glance it looks like a simulation problem, and the brute-force approach checks every subsequent interval to extend the current end point in &lt;code&gt;O(N²)&lt;/code&gt; time. The key insight is that once intervals are sorted by start time, any overlapping intervals are guaranteed to sit adjacent to one another, so you only ever need to compare the current interval against the most recently merged one.&lt;/p&gt;
&lt;p&gt;That makes the optimal algorithm clean and compact: sort by &lt;code&gt;start&lt;/code&gt; and scan left to right; if the end of the last interval in the result list is smaller than the current interval&amp;rsquo;s start, append the current interval as a new entry; otherwise, update the last interval&amp;rsquo;s end to the maximum of both ends. For input &lt;code&gt;[[1,3],[2,6],[8,10],[15,18]]&lt;/code&gt;, this produces &lt;code&gt;[[1,6],[8,10],[15,18]]&lt;/code&gt;. Overall time complexity is &lt;code&gt;O(N log N)&lt;/code&gt; due to sorting, while the linear scan takes &lt;code&gt;O(N)&lt;/code&gt;. The author also shares interview tips: clearly explain why sorting makes overlapping intervals contiguous, and remember the &amp;ldquo;sort first, then sweep left to right&amp;rdquo; pattern for related problems like Insert Interval, Meeting Rooms, and Non-overlapping Intervals.&lt;/p&gt;
&lt;h2 id="best-time-to-buy-and-sell-stock"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/best-time-to-buy-and-sell-stock-3792" rel="noopener noreferrer"&gt;Best Time to Buy and Sell Stock&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh follows up with another classic LeetCode problem, Best Time to Buy and Sell Stock: given an array of daily stock prices where you may buy once and sell once on a later day, find the maximum profit. For &lt;code&gt;[7,1,5,3,6,4]&lt;/code&gt;, buying at 1 and selling at 6 yields a profit of 5. The brute-force approach treats every day as a buy day, checks every subsequent sell day, and tracks the maximum profit—correct, but &lt;code&gt;O(N²)&lt;/code&gt; because it evaluates far too many redundant buy-sell pairs.&lt;/p&gt;
&lt;p&gt;The key observation is that on any given day, you don&amp;rsquo;t need to remember every prior price—only the lowest price seen so far, because the best profit you could make by selling today is today&amp;rsquo;s price minus that historical minimum. The author notes that he initially considered a dynamic programming array &lt;code&gt;dp[i]&lt;/code&gt;, before realizing that the minimum price is the only state that matters, collapsing the array into two scalar variables: &lt;code&gt;minPrice&lt;/code&gt; and &lt;code&gt;maxProfit&lt;/code&gt;. A single pass that computes today&amp;rsquo;s potential profit, updates the best answer, and updates the running minimum achieves &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space. This is the classic &amp;ldquo;prefix minimum&amp;rdquo; pattern: whenever a problem asks for a maximum profit, maximum difference, or future outcome relative to past values, think about maintaining a running minimum or maximum during a single sweep.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #113</title><link>https://miti99.com/en/post/2026/06/24/</link><pubDate>Wed, 24 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #113.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="migrating-from-go-to-rust"&gt;&lt;a href="https://corrode.dev/learn/migration-guides/go-to-rust/" rel="noopener noreferrer"&gt;Migrating from Go to Rust&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthias Endler writes a comprehensive guide for backend teams considering migrating services from Go to Rust. The central message isn&amp;rsquo;t &amp;ldquo;Rust is always faster than Go,&amp;rdquo; but that Rust pushes many classes of risk into the type system so the compiler catches them before production: &lt;code&gt;nil&lt;/code&gt; values, error handling, data races, resource lifetimes, and ownership. Go optimizes for team velocity—fast compile times, a strong standard library, and easy-to-use goroutines. Rust trades that for a stricter compiler, no GC, &lt;code&gt;Result&lt;/code&gt;, &lt;code&gt;Option&lt;/code&gt;, traits, and &lt;code&gt;Send&lt;/code&gt;/&lt;code&gt;Sync&lt;/code&gt; checks. Familiar Go habits have to be remapped: &lt;code&gt;if err != nil&lt;/code&gt; becomes &lt;code&gt;Result&lt;/code&gt; with &lt;code&gt;?&lt;/code&gt;, &lt;code&gt;nil&lt;/code&gt; becomes &lt;code&gt;Option&lt;/code&gt;, interfaces become traits, and goroutines become tasks when genuinely needed.&lt;/p&gt;
&lt;p&gt;The most practical section covers migration strategy: don&amp;rsquo;t rewrite everything at once. Start with a hot path, worker, or clearly bounded service, keep the existing API contract, and shift traffic gradually endpoint by endpoint through a gateway using the strangler pattern. While &lt;code&gt;cgo&lt;/code&gt; works, it is often more complex than splitting the Rust portion into a separate service. The author is also candid about the costs: the borrow checker makes the first month rough, compile times are slower, async function coloring is annoying, and parts of the ecosystem are smaller. There is no need to abandon Go entirely: Go remains a great fit for Kubernetes tooling, CLIs, and &amp;ldquo;boring&amp;rdquo; glue services, while Rust is worth the investment for foundational services where reliability, P99 latency, and bugs like nil dereferences or data races carry higher operational costs than the learning and build overhead.&lt;/p&gt;
&lt;h2 id="ai-engineering-for-developers"&gt;&lt;a href="https://www.lucavallin.com/blog/ai-engineering-for-developers" rel="noopener noreferrer"&gt;AI Engineering for Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Luca Cavallin writes a deep-dive guide to AI engineering for developers already comfortable with backends, HTTP, queues, Kubernetes, and production operations. His main argument: when bringing LLMs into a product, the model is not the whole product; what actually creates value is the system around it—prompts, RAG, evals, agents, inference, observability, security, and cost controls. That makes the discipline much closer to backend engineering than model training. Because AI outputs are non-deterministic and can shift across models, prompts, or data, a working demo isn&amp;rsquo;t enough to ship: you need eval datasets, regression checks on every prompt or model change, canary rollouts, and monitoring from day one.&lt;/p&gt;
&lt;p&gt;The article progresses from fundamentals to practical execution: selecting models by task, cost, and latency; exhausting prompt engineering before reaching for RAG; treating RAG primarily as a search problem where hybrid search, rerankers, chunking strategy, and source citations matter more than stuffing more context; fine-tuning only after prompting and RAG hit their ceiling; and optimizing inference through caching, batching, and model routing. Agents are framed as tool-calling loops that require strict schemas, narrow permissions, end-to-end tracing, and human approval gates for risky actions. The production section emphasizes guardrails, dedicated CI/CD pipelines for prompt and model changes, per-feature cost attribution, and treating every agent as a service with its own identity, least-privilege access, and audit logs.&lt;/p&gt;
&lt;h2 id="the-invisible-engineering-behind-lambdas-network"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/04/the-invisible-engineering-behind-lambdas-network.html" rel="noopener noreferrer"&gt;The invisible engineering behind Lambda’s network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on All Things Distributed recounts nearly a decade of networking optimizations behind AWS Lambda—the kind of &amp;ldquo;invisible&amp;rdquo; engineering customers only notice because functions start faster and more reliably. The original bottleneck was cold starts when Lambda connected to a customer VPC: beyond spinning up a Firecracker microVM and initializing the runtime, the system had to establish a private network path into the customer&amp;rsquo;s VPC, with Geneve tunnel creation sitting right on the hot path. Rather than maintaining custom kernel patches, the Lambda team turned to eBPF: pre-creating tunnels with a dummy VNI and overwriting the packet header once the real VNI arrived, cutting tunnel setup latency from ~150ms to 200 microseconds.&lt;/p&gt;
&lt;p&gt;Even more instructive is how they scaled to 4,000 networks per worker. Instead of creating tap devices, veth pairs, namespaces, and routing rules on every function invocation, they pre-allocated everything at worker startup, turning a load-variable cost into a one-time fixed cost. They replaced stateful NAT with stateless eBPF packet rewriting, cutting NAT setup latency 100x; collapsed over 125,000 iptables rules in the root namespace down to 144 static rules by moving per-slot rules into their respective namespaces; and reduced RTNL lock contention by reordering network creation and attaching eBPF programs in batches. At scale, iptables rules, conntrack, or a single kernel lock can all become bottlenecks. The result is a unified topology serving both traditional workloads and SnapStart, boosting snapshot network throughput 20x and getting repackaged for reuse in Aurora DSQL.&lt;/p&gt;
&lt;h2 id="selective-test-execution-at-stripe-fast-ci-for-a-50m-line-ruby-monorepo"&gt;&lt;a href="https://stripe.dev/blog/selective-test-execution-at-stripe-fast-ci-for-a-50m-line-ruby-monorepo" rel="noopener noreferrer"&gt;Selective Test Execution at Stripe: Fast CI for a 50M-line Ruby monorepo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aditya Anchuri describes how Stripe keeps CI fast for a ~50-million-line Ruby monorepo containing nearly 100,000 test files and 1.2 million test targets. Running the entire suite sequentially would take roughly four months, while Stripe runs around 50,000 builds per week. Their Selective Test Execution (STE) system solves this by running an average of just ~5% of the test suite per build (with a median under 0.5%), consuming less than 10% of the compute required by a run-everything strategy.&lt;/p&gt;
&lt;p&gt;What makes Stripe&amp;rsquo;s approach clever is that they don&amp;rsquo;t attempt static dependency analysis for Ruby, where metaprogramming, dynamic dispatch, configuration files, and code generation make static analysis either miss dependencies or become overly conservative. Instead, they observe runtime behavior: an internal C++ library injected via &lt;code&gt;LD_PRELOAD&lt;/code&gt; intercepts every file open, associates read files with the currently executing test, and propagates tracking across child processes. The &lt;code&gt;open&lt;/code&gt; path writes only minimal logs, keeping aggregation and indexing off the hot path. Those logs are compiled into a roaring bitmap index mapping changed files to required tests, storing roughly three billion data points while remaining fast to query. File changes are detected using &lt;code&gt;hashdeep&lt;/code&gt; so generated files are covered alongside git-tracked files. STE also relies on reproducible baseline data and practical CI safety nets: always re-running currently failing tests, always running tests that glob the filesystem, handling linters via changed-file lists, and storing metadata in MongoDB with Monotonic Revision IDs to quickly select baselines in commit order.&lt;/p&gt;
&lt;h2 id="being-oncall-taught-me-everything"&gt;&lt;a href="https://yaoyue.org/blog/2026-oncall/" rel="noopener noreferrer"&gt;Being oncall taught me everything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yao Yue looks back on 7.5 years of being on call for Twitter&amp;rsquo;s distributed caching layer—the highest-throughput service and the one involved in the most severe site-wide outages. The post doesn&amp;rsquo;t romanticize on-call life, but argues that living alongside production is what shaped the author&amp;rsquo;s mindset as an infrastructure engineer. On-call teaches you that at scale, predictability matters more than being fast in the average case, tail latency matters more than the median, simple and clear architecture is a lifeline during a crisis, and operational excellence (deep observability, consistent configuration, automation readiness, sensible defaults) comes from up-front design rather than frantic patching two weeks before launch.&lt;/p&gt;
&lt;p&gt;Even more memorable are the human lessons. Periodically restarting Memcached to prevent site-wide cascading failures sometimes triggered incidents of its own, teaching the author to pick low-risk windows, give advance notice, and—most importantly—own mistakes immediately, since that is the fastest way to earn back teammates&amp;rsquo; trust. Many outages were resolved only through doggedly narrowing down possibilities and leaning on colleagues across every layer of the stack: site ops, kernel engineers, upstream service owners, managers, and fellow on-call engineers. The conclusion is blunt: engineers don&amp;rsquo;t truly understand software until they see it run and break in production, and people who write software shouldn&amp;rsquo;t consider themselves above deploying, monitoring, or debugging what they build.&lt;/p&gt;
&lt;h2 id="claude-as-your-performance-analysis-partner"&gt;&lt;a href="https://developers.redhat.com/articles/2026/05/29/claude-your-performance-analysis-partner" rel="noopener noreferrer"&gt;Claude as your performance analysis partner&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Archana Ravindar experiments with using Claude as a partner for Go performance analysis across CPU profiles and execution traces, focusing on the Green Tea garbage collector on POWER10 using the &lt;code&gt;sweet&lt;/code&gt; benchmark suite. Claude&amp;rsquo;s value doesn&amp;rsquo;t lie in immediately generating a working optimization patch, but in rapidly digesting massive, dense artifacts like &lt;code&gt;pprof&lt;/code&gt; outputs, assembly dumps, and trace timelines. For example, Claude pinpointed a hot path in &lt;code&gt;runtime.tryDeferToSpanScan&lt;/code&gt;, spotted an atomic &lt;code&gt;Load8&lt;/code&gt; followed by &lt;code&gt;Or8&lt;/code&gt; pattern, and suggested fusing them into a single &lt;code&gt;Or32&lt;/code&gt; instruction. That experiment actually ran slower, and Claude then helped explain why: false sharing and contention across GC workers—a clear illustration that fewer atomic instructions doesn&amp;rsquo;t automatically mean faster code.&lt;/p&gt;
&lt;p&gt;Claude also proved useful for low-level analysis: cross-referencing assembly to see that the compiler wasn&amp;rsquo;t caching &lt;code&gt;q.class.sizeclass&lt;/code&gt;, ranking GC TODO comments by profile heat, and suggesting patterns to look for in traces such as idle processors during GC, mark assist gaps, overly frequent GC cycles, or prolonged &lt;code&gt;gcMarkDone&lt;/code&gt; phases. The author draws a clear distinction: profiles tell you where cost lives, while traces explain why the system is stalling, especially around GC and scheduling. Still, every hypothesis must be benchmarked, because optimizations tied to hardware architecture, cache lines, instruction sets, or register pressure are easy to get wrong without full context; the best use of AI here is narrowing the search space and building an investigation checklist, not replacing benchmarks.&lt;/p&gt;
&lt;h2 id="things-you-didn"&gt;&lt;a href="https://jon.chrt.dev/2026/04/15/things-you-didnt-know-about-indexes.html" rel="noopener noreferrer"&gt;Things you didn&amp;rsquo;t know about indexes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jon Charter explains Postgres indexes with an approachable analogy: an index is like the index at the back of a book, letting the database locate rows through a sorted structure instead of scanning the entire table. That speed comes with a fundamental trade-off: faster reads mean slower writes. Data modifications (&lt;code&gt;INSERT&lt;/code&gt;, &lt;code&gt;UPDATE&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;) usually have to update indexes as well and incur cleanup overhead; indexes also consume disk space, compete for cache memory, and give the query planner more paths to evaluate. Consequently, &amp;ldquo;index everything&amp;rdquo; is rarely a good strategy.&lt;/p&gt;
&lt;p&gt;The most useful section covers common pitfalls that prevent an index from being used. Composite indexes depend on column order, so the order must match real query patterns: &lt;code&gt;(type_1, type_2)&lt;/code&gt; helps queries filtering on &lt;code&gt;type_1&lt;/code&gt; or both columns, but is generally ineffective when filtering only on &lt;code&gt;type_2&lt;/code&gt; (though PostgreSQL 18&amp;rsquo;s skip scan helps in some cases). Wrapping a column in a function like &lt;code&gt;lower(name)&lt;/code&gt; causes a plain index on &lt;code&gt;name&lt;/code&gt; to be ignored because the database needs a structure sorted by the exact expression &lt;code&gt;lower(name)&lt;/code&gt;; implicit type casts cause the same issue. The right way to verify index usage is running &lt;code&gt;EXPLAIN&lt;/code&gt; or &lt;code&gt;EXPLAIN ANALYZE&lt;/code&gt; to confirm what the planner actually chooses rather than guessing. Finally, the post introduces functional indexes, partial indexes for small slices of data like soft-deleted rows or &lt;code&gt;is_legendary = true&lt;/code&gt;, and covering indexes with &lt;code&gt;INCLUDE&lt;/code&gt; to enable &lt;code&gt;Index Only Scan&lt;/code&gt;.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #112</title><link>https://miti99.com/en/post/2026/06/23/</link><pubDate>Tue, 23 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #112.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-few-interesting-modern-pixel-fonts"&gt;&lt;a href="https://unsung.aresluna.org/a-few-interesting-modern-pixel-fonts/" rel="noopener noreferrer"&gt;A few interesting modern pixel fonts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marcin Wichary surveys a few modern pixel fonts built around interesting ideas. Andrew Gleeson&amp;rsquo;s Analog Mono &amp;ldquo;atones for the sins&amp;rdquo; of VCR OSD Mono, the classic pixel font seen across 1990s VCRs, TVs, and camcorders whose baseline sat so low that every character with a descender was pulled upward. Kumiko Yoshida&amp;rsquo;s Coral Pixels is a color font that deliberately preserves the characteristic color fringing of 1990s–2000s subpixel rendering: what used to be a technical artifact is now nostalgic material and an intentional visual element. Joseph Fatula&amp;rsquo;s Two Slice pushes minimalism to the extreme at just 2 pixels tall while remaining &amp;ldquo;barely readable.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The author notes that all of these are vector fonts masquerading as pixels so they can be installed on modern operating systems, which leads to Vercel&amp;rsquo;s Geist Pixel. Although its marketing pitch is slightly grandiose, it hits on an important problem: pixel fonts often break when put into real products because they don&amp;rsquo;t scale well across screen sizes, their metrics clash with existing typography systems, or they are purely decorative. According to the author, the Achilles&amp;rsquo; heel of many fonts lies not in the letterforms themselves, but in the &amp;ldquo;invisible&amp;rdquo; work around them such as kerning, metadata, extended character sets, and vertical metrics. The lesson for UI designers is that nostalgia can be a starting point, but integration stability is what determines whether a font is actually usable in a product.&lt;/p&gt;
&lt;h2 id="the-best-engineers-write-less-code"&gt;&lt;a href="https://shvetsm.github.io/posts/the-best-engineers-write-less-code/" rel="noopener noreferrer"&gt;The Best Engineers Write Less Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the idea that we no longer need to write good software because LLMs can generate code. Bad software is still bad software, whether written by Claude Code or an inexperienced developer: latency, complexity, and maintenance costs remain real, and there will be plenty of work cleaning up the low-quality code currently being pushed to production. Businesses measure everything in time, because time is money; that is also why they are excited about AI—it is faster and cheaper.&lt;/p&gt;
&lt;p&gt;According to the author, the best thing an engineer can do for stakeholders is avoid building unnecessary things, since every feature carries long-term costs in maintenance, debugging, infrastructure, support, migrations, and cognitive load. On the path to becoming a senior engineer, you shift from &amp;ldquo;I can build that, it&amp;rsquo;ll take a few days&amp;rdquo; to &amp;ldquo;Why are we building this?&amp;rdquo;, and the second question is critical: code is a liability unless it solves the right problem. The worst outcome is building the wrong thing. The way to reduce risk is genuine Agile in spirit rather than ceremony: align on why the work is needed, adjust requirements to deliver value faster, and work in short intervals to show progress and gather feedback. Great engineers are measured not by the volume of code they produce, but by the value they deliver relative to the complexity they leave behind—and the best use of spare time is deleting code.&lt;/p&gt;
&lt;h2 id="fast-is-better-than-slow"&gt;&lt;a href="https://dubroy.com/blog/fast-is-better-than-slow/" rel="noopener noreferrer"&gt;Fast is better than slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Patrick Dubroy noticed that the best programmers he has ever worked with all share one trait: they are fast, often turning up with a patch or prototype an hour or two after discussing a problem. He argues that they aren&amp;rsquo;t fast because they&amp;rsquo;re good, they&amp;rsquo;re good because they&amp;rsquo;re fast: moving quickly gets you data sooner, leads to better decisions, compounds learning over time, and lets you try multiple approaches before picking the best one. This does not mean hustle culture or working overtime; there are many ways to speed up without putting in extra hours.&lt;/p&gt;
&lt;p&gt;His advice has more to do with day-to-day software engineering habits than raw coding skill. Don&amp;rsquo;t procrastinate just because you aren&amp;rsquo;t sure where to start, as waiting rarely makes the task easier. Make use of small pockets of time instead of waiting for long uninterrupted blocks, since fragmentation can eat up 25–35% of your day. Don&amp;rsquo;t be afraid to look silly: share work early using the &amp;ldquo;70% rule,&amp;rdquo; open a PR right away and welcome feedback instead of polishing endlessly, and proactively ask coworkers for help because software development is a team sport. Pick your battles: in code review, most disagreements are small enough that making the requested change is faster than arguing, and Dubroy himself often approves with &amp;ldquo;LGTM with comments.&amp;rdquo; Finally, build only what was asked for—trying to &amp;ldquo;overdeliver&amp;rdquo; usually means guessing at future requirements, and the less experience you have, the more likely you are to guess wrong.&lt;/p&gt;
&lt;h2 id="java-cheat-sheet"&gt;&lt;a href="https://tms-outsource.com/cs/java-cheat-sheet/" rel="noopener noreferrer"&gt;Java Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a quick Java reference by Bogdan Sandu focused on syntax, common patterns, and immediately applicable idioms. The material is organized into sections: data types and casting, operators, control flow, arrays, strings and &lt;code&gt;StringBuilder&lt;/code&gt;, classes and objects, OOP concepts, access modifiers, the Collections Framework, exception handling, streams and lambdas, concurrency, I/O, and modern Java features. Helpfully, it doesn&amp;rsquo;t just list syntax—it also calls out classic beginner pitfalls like comparing &lt;code&gt;String&lt;/code&gt; instances with &lt;code&gt;==&lt;/code&gt;, confusing array &lt;code&gt;.length&lt;/code&gt; with string &lt;code&gt;.length()&lt;/code&gt;, handling &lt;code&gt;null&lt;/code&gt;, going out of array bounds, or concatenating strings in a loop instead of using &lt;code&gt;StringBuilder&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For junior developers, a cheat sheet like this is well suited for a quick refresher when switching to Java from another language, or when recalling a standard API without wading through long documentation. Even so, it should be treated as an initial lookup map: it does not replace official docs, a deep understanding of the JVM, OOP, collections, and concurrency, or hands-on experience writing production code.&lt;/p&gt;
&lt;h2 id="swapping-go-for-rust-10x-cheaper-k8s-ingress"&gt;&lt;a href="https://dev.to/syedahmershah/swapping-go-for-rust-10x-cheaper-k8s-ingress-2b4p" rel="noopener noreferrer"&gt;Swapping Go for Rust: 10x Cheaper K8s Ingress&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Syed Ahmer Shah recounts cutting the AWS bill for a Kubernetes ingress layer from roughly $4,200 to about $390 per month. The original setup ran Traefik across 3 pods, averaging around 380MB RSS per pod (roughly 180MB idle, over 400MB under load), requiring &lt;code&gt;t3.large&lt;/code&gt; nodes for headroom. The author attributes this to Go&amp;rsquo;s garbage collector, which optimizes for latency rather than memory footprint: in a proxy, every request allocates headers, buffers, and connection state, so under sustained load the GC rarely gets a &amp;ldquo;good moment&amp;rdquo; to clean up, whereas Rust frees memory deterministically as soon as values go out of scope. It is worth noting that this changed both the architecture and infrastructure (Envoy, smaller nodes), so it cannot be treated as an isolated benchmark of swapping languages alone.&lt;/p&gt;
&lt;p&gt;Rather than rewriting Traefik, the team moved core proxying to Envoy (C++) alongside a small Rust service that took over custom routing logic previously living in middleware. The first week hit three incidents—not because of Rust, but because Envoy&amp;rsquo;s explicit configuration model differed sharply from Traefik&amp;rsquo;s annotation &amp;ldquo;magic.&amp;rdquo; After about three weeks, the ingress layer dropped from 3 Traefik pods at ~380MB RSS each to 2 Envoy pods plus the Rust layer at ~40MB per pod; node costs fell from roughly $340 to $30 per month. The takeaway isn&amp;rsquo;t &amp;ldquo;replace Go with Rust&amp;rdquo;: Go remains a great fit for APIs, CLIs, and standard microservices, while Rust is worth considering for high-performance data planes. The migration took two engineers about three weeks, so if Traefik is working fine and the bill isn&amp;rsquo;t hurting, leave it alone.&lt;/p&gt;
&lt;h2 id="persistent-multiplayer-state-without-chaos"&gt;&lt;a href="https://packagemain.tech/p/persistent-multiplayer-state-without" rel="noopener noreferrer"&gt;Persistent multiplayer state without chaos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julien Singler shares an architecture for maintaining consistent state in a live multiplayer game, where PostgreSQL holds the canonical data and Redis handles speed-critical operations. In a single-player game, state is relatively straightforward; but when multiple players can act on the same target simultaneously, scheduled jobs must finish on time regardless of who is online, and players returning days later expect their progress intact, state becomes the hardest problem. Keeping critical data only in memory or flushing to disk only on logout easily leads to lost progress or economy bugs.&lt;/p&gt;
&lt;p&gt;The Go backend is structured into handler, service, and repository layers. Every critical state change goes through a PostgreSQL transaction as the single source of truth. Read-heavy data is fetched from Redis first, falling back to PostgreSQL on a cache miss, and the cache is invalidated on writes before returning success so players never see stale state. Redis holds only rebuildable state such as caches, online presence, and short-lived locks: distributed locks via &lt;code&gt;SetNX&lt;/code&gt; ensure periodic jobs run only once across multiple backend instances (though bare &lt;code&gt;SetNX&lt;/code&gt; alone does not guarantee exactly-once processing if a crash or lock expiration occurs). Scheduled jobs rely on an indexed &lt;code&gt;finishes_at&lt;/code&gt; column rather than scanning every player every minute, and per-player mutations use &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; inside transactions instead of a custom lock manager.&lt;/p&gt;
&lt;h2 id="we"&gt;&lt;a href="https://plc.vc/cdx" rel="noopener noreferrer"&gt;We&amp;rsquo;re in the Over-engineering Game Now&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Clark writes that he spent his entire career priding himself on scoping projects to minimize engineering effort while maximizing flexibility, since engineering time is a software company&amp;rsquo;s scarcest resource. Yet he also loves product design and polished details, leaving him constantly torn between wanting to craft things more carefully and worrying about wasting resources. Now, using Claude and Codex on personal projects, he happily &amp;ldquo;over-engineers&amp;rdquo;: his blog has a dynamic changelog, a &amp;ldquo;vibe meter,&amp;rdquo; an MCP that generates weekly roundups, and hundreds of other ideas he tried and threw away.&lt;/p&gt;
&lt;p&gt;His central thesis is that AI coding blurs the line between over-engineering and simply finishing a product well. His iOS app no longer starts as a bare-bones MVP, but launches feature-complete with built-in feedback loops that trigger agentic workflows. Improvements that used to languish forever in the backlog because they were never high enough priority—or too small to even file a ticket for—can now be iterated on and polished continuously. He argues this shift will raise user expectations: when building good software becomes nearly free, clunky products will be much harder to excuse. Rather than merely an era of vibe coding or apps for an audience of one, he believes we are entering a phase where product vision is no longer bottlenecked by engineering resources, leaving only one question: what do you actually want to build?&lt;/p&gt;
&lt;h2 id="package-managers-that-package-package-managers"&gt;&lt;a href="https://nesbitt.io/2026/05/28/package-managers-that-package-package-managers.html" rel="noopener noreferrer"&gt;Package managers that package package managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Nesbitt built a matrix mapping which package managers can install which other package managers. The idea started from a strange loop: PyPI has a package containing the Node binary, and npm has a package containing a portable CPython build, meaning &lt;code&gt;pip install&lt;/code&gt; and &lt;code&gt;npm install&lt;/code&gt; can hand control back and forth indefinitely. Covering 42 clients using data from ecosyste.ms for language registries and Repology for Linux distributions, the densest rows belong to system package managers like AUR (40/42), nixpkgs, Homebrew, DNF, and Debian, since packaging arbitrary binaries is their job; as columns, however, they are nearly empty because nobody needs to redistribute &lt;code&gt;apt&lt;/code&gt; or DNF when they ship with the OS. Conda sits between the two worlds, while PyPI is the most prolific language registry because cross-language tools like Conan and Meson are written in Python.&lt;/p&gt;
&lt;p&gt;The post also highlights notable software supply chain implications. Twenty-five of the 42 tools publish themselves through their own registry. A CVE in pip might be tracked under &lt;code&gt;pkg:pypi/pip&lt;/code&gt; or &lt;code&gt;pkg:deb/python3-pip&lt;/code&gt;, but copies of pip inside Homebrew, conda-forge, nixpkgs, or Spack carry the same vulnerability and each ecosystem must map advisories on its own, making upstream vulnerability tracing much harder. Searching by package name is also unreliable because short names on flat-namespace registries are often squatted by unrelated projects, whereas reverse-linking to the source repository yields cleaner matches. Finally, the author constructs a 14-step installation chain stretching from an Arch Linux machine to the Elm compiler.&lt;/p&gt;
&lt;h2 id="beyond-the-prompt-claude-code"&gt;&lt;a href="https://arps18.github.io/posts/claude-code-mastery/" rel="noopener noreferrer"&gt;Beyond the Prompt: Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpan Patel writes an extensive guide to using Claude Code as a workflow-driven agent rather than a prompt-in, code-out chatbot. The core focus is building feedback loops so Claude can verify its own work: reading code, planning, editing, running tests, reviewing, and updating its rules whenever it makes a mistake. The author recommends exploring before coding, using plan mode for multi-file changes, pointing directly to files or logs instead of giving vague descriptions, and delegating tasks the way you would to an engineer rather than micromanaging every small step.&lt;/p&gt;
&lt;p&gt;A standout section covers organizing the &lt;code&gt;.claude&lt;/code&gt; directory: &lt;code&gt;CLAUDE.md&lt;/code&gt; for shared project rules, &lt;code&gt;CLAUDE.local.md&lt;/code&gt; for personal notes, alongside settings, MCP servers, skills, commands, rules, and subagents. &lt;code&gt;CLAUDE.md&lt;/code&gt; should stay concise like a guardrail—containing only rules that genuinely prevent mistakes rather than documenting the entire codebase—while recurring workflows should be turned into reusable skills, commands, or subagents in the repo. For larger teams, plugins, MCPs, and subagents help isolate context, run independent reviews, and execute parallel streams of work, delivering the most value when baked into shared onboarding rather than kept as personal tweaks.&lt;/p&gt;
&lt;h2 id="how"&gt;&lt;a href="https://performance.dev/how-is-linear-so-fast-a-technical-breakdown" rel="noopener noreferrer"&gt;How&amp;rsquo;s Linear so fast? A technical breakdown&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky breaks down why Linear feels instantaneous despite being a client-side web application. The core idea is that Linear removes network latency from the primary interaction path. The data the UI reads is already in the browser, primarily via IndexedDB and an in-memory object pool; mutations are applied optimistically locally first, written to a persistent transaction queue, and then synced to the server. The server acts as an arbiter that acknowledges changes and broadcasts deltas back, rather than something the UI waits on before responding to the user. At runtime, MobX enables fine-grained updates so each delta re-renders only the specific fields and components affected rather than an entire list.&lt;/p&gt;
&lt;p&gt;The post also dives into initial load performance, where speed comes from compounding small details: trimming JavaScript and CSS payloads, targeting only modern browsers, aggressive code splitting, preloading modules to avoid waterfall requests, service worker caching, preloading fonts with the proper &lt;code&gt;crossorigin&lt;/code&gt; attribute, embedding an app shell, and rendering local data before background authentication finishes. Beyond engineering, speed comes from product design: every action has a keyboard shortcut, the command palette is always one keystroke away and runs against local data, and animations are brief and stick to cheap properties like &lt;code&gt;transform&lt;/code&gt; and &lt;code&gt;opacity&lt;/code&gt;. Performance is thus as much about user perception as it is about raw engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>