<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Algorithms on miti99</title><link>https://miti99.com/en/tags/algorithms/</link><description>Recent content in Algorithms 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/tags/algorithms/index.xml" rel="self" type="application/rss+xml"/><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 #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 #103</title><link>https://miti99.com/en/post/2026/05/23/</link><pubDate>Sat, 23 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #103.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="drunk-post-things-i"&gt;&lt;a href="https://luminousmen.substack.com/p/drunk-post-things-ive-learned-as" rel="noopener noreferrer"&gt;Drunk Post: Things I&amp;rsquo;ve Learned as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post preserves a famous r/ExperiencedDevs thread where a data engineer with 10 years of experience got &amp;ldquo;a little tipsy&amp;rdquo; and wrote down every career lesson he had learned. The original account has since been deleted, but its rare candor keeps the post widely shared. On career growth, the author argues that switching companies is the most effective way to get promoted, job titles matter less than what you actually accomplish, and the closer you are to the product and revenue, the more valued you are — regardless of how technically complex your work is.&lt;/p&gt;
&lt;p&gt;On the technical side, every domain has only about 10–20 core principles, and the fundamentals change very slowly even as tools churn constantly. Good code is code a junior engineer can read and understand, and the best code is code you never had to write at all. Writing documentation is the most underrated skill, right alongside writing proposals for change. For newcomers, SQL is the highest-ROI language; testing is essential, but TDD is overly worshiped. Good engineers know best practices, while senior engineers know when to break them. What the author is proudest of is not any grand system he built, but helping others do better work. The archivist agrees with nearly all of it, except for the author&amp;rsquo;s preference for dynamic languages.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-to-code"&gt;&lt;a href="https://www.chrismdp.com/coding-with-ai-april-2026/" rel="noopener noreferrer"&gt;How I Use AI to Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Parsons argues that if you are still tethered to an IDE like Cursor or Copilot, you are a year behind: the best tools have left the editor for the command line, and he recommends Claude Code or Codex CLI. Programming is AI&amp;rsquo;s &amp;ldquo;home turf&amp;rdquo; because code can be executed and verified immediately. He distinguishes &amp;ldquo;vibe coding&amp;rdquo; (never checking the output) from &amp;ldquo;agentic engineering&amp;rdquo; (deliberately deciding which changes require human inspection and which can be entrusted to tests and automated checks). His core message: senior engineers should train AI to write better code rather than manually reviewing every single diff, because the harness surrounding the model matters more than the prompt.&lt;/p&gt;
&lt;p&gt;A good harness consists of persistent instructions in CLAUDE.md or AGENTS.md, skill files that both enforce rules and load extra context on demand, a verification loop so the agent can check its own work, and a feedback loop that feeds lessons back into those three components — with all knowledge stored in a dedicated markdown repository. The author also walks back his earlier advice to specify the entire solution up front, calling that waterfall in disguise: specify the problem, not the solution. Output quality hinges on context volume — too little yields generic results, while too much drowns the model in noise. Once code generation is no longer the bottleneck, verification becomes the new bottleneck, giving teams with strong automated testing and CI/CD foundations a massive advantage.&lt;/p&gt;
&lt;h2 id="email-is-crazy"&gt;&lt;a href="https://samkhawase.com/blog/email-is-crazy/" rel="noopener noreferrer"&gt;Email is crazy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Email is one of the most successful communication technologies in history, yet underneath it lies a patchwork system governed by more than 100 RFCs. Sam Khawase traces the journey of a single message from Alice to Bob: the mail client merely &amp;ldquo;submits&amp;rdquo; the message to a server, the relay server looks up DNS MX records to find the recipient&amp;rsquo;s mail server, and email is fundamentally a store-and-forward queueing system that retries for days rather than a real-time channel. SMTP was born in an era of trust-based academic networks, so the envelope address (&lt;code&gt;MAIL FROM&lt;/code&gt;) and the user-visible &lt;code&gt;From&lt;/code&gt; header are allowed to differ — the root vulnerability that makes phishing and spam possible.&lt;/p&gt;
&lt;p&gt;Instead of replacing SMTP, the industry bolted on three authentication layers: SPF (a list of authorized sending IPs, which breaks when mail is forwarded), DKIM (a cryptographic signature whose public key lives in DNS), and DMARC (requiring the domain in the &lt;code&gt;From&lt;/code&gt; header to align with the domain validated by SPF or DKIM, paired with a policy of none, quarantine, or reject). Messages then pass through each provider&amp;rsquo;s proprietary filtering stack: IP reputation, domain reputation, content analysis, virus scanning, and link checking. Encryption is usually just &amp;ldquo;Opportunistic TLS&amp;rdquo;: if the receiving server doesn&amp;rsquo;t support &lt;code&gt;STARTTLS&lt;/code&gt;, the connection falls back to plaintext (though policies like MTA-STS can enforce TLS), and TLS only encrypts the transport hop rather than end-to-end. Worst of all, an email can be silently dropped into a spam folder without notifying anyone — completely legal under RFC 5321. Even so, email reliably delivers billions of messages every single day.&lt;/p&gt;
&lt;h2 id="high-performance-git"&gt;&lt;a href="https://gitperf.com/" rel="noopener noreferrer"&gt;High Performance Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;High Performance Git&lt;/em&gt; is a book by Ted Nyman about Git&amp;rsquo;s internal architecture and how to operate massive repositories. Rather than teaching a handful of everyday commands, the book views Git as a stack of layers — a content-addressable database, a filesystem cache, a graph walker, and a wire transfer protocol — and analyzes the performance cost of each layer.&lt;/p&gt;
&lt;p&gt;The chapters progress from objects, refs, the index, and history traversal to packfiles, repository maintenance, sparse checkout, partial clone, transfer protocols, operating at scale, troubleshooting, configuration, and data recovery. The book is aimed at anyone who needs Git to stay fast as codebases, histories, and teams grow: build and CI engineers, monorepo maintainers, and developer productivity teams. The entire book is released for free as a PDF under a Creative Commons Attribution-ShareAlike 4.0 license.&lt;/p&gt;
&lt;h2 id="you-can-beat-the-binary-search"&gt;&lt;a href="https://lemire.me/blog/2026/04/27/you-can-beat-the-binary-search/" rel="noopener noreferrer"&gt;You can beat the binary search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire looks for ways to speed up checking whether a value exists in a sorted array of 16-bit integers — a common operation in Roaring Bitmaps, which currently use binary search. He builds on two observations: modern CPUs (both 64-bit ARM and x64) have SIMD instructions that compare eight 16-bit integers at once, and they have substantial memory-level parallelism, so splitting the array into four parts instead of two can be more effective. This leads to the SIMD Quad algorithm: divide the array into blocks of 16 elements, use a quaternary search on the last element of each block to narrow down the candidate block, and then use SIMD to check all 16 elements in that block simultaneously.&lt;/p&gt;
&lt;p&gt;Benchmarks on Apple M4 and Intel Emerald Rapids show SIMD Quad beating binary search across the article&amp;rsquo;s tests: on Intel it is more than 2x faster when the cache is &amp;ldquo;hot,&amp;rdquo; while on Apple it is more than 2x faster when the cache is &amp;ldquo;cold.&amp;rdquo; The &amp;ldquo;quad&amp;rdquo; step makes almost no difference on Apple, but helps significantly on Intel with large arrays and cold caches. The takeaway: classic algorithms weren&amp;rsquo;t designed for hardware with as much parallelism as today&amp;rsquo;s CPUs, leaving plenty of room for performance gains.&lt;/p&gt;
&lt;h2 id="how-might-a-browser-be-developed"&gt;&lt;a href="https://aifoc.us/how-might-a-browser-be-developed/" rel="noopener noreferrer"&gt;How might a browser be developed?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Kinlan asks: how will browsers be developed in the age of AI? Drawing from experiments building browsers with AI and ultra-fast inference chips, he observes that a comprehensive specification paired with an extensive unit test suite acts as an effective guardrail to keep models on track. In the near term, standards bodies could build a &amp;ldquo;reference browser&amp;rdquo; to uncover gaps in specifications and test suites, while browser vendors use AI to implement features from those battle-tested specs. The focus would then shift to writing great specifications, and browsers would differentiate themselves by their vision for the web rather than raw engineering headcount or budget.&lt;/p&gt;
&lt;p&gt;His longer-term vision ventures into sci-fi territory: a browser that synthesizes feature implementations on the fly at runtime from markup, or even purely from expressed intent. For instance, instead of waiting on WebBluetooth support, the browser could generate the code to talk to a heart-rate monitor directly from available hardware documentation. That could eliminate polyfills and make accessibility and localization happen by default, but it also threatens the web&amp;rsquo;s core promise: that the same URL delivers roughly the same experience to everyone, since the experience would now depend on each user&amp;rsquo;s device and local model. Kinlan urges the industry to start thinking seriously about this trajectory now.&lt;/p&gt;
&lt;h2 id="agentic-coding-is-a-trap"&gt;&lt;a href="https://larsfaye.com/articles/agentic-coding-is-a-trap" rel="noopener noreferrer"&gt;Agentic Coding is a Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lars Faye warns against the trend of &amp;ldquo;agentic coding,&amp;rdquo; where AI writes all the code while humans merely plan and orchestrate. The core issue is the &amp;ldquo;supervision paradox,&amp;rdquo; which Anthropic itself has acknowledged: using AI effectively requires supervising it, yet supervision demands the exact programming skills that atrophy when you overuse AI. Another Anthropic study recorded a 47% drop in debugging proficiency. Unlike past transitions such as moving from assembly to FORTRAN, the skill erosion this time is already visible even among veteran engineers, while junior engineers lose the struggle with code that serves as their most important learning mechanism.&lt;/p&gt;
&lt;p&gt;The author argues that AI is accelerating the wrong part of the job: we don&amp;rsquo;t actually need to write code faster, especially code we don&amp;rsquo;t understand, and for many developers, writing code &lt;em&gt;is&lt;/em&gt; how they think and plan. There is also vendor lock-in risk — when Claude goes down, many teams grind to a halt — and unpredictable token costs, whereas human salaries are fixed. His prescription is to demote AI back to an assistant role: use AI for specs and planning, but write 20% to 100% of the code yourself depending on the task, never generate more code than you can review in a single sitting, and never ask AI to do something you haven&amp;rsquo;t done or couldn&amp;rsquo;t do yourself.&lt;/p&gt;
&lt;h2 id="be-the-idiot"&gt;&lt;a href="https://luminousmen.substack.com/p/be-the-idiot" rel="noopener noreferrer"&gt;Be the Idiot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;luminousmen argues that most engineering failures happen because someone was afraid of looking stupid, making clarifying questions not a weakness but a core professional skill. Drawing inspiration from military radio protocols — where the receiver always reads back an order to confirm, not out of incompetence, but because being understood matters more than sounding smart — the author applies two principles to software engineering: repeat critical information across multiple channels such as types, docstrings, and explicit parameter names; and choose unambiguous wording, like &lt;code&gt;timeout_seconds: 30&lt;/code&gt; instead of &lt;code&gt;timeout: short&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author shares four &amp;ldquo;dumb&amp;rdquo; questions that have saved him time and again: what happens when this fails, how do we know it&amp;rsquo;s working properly, what does &amp;ldquo;done&amp;rdquo; look like, and can you show me an example? Phrasing matters too: instead of asking &amp;ldquo;Why are we doing this stupid thing?&amp;rdquo;, ask &amp;ldquo;Is there a specific reason we&amp;rsquo;re using X here?&amp;rdquo; — assuming you&amp;rsquo;re missing context rather than assuming the other person is wrong. About 80% of the time he really was missing context, and the other 20% of the time the question sparked a valuable discussion. After all, the only thing more expensive than looking dumb in a meeting is building the wrong thing because nobody dared to ask.&lt;/p&gt;
&lt;h2 id="3-constraints-before-i-build-anything"&gt;&lt;a href="https://jordanlord.co.uk/blog/3-constraints/" rel="noopener noreferrer"&gt;3 constraints before I build anything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jordan Lord shares three constraints he applies before building any product, distilled from 10 years of product work and multiple failures caused by overcomplication or lack of identity. To him, constraints are a catalyst for creativity because they narrow the option space. The first constraint is &amp;ldquo;one page or nothing&amp;rdquo;: every idea must fit onto a single-page brief that serves as a north star when talking to investors, teammates, or family. If you can&amp;rsquo;t fill one page, the idea isn&amp;rsquo;t ready; if you need more than one page, it&amp;rsquo;s too complicated.&lt;/p&gt;
&lt;p&gt;The second constraint: the core technology must be separable from the product. That could be a method, tool, or library that powers the current product but survives if the product pivots — much like Git was created to support Linux kernel development, or Kubernetes at Google. Products pivot, while core technology compounds in value over time. The third constraint: a defining constraint must shape the product and remain immediately visible to the user, like Minecraft being built entirely out of blocks or IKEA&amp;rsquo;s flat-pack self-assembly furniture. It wards off feature creep and creates unmistakable identity. Any idea that fails to pass all three constraints doesn&amp;rsquo;t get built.&lt;/p&gt;
&lt;h2 id="swissing-a-table"&gt;&lt;a href="https://philpearl.github.io/post/swissing_a_table/" rel="noopener noreferrer"&gt;Swissing a Table&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Pearl explores the Swiss table — the hash table design behind Go&amp;rsquo;s new map implementation — by evolving a simple open-addressed hash table step by step. First, he replaces linear probing with a quadratic-style probing sequence like Go&amp;rsquo;s; next, he groups 8 key–value pairs into a bucket; then he adds 8 control bytes per group (the highest bit marks an empty slot, while the lower 7 bits store a hash fragment); and finally he uses bitwise SWAR tricks on a 64-bit integer to match all 8 control bytes simultaneously instead of checking slots one by one.&lt;/p&gt;
&lt;p&gt;Insertion benchmarks show that a Swiss table doesn&amp;rsquo;t always win: when the table is sparse (around 10–4,000 elements), it is 19–36% slower than the simple table, only pulling ahead as the table fills up and cutting insertion time by up to 71.65% when completely full (32,768 elements). According to the author, the biggest win is that the table can run at high load factors with very little performance degradation — making it primarily a memory-saving optimization rather than a raw speed boost. Go&amp;rsquo;s map currently uses SIMD on amd64 (Intel) but not yet on ARM, so the author saves the SIMD exploration for a follow-up post.&lt;/p&gt;
&lt;h2 id="the-ai-engineering-stack-we-built-internally--on-the-platform-we-ship"&gt;&lt;a href="https://blog.cloudflare.com/internal-ai-engineering-stack/" rel="noopener noreferrer"&gt;The AI engineering stack we built internally — on the platform we ship&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares the internal AI infrastructure they built over 11 months, running entirely on the same products they sell to customers. Over a 30-day window, 3,683 internal users (93% of R&amp;amp;D) used AI coding tools, driving over 20 million requests through AI Gateway and 241 billion tokens; in some weeks, merge request volume nearly doubled the previous quarter&amp;rsquo;s baseline. The architecture spans three layers. The foundation layer uses Cloudflare Access for zero-trust authentication, AI Gateway for routing, cost tracking, and data retention controls, and Workers AI to serve open-weight models at a fraction of proprietary model costs. A single login command configures everything, and routing traffic through an intermediate Worker from day one let them roll out new features later without touching user-side configs.&lt;/p&gt;
&lt;p&gt;The knowledge layer uses Backstage as a service catalog and automatically generates &lt;code&gt;AGENTS.md&lt;/code&gt; files across roughly 3,900 repositories, describing structure, conventions, and boundaries so agents don&amp;rsquo;t have to guess. The execution layer runs an AI Code Reviewer on every merge request: it classifies risk level, dispatches specialized agents, organizes findings by category and severity, and cites specific rules from the Engineering Codex — Cloudflare&amp;rsquo;s internal engineering standards packaged as agent skills. According to Cloudflare, none of the individual pieces are novel; the differentiator is how they are wired together.&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_!7jIm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5632abfa-88b9-4f40-8feb-13b4a7c6e1ce_2484x3002.png" alt="MCP vs Skills, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gUOK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F32f62036-5c89-4686-941e-57d84297de42_2484x3002.png" alt="5 Way to Defend Prompt Injection"&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 #101</title><link>https://miti99.com/en/post/2026/05/04/</link><pubDate>Mon, 04 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #101.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ai-assisted-engineering-q1-2026-impact-report"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-assisted-engineering-q1-2026-impact" rel="noopener noreferrer"&gt;AI-Assisted Engineering: Q1 2026 Impact Report&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DX&amp;rsquo;s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI&amp;rsquo;s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping &lt;strong&gt;4x&lt;/strong&gt; as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the &amp;ldquo;player-coach&amp;rdquo; model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save &lt;strong&gt;4.9 hours per week&lt;/strong&gt;, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.&lt;/p&gt;
&lt;p&gt;The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is &amp;ldquo;no longer optional.&amp;rdquo; &amp;ldquo;Shadow AI&amp;rdquo; — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI&amp;rsquo;s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.&lt;/p&gt;
&lt;h2 id="my-ai-workflow-without-losing-my-skills"&gt;&lt;a href="https://marcgg.com/blog/2026/04/15/my-current-ai-workflow/" rel="noopener noreferrer"&gt;My AI Workflow (Without Losing My Skills)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G shares how he leverages AI without losing his programming skills. His concern stems from the &amp;ldquo;automation paradox&amp;rdquo; (he cites an episode of the &lt;em&gt;99% Invisible&lt;/em&gt; podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he &amp;ldquo;vibe codes&amp;rdquo; freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an &amp;ldquo;Omega Mess,&amp;rdquo; in Sandi Metz&amp;rsquo;s terminology).&lt;/p&gt;
&lt;p&gt;A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.&lt;/p&gt;
&lt;h2 id="managing-context-in-long-run-agentic-applications"&gt;&lt;a href="https://slack.engineering/managing-context-in-long-run-agentic-applications/" rel="noopener noreferrer"&gt;Managing Context in Long-Run Agentic Applications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is &lt;strong&gt;never carrying raw conversation history into subsequent agent calls&lt;/strong&gt;; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren&amp;rsquo;t weighed down by accumulated stale context.&lt;/p&gt;
&lt;p&gt;The first channel is the &lt;strong&gt;Director&amp;rsquo;s Journal&lt;/strong&gt;, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the &lt;strong&gt;Critic&amp;rsquo;s Review&lt;/strong&gt;, which scores the confidence of specialist agents&amp;rsquo; findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the &lt;strong&gt;Critic&amp;rsquo;s Timeline&lt;/strong&gt;, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director&amp;rsquo;s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.&lt;/p&gt;
&lt;h2 id="how-the-heck-does-shazam-work"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-shazam-work" rel="noopener noreferrer"&gt;How The Heck Does Shazam Work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: &lt;strong&gt;throw away almost all the data&lt;/strong&gt;, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a &lt;strong&gt;Fast Fourier Transform (FFT)&lt;/strong&gt; to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse &amp;ldquo;constellation map&amp;rdquo;; background noise rarely produces prominent peaks, making this approach highly noise-resistant.&lt;/p&gt;
&lt;p&gt;To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an &lt;strong&gt;inverted index&lt;/strong&gt; — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.&lt;/p&gt;
&lt;h2 id="agents-with-taste"&gt;&lt;a href="https://emilkowal.ski/ui/agents-with-taste" rel="noopener noreferrer"&gt;Agents with Taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain &lt;em&gt;why&lt;/em&gt; a design choice works, then feed them to the agent. His argument is that taste isn&amp;rsquo;t magic — &amp;ldquo;almost every decision about taste has a rational explanation if you look closely enough,&amp;rdquo; and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.&lt;/p&gt;
&lt;p&gt;The examples are concrete: animations should start from &lt;code&gt;scale(0.95)&lt;/code&gt; rather than &lt;code&gt;scale(0)&lt;/code&gt; because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as &lt;code&gt;ease-out&lt;/code&gt; for elements entering the viewport and &lt;code&gt;ease&lt;/code&gt; for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.&lt;/p&gt;
&lt;h2 id="floating-point-from-scratch-hard-mode"&gt;&lt;a href="https://essenceia.github.io/projects/floating_dragon/" rel="noopener noreferrer"&gt;Floating Point from Scratch: Hard Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose &lt;strong&gt;bfloat16&lt;/strong&gt; (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a &lt;strong&gt;dual-path&lt;/strong&gt; architecture: the &amp;ldquo;close path&amp;rdquo; handles subtraction when the exponent difference is less than 2, while the &amp;ldquo;far path&amp;rdquo; handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.&lt;/p&gt;
&lt;p&gt;Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library&amp;rsquo;s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of &lt;strong&gt;454 MHz&lt;/strong&gt; under nominal conditions. One fun lesson: a leading-zero counter written simply with &lt;code&gt;casez&lt;/code&gt; outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.&lt;/p&gt;
&lt;h2 id="the-peril-of-laziness-lost"&gt;&lt;a href="https://bcantrill.dtrace.org/2026/04/12/the-peril-of-laziness-lost/" rel="noopener noreferrer"&gt;The Peril of Laziness Lost&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bryan Cantrill argues that LLMs are eroding one of a great programmer&amp;rsquo;s most important virtues: &lt;strong&gt;laziness&lt;/strong&gt;, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a &lt;em&gt;natural filter&lt;/em&gt; forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.&lt;/p&gt;
&lt;p&gt;A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan&amp;rsquo;s output revealed redundant test suites, a &amp;ldquo;Hello World&amp;rdquo; Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and &amp;ldquo;grind&amp;rdquo; culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.&lt;/p&gt;
&lt;h2 id="cleaning-up-merged-git-branches-a-one-liner-from-the-cia"&gt;&lt;a href="https://spencer.wtf/2026/02/20/cleaning-up-merged-git-branches-a-one-liner-from-the-cias-leaked-dev-docs.html" rel="noopener noreferrer"&gt;Cleaning Up Merged Git Branches: A One-Liner from the CIA&amp;rsquo;s Leaked Dev Docs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against &lt;code&gt;master&lt;/code&gt;; his updated version for modern repositories compares against &lt;code&gt;origin/main&lt;/code&gt; and excludes both &lt;code&gt;main&lt;/code&gt; and &lt;code&gt;develop&lt;/code&gt;:&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;/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;git branch --merged origin/main &lt;span class="p"&gt;|&lt;/span&gt; grep -vE &lt;span class="s2"&gt;&amp;#34;^\s*(\*|main|develop)&amp;#34;&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; xargs -n &lt;span class="m"&gt;1&lt;/span&gt; git branch -d
&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;p&gt;The pipeline chains three steps: &lt;code&gt;git branch --merged origin/main&lt;/code&gt; lists merged branches, &lt;code&gt;grep -vE&lt;/code&gt; strips out the current branch and primary branches to prevent accidental deletion, and &lt;code&gt;xargs&lt;/code&gt; deletes each remaining branch using the lowercase &lt;code&gt;-d&lt;/code&gt; flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his &lt;code&gt;ciaclean&lt;/code&gt;) so you don&amp;rsquo;t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.&lt;/p&gt;
&lt;h2 id="agent-harness-engineering"&gt;&lt;a href="https://addyosmani.com/blog/agent-harness-engineering/" rel="noopener noreferrer"&gt;Agent Harness Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that the quality of a coding agent depends more on its &lt;strong&gt;harness&lt;/strong&gt; — the operational scaffolding around the model — than on the model itself: &amp;ldquo;a mediocre model with a great harness will beat a great model with a bad harness.&amp;rdquo; The gap between what today&amp;rsquo;s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (&lt;code&gt;AGENTS.md&lt;/code&gt;, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.&lt;/p&gt;
&lt;p&gt;Key principles include the &amp;ldquo;skill issue&amp;rdquo; mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The &lt;strong&gt;Ratchet Principle&lt;/strong&gt; treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its &lt;code&gt;AGENTS.md&lt;/code&gt; under 60 lines, like a pilot&amp;rsquo;s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn&amp;rsquo;t disappear — it moves on to tackling harder problems.&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 #96</title><link>https://miti99.com/en/post/2026/04/16/</link><pubDate>Thu, 16 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #96.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="clean-architecture--separation-of-concerns-trong-go"&gt;&lt;a href="https://vjerci.com/writings/clean/separation-of-concerns/" rel="noopener noreferrer"&gt;Clean Architecture → Separation of Concerns trong Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the principle of Separation of Concerns in Go: once a responsibility is handled in one place in the system, other parts shouldn&amp;rsquo;t have to worry about it or duplicate it. The author opens with an anti-pattern where a single handler function parses an HTTP request, validates the payload, and executes SQL queries directly. When everything is tangled together like that, changing any detail requires understanding the whole stack, and the codebase quickly becomes unmaintainable as complexity grows.&lt;/p&gt;
&lt;p&gt;The fix is splitting the service into four layers: HTTP handlers only decode requests and encode responses, Services hold pure business logic decoupled from infrastructure, Repositories handle all database queries, and Models define data structures with zero dependencies on other layers. Go makes this natural through structural typing: a struct satisfies an interface implicitly without &lt;code&gt;implements&lt;/code&gt; declarations. The author recommends giving each package a single, obvious responsibility and wiring components together via constructor dependency injection so the dependency graph is visible right in &lt;code&gt;main&lt;/code&gt;. Helpful Go tips include using your IDE&amp;rsquo;s &amp;ldquo;Find Implementations&amp;rdquo; shortcut and adding a compile-time interface check like &lt;code&gt;var _ MyInterface = (*MyStruct)(nil)&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-garbage-collector"&gt;&lt;a href="https://internals-for-interns.com/posts/go-garbage-collector" rel="noopener noreferrer"&gt;The Garbage Collector&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explores Go 1.26&amp;rsquo;s garbage collector, which introduces the GreenTea GC. Go&amp;rsquo;s collector is a non-moving, concurrent, tri-color mark-and-sweep collector: because objects never move in memory over their lifetime, pointers stay valid and interoperating with &lt;code&gt;unsafe&lt;/code&gt; or C code is much simpler. Each GC cycle runs through four phases: sweep termination, concurrent mark (running alongside application goroutines and capped at roughly 25% of CPU), mark termination, and lazy sweep driven by allocation demand—pausing the program (stop-the-world) only twice for very brief intervals.&lt;/p&gt;
&lt;p&gt;GreenTea&amp;rsquo;s key innovation is queuing entire memory spans (contiguous pages holding same-sized objects) rather than individual object pointers during marking, batching marked objects together before scanning to dramatically improve CPU cache locality. When a span has more than 12.5% of its objects marked, the collector uses AVX-512 SIMD instructions on x86-64 to scan it 4–8x faster. A hybrid Yuasa–Dijkstra write barrier shades both overwritten and newly written pointers during concurrent marking so live objects are never missed. If goroutines allocate faster than background workers can mark, &lt;em&gt;mark assist&lt;/em&gt; forces allocating goroutines to do marking work themselves as backpressure. Finally, the GC Pacer schedules cycles using &lt;code&gt;GOGC&lt;/code&gt; (default 100, triggering when the heap doubles) and &lt;code&gt;GOMEMLIMIT&lt;/code&gt; (a soft memory cap for the Go runtime).&lt;/p&gt;
&lt;h2 id="the-skill-of-using-ai-agents-well"&gt;&lt;a href="https://www.lesswrong.com/posts/9xAwybDhtgzGYPnbs/the-skill-of-using-ai-agents-well" rel="noopener noreferrer"&gt;The Skill of Using AI Agents Well&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical habits for working effectively with AI coding agents, centered on one insight: the real bottleneck is human attention, not AI capability. Accordingly, the author designs his workflow to minimize personal friction: always use the strongest frontier model at its highest reasoning setting, turn on verbose debug logging so the agent can diagnose failures on its own, and give every AI session its own isolated branch via &lt;code&gt;git worktree&lt;/code&gt; so multiple agents can run in parallel without stepping on each other&amp;rsquo;s files. Tasks that parallelize naturally—like testing five hypotheses at once—get fanned out to subagents.&lt;/p&gt;
&lt;p&gt;For permissions, he recommends whitelisting obviously safe commands, using a secondary AI classifier to auto-approve routine permission prompts, and enabling audio notifications when an agent blocks waiting for human input. Spinning up a fresh agent session purely to review a diff regularly catches bugs the authoring session missed, while a central dashboard across all active sessions makes it easy to see which agents need attention. He also delegates setup chores like spinning up test databases or driving browser UI checks entirely to agents, switches providers promptly whenever a model feels degraded, and is experimenting with cross-session memory systems—though he hasn&amp;rsquo;t found a silver bullet there yet.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://newsletter.manager.dev/p/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 piece rounds up seven unwritten laws that software engineers usually learn only after painful production incidents. First, when production breaks right after a deployment, roll back first and investigate second—don&amp;rsquo;t burn hours trying to prove your commit was innocent while users are down. Second, a backup doesn&amp;rsquo;t exist until you have successfully restored from it; you also need to know your recovery point objective, who has permissions to run the restore, and how long a restore actually takes now that the database is ten times larger. Third, logging is an eternal balancing act: either too sparse to diagnose an outage, or a noisy flood missing a shared correlation/request ID across services.&lt;/p&gt;
&lt;p&gt;Fourth, every data migration needs a tested rollback plan, because an untested rollback plan will almost certainly fail when you need it most. Fifth, every external dependency &lt;em&gt;will&lt;/em&gt; eventually fail—know its rate limits, test how your app behaves when it goes down, and prepare caches, queues, or graceful degradation; chaining two independent 99.9% services in series drops combined availability to ~99.8%. Sixth, risky production operations require the &amp;ldquo;four-eyes principle&amp;rdquo;: have a teammate watch, because simply explaining what you are about to do out loud often catches the mistake. Finally, nothing is more permanent than a temporary hack—so build a small, scoped, clean solution rather than a messy kludge.&lt;/p&gt;
&lt;h2 id="big-tech-engineers-need-big-egos"&gt;&lt;a href="https://www.seangoedecke.com/big-tech-needs-big-egos/" rel="noopener noreferrer"&gt;Big tech engineers need big egos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke pushes back against the cliché that there is no room for ego in software engineering, arguing that engineers at big tech companies actually need a healthy dose of ego to succeed. Day to day, senior engineers constantly confront their own mistakes and sprawl across codebases too vast for any one person to hold in their head—requiring stubborn self-belief that they can solve problems that look impossible at first glance. Organizationally, strong self-confidence lets an engineer stake out a clear technical position amid ambiguity, make unpopular calls that affect hundreds of peers, and push back when senior leadership misunderstands a technical constraint.&lt;/p&gt;
&lt;p&gt;The paradox is that effective big-tech engineers must also be able to set their ego aside entirely before the org chart: accepting canceled projects, losing internal political battles, or executing murky top-down priorities without becoming bitter. Goedecke calls this the &amp;ldquo;chameleon&amp;rdquo; posture—assertive with peers, yet adaptable toward hierarchy. Burnout, he argues, rarely comes from working too hard; it comes from unrewarded effort, especially when a technically sound decision gets punished because it clashed with organizational politics. Mastering that delicate balance is a big reason truly effective staff-plus engineers are so rare.&lt;/p&gt;
&lt;h2 id="sorting-algorithms"&gt;&lt;a href="https://simonwillison.net/2026/Mar/11/sorting-algorithms/" rel="noopener noreferrer"&gt;Sorting algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he used Claude Artifacts to build an animated side-by-side visualization of classic sorting algorithms—starting with bubble sort, selection sort, insertion sort, merge sort, quicksort, and heapsort. When asked to add Timsort, Claude autonomously cloned the CPython repository from GitHub and read &lt;code&gt;Objects/listobject.c&lt;/code&gt; and &lt;code&gt;Objects/listsort.txt&lt;/code&gt; to implement it. However, when Willison asked GPT-5.4 Thinking to audit the result, it pointed out that Claude had actually written a simplified adaptive mergesort inspired by Timsort rather than the full algorithm—a great illustration of using one frontier model to cross-check another.&lt;/p&gt;
&lt;p&gt;After a few rounds of UI polish, the artifact gained a &amp;ldquo;Run all&amp;rdquo; button that races all seven algorithms simultaneously in a grid, complete with live comparison and swap counters and color-coded operations: pink for comparisons, orange for swaps, red for pivots, and purple for sorted runs. In the live race, Timsort finishes first, followed closely by quicksort and merge sort, with bubble sort trailing far behind. The post showcases how quickly modern AI tools can turn a conversational prompt into a rich, interactive learning tool.&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/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F438c4c2f-0fa8-4748-9953-b63fd69674f4_2508x3000.png" alt="12 Claude Code Features Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F75e97a13-b186-4f16-ab59-f9a96867f744_1899x1536.jpeg" alt="How does REST API work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0169578f-af50-4b3a-b8ed-542ee7ebf80f_2250x2814.png" alt="7 Key Load Balancer Use Cases"&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 #91</title><link>https://miti99.com/en/post/2026/03/17/</link><pubDate>Tue, 17 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/17/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #91.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages"&gt;&lt;a href="https://dev.to/ganesh-kumar/how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages-42o4" rel="noopener noreferrer"&gt;How Go Slices Work Under the Hood: What Makes Them Stand Out from Other Languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slices are one of the most heavily used data structures in Go. On the surface they look like simple dynamic arrays, but under the hood every slice is just a three-word header: a pointer to an underlying array, a length (&lt;code&gt;len&lt;/code&gt;), and a capacity (&lt;code&gt;cap&lt;/code&gt;). Slicing with &lt;code&gt;[start:end]&lt;/code&gt; doesn&amp;rsquo;t copy the elements—it simply creates a new slice header pointing into the same backing array, which makes slicing very cheap. The author walks through examples printing &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; after each slice operation, and explains why a slice declared with &lt;code&gt;var s []int&lt;/code&gt; starts out as &lt;code&gt;nil&lt;/code&gt; with both &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; equal to 0.&lt;/p&gt;
&lt;p&gt;The highlight of the post is the growth algorithm inside &lt;code&gt;append&lt;/code&gt;, traced directly from the Go runtime source (&lt;code&gt;runtime/slice.go&lt;/code&gt;). When a slice runs out of capacity, Go allocates a larger backing array: if the current capacity is under 256 elements, it doubles; at 256 and above, the growth factor tapers smoothly from 2x down toward ~1.25x (prior to Go 1.18, that threshold was 1,024). When appending a batch of elements that exceeds double the old capacity, Go jumps straight to the required size and rounds up to the allocator&amp;rsquo;s size class. Because reallocation and copying are expensive, the practical takeaway is to preallocate with &lt;code&gt;make([]T, len, cap)&lt;/code&gt; whenever you know the expected size ahead of time.&lt;/p&gt;
&lt;h2 id="why-go-can"&gt;&lt;a href="https://niketpatel.com/essays/why-go-cant-try" rel="noopener noreferrer"&gt;Why Go Can&amp;rsquo;t Try&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay explains why Go has never gained a &lt;code&gt;try&lt;/code&gt; keyword like Zig or Rust, arguing that the real reason isn&amp;rsquo;t simply the Go team&amp;rsquo;s fondness for explicitness. Ironically, Zig is even more explicit than Go: a return type like &lt;code&gt;!Config&lt;/code&gt; advertises that a function can fail, and the compiler tracks every possible error and enforces exhaustive handling. Go, by contrast, lets you write &lt;code&gt;data, _ := os.ReadFile(path)&lt;/code&gt; without a peep from the compiler, so the explicitness of &lt;code&gt;if err != nil&lt;/code&gt; is largely social convention. While the Go team often argues that &lt;code&gt;try&lt;/code&gt; hides control flow across invisible exit points, the author contends that isn&amp;rsquo;t the root of the problem.&lt;/p&gt;
&lt;p&gt;The real blocker is Go&amp;rsquo;s &lt;code&gt;error&lt;/code&gt; type itself: because &lt;code&gt;error&lt;/code&gt; is just an interface with a single &lt;code&gt;Error() string&lt;/code&gt; method, the compiler has no idea which concrete errors a function can return; utilities like &lt;code&gt;errors.Is()&lt;/code&gt;, &lt;code&gt;errors.As()&lt;/code&gt;, and &lt;code&gt;fmt.Errorf(&amp;quot;%w&amp;quot;)&lt;/code&gt; are purely runtime conventions. Zig&amp;rsquo;s error sets are the exact opposite: finite, compiler-tracked, and represented as zero-overhead 16-bit integers—which means they can&amp;rsquo;t carry arbitrary runtime context, a trade-off Zig offsets with compiler-generated error return traces. Adding &lt;code&gt;try&lt;/code&gt; to Go without changing the &lt;code&gt;error&lt;/code&gt; type would be pure syntactic sugar with no exhaustiveness checking, while changing &lt;code&gt;error&lt;/code&gt; would break the entire standard library and every existing Go program. So &lt;code&gt;if err != nil&lt;/code&gt; is here to stay.&lt;/p&gt;
&lt;h2 id="the-scheduler--understanding-the-go-runtime"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-scheduler" rel="noopener noreferrer"&gt;The Scheduler — Understanding the Go Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explains the Go runtime scheduler—the component that answers &amp;ldquo;which goroutine runs next?&amp;rdquo; and multiplexes millions of goroutines onto a handful of OS threads. At its core is the GMP model: G is a goroutine, starting with a tiny 2KB stack (compared to 1–8MB for an OS thread); M is an OS thread that actually executes instructions; and P is a logical processor context holding a local run queue of up to 256 goroutines, with the number of Ps equal to &lt;code&gt;GOMAXPROCS&lt;/code&gt;. Decoupling P from M means that when an OS thread blocks in a syscall, its P can be handed off to another thread so queued goroutines keep running. Notably, there is no dedicated central scheduler thread: goroutines park themselves, enqueue themselves onto channel wait queues, and clean themselves up on exit for reuse.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;findRunnable()&lt;/code&gt; function searches for work in a specific order: garbage-collector work, then once every 61 ticks a check of the global run queue to prevent starvation, followed by the local run queue, the global run queue again, the network poller, and finally work stealing—taking half the goroutines from another P&amp;rsquo;s local queue. Threads that run out of work spin briefly looking for new work before parking, with the number of spinning threads capped. The article also covers preemption—both cooperative via function-prologue stack checks and asynchronous via &lt;code&gt;SIGURG&lt;/code&gt; signals. Because a goroutine&amp;rsquo;s saved state is tiny, switching goroutines takes just 50–100 nanoseconds, 10–40x faster than an OS thread context switch.&lt;/p&gt;
&lt;h2 id="go-string-concatenation-performance-benchmark"&gt;&lt;a href="https://www.winterjung.dev/en/string-concat-performance-benchmark-in-go/" rel="noopener noreferrer"&gt;Go String Concatenation Performance Benchmark&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author benchmarks the speed and memory footprint of Go string concatenation techniques, comparing &lt;code&gt;+&lt;/code&gt;, &lt;code&gt;+=&lt;/code&gt;, &lt;code&gt;fmt.Sprintf()&lt;/code&gt;, &lt;code&gt;fmt.Sprint()&lt;/code&gt;, &lt;code&gt;strings.Join()&lt;/code&gt;, &lt;code&gt;bytes.Buffer&lt;/code&gt;, and &lt;code&gt;strings.Builder&lt;/code&gt; (both with and without preallocating via &lt;code&gt;Grow()&lt;/code&gt;). The benchmarks cover two common scenarios: concatenating a fixed, known number of strings—such as building a cache key from a few fields—and concatenating a variable number of strings in a loop, such as assembling dynamic query conditions. All benchmark code and raw results are published so readers can reproduce them.&lt;/p&gt;
&lt;p&gt;The findings are clear: &lt;code&gt;strings.Builder&lt;/code&gt; with &lt;code&gt;Grow()&lt;/code&gt; and &lt;code&gt;strings.Join()&lt;/code&gt; are the fastest and most memory-efficient options across almost every scenario. When concatenating a small, fixed number of strings, the plain &lt;code&gt;+&lt;/code&gt; operator is completely fine, while &lt;code&gt;fmt.Sprintf()&lt;/code&gt; is significantly slower. In the 256-string loop benchmark, the top two methods take just 2.6–2.8 microseconds with a single allocation, whereas using &lt;code&gt;+=&lt;/code&gt; in a loop takes over 37 microseconds, allocates ~185KB of memory, and performs 255 allocations because every iteration creates a brand-new immutable string. The rule of thumb: for loops, reach for &lt;code&gt;strings.Builder&lt;/code&gt; or &lt;code&gt;strings.Join()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="message-passing-is-shared-mutable-state"&gt;&lt;a href="https://causality.blog/essays/message-passing-is-shared-mutable-state/" rel="noopener noreferrer"&gt;Message Passing Is Shared Mutable State&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay argues that message passing does not eliminate shared mutable state—it merely relocates it. Back in 2006, Edward Lee predicted that &amp;ldquo;shared memory vs. message passing&amp;rdquo; was a false dichotomy, because swapping locks for messages only changes the shape of concurrency bugs. Go, with its motto &amp;ldquo;share memory by communicating,&amp;rdquo; became the largest real-world test of that thesis: a 2019 study of 171 concurrency bugs across Docker, Kubernetes, etcd, gRPC, and CockroachDB found that roughly 58% of blocking bugs (goroutines hanging forever) were caused by message passing. Worse, Go&amp;rsquo;s built-in deadlock detector caught only 2 of the 21 blocking bugs tested.&lt;/p&gt;
&lt;p&gt;Under the hood, the author points out, a Go channel is literally a shared concurrent queue protected by a mutex, without separate send and receive capability endpoints—so every classic shared-state hazard has a channel equivalent: deadlocks, goroutine leaks, race conditions when multiple goroutines read from the same channel, and protocol violations like sending on a closed channel. A representative Kubernetes bug left a child goroutine blocked forever because nobody read from an unbuffered channel after a timeout; the fix was changing the buffer size to one. Even Erlang, with its strictly isolated processes, was found in academic studies to suffer from race conditions around ETS tables—shared mutable memory bolted back on for performance.&lt;/p&gt;
&lt;h2 id="things-i"&gt;&lt;a href="https://sjer.red/blog/2026/built-with-ai/" rel="noopener noreferrer"&gt;Things I&amp;rsquo;ve Done with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With roughly seven years of professional experience plus seven years of self-taught programming before that, the author traces his journey from AI skeptic to heavy adopter. Having previously ignored GitHub Copilot and dismissed Cursor as hype, he used to care deeply about clean architecture, expressive type systems, and long-term maintainability. The turning point came when he asked &lt;em&gt;why&lt;/em&gt; we care about those things: on the job, what matters is delivering business value, and code doesn&amp;rsquo;t need to be &amp;ldquo;clean&amp;rdquo; in the traditional human sense if it has thorough automated tests that allow AI agents to maintain it safely. Since October 2025, he stopped writing code by hand and now only writes prompts and reviews output.&lt;/p&gt;
&lt;p&gt;Over nine months using Cursor and Claude Code, he shipped more than a dozen personal projects: consolidating everything into a single monorepo, migrating CI to Buildkite and Bazel, building Clauderon—an orchestrator for multiple coding agents—along with Discord bots and mobile apps. At work, AI drafts design docs, builds diagnostic tools, and automates operational chores; small product-manager requests are now nearly free, leaving code review and manual QA as the main work. Still, he admits the review-heavy workflow is mentally tiring, and argues that testing and documentation have become the new bottlenecks where the industry needs better tooling.&lt;/p&gt;
&lt;h2 id="pushing-and-pulling-three-reactivity-algorithms"&gt;&lt;a href="https://jonathan-frere.com/posts/reactivity-algorithms/" rel="noopener noreferrer"&gt;Pushing and Pulling: Three Reactivity Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares three algorithms for building reactive systems—systems that automatically recompute derived values when inputs change, easiest to picture as a spreadsheet where editing one cell updates every formula that depends on it. The author evaluates them against four criteria: efficiency (computing each node at most once per update), granularity (updating only nodes that are actually affected), glitch-freedom (never exposing inconsistent intermediate states), and support for dynamic dependencies. Pure &lt;em&gt;push&lt;/em&gt; reactivity lets each node notify its dependents directly, giving fine granularity, but nodes in diamond dependencies can be recomputed multiple times and expose glitches unless the entire graph is topologically sorted. Pure &lt;em&gt;pull&lt;/em&gt; reactivity works like nested function calls: it is naturally glitch-free and supports dynamic dependencies for free, but has no idea which inputs changed without either recomputing everything or maintaining hard-to-invalidate caches.&lt;/p&gt;
&lt;p&gt;A hybrid &lt;em&gt;push–pull&lt;/em&gt; algorithm gets the best of both worlds: the push phase simply walks downstream to mark affected nodes as &amp;ldquo;dirty&amp;rdquo; and records which output nodes need updating, regardless of traversal order; the pull phase then lazily recomputes only the dirty nodes from the outputs backward and marks them clean. Each node is visited at most once per phase, running in O(n) time where n is the number of affected nodes, and satisfying all four criteria. The main caveat is that the entire pull phase must finish synchronously between two input mutations, so long-running async work has to be handled outside the core graph.&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_!Fevp!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Feb1ae3fa-80a7-464d-97a2-869170caaa2f_2360x2960.png" alt="Git Workflow: Essential Commands"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!huHJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9262eb79-a1cc-4308-8f72-01fdf91e429d_1388x1782.jpeg" alt="How can Cache Systems go wrong?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7p1w!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd5ebb98a-9f98-4c32-9268-2d14086569d8_2360x2960.png" alt="Top Cyber Attacks Explained"&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 #71</title><link>https://miti99.com/en/post/2025/12/14/</link><pubDate>Sun, 14 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #71.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-modern-guide-to-sql-joins"&gt;&lt;a href="https://kb.databasedesignbook.com/posts/sql-joins/" rel="noopener noreferrer"&gt;A modern guide to SQL JOINs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexey Makhotkin writes an extensive guide to SQL JOINs with a markedly different approach from typical tutorials: teaching LEFT JOIN before INNER JOIN, and using only equality comparisons between two IDs in the ON condition while pushing all other filtering conditions into WHERE. He divides joins into three cases. The N:1 case, where the primary key sits on the right side of the ON condition, is the most useful because the number of result rows never exceeds the row count of the left table. The 1:N case is awkward and best avoided, while M:N is a source of subtle bugs. All examples use a small database with employee and payment tables, accompanied by live runnable queries on dbfiddle.uk.&lt;/p&gt;
&lt;p&gt;The later sections explain INNER JOIN as a filtered Cartesian product, how to use self-joins to handle hierarchical data like manager relationships, and why Venn diagrams are a misleading visualization: they fail to show how rows get multiplied. He also argues that RIGHT JOIN is redundant, and thoroughly analyzes the double-counting bug that happens when chaining multiple LEFT JOINs followed by a GROUP BY, along with how to redesign the query to be both correct and fast. The overarching message: SQL is too permissive and won&amp;rsquo;t protect you from simple mistakes, so impose discipline on yourself when writing queries.&lt;/p&gt;
&lt;h2 id="punycode-my-new-favorite-algorithm"&gt;&lt;a href="https://www.iankduncan.com/engineering/2025-12-01-punycode" rel="noopener noreferrer"&gt;Punycode: My New Favorite Algorithm&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ian Duncan recounts his experience implementing Punycode from scratch in Haskell—the algorithm that enables internationalized domain names like &lt;code&gt;bücher-café.de&lt;/code&gt; or &lt;code&gt;北京-旅游.cn&lt;/code&gt; to work on DNS, which only accepts ASCII letters, digits, and hyphens. The core idea is neat: keep the ASCII characters as they are, add a hyphen as a delimiter, and then encode the remaining characters in ascending order of their Unicode code points. Each character is represented by the distance (delta) from the previous character and its insertion position, written as a variable-length base-36 number. Because characters from the same script sit close together in the Unicode table, the delta is usually small, and sorting by code point means duplicate characters have a delta of zero and take only a single digit.&lt;/p&gt;
&lt;p&gt;He devotes most of the post to explaining the rationale behind design choices that RFC 3492 prescribes without justification: base 36 is the largest case-insensitive base allowed by DNS; the bias parameter adapts after each character so the encoding threshold works well for both German and Chinese; and the damping mechanism and skew constant keep the bias from swinging too wildly. The post also compares Punycode against fixed-width encodings to show how inefficient they are, and closes with an interactive visualizer that walks through each encoding step across different scripts.&lt;/p&gt;
&lt;h2 id="evolution-and-scale-of-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/evolution-and-scale-of-ubers-delivery-search-platform/" rel="noopener noreferrer"&gt;Evolution and Scale of Uber&amp;rsquo;s Delivery Search Platform&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Uber Eats team shares how they built a semantic search system so users can find stores, dishes, and grocery items even when queries contain synonyms, typos, or mixed languages. The model uses a two-tower architecture built on the Qwen LLM: query vectors are computed in real time, while document vectors are batch-computed for billions of candidates and indexed in Apache Lucene Plus. To balance quality and cost, the team experimented with three factors: the number of nearest neighbors k retrieved per shard, int7 versus float32 quantization, and vector dimensionality via Matryoshka Representation Learning (MRL). Reducing k from 1,200 to around 200 cut latency by 34% and CPU usage by 17%, while int7 quantization more than halved latency while keeping recall above 0.95. Regional and document-type filters run first to narrow the candidate set.&lt;/p&gt;
&lt;p&gt;For reliability, the system automatically retrains the model and rebuilds the index every two weeks. Each index has two vector columns—blue and green—with configuration specifying which column is currently serving traffic, enabling safe updates and rollbacks. Every refresh must pass three validation checks: sufficient document count, zero byte-level changes to the currently serving column, and staging recall that is at least as good as production. At serving time, the service also cross-checks the model ID that generated the query vector against the model ID recorded in the index to catch misconfigurations.&lt;/p&gt;
&lt;h2 id="16-api-gateway-concepts-every-software-engineer-should-know"&gt;&lt;a href="https://designgurus.substack.com/p/16-api-gateway-concepts-every-software" rel="noopener noreferrer"&gt;16 API Gateway Concepts Every Software Engineer Should Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arslan Ahmad explains 16 key concepts behind an API Gateway, the component that serves as the single entry point into a microservices system. Instead of needing to know the address of every individual service, client applications call only the gateway, which routes requests by path, method, or headers. The gateway is also the natural place to handle cross-cutting concerns: authentication (validating JWTs and returning 401 if invalid), authorization (returning 403 when required roles are missing), rate limiting (returning 429 when thresholds are exceeded), and dynamic throttling based on service tiers or system load. Each concept comes with a concrete example, making it handy for beginners or anyone preparing for system design interviews.&lt;/p&gt;
&lt;p&gt;The remaining concepts cover traffic splitting for gradual canary rollouts, request and response transformation for backward compatibility with legacy clients, caching, load balancing, circuit breakers to prevent cascading failures, timeouts, retries, and logging and monitoring. He concludes that the API Gateway is arguably the most strategic component in a distributed system—the place where security, resilience, performance, and operational observability converge.&lt;/p&gt;
&lt;h2 id="how-reddit-migrated-comments-functionality-from-python-to-go"&gt;&lt;a href="https://blog.bytebytego.com/p/how-reddit-migrated-comments-functionality" rel="noopener noreferrer"&gt;How Reddit Migrated Comments Functionality from Python to Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteGo post summarizes how Reddit migrated its comments functionality from a monolithic Python service to Go microservices in 2024. Comments were chosen first because they represent the largest dataset and carry the highest write traffic. For reads, the team used a &amp;ldquo;tap compare&amp;rdquo; technique: a small fraction of traffic was routed to the Go service, which also called the legacy Python endpoint, compared the two responses, and logged discrepancies while still returning the Python result to users. Writes were much harder because every write had to simultaneously update Postgres, Memcached, and Redis (which stores CDC events that require 100% delivery), while comment IDs are unique and cannot be written twice to the production databases. The solution was &amp;ldquo;sister datastores&amp;rdquo;: three isolated datastores dedicated to the Go service whose contents could be compared against the production data written by Python.&lt;/p&gt;
&lt;p&gt;The migration ran into several hurdles: data serialized differently between the two languages, Python&amp;rsquo;s ORM had implicit optimizations that caused hand-written Go queries to put unexpected pressure on Postgres, and race conditions when two users edited a comment simultaneously created false positives in the comparison logs. The final results were strong: all three write endpoints cut p99 latency in half, dropping from spikes of up to 15 seconds to a steady sub-100 milliseconds. Reddit chose Go over splitting into Python microservices for its superior concurrency model and because Go was already widely adopted across their infrastructure.&lt;/p&gt;
&lt;h2 id="on-idempotency-keys"&gt;&lt;a href="https://www.morling.dev/blog/on-idempotency-keys/" rel="noopener noreferrer"&gt;On Idempotency Keys&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gunnar Morling discusses idempotency keys, the mechanism that enables exactly-once processing in distributed systems even though exactly-once message delivery cannot be guaranteed. The receiver compares an incoming message&amp;rsquo;s key against previously processed keys to skip duplicates, and processing the message alongside storing the key must happen atomically, typically within the same database transaction. He examines three ways to generate keys. UUIDv4 is simple but forces the receiver to retain every key ever seen; UUIDv7 or ULID includes a timestamp component so older keys can be evicted. Monotonically increasing sequences let the receiver remember only the highest value, but complicate things for the sender under concurrent requests, since sequence generation must be serialized and can easily become a bottleneck.&lt;/p&gt;
&lt;p&gt;The third approach derives keys from the sender database&amp;rsquo;s transaction log, a variant of the outbox pattern using CDC tools like Debezium. In Postgres, for example, the LSN position in the WAL increases monotonically and can serve as the key, provided events within the same transaction can be distinguished. He concludes that there is no silver bullet: UUIDs with a retention window are sufficient for many use cases, while monotonically increasing sequences derived from the transaction log become increasingly attractive as message volume grows, at the cost of added operational complexity.&lt;/p&gt;
&lt;h2 id="no-code-reviews-by-default"&gt;&lt;a href="https://www.raycast.com/blog/no-code-reviews-by-default" rel="noopener noreferrer"&gt;No code reviews by default&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas Paul Mann, co-founder of Raycast, shares the company&amp;rsquo;s engineering culture: no mandatory code reviews. Engineers push changes straight to &lt;code&gt;main&lt;/code&gt; and only request a review when they feel it&amp;rsquo;s needed. In his view, pull requests erode trust in a team that should operate on trust, don&amp;rsquo;t truly prevent bugs since many issues only surface after extended real-world use, and slow down momentum because code review is rarely anyone&amp;rsquo;s top priority. Instead, each engineer takes end-to-end ownership of their feature from initial idea through ongoing maintenance.&lt;/p&gt;
&lt;p&gt;In practice, continuous integration builds and tests every commit, and the team ships daily internal releases so everyone can dogfood changes and give early feedback. Unfinished features are hidden behind feature flags. Engineers still open pull requests when touching unfamiliar parts of the codebase—such as adding a database migration for the first time—or simply ping a teammate to take a look after committing. His closing advice: don&amp;rsquo;t follow &amp;ldquo;best practices&amp;rdquo; dogmatically; set rules that fit your own team&amp;rsquo;s context.&lt;/p&gt;
&lt;h2 id="estimates--a-necessary-evil"&gt;&lt;a href="https://thorsell.io/2025/12/07/estimates.html" rel="noopener noreferrer"&gt;Estimates – a necessary evil?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Erik Thorsell, who has worked as both a software developer and a product owner (PO), analyzes why time estimates are a constant source of tension between the two roles. POs need estimates to prioritize the backlog and weigh a big, eagerly awaited feature against several smaller ones when a release date has already been announced—and things get even messier when multiple POs have to coordinate on the same product. Developers, on the other hand, hate estimates because they&amp;rsquo;re asked to predict unforeseeable problems. He argues that technical debt is the primary source of conflict: a task expected to take two days can drag on for weeks when it hits legacy code, while a less technical PO struggles to see the cost of ignoring it.&lt;/p&gt;
&lt;p&gt;The problem gets worse when estimates are treated as deadlines. His team became noticeably more cautious and started padding every estimate with buffer time, turning estimates into &amp;ldquo;guardrails&amp;rdquo; to avoid being blamed for unrealistic expectations. Still, many deadlines exist for legitimate business reasons, so everyone has to play the estimation game. DevOps flow concepts don&amp;rsquo;t directly solve this, but they do reduce the risk of shipping software. His takeaway: POs are under pressure too, and the best way to help them is to continuously communicate progress and obstacles along the way.&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 #68</title><link>https://miti99.com/en/post/2025/12/11/</link><pubDate>Thu, 11 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #68. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; GLM-4.6 (For this post I configured CCR to use multiple models on iFlow Platform)&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="conscious-debugging-10-effective-strategies-that-actually-work-"&gt;&lt;a href="https://thetshaped.dev/p/conscious-debugging-10-effective-debugging-strategies-debug-like-pro" rel="noopener noreferrer"&gt;Conscious Debugging: 10 Effective Strategies That Actually Work 🐛&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Petar Ivanov argues that debugging isn&amp;rsquo;t a matter of luck, but a trainable skill—and mastering it saves time, effort, money, and stress. The article organizes 10 debugging strategies into three groups. The first group lays the groundwork: reproduce the bug consistently with concrete steps, shorten the reproduction cycle so you can test more hypotheses quickly, and gather full context from logs, session recordings, or user reports before diving into the code. In microservice architectures, sketching the end-to-end request flow across services gives you a clear mental map of the system.&lt;/p&gt;
&lt;p&gt;The second group covers active debugging techniques: narrow down the culprit via binary search (commenting out half the suspected code path to see whether the bug persists), use a real debugger to set breakpoints and inspect variables, explain the code line by line to a &amp;ldquo;rubber duck&amp;rdquo; or a teammate, and work like a scientist—form a hypothesis, test it, observe the outcome, fix, and verify. When you hit a wall, write down everything you&amp;rsquo;ve tried so far, take an intentional break, and use AI smartly by feeding it full context—AI isn&amp;rsquo;t magic, but it&amp;rsquo;s a valuable assistant when given complete information.&lt;/p&gt;
&lt;h2 id="the-fate-of"&gt;&lt;a href="https://nolanlawson.com/2025/11/16/the-fate-of-small-open-source/" rel="noopener noreferrer"&gt;The fate of &amp;ldquo;small&amp;rdquo; open source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson looks back at &lt;code&gt;blob-util&lt;/code&gt;, a small npm library he wrote roughly 10 years ago that still gets over 5 million weekly downloads. Now that around 80% of developers use AI in their workflow, tiny utilities like this can be generated on demand by an LLM—he asked Claude to write a &lt;code&gt;Blob&lt;/code&gt;-to-&lt;code&gt;ArrayBuffer&lt;/code&gt; helper and got code nearly identical to his own. Many see this as pure progress: fewer dependencies and less performance, maintenance, and supply-chain risk. Yet Lawson argues something valuable is being lost: &lt;code&gt;blob-util&lt;/code&gt; was written in the spirit of a teacher, complete with documentation that helped developers understand how to work effectively with binary data in JavaScript. When we prioritize instant answers over learning and understanding, the motivation to publish small libraries and explain underlying concepts fades too.&lt;/p&gt;
&lt;p&gt;His conclusion: the era of small, low-complexity open-source packages is over—a decline that started as Node.js and browsers built more features into the platform, with LLMs serving as the final nail in the coffin. Even so, open source still has a bright future in larger, more ambitious projects or niche domains outside an LLM&amp;rsquo;s training distribution, such as his memory-leak hunter &lt;code&gt;fuite&lt;/code&gt; or Dominic Gannaway&amp;rsquo;s Ripple.js framework—work that demands original research and creative engineering.&lt;/p&gt;
&lt;h2 id="programming-languages-in-the-age-of-ai-agents"&gt;&lt;a href="https://alexn.org/blog/2025/11/16/programming-languages-in-the-age-of-ai-agents/" rel="noopener noreferrer"&gt;Programming Languages in the Age of AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexandru Nedelcu asks: when AI agents write our code, does programming language choice still matter, or will everyone converge on a handful of mainstream languages simply because AI has the most training data for them? He acknowledges the feedback loop is real—Python is popular, so AI writes good Python, making Python even more popular—but offers two reasons for optimism. First, compilers with expressive static type systems (Scala, Haskell, Rust) give AI agents faster, tighter feedback than unit tests alone, helping them iterate toward a working solution and curbing hallucinations. For example, AI can successfully write Scala 3 macros despite scarce public training examples by iteratively fixing compiler errors.&lt;/p&gt;
&lt;p&gt;Second, humans still have to review and understand AI-generated code, because merely running a program and eyeballing the output is far too shallow a check. Nedelcu warns of &amp;ldquo;comprehension debt&amp;rdquo;—when no one on the team understands how the system actually works anymore—and cites Peter Naur&amp;rsquo;s view that programming is fundamentally about building a shared human &amp;ldquo;theory&amp;rdquo; of the problem. Because source code remains the ultimate source of truth, good code must clearly express design intent and invariants; high-level expressive languages preserve that specification without loss. Deductive and equational reasoning from functional programming therefore become even more valuable when collaborating with AI.&lt;/p&gt;
&lt;h2 id="heading"&gt;&lt;a href="https://brenocon.com/dean_perf.html" rel="noopener noreferrer"&gt;&amp;ldquo;Numbers Everyone Should Know&amp;rdquo; from Jeff Dean&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page collects Jeff Dean&amp;rsquo;s famous &amp;ldquo;Numbers Everyone Should Know&amp;rdquo; table from Google—reference latencies for fundamental computer operations meant as historical order-of-magnitude rules of thumb rather than benchmarks for today&amp;rsquo;s hardware. An L1 cache reference takes ~0.5 ns, L2 cache ~7 ns, a branch mispredict ~5 ns, and a mutex lock/unlock or main memory reference ~100 ns. Compressing 1 KB with Zippy or sending 1 KB over a 1 Gbps network takes ~10,000 ns (0.01 ms); reading 1 MB sequentially from memory takes 0.25 ms, while a round trip within the same datacenter takes 0.5 ms. A disk seek takes 10 ms, reading 1 MB sequentially from disk takes 30 ms, and sending a packet from California to the Netherlands and back takes 150 ms.&lt;/p&gt;
&lt;p&gt;The lasting value of the table lies in the relative orders of magnitude between operations rather than the exact numbers: main memory is roughly 200x slower than L1 cache, and a disk seek is tens of millions of times slower than L1. For engineers, internalizing these gaps lets you do quick back-of-the-envelope performance estimates during design, understand why caching and minimizing I/O matter so much, and avoid common performance traps when building distributed or data-intensive systems.&lt;/p&gt;
&lt;h2 id="the-internet-is-cool-thank-you-tcp"&gt;&lt;a href="https://cefboud.com/posts/tcp-deep-dive-internals/" rel="noopener noreferrer"&gt;The Internet is Cool. Thank you, TCP&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Moncef Abboud explains why TCP is the workhorse of the Internet, underpinning HTTP, SMTP, and SSH. Underlying networks are inherently unreliable: packets can be dropped, corrupted, duplicated, or delivered out of order. While IP routes packets from host to host, the transport layer uses ports to deliver data to the right process—like a building&amp;rsquo;s street address versus an apartment number. TCP handles retransmissions, checksums, and ordering right at the two endpoints so intermediate routers stay simple and application developers don&amp;rsquo;t have to reinvent reliability. Alongside that, flow control (the &lt;code&gt;window&lt;/code&gt; field) tells the sender how much room remains in the receiver&amp;rsquo;s buffer, while congestion control was born after the &amp;ldquo;congestion collapse&amp;rdquo; of 1986, when throughput across an early Internet link plunged to just 40 bits per second.&lt;/p&gt;
&lt;p&gt;On the hands-on side, the post walks through C code for a TCP echo server and a minimal &amp;ldquo;fake&amp;rdquo; HTTP server just complete enough to fool &lt;code&gt;curl&lt;/code&gt;, illustrating Berkeley socket calls like &lt;code&gt;socket&lt;/code&gt;, &lt;code&gt;bind&lt;/code&gt;, &lt;code&gt;listen&lt;/code&gt;, &lt;code&gt;accept&lt;/code&gt;, &lt;code&gt;send&lt;/code&gt;, and &lt;code&gt;recv&lt;/code&gt;. The author also dissects the TCP segment header: how every connection is uniquely identified by a 5-tuple (protocol, source IP and port, destination IP and port), how the &lt;code&gt;SYN&lt;/code&gt; → &lt;code&gt;SYN-ACK&lt;/code&gt; → &lt;code&gt;ACK&lt;/code&gt; three-way handshake establishes a connection, how &lt;code&gt;FIN&lt;/code&gt; or &lt;code&gt;RST&lt;/code&gt; tears it down, and how sequence numbers and acknowledgment numbers keep byte streams intact and in order.&lt;/p&gt;
&lt;h2 id="myths-programmers-believe-about-cpu-caches"&gt;&lt;a href="https://software.rajivprab.com/2018/04/29/myths-programmers-believe-about-cpu-caches/" rel="noopener noreferrer"&gt;Myths Programmers Believe about CPU Caches&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on experience working on CPU caches at Intel and Sun, the author debunks a widespread misconception: that concurrency is hard because &amp;ldquo;each CPU core can hold different, stale values in its private cache,&amp;rdquo; and that Java&amp;rsquo;s &lt;code&gt;volatile&lt;/code&gt; keyword exists to force reads and writes straight to main memory. In reality, caches on modern x86 CPUs are kept coherent automatically by hardware cache-coherency protocols like MESI, where every cache line is tagged as Modified, Exclusive, Shared, or Invalid. If a &lt;code&gt;volatile&lt;/code&gt; read actually had to go all the way to RAM every time, it would be ~200x slower; in practice, a &lt;code&gt;volatile&lt;/code&gt; read can be as cheap as an L1 cache hit.&lt;/p&gt;
&lt;p&gt;Why, then, do we still need &lt;code&gt;volatile&lt;/code&gt; and atomics? Because CPU registers are &lt;em&gt;not&lt;/em&gt; coherent across cores, and compilers are free to keep variables in registers or reorder instructions under the assumption of single-threaded execution. In Java, a &lt;code&gt;volatile&lt;/code&gt; write establishes a happens-before relationship with subsequent reads of that same variable. That guarantee governs both compiler optimizations and hardware memory ordering; single-cache-line coherency alone does not guarantee that all threads observe changes across multiple variables in the same order. Misunderstanding this leads to flawed designs, such as assuming a single-core machine is immune to race conditions. The author also shows how hardware cache-coherency principles map directly onto distributed systems and database isolation levels.&lt;/p&gt;
&lt;h2 id="why-nan--nan-in-javascript-and-the-ieee-754-story-behind-it"&gt;&lt;a href="https://pzarycki.com/en/posts/js-nan/" rel="noopener noreferrer"&gt;Why NaN !== NaN in JavaScript (and the IEEE 754 story behind it)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In JavaScript, &lt;code&gt;typeof NaN&lt;/code&gt; returns &lt;code&gt;&amp;quot;number&amp;quot;&lt;/code&gt;, and many operations like addition, subtraction, or &lt;code&gt;Math.max&lt;/code&gt; propagate &lt;code&gt;NaN&lt;/code&gt;—though not every operation does. Tracing through the source code of Firefox and V8, the author finds that both delegate to C++&amp;rsquo;s &lt;code&gt;std::isnan&lt;/code&gt;, a clue that &lt;code&gt;NaN&lt;/code&gt;&amp;rsquo;s behavior wasn&amp;rsquo;t invented by JavaScript at all, but comes from the 1985 IEEE 754 floating-point standard. Rewriting the example in C produces the exact same result—&lt;code&gt;x != x&lt;/code&gt; evaluates to true when &lt;code&gt;x&lt;/code&gt; is &lt;code&gt;NaN&lt;/code&gt;—and inspecting the compiled assembly shows the comparison is executed directly by the CPU via the &lt;code&gt;ucomisd&lt;/code&gt; instruction on x86. In other words, &lt;code&gt;NaN !== NaN&lt;/code&gt; is intentional hardware-level behavior, not a JavaScript quirk.&lt;/p&gt;
&lt;p&gt;Before IEEE 754, every hardware vendor handled arithmetic errors differently, often causing expressions like &lt;code&gt;0/0&lt;/code&gt; to trap and crash the program immediately, making portable numerical code a nightmare—imagine that happening inside flight-control software. &lt;code&gt;NaN&lt;/code&gt; solved this by propagating quietly through a chain of calculations so programmers can check for errors once at the end rather than after every single arithmetic step. In JavaScript, the reliable ways to check for &lt;code&gt;NaN&lt;/code&gt; are &lt;code&gt;Number.isNaN()&lt;/code&gt; or &lt;code&gt;x !== x&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="towards-interplanetary-quic-traffic"&gt;&lt;a href="https://ochagavia.nl/blog/towards-interplanetary-quic-traffic/" rel="noopener noreferrer"&gt;Towards interplanetary QUIC traffic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adolfo Ochagavía recounts a consulting project to prove that QUIC—the reliable transport protocol underlying HTTP/3—can operate across deep space, such as communicating between Earth and a rover on Mars. The challenges are extreme: one-way signal delay ranges from 3 to 23 minutes, and links drop regularly as relay satellites pass out of view. With default settings, QUIC times out long before completing a handshake. The limitation, however, lies in default parameters tuned for terrestrial broadband rather than in the protocol itself: QUIC allows deep tuning of initial RTT estimates, idle timeouts, and congestion control algorithms, whereas TCP is fundamentally ill-suited for deep space.&lt;/p&gt;
&lt;p&gt;Testing against virtual machines with real simulated delays would be painfully slow when a single Mars round trip takes up to 46 minutes. Ochagavía solved this by running both client and server inside a single process, routing packets through a custom in-memory network simulator, and enabling Tokio&amp;rsquo;s time-skipping test clock. Thanks to the modular design of &lt;code&gt;quinn&lt;/code&gt;—Rust&amp;rsquo;s most popular QUIC implementation—everything plugged together cleanly: tests run almost instantaneously, behave deterministically (identical seeds yield identical runs), and dump &lt;code&gt;.pcap&lt;/code&gt; packet captures at both endpoints for inspection in Wireshark. Mars rovers still transmit images over CFDP today, but in a few years the answer might well be QUIC.&lt;/p&gt;
&lt;h2 id="bloom-filters-the-niche-trick-behind-a-16-faster-api"&gt;&lt;a href="https://incident.io/blog/bloom-filters" rel="noopener noreferrer"&gt;Bloom filters: the niche trick behind a 16× faster API&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The engineering team at incident.io shares how they cut the P95 latency of an alert-filtering API from 5 seconds down to 0.3 seconds. Alerts are stored in PostgreSQL, with customer-defined custom attributes like &lt;code&gt;&amp;quot;team&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;feature&amp;quot;&lt;/code&gt; packed inside a &lt;code&gt;JSONB&lt;/code&gt; column. Their old algorithm fetched batches of 500 rows, deserialized the &lt;code&gt;JSONB&lt;/code&gt; payloads into Go structs, and filtered them in memory, looping until it filled a single page of results. For large enterprise customers with millions of alerts, this forced the API to scan and deserialize massive amounts of irrelevant data. The team weighed two options: a PostgreSQL GIN index—the standard textbook choice for &lt;code&gt;JSONB&lt;/code&gt;—or a Bloom filter, a probabilistic data structure that tells you whether an element is &amp;ldquo;definitely not in the set&amp;rdquo; or &amp;ldquo;possibly in the set.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;They chose a Bloom filter out of concern that a GIN index would balloon disk and memory usage while slowing down writes. Each alert&amp;rsquo;s attribute key-value pairs are hashed into a &lt;code&gt;bit(512)&lt;/code&gt; column sized for a ~1% false-positive rate at their attribute cardinality. At query time, Postgres performs a fast bitwise AND check (&lt;code&gt;bitmap &amp;amp; bitmask == bitmask&lt;/code&gt;) to discard non-matching rows cheaply, then runs the exact &lt;code&gt;JSONB&lt;/code&gt; check on the surviving candidates to filter out false positives. Combined with a mandatory time-window filter (defaulting to 30 days) that exploits the chronological sort order of ULID primary keys, query performance became fast and predictable even for their largest customers. The takeaway: sometimes a niche computer science trick beats the standard off-the-shelf index.&lt;/p&gt;
&lt;h2 id="making-things-true"&gt;&lt;a href="https://threadreaderapp.com/thread/1990057444253241545.html" rel="noopener noreferrer"&gt;making things true&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this thread, Ryo Lu argues that design isn&amp;rsquo;t about surface aesthetics like picking colors or polishing UI chrome, but about seeing through the surface to the underlying structure: decomposing a complex domain into fundamental building blocks, understanding how they relate, and recombining them into something simpler and more powerful. When building Notion, the team didn&amp;rsquo;t set out to make yet another note-taking app or project tracker; instead, they searched for the &amp;ldquo;atoms&amp;rdquo; of software: blocks, databases, views, and relations. Viewed through that lens, Asana, Linear, Evernote, and Airtable are just rigid presets of the same underlying concepts, whereas Notion hands users Lego bricks to assemble whatever tool they need. Cursor does something similar one layer deeper, removing friction between human intent and working software: you describe what you want, and AI handles the decomposition into code.&lt;/p&gt;
&lt;p&gt;Lu zooms out further: human language, music, and DNA are all finite sets of primitives that combine in infinite ways. The true turning points in computing history weren&amp;rsquo;t flashy features, but new primitives—the command line, the GUI, the hyperlink, mobile sensors—and AI is the newest primitive of that kind. For software builders, the lesson is to practice spotting the core primitives of a system by asking what a thing truly is at its core and how much you can strip away before it stops being itself.&lt;/p&gt;
&lt;h2 id="what-good-execution-looks-like"&gt;&lt;a href="https://yusufaytas.com/what-good-execution-looks-like/" rel="noopener noreferrer"&gt;What Good Execution Looks Like&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yusuf Aytas observes that great execution feels &amp;ldquo;quiet&amp;rdquo;—not slow or passive, but smooth enough that people coordinate naturally and management&amp;rsquo;s presence almost fades into the background. Poor execution, by contrast, is loud and full of heroics: projects stall, approval layers multiply, processes calcify, status updates turn defensive, and meetings explode. In Aytas&amp;rsquo;s view, strong execution rests on a handful of foundations: clear direction (what matters, where we&amp;rsquo;re going, and why), stable priorities, unambiguous ownership with a single directly responsible individual, lightweight process designed solely to reduce uncertainty, maintain momentum, and surface problems early, mutual trust, a steady cadence, and fast, honest feedback loops.&lt;/p&gt;
&lt;p&gt;Signs of healthy execution include low operational noise, psychological safety to raise risks early without fear of blame, and genuine autonomy where leaders clear roadblocks instead of micromanaging details. Execution is measurable, too: predictable lead times and throughput, small frequent releases, high-signal alerts instead of pager fatigue, and a low change-failure rate. The core message: quietness isn&amp;rsquo;t a lack of urgency—it&amp;rsquo;s the sound of an organization that isn&amp;rsquo;t fighting itself.&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_!tANe!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7f80d730-11c4-4d55-81bf-fa4629cc2f0f_2360x2960.png" alt="How to Design Good APIs"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gReB!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2e93eb2-84ab-427f-b587-e14b599e0fee_2360x2960.png" alt="Types of Virtualization"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=7_wkWQ9rB5I" rel="noopener noreferrer"&gt;Why is Kafka Popular?&lt;/a&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 #53</title><link>https://miti99.com/en/post/2025/09/09/</link><pubDate>Tue, 09 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I experimented with consolidating all my previous coding agent rules into a single &lt;code&gt;AGENTS.md&lt;/code&gt; file, then pointing &lt;code&gt;CLAUDE.md&lt;/code&gt; to read that file.&lt;/del&gt; Enjoy Newsletter #53.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="anti-cheat-secure-boot--tpm"&gt;&lt;a href="https://andrewmoore.ca/blog/post/anticheat-secure-boot-tpm/" rel="noopener noreferrer"&gt;Anti-cheat, Secure Boot &amp;amp; TPM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Moore explains why anti-cheat systems like those in Battlefield 6 or Riot&amp;rsquo;s Vanguard have started requiring players to enable Secure Boot and TPM 2.0, while pushing back against claims that this is a pretext for harvesting player data. Secure Boot relies on a key hierarchy (Platform Key, Key Exchange Key, the DB allowlist of signatures, and the DBX blocklist) to ensure firmware only executes validly signed boot images. Combined with Windows only loading Microsoft-signed kernel drivers, cheat developers have a hard time injecting code into the kernel without an unpatched vulnerability.&lt;/p&gt;
&lt;p&gt;However, an anti-cheat client cannot simply trust the operating system when it reports that Secure Boot is enabled, which is where the TPM becomes the crucial link. The firmware TPM (fTPM) built into modern AMD and Intel CPUs holds a unique Endorsement Key backed by a manufacturer certificate, providing unforgeable hardware identification—meaning a hardware ban forces a cheater to buy a new CPU. In addition, the TPM&amp;rsquo;s PCR registers record a cryptographic hash chain of every event during the boot sequence, and through remote attestation via &lt;code&gt;TPM2_Quote&lt;/code&gt;, the anti-cheat server can verify that the boot environment has not been tampered with. The takeaway: this setup doesn&amp;rsquo;t eliminate cheating completely—especially hardware-based cheats—but it makes ban evasion far more expensive, doesn&amp;rsquo;t compromise user privacy, and forms an important layer of defense in depth.&lt;/p&gt;
&lt;h2 id="left-to-right-programming"&gt;&lt;a href="https://graic.net/p/left-to-right-programming" rel="noopener noreferrer"&gt;Left to Right Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that a program should remain syntactically valid while it is being typed from left to right, so the editor can offer autocomplete and type checking at every step. A classic counterexample is Python&amp;rsquo;s list comprehension: when writing &lt;code&gt;words_on_lines = [line.split() for line in text.splitlines()]&lt;/code&gt;, the variable &lt;code&gt;line&lt;/code&gt; is used before it is declared, so the editor doesn&amp;rsquo;t know its type when you type the dot and cannot suggest methods. By contrast, in Rust (&lt;code&gt;let words_on_lines = text.lines().map(|line| line.split_whitespace());&lt;/code&gt;) or JavaScript, expressions are built from left to right: the source is stated first, and the moment you type a dot, the editor can suggest relevant methods.&lt;/p&gt;
&lt;p&gt;The article connects this to the design principle of &amp;ldquo;progressive disclosure&amp;rdquo;: complexity should only surface when the user actually needs it. In C, because methods cannot be attached to structs, you have to know function names like &lt;code&gt;fread&lt;/code&gt; or &lt;code&gt;fclose&lt;/code&gt; ahead of time rather than discovering them through autocomplete after typing &lt;code&gt;file.&lt;/code&gt;. Python runs into a similar issue with global functions like &lt;code&gt;len&lt;/code&gt; or &lt;code&gt;map&lt;/code&gt;; as logic grows more complex, a single line of Python nesting multiple &lt;code&gt;filter&lt;/code&gt;, &lt;code&gt;lambda&lt;/code&gt;, and comprehension expressions becomes much harder to read than a method chain in JavaScript that reads sequentially from left to right. The closing message for language and library designers is simple: build discoverable APIs.&lt;/p&gt;
&lt;h2 id="big-o-notation"&gt;&lt;a href="https://samwho.dev/big-o/" rel="noopener noreferrer"&gt;Big O Notation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide on samwho.dev introduces Big O notation visually with live in-browser examples. Rather than measuring wall-clock time, Big O describes how execution time grows as input size increases. The author walks through four common complexity classes: summing numbers from 1 to &lt;code&gt;n&lt;/code&gt; with a loop is O(n) (linear), whereas using the formula &lt;code&gt;(n*(n+1))/2&lt;/code&gt; is O(1) (constant)—noting that O(1) does not mean &amp;ldquo;instant,&amp;rdquo; only that runtime does not depend on input size. Bubble sort illustrates O(n²) (quadratic), while guessing a number between 1 and 100 via binary search, halving the search space on each guess, illustrates O(log n) (logarithmic). Big O describes an asymptotic upper bound: O(2n) simplifies to O(n), keeping only the fastest-growing term. You can analyze best, average, or worst cases; the article focuses on the worst case.&lt;/p&gt;
&lt;p&gt;The final section shares practical performance tips: use a hash-table-backed &lt;code&gt;Set&lt;/code&gt; for average O(1) lookups instead of scanning an array (even though building the &lt;code&gt;Set&lt;/code&gt; costs O(n)), avoid calling &lt;code&gt;.indexOf&lt;/code&gt; inside a loop since that quietly turns the whole function into O(n²), and memoize intermediate results—as shown with factorials—to avoid redundant computation at the cost of extra memory. The most important advice: always benchmark before and after changing code, and don&amp;rsquo;t blindly trust performance claims you read online.&lt;/p&gt;
&lt;h2 id="personal-ai-evaluations-august-2025"&gt;&lt;a href="https://darkcoding.net/software/personal-ai-evals-aug-2025/" rel="noopener noreferrer"&gt;Personal AI Evaluations August 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Graham King evaluates large language models (LLMs) against his own day-to-day needs instead of relying on public leaderboards: he selected 12 questions out of 130 prompts from his bash history across four categories (coding, sysadmin, technical explanations, and general knowledge/creative), and ran them against 11 models via OpenRouter—including Claude Sonnet 4, DeepSeek, Gemini 2.5 Flash and Pro, Kimi K2, GPT-OSS-120B, Qwen3, and GLM 4.5. He wrote a custom Rust tool to anonymize the responses for blind grading while recording cost, latency, and throughput for each model.&lt;/p&gt;
&lt;p&gt;His main conclusion is that almost all current models give good answers, making cost and latency the deciding factors. Proprietary models like Gemini 2.5 Pro and Claude Sonnet did not stand out—in fact, they often scored lower than open-weight models while costing dramatically more. Gemini 2.5 Flash was the fastest; Kimi K2, Qwen3, and DeepSeek were among the cheapest; and two DeepSeek models alongside two Qwen3 models achieved the highest average accuracy. Reasoning mode rarely helped outside of a poetry prompt, and the entire evaluation produced only a single hallucination, when GPT-OSS-120B invented a nonexistent movie. Based on these results, the author now queries multiple models in parallel using &lt;code&gt;tmux&lt;/code&gt;: DeepSeek for everyday questions, adding Gemini Flash and Qwen3 when he wants a second opinion, and reserving reasoning models for particularly tough problems.&lt;/p&gt;
&lt;h2 id="how-to-keep-services-running-during-failures"&gt;&lt;a href="https://newsletter.scalablethread.com/p/how-to-keep-services-running-during" rel="noopener noreferrer"&gt;How to Keep Services Running During Failures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post from The Scalable Thread introduces graceful degradation, the design principle of keeping a system&amp;rsquo;s core functionality running when a component fails rather than letting the entire service go down. For example, if a video platform&amp;rsquo;s recommendation service fails, the homepage can fall back to showing trending videos while video playback continues working normally. The first group of strategies focuses on traffic control: rate limiting caps incoming requests during flash sales or DDoS attacks; request coalescing collapses thousands of identical concurrent queries into a single database hit; load shedding proactively drops non-essential requests (such as click tracking) to preserve capacity for checkout transactions; and retries with jitter add random backoff delays to prevent a &amp;ldquo;thundering herd problem&amp;rdquo; when a recovering service comes back online.&lt;/p&gt;
&lt;p&gt;The second group of strategies handles faults and improves observability. A circuit breaker acts like an electrical breaker: when a payment service repeatedly fails, the ordering service trips the breaker and fails fast for a cooldown period (say, 60 seconds) before letting a few probe requests through to check whether the downstream service has recovered. Request timeouts prevent upstream services from exhausting thread pools or connection limits waiting on a slow dependency. Finally, monitoring and alerting on metrics like error rates, latency, and message broker queue depth help engineers catch and contain incidents before they cascade.&lt;/p&gt;
&lt;h2 id="why-was-apache-kafka-created"&gt;&lt;a href="https://bigdata.2minutestreaming.com/p/why-was-apache-kafka-created" rel="noopener noreferrer"&gt;Why Was Apache Kafka Created?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from 2 Minute Streaming explains why Kafka was created in the first place. Around 2012, LinkedIn relied on user activity data to power many core features, but operated two separate data pipelines: an hourly batch system that pushed XML messages through HTTP servers into Oracle and Hadoop data warehouses, and a near-real-time monitoring pipeline built on Zenoss. Both required heavy manual operations, suffered from large backlogs, and consisted of fragile point-to-point connections that couldn&amp;rsquo;t be unified. Specific pain points included parsing hundreds of XML schemas, breaking downstream consumers whenever a schema changed, multi-hour latency, and clean data being locked inside the data warehouse.&lt;/p&gt;
&lt;p&gt;Kafka solved these problems with a distributed, replicated architecture that scales horizontally via partitions, an append-only log structure that supports multiple independent consumers, and disk persistence that decouples producers from consumers. LinkedIn also migrated from XML to Avro (roughly 7x smaller), built a schema versioning service—the precursor to Schema Registry—with backward-compatibility checks, enforced &amp;ldquo;schema on write&amp;rdquo; to validate data before it entered Kafka, and shifted schema ownership to the teams producing the data backed by mandatory review workflows. What surprised the author most is that LinkedIn&amp;rsquo;s original papers emphasized schemas over 13 years ago, whereas he considers the lack of native, built-in schema enforcement to be Kafka&amp;rsquo;s biggest design mistake.&lt;/p&gt;
&lt;h2 id="how-we-vibe-code-at-a-faang"&gt;&lt;a href="https://www.reddit.com/r/vibecoding/comments/1myakhd/how_we_vibe_code_at_a_faang/" rel="noopener noreferrer"&gt;How We Vibe Code at a FAANG&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Reddit user who introduces himself as an AI engineer with over ten years of experience—roughly half of it at FAANG or similar companies—shares how his team integrates AI into a production software development workflow, pushing back against the claim that AI-assisted coding isn&amp;rsquo;t viable for real-world systems. Their process still starts with rigorous technical design docs: a proposal must win stakeholder alignment, followed by a full system design covering architecture and cross-team integrations, and then a design review where senior engineers tear it apart—what the author calls front-loading the pain. Next come subsystem documentation, task breakdowns, and sprint planning with PMs and TPMs.&lt;/p&gt;
&lt;p&gt;Only when it is time to write code does AI become a productivity &amp;ldquo;force multiplier&amp;rdquo;: the team practices Test-Driven Development, having AI agents write the tests first before implementing the feature. Every pull request still requires approval from two human engineers before merging (with AI also starting to assist in code reviews), followed by staging verification before production rollout. According to the poster, end-to-end delivery time from feature proposal to production is about 30% faster. Many commenters pointed out that this isn&amp;rsquo;t really &amp;ldquo;vibe coding&amp;rdquo; at all, but disciplined AI-assisted engineering inside a mature enterprise workflow—a distinction the author himself agreed with.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict on &lt;code&gt;AGENTS.md&lt;/code&gt; effectiveness: Not great yet—it still left quite a lot of English terms untranslated. I&amp;rsquo;ll try to refine it further in upcoming posts. See you next time!&lt;/em&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 #51</title><link>https://miti99.com/en/post/2025/08/31/</link><pubDate>Sun, 31 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/31/</guid><description>&lt;p&gt;&lt;em&gt;Hey everyone, I&amp;rsquo;ve hit one of my lazy cycles again (and honestly, since I churned through quite a bit of material earlier, there isn&amp;rsquo;t that much backlog left anyway), so I&amp;rsquo;ll be switching to roughly 1–2 posts a week depending on my mood. Also, last week my idol ✨🌙 recommended the book &lt;del&gt;&lt;a href="https://nhanam.vn/tim-minh-trong-the-gioi-hau-tuoi-tho-nha-nam" rel="noopener noreferrer"&gt;Tìm mình trong thế giới hậu tuổi thơ&lt;/a&gt;&lt;/del&gt; (Finding Yourself in the Post-Childhood World), which is quite a good read—feel free to check it out if you&amp;rsquo;re interested. For now, enjoy Newsletter #51.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="p-fast-trie-lexically-ordered-hash-map"&gt;&lt;a href="https://dotat.at/@/2025-08-04-p-fast-trie.html" rel="noopener noreferrer"&gt;p-fast trie: lexically ordered hash map&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tony Finch sketches out a data structure idea that even he isn&amp;rsquo;t sure is actually a good one: the &amp;ldquo;p-fast trie,&amp;rdquo; a hash map that preserves the lexicographical order of its keys. Instead of maintaining a tree with internal pointers like a qp-trie, a p-fast trie stores every proper prefix of every key in a hash map partitioned by prefix length, where each prefix corresponds to an internal branch node. Keys are treated as bit strings sliced into 6-bit chunks; each internal node contains a 64-bit bitmap marking which next chunks exist, along with a popcount-compressed array pointing to the nearest preceding leaf. The leaves themselves are linked into a circular doubly linked list in sorted order, so finding the preceding leaf immediately gives you the succeeding one as well. As a result, exact lookups take a single O(1) hash map probe, while predecessor/successor queries use binary search over the prefix length, achieving O(log k) instead of O(k) like a qp-trie (where k is the key length).&lt;/p&gt;
&lt;p&gt;The author is candid about its weaknesses: a p-fast trie uses far more memory because it requires so many internal nodes, insertions and deletions must update multiple prefixes at once—making concurrent access hard to implement safely—and jumping around across long prefixes is much less friendly to CPU caches than a qp-trie. Its remaining advantage is that predecessor/successor searches only require one pass rather than two. A concise read for anyone interested in how an engineer weighs trade-offs when designing data structures.&lt;/p&gt;
&lt;h2 id="big-o-vs-hardware-better-complexity--better-performance"&gt;&lt;a href="https://blog.codingconfessions.com/p/big-o-vs-hardware" rel="noopener noreferrer"&gt;Big O vs Hardware: Better Complexity ≠ Better Performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abhinav Upadhyay demonstrates that better asymptotic complexity does not guarantee faster execution on real hardware. He grounds his analysis in the &amp;ldquo;Iron Law&amp;rdquo; of processor performance: execution time depends on the number of instructions executed and the number of instructions the CPU completes per cycle (IPC). The article compares three algorithms for computing the greatest common divisor (GCD): Euclid&amp;rsquo;s subtraction algorithm at O(max(a, b)), Euclid&amp;rsquo;s modulo algorithm at O(log(max(a, b))), and Stein&amp;rsquo;s binary GCD algorithm. For very large inputs, the modulo version is roughly 10,000 times faster than the subtraction version. Yet for &lt;code&gt;a = 130000, b = 13&lt;/code&gt;, the subtraction version—despite looping nearly 10,000 times—finishes earlier than the modulo version, which needs only a single step, because on Intel Skylake integer addition/subtraction has a 1-cycle latency and can execute 4 instructions per cycle, whereas integer division has a latency of 42–95 cycles.&lt;/p&gt;
&lt;p&gt;Stein&amp;rsquo;s algorithm is much more hardware-friendly: it replaces division with bit shifts and trailing-zero counts, keeping the instruction count low while maintaining high IPC. In the author&amp;rsquo;s benchmark across number pairs in &lt;code&gt;[1, 100000)&lt;/code&gt; with a step of 5, Stein&amp;rsquo;s algorithm came out fastest; the modulo version executed the fewest instructions (13 billion) but achieved an IPC of just 0.15, making it the slowest overall, whereas the subtraction version executed 97 billion instructions and still finished 1.5 seconds earlier. The takeaway: Big O still matters at scale, but real-world speed requires understanding instruction costs on modern CPUs, profiling with tools like &lt;code&gt;perf&lt;/code&gt;, and considering hybrid algorithms tailored to input size.&lt;/p&gt;
&lt;h2 id="claude-code-is-all-you-need"&gt;&lt;a href="https://dwyer.co.za/static/claude-code-is-all-you-need.html" rel="noopener noreferrer"&gt;Claude Code Is All You Need&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gareth Dwyer, a long-time &lt;code&gt;vim&lt;/code&gt; user, reflects on several weeks with Claude Code, Anthropic&amp;rsquo;s terminal-based AI coding tool, sharing three main takeaways: give it high autonomy (he runs it with permission prompts bypassed, even on live servers), feed it plenty of input because output quality scales with context, and note that it designs surprisingly good UIs. A standout example is SmartSplit, a Splitwise clone generated in one shot from a ~500-word specification file; still, the model remains inconsistent, and a vague spec produced a completely broken app. He also found the model writes PHP remarkably well and argues that frameworks exist mainly to serve humans rather than AI.&lt;/p&gt;
&lt;p&gt;According to the author, Claude Code&amp;rsquo;s power comes from a simple loop that calls the model repeatedly. He tried extending that loop into an &amp;ldquo;autonomous startup&amp;rdquo; on a VPS: Claude wrote its own prompts, picked an idea, and stood up a full web application complete with Nginx and TLS certificates—even though its product idea made no sense—before eventually getting blocked for violating usage policies. On real work, Claude Code helped him migrate an unfamiliar Laravel/MySQL application to a cheap VPS, saving an estimated 16–32 hours, though it still needed his supervision. Other projects included a Hacker News comment-scoring plugin, a poster generator, and categorizing bank statements. As for the article itself, he wrote nearly all of it by hand, finding that the model is much better at organizing existing material than at creative writing.&lt;/p&gt;
&lt;h2 id="http-is-not-simple"&gt;&lt;a href="https://daniel.haxx.se/blog/2025/08/08/http-is-not-simple/" rel="noopener noreferrer"&gt;HTTP is not simple&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg—author of &lt;code&gt;curl&lt;/code&gt;, with nearly three decades of writing client-side HTTP code and contributing to HTTP specifications at the IETF—pushes back against the notion that &amp;ldquo;HTTP is a simple protocol.&amp;rdquo; HTTP/1 looks approachable because it is human-readable text and anyone can &lt;code&gt;telnet&lt;/code&gt; into a server and type &lt;code&gt;GET&lt;/code&gt; by hand, but the machinery underneath is anything but simple. Headers are line-oriented with no specification limit on line length, terminated by CRLF (or sometimes bare LF), and consist of raw octets rather than UTF-8. Whitespace is mandatory in some places and optional in others, and tokens may or may not be quoted. There are at least three ways to determine where a response body ends (&lt;code&gt;Content-Length&lt;/code&gt;, chunked transfer encoding, &lt;code&gt;Connection: close&lt;/code&gt;)—the source of countless security vulnerabilities; parsing numbers in text form requires handling overflow, signs, and leading zeros; and headers can be combined or &amp;ldquo;folded&amp;rdquo; across multiple lines.&lt;/p&gt;
&lt;p&gt;On top of that, features exist in the spec that rarely work reliably in practice, such as pipelining or &lt;code&gt;100 Continue&lt;/code&gt; responses; sending a request body with &lt;code&gt;GET&lt;/code&gt; lacks broad interoperability (prompting the proposed &lt;code&gt;QUERY&lt;/code&gt; method); and browsers routinely guess user intent instead of rejecting malformed input, forcing other HTTP clients to mimic browser quirks rather than strictly following the spec. &amp;ldquo;HTTP/1.1&amp;rdquo; appears in at least 40 RFCs, and RFCs 9110–9112 alone run 95,740 words—over seven hours of nonstop reading. The author suggests complexity may simply be the price of success, as DNS and SMTP also started out simple before growing complex over time, and HTTP will only get more complex from here.&lt;/p&gt;
&lt;h2 id="building-a-web-search-engine-from-scratch-in-two-months-with-3-billion-neural-embeddings"&gt;&lt;a href="https://blog.wilsonl.in/search-engine/" rel="noopener noreferrer"&gt;Building a web search engine from scratch in two months with 3 billion neural embeddings&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wilson Lin chronicles his two-month journey building a web search engine from scratch, motivated by two observations: traditional search results are increasingly overrun with SEO spam, while transformer-based text embedding models have become remarkably good at understanding natural language. His goal was to capture the intent of a full query rather than matching keywords. Web pages are normalized to strip out menus, footers, and comment sections, keeping only semantically meaningful prose, which is then split into sentences using spaCy; each sentence is augmented with context from section headings or lead-in lines before lists so indirect references don&amp;rsquo;t lose their meaning.&lt;/p&gt;
&lt;p&gt;At scale, a cluster of 200 GPUs generated 3 billion SBERT embeddings, while hundreds of crawlers peaked at 50,000 pages per second to index 280 million pages; RocksDB and HNSW were sharded across 200 CPU cores, 4 TB of RAM, and 82 TB of SSD storage, delivering end-to-end query latency around 500 ms. The post also explains why he had to abandon object storage and then PostgreSQL in favor of RocksDB, and how combining Hetzner, Oracle Cloud, and Runpod kept infrastructure costs dozens of times cheaper than AWS. His two biggest takeaways: quantity has a quality all its own, because a search engine is useless if it hasn&amp;rsquo;t indexed what you&amp;rsquo;re looking for; and crawling and content filtering are the hardest parts of the job. Next steps include leveraging Common Crawl, adopting static embedding models, rewriting the crawler in Rust, and curating a high-signal index.&lt;/p&gt;
&lt;h2 id="bonus-cool-diagrams-from-bytebytego"&gt;Bonus: Cool diagrams from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/7136a64a-5300-4eed-852f-cdaf6cf73c6a_3000x3900.png" alt="What is the SOLID Principle?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fe53c806-a56f-4004-97e8-bbc6b5b9eb3d_3000x3900.jpeg" alt="Common HTTP Status Codes"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/db0481bd-807d-419c-a71e-913a13cb855e_1280x808.jpeg" alt="How Clean Architecture Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/ba21dab1-a39e-4c3a-a815-08d8be09de49_2360x2492.png" alt="How does Docker Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/7f891bc7-8657-47ff-8974-efcfcc0f0bb1_2250x2624.png" alt="A Guide to Top Caching Strategies"&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 #41</title><link>https://miti99.com/en/post/2025/07/31/</link><pubDate>Thu, 31 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/31/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #41.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-fastest-way-to-detect-a-vowel-in-a-string"&gt;&lt;a href="https://austinhenley.com/blog/vowels.html" rel="noopener noreferrer"&gt;The Fastest Way to Detect a Vowel in a String&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Austin Henley benchmarks 11 different ways to check whether a string contains a vowel in Python—ranging from a simple &lt;code&gt;for&lt;/code&gt; loop, a C-style loop with chained &lt;code&gt;or&lt;/code&gt; conditions, nested loops, set intersection, a generator expression with &lt;code&gt;any()&lt;/code&gt;, recursion, and &lt;code&gt;filter&lt;/code&gt;/&lt;code&gt;map&lt;/code&gt; with a lambda, all the way to regular expressions and a &amp;ldquo;just for fun&amp;rdquo; prime-number character encoding. The initial results are surprising: on short strings (length 10), a simple loop wins, but from length 100 upward, regex takes the lead while the C-style loop falls far behind. The reason is that Python&amp;rsquo;s regex engine is written in C and uses a bitmap lookup table to match characters instead of interpreting Python bytecode one character at a time.&lt;/p&gt;
&lt;p&gt;The post-publication update is even better: readers pointed out that Python&amp;rsquo;s built-in &lt;code&gt;str.find()&lt;/code&gt; beats regex thanks to CPython&amp;rsquo;s optimized substring search, and simply flipping the loop order—iterating over the vowel string and checking &lt;code&gt;if v in s&lt;/code&gt; against the input—beats both regex and &lt;code&gt;find()&lt;/code&gt;, running roughly 16x faster than regex on long strings. The takeaway is that performance differences in Python mostly come down to the CPython interpreter boundary: whichever approach pushes more of the loop into C wins. In practice, write the readable version unless you are processing millions of strings.&lt;/p&gt;
&lt;h2 id="writing-toy-software-is-a-joy"&gt;&lt;a href="https://blog.jsbarretto.com/post/software-is-joy" rel="noopener noreferrer"&gt;Writing Toy Software Is A Joy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joshua Barretto encourages programmers to build &amp;ldquo;toy software&amp;rdquo;—small, from-scratch projects—to deeply understand how systems work under the hood and rediscover the joy of programming. Starting from Richard Feynman&amp;rsquo;s line, &amp;ldquo;What I cannot create, I do not understand,&amp;rdquo; Barretto argues that building a simplified version of a familiar tool teaches you its core constraints far better than reading theory alone. The guiding rule is the 80:20 principle: spend 20% of the effort to get the 80% of functionality that is actually interesting, implement only what you need, and let the program crash until you are forced to handle an edge case. That mindset turns intimidating systems into approachable weekend projects.&lt;/p&gt;
&lt;p&gt;The post lists 23 project ideas with difficulty ratings (from 3 to 8 out of 10), time estimates, and reference links: easier picks include a regex engine, a CHIP-8 emulator, a hash table, and an interpreter; medium ones cover a physics engine, a text editor, a voxel engine, and an orbital simulator; the hardest are an x86 OS kernel and a compiler for a C-like language. Barretto strongly advises leaving large language models (LLMs) out of these projects, because understanding shouldn&amp;rsquo;t be &amp;ldquo;served on a platter&amp;rdquo;: struggling through the problem yourself is the entire point, especially as everyday software work becomes increasingly commoditized and AI-assisted.&lt;/p&gt;
&lt;h2 id="field-notes-from-shipping-real-code-with-claude"&gt;&lt;a href="https://diwank.space/field-notes-from-shipping-real-code-with-claude" rel="noopener noreferrer"&gt;Field Notes From Shipping Real Code With Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diwank shares battle-tested lessons from shipping production code with Claude. He divides AI-assisted work into three distinct modes: &amp;ldquo;playground&amp;rdquo; mode for weekend hacks and prototypes where Claude writes 80–90% of the code with minimal guardrails; pair-programming mode for codebases under roughly 5,000 lines; and production/monorepo scale with real users, where every step requires deliberate orchestration. The anchor of the workflow is &lt;code&gt;CLAUDE.md&lt;/code&gt;, which acts as the codebase&amp;rsquo;s &amp;ldquo;constitution&amp;rdquo;—recording the reasoning behind architectural decisions, coding standards, test commands, repository conventions, and hard off-limits rules. Complementing it are inline &amp;ldquo;anchor comments&amp;rdquo; like &lt;code&gt;AIDEV-NOTE:&lt;/code&gt;—short, greppable markers that guide both AI agents and human readers.&lt;/p&gt;
&lt;p&gt;His non-negotiable rule is that humans write the tests, because tests encode business requirements and edge cases that AI doesn&amp;rsquo;t truly understand; he illustrates this with an AI-generated test suite that passed green while completely missing a memory leak. AI is strictly forbidden from modifying test files, changing API contracts, touching database migrations, committing secrets, or guessing at domain logic. He also recommends using &lt;code&gt;git worktree&lt;/code&gt; for parallel AI experiments, prefixing AI-assisted commits with &lt;code&gt;[AI]&lt;/code&gt;, and being transparent across the team by agreeing on shared rules upfront—because strong engineering discipline is what separates AI as a force multiplier from AI as a chaos generator.&lt;/p&gt;
&lt;h2 id="why-generative-ai-coding-tools-and-agents-do-not-work-for-me"&gt;&lt;a href="https://blog.miguelgrinberg.com/post/why-generative-ai-coding-tools-and-agents-do-not-work-for-me" rel="noopener noreferrer"&gt;Why Generative AI Coding Tools and Agents Do Not Work For Me&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Miguel Grinberg, author of Flask-SocketIO and several widely used Python libraries, explains why generative AI coding tools and agents don&amp;rsquo;t fit his workflow. His central argument is that they don&amp;rsquo;t actually save him time: because he is personally accountable for every line of code he ships to production, with or without AI, he has to read and fully understand every line before committing. Reviewing AI-generated code takes him just as long as—or longer than—writing it himself, wiping out any time &amp;ldquo;saved&amp;rdquo; during generation.&lt;/p&gt;
&lt;p&gt;Grinberg also pushes back on comparing AI to an intern: a human intern learns and grows more autonomous over time, whereas in his view AI tools have no durable memory across sessions, resetting to square one on every task like an intern with amnesia. He views learning new languages and frameworks firsthand as both a joy and a long-term career investment, not a chore to offload to a machine. And while reviewing open-source community contributions also takes effort, it brings rewards AI never provides: genuine human connection, thoughtful feedback, and fresh ideas that make the project better.&lt;/p&gt;
&lt;h2 id="ai-coding-assistants-aren"&gt;&lt;a href="https://leaddev.com/velocity/ai-coding-assistants-arent-really-making-devs-feel-more-productive" rel="noopener noreferrer"&gt;AI coding assistants aren&amp;rsquo;t really making devs feel more productive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;LeadDev reporter Chantal Kapani examines data from the 2025 Engineering Leadership Report (surveying 617 engineering leaders in March) on perceived productivity gains from AI coding assistants, finding that the impact so far is much more modest than the hype suggests. Only 6% of respondents reported a significant productivity boost, while 39% saw minor improvements in the 1–10% range. Teams primarily use AI for code generation (47%), refactoring (45%), documentation (44%), internal communication (28%), and bug fixing (22%). Those numbers contrast sharply with upbeat vendor and enterprise claims like GitHub&amp;rsquo;s report that 88% of users feel more productive or JPMorgan Chase citing 10–20% efficiency gains, though the studies differ in sample and methodology.&lt;/p&gt;
&lt;p&gt;Industry experts quoted in the piece point to several reasons for the gap: current AI tools focus narrowly on typing code while ignoring deeper workflow bottlenecks; many rollouts are driven top-down by executive excitement rather than validated bottom-up; real delivery latency sits in test runtimes and deployment pipelines rather than keystrokes; and developers are rarely consulted before tools are mandated. The takeaway is to diagnose a team&amp;rsquo;s actual bottlenecks first before assuming AI is the fix.&lt;/p&gt;
&lt;h2 id="how-to-vibe-code-as-a-senior-engineer"&gt;&lt;a href="https://blog.alexmaccaw.com/how-to-vibe-code-as-a-senior-engineer" rel="noopener noreferrer"&gt;How to Vibe Code as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex MacCaw shares how to &amp;ldquo;vibe code&amp;rdquo; effectively as a senior engineer: letting AI models write the bulk of the code while the human steers through crisp prompts and architectural oversight. In his experience, the prerequisites are a rock-solid project scaffold—such as &lt;code&gt;ai-monorepo-scaffold&lt;/code&gt;—with clear examples of migrations, routes, and schemas for the AI to mimic; &lt;code&gt;.cursor/rules&lt;/code&gt; files that instruct the agent to plan first, preserve type safety, and run tests so it behaves like &amp;ldquo;a clean, responsible junior engineer&amp;rdquo;; pulling every relevant file (including type definitions) into context; using Cursor for near-instant lint and typecheck feedback; and picking frontier models like Claude Opus 4 or Gemini 2.5 Pro in &amp;ldquo;thinking&amp;rdquo; mode, prioritizing output quality over token cost.&lt;/p&gt;
&lt;p&gt;On prompting technique, MacCaw advises always asking the model for a plan to approve before it writes code, specifying exact outcomes and target file paths, providing concrete examples, setting explicit constraints (like &amp;ldquo;avoid &lt;code&gt;any&lt;/code&gt;&amp;rdquo;), keeping scope tight, and switching to longer conversational prompts when stuck. He also catalogs AI&amp;rsquo;s recurring blind spots: not knowing what context it is missing, reaching for TypeScript&amp;rsquo;s &lt;code&gt;any&lt;/code&gt; instead of proper types, jumping straight into code without confirming direction, and lacking architectural taste for a project&amp;rsquo;s conventions. MacCaw suggests we may be witnessing &amp;ldquo;the final chapter of human-led programming&amp;rdquo; before AI closes those remaining gaps.&lt;/p&gt;
&lt;h2 id="sql-noir---interactive-sql-game"&gt;&lt;a href="https://www.sqlnoir.com/blog/games-to-learn-sql" rel="noopener noreferrer"&gt;SQL Noir - Interactive SQL Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hristo Bogoev, creator of SQL Noir, rounds up five interactive games that teach SQL through hands-on problem-solving rather than dry textbooks. First is his own SQL Noir, a detective game where you solve crimes by writing SQL queries across six progressively harder cases with realistic schemas, instant feedback, and both free and paid cases. Next is SQL Island, a castaway survival game that works well for beginners despite its dated interface; Northwestern University&amp;rsquo;s SQL Murder Mystery, a single self-contained case that is great for practicing &lt;code&gt;JOIN&lt;/code&gt;s; and SQL Police Department (SQLPD), a paid platform featuring multiple cases, guided hints, and strong storytelling.&lt;/p&gt;
&lt;p&gt;Rounding out the list is SQLZoo, a free interactive tutorial site over 20 years old that systematically covers everything from basic &lt;code&gt;SELECT&lt;/code&gt;s to advanced topics like window functions, albeit without a story wrapper. Together they make a fun practice list for junior developers: newcomers can start with SQL Island or SQL Noir for narrative momentum, then solidify their fundamentals on SQLZoo.&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 #36</title><link>https://miti99.com/en/post/2025/07/25/</link><pubDate>Fri, 25 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/25/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #36.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-makes-strong-engineers-strong"&gt;&lt;a href="https://www.seangoedecke.com/what-makes-strong-engineers-strong/" rel="noopener noreferrer"&gt;What Makes Strong Engineers Strong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that what separates strong engineers from the rest is their ability to tackle unfamiliar problems faster than anyone else, and he ranks the four traits behind that ability in descending order of importance. First is self-belief: strong engineers take on work they have never done before even when they aren&amp;rsquo;t sure how, dive straight into hard problems instead of procrastinating, and let each success build the confidence to take on even harder work in a compounding loop. Second is pragmatism: they value working solutions over architectural purity, happily make trade-offs to ship on time, and frequently clash with smart but ineffective engineers over unnecessary rewrites; when disputes arise, who actually ships is the ultimate tiebreaker.&lt;/p&gt;
&lt;p&gt;Third is speed. Every strong engineer works fast—by not procrastinating and by compounding experience rapidly—and that speed lets them run more experiments and pursue high-value ideas. That pace comes not from working longer hours, but from intense bursts of focus. Last on the list is raw technical ability: a solid baseline is required, but genius-level intellect isn&amp;rsquo;t; what matters is whether your strengths match the job, and raw intelligence can even get in the way if it undermines pragmatism and speed.&lt;/p&gt;
&lt;h2 id="how-do-ai-code-reviews-impact-engineering-teams"&gt;&lt;a href="https://rdel.substack.com/p/rdel-92-how-do-ai-code-reviews-impact" rel="noopener noreferrer"&gt;How do AI Code Reviews Impact Engineering Teams?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post summarizes a study at Beko in which 238 developers used a GPT-4-powered automated code review tool (Qodo PR-Agent) over ten months, analyzing 4,335 pull requests through surveys and behavioral telemetry. Developers acted on 73.8% of the AI&amp;rsquo;s comments, and 68.8% of participants felt code quality improved. However, median pull-request cycle time actually increased from 5 hours 52 minutes to 8 hours 20 minutes, human reviewer comments barely budged (from 0.31 to 0.28 per pull request), and 26.2% of AI comments were ignored as irrelevant—meaning noisy suggestions created extra triage overhead.&lt;/p&gt;
&lt;p&gt;The core takeaway is that AI code review complements human reviewers rather than replacing them: it improves perceived quality, but neither reduces overall review effort nor speeds up delivery. The study advises teams to treat AI comments as early signal rather than final verdicts, track metrics to measure real impact on quality and velocity, and invest early in prompt tuning and noise filtering as the technology matures.&lt;/p&gt;
&lt;h2 id="writing-that-changed-how-i-think-about-pl"&gt;&lt;a href="https://bernsteinbear.com/blog/pl-writing/" rel="noopener noreferrer"&gt;Writing that changed how I think about PL&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein curates 16 papers, blog posts, videos, and repositories that fundamentally reshaped how he thinks about programming languages and compilers. Highlights include Andy Wingo&amp;rsquo;s post making copying garbage collectors concrete and approachable; CF Bolz-Tereick&amp;rsquo;s optimizer series introducing union-find and using Z3 as a proof engine; Chris Fallin&amp;rsquo;s work on register-allocator correctness showing how to verify a system per-compilation rather than proving the compiler itself once and for all; Russ Cox&amp;rsquo;s regular-expression series explaining how nondeterministic automata become user-space &amp;ldquo;threads&amp;rdquo;; and Andrej Karpathy&amp;rsquo;s micrograd for learning neural networks from scratch without external libraries.&lt;/p&gt;
&lt;p&gt;What unites every entry on the list is turning abstract concepts into clean, compact implementations you can grasp in an afternoon instead of months of study. For younger developers curious about compilers and interpreters, it serves as both a high-signal reading list and a testament to the power of clear, concise technical writing.&lt;/p&gt;
&lt;h2 id="llms-are-making-me-dumber"&gt;&lt;del&gt;&lt;a href="https://vvvincent.me/llms-are-making-me-dumber/" rel="noopener noreferrer"&gt;LLMs are Making Me Dumber&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Vincent Cheng poses a provocative question: are large language models (LLMs) making us dumber? He shares personal observations on how AI is reshaping his own learning process and skill development.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;He points to the cognitive &amp;ldquo;shortcuts&amp;rdquo; AI makes tempting: using LLMs to finish coding projects without deeply understanding the codebase, solving math problems by letting AI generate the answer, or drafting emails without practicing writing. Those habits can atrophy problem-solving muscles and trade deep learning for short-term output speed.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;At the same time, Cheng acknowledges the immediate productivity gains and draws historical parallels to pocket calculators, GPS, and the Industrial Revolution. Recognizing the uncertainty around long-term effects, he argues for a deliberate middle ground.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;His prescription is to consciously protect core skills like independent thinking, decision-making, and sustained focus while using LLMs strategically without surrendering personal agency. As he writes: &amp;ldquo;Total offloading cripples real learning while maximizing short-term speed and output, and finding the right balance is critical.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="how-cursor-indexes-codebases-fast"&gt;&lt;a href="https://read.engineerscodex.com/p/how-cursor-indexes-codebases-fast" rel="noopener noreferrer"&gt;How Cursor Indexes Codebases Fast&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article breaks down how Cursor, the AI-first code editor, indexes an entire codebase so quickly. The pipeline runs in five steps: first, files are chunked locally on the user&amp;rsquo;s machine into meaningful segments; next, Cursor computes a Merkle tree—a hash tree across all eligible files—and syncs it with the server; those code chunks are then converted into vectors using an embedding model; the vectors and metadata such as line numbers and obfuscated file paths are stored in Turbopuffer, a remote vector database; finally, every ten minutes, Cursor compares the Merkle tree to detect modified files and syncs only the diffs. Rather than slicing by fixed character or token counts, smart chunking relies on abstract syntax trees (ASTs) via tools like tree-sitter to preserve semantic boundaries while staying within token limits.&lt;/p&gt;
&lt;p&gt;On privacy, according to Cursor&amp;rsquo;s documentation, raw source code is not persisted on Cursor&amp;rsquo;s servers after a request completes, and file paths are encrypted using a client-side secret key. When you ask a question, your query is embedded into a vector and matched against stored vectors to locate relevant code ranges; those lines are then read locally from disk and sent as context to the large language model. The Merkle tree is the key piece that makes change detection fast and incremental syncing practical, especially on large repositories where re-indexing from scratch would be prohibitively expensive.&lt;/p&gt;
&lt;h2 id="a-leap-year-check-in-three-instructions"&gt;&lt;a href="https://hueffner.de/falk/blog/a-leap-year-check-in-three-instructions.html" rel="noopener noreferrer"&gt;A Leap Year Check in Three Instructions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Falk Hüffner presents a leap-year check that compiles down to roughly three CPU instructions. The standard definition requires multiple conditions: divisible by 4, and not divisible by 100 unless also divisible by 400. Hüffner packs all of that logic into a single multiplication, a bitwise AND, and a comparison against &amp;ldquo;magic&amp;rdquo; constants: &lt;code&gt;return ((y * 1073750999u) &amp;amp; 3221352463u) &amp;lt;= 126976u;&lt;/code&gt;. To find those constants, he used the Z3 bitvector constraint solver to search a 96-bit space; starting from a small year range and expanding iteratively, about half an hour of search produced constants that hold for every year from 0 to 102,499. A 64-bit variant extends the valid range up to year 5,965,232,499 and is proven optimal using the same technique.&lt;/p&gt;
&lt;p&gt;On performance, benchmarking on an i7-8700K with predictable inputs (always testing 2025) shows almost no difference (0.65 ns vs. 0.69 ns). With random years, however, the branchless formula runs 3.8x faster than the standard implementation by avoiding branch misprediction penalties. Hüffner notes that real-world applications mostly check predictable years like the current one, so realistic benchmarks are needed before adopting this trick in places like CPython&amp;rsquo;s &lt;code&gt;datetime&lt;/code&gt; module. Still, it is a fun exercise in bit twiddling and using constraint solvers for algorithmic optimization.&lt;/p&gt;
&lt;h2 id="reservoir-sampling"&gt;&lt;a href="https://samwho.dev/reservoir-sampling/" rel="noopener noreferrer"&gt;Reservoir Sampling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reservoir sampling is an algorithm for drawing a uniform random sample from a stream of items whose total length isn&amp;rsquo;t known in advance. It maintains a &amp;ldquo;reservoir&amp;rdquo; array of size &lt;code&gt;k&lt;/code&gt;, initialized with the first &lt;code&gt;k&lt;/code&gt; items of the stream (or all of them if the stream is shorter). Each subsequent item at 1-based index &lt;code&gt;n&lt;/code&gt; (where &lt;code&gt;n &amp;gt; k&lt;/code&gt;) is selected with probability &lt;code&gt;k/n&lt;/code&gt;; if chosen, it replaces a uniformly random element currently in the reservoir, and otherwise it is discarded. The math guarantees that the probability an older item survives in the reservoir equals the probability the new item is kept, giving every item seen so far an equal chance—just like every card in a deck having an equal chance of being drawn.&lt;/p&gt;
&lt;p&gt;Sam Rose illustrates the practical payoff with a log-ingestion service. During traffic spikes, instead of naively keeping only the first &lt;code&gt;k&lt;/code&gt; logs, reservoir sampling captures a fair, representative sample without overwhelming storage: memory usage stays strictly bounded at &lt;code&gt;k&lt;/code&gt; items, quiet periods record nearly every log, and peak periods automatically cap volume. Rose also touches on weighted variants that prioritize specific classes of items, such as error logs, for more nuanced sampling policies. Reservoir sampling cleanly solves a problem that sounds impossible at first glance: fair sampling when you don&amp;rsquo;t know how many items will arrive.&lt;/p&gt;
&lt;h2 id="beware-the-complexity-merchants"&gt;&lt;a href="https://chrlschn.dev/blog/2025/05/beware-the-complexity-merchants/" rel="noopener noreferrer"&gt;Beware the Complexity Merchants&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Chen warns against &amp;ldquo;complexity merchants&amp;rdquo;: engineers who introduce unnecessary complexity into systems, whether out of ego or to manufacture job security. By building Byzantine systems that only they understand, they carve out personal fiefdoms that constantly demand attention, budget, and headcount, then use the resulting pain to justify their own indispensability and influence—complete with the familiar refrain, &amp;ldquo;Who else is going to deal with all this complexity?&amp;rdquo; Chen quotes Ray Ozzie: &amp;ldquo;Complexity kills. It sucks the life out of developers; it makes products difficult to plan, build, and test.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;To push back, the post recommends requiring engineers to stabilize or simplify existing complexity before adding new layers, favoring &amp;ldquo;boring&amp;rdquo; battle-tested solutions over resume-driven tech, insisting on thorough documentation so systems can be handed off cleanly, staying skeptical of &amp;ldquo;silver bullet&amp;rdquo; pitches, and treating knowledge hoarding or deliberate obfuscation as red flags. The core message is that simple, well-documented systems enable shared team ownership and eliminate the environment complexity merchants rely on to build leverage.&lt;/p&gt;
&lt;h2 id="asserting-implications"&gt;&lt;a href="https://tigerbeetle.com/blog/2025-05-26-asserting-implications/" rel="noopener noreferrer"&gt;Asserting Implications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short note from TigerBeetle looks at how to write assertions for logical implications (&lt;code&gt;A ⇒ B&lt;/code&gt;) so they stay immediately readable. Most programming languages lack a dedicated implication operator, even though implications show up constantly in assertions. The textbook rewrite relies on the equivalence &lt;code&gt;A ⇒ B ⇔ ¬A ∨ B&lt;/code&gt;, yielding &lt;code&gt;assert(!a or b);&lt;/code&gt;, which forces the reader to mentally invert the condition to recover the original intent. The author recommends writing a plain conditional instead: &lt;code&gt;if (a) assert(b);&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;A real example from the TigerBeetle codebase makes the contrast clear: instead of &lt;code&gt;assert(header_b != null or replica.commit_min == replica.op_checkpoint);&lt;/code&gt;, write &lt;code&gt;if (header_b == null) assert(replica.commit_min == replica.op_checkpoint);&lt;/code&gt;. The second version states directly which condition triggers the check, making the invariant obvious at a glance. It is a tiny change, but a great reminder to optimize correctness checks for human readability.&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 #20</title><link>https://miti99.com/en/post/2025/05/07/</link><pubDate>Wed, 07 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #20.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="performance-improvements-in-jdk-24"&gt;&lt;a href="https://inside.java/2025/03/19/performance-improvements-in-jdk24/" rel="noopener noreferrer"&gt;Performance Improvements in JDK 24&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Inside.java article rounds up the most notable performance improvements in JDK 24 over JDK 23, organized by JDK bug tracker issue. In the core libraries, bulk operations in the Foreign Function &amp;amp; Memory API such as &lt;code&gt;MemorySegment::fill&lt;/code&gt;, &lt;code&gt;copy&lt;/code&gt;, and &lt;code&gt;mismatch&lt;/code&gt; are now handled in pure Java when memory segments are small enough, avoiding the overhead of transitioning to native code via &lt;code&gt;Unsafe&lt;/code&gt;. String concatenation now uses cacheable, reusable hidden classes instead of constructing chains of intermediate &lt;code&gt;MethodHandle&lt;/code&gt; combinators; SHA3 digests are up to 27% faster by reducing conversions between &lt;code&gt;byte&lt;/code&gt; and &lt;code&gt;long&lt;/code&gt; arrays; and internal migrations to the new Class-File API have been tuned to minimize startup overhead.&lt;/p&gt;
&lt;p&gt;At the runtime layer, JEP 491 allows virtual threads blocked inside a &lt;code&gt;synchronized&lt;/code&gt; block to unmount from their carrier thread rather than pinning it, significantly improving scalability for code that uses &lt;code&gt;synchronized&lt;/code&gt;. &lt;code&gt;String::indexOf&lt;/code&gt; is roughly 1.3x faster on x64 platforms with AVX2. JEP 483 (Ahead-of-Time Class Loading &amp;amp; Linking), the first deliverable from Project Leyden, uses an AOT cache to cut startup time by around 42% in the article&amp;rsquo;s benchmark. JEP 450 introduces experimental 8-byte compact object headers, reducing memory footprint by 10–20% on typical workloads. Finally, the RISC-V port gained several new intrinsics including CRC32, Adler32, string comparison optimizations, and byte-reversal operations.&lt;/p&gt;
&lt;h2 id="clean-your-memory-from-finalize-to-cleaner"&gt;&lt;a href="https://blog.frankel.ch/java-cleaner/" rel="noopener noreferrer"&gt;Clean your Memory: From Finalize to Cleaner&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago explains that Java&amp;rsquo;s garbage collector (GC) only manages heap memory and does not automatically release external resources like sockets or file handles; mismanaging them can lead to resource leaks, gradual slowdowns, or crashes. The old approach was overriding &lt;code&gt;finalize()&lt;/code&gt;, which has been deprecated because its execution timing is unpredictable, objects require at least one extra GC cycle to be reclaimed, accidental object resurrection can cause leaks, and the dedicated Finalizer thread is prone to contention. Its replacement is the &lt;code&gt;Cleaner&lt;/code&gt; API, introduced in Java 9: under the hood, it uses &lt;code&gt;PhantomReference&lt;/code&gt; and a background daemon thread while hiding the complexity of raw reference queues. You register an object alongside a cleanup action, and once the object becomes phantom-reachable, that action is enqueued to run on the background thread.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Cleaner&lt;/code&gt; pairs well with &lt;code&gt;AutoCloseable&lt;/code&gt;: the &lt;code&gt;close()&lt;/code&gt; method invokes &lt;code&gt;clean()&lt;/code&gt; for immediate deterministic cleanup, while the &lt;code&gt;Cleaner&lt;/code&gt; acts as a safety net. Even so, Fago stresses that &lt;code&gt;Cleaner&lt;/code&gt; should only be a fallback when resources cannot be released via &lt;code&gt;try-with-resources&lt;/code&gt; or an explicit &lt;code&gt;close()&lt;/code&gt; call, since cleanup is asynchronous and carries background-thread overhead. When writing a cleanup action, avoid lambdas that capture fields through &lt;code&gt;this&lt;/code&gt;, as doing so accidentally keeps a strong reference to the very object you want collected; cleanup logic should also be short and non-blocking, since multiple actions may share the same &lt;code&gt;Cleaner&lt;/code&gt; thread pool.&lt;/p&gt;
&lt;h2 id="5-hidden-git-tips-for-java-developers"&gt;&lt;a href="https://www.azul.com/blog/5-hidden-git-tips-for-java-developers/" rel="noopener noreferrer"&gt;5 Hidden Git Tips for Java Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On the Azul blog, Luqman Saeed walks through five underappreciated Git features beyond the everyday &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; trio, with examples tailored to Java projects. First is &lt;code&gt;git bisect&lt;/code&gt;: when you don&amp;rsquo;t know which commit introduced a bug, you mark the current commit as bad (&lt;code&gt;git bisect bad&lt;/code&gt;) and an older working commit as good (&lt;code&gt;git bisect good &amp;lt;commit-hash&amp;gt;&lt;/code&gt;), and Git performs a binary search by checking out midpoint commits for you to test until the culprit is found, finishing with &lt;code&gt;git bisect reset&lt;/code&gt;. Next, &lt;code&gt;git blame &amp;lt;file&amp;gt;&lt;/code&gt; shows who last modified each line and when (pass &lt;code&gt;-L 50,60&lt;/code&gt; to inspect a specific line range), giving you helpful context before debugging or refactoring. When you need to switch tasks mid-flight, &lt;code&gt;git stash&lt;/code&gt; shelves uncommitted changes and &lt;code&gt;git stash pop&lt;/code&gt; restores them; &lt;code&gt;git stash list&lt;/code&gt; and &lt;code&gt;git stash apply &amp;lt;stash-id&amp;gt;&lt;/code&gt; let you manage multiple stashes.&lt;/p&gt;
&lt;p&gt;For temporary build artifacts generated by Maven or Gradle like &lt;code&gt;.class&lt;/code&gt; files or the &lt;code&gt;target/&lt;/code&gt; directory, &lt;code&gt;git clean -n&lt;/code&gt; previews what would be deleted, &lt;code&gt;-f&lt;/code&gt; removes untracked files, &lt;code&gt;-fd&lt;/code&gt; removes untracked directories as well, and &lt;code&gt;-x&lt;/code&gt; also deletes ignored files such as &lt;code&gt;.idea/&lt;/code&gt;. Finally, Git hooks are scripts that run automatically before or after events like commits, pushes, or merges—for example, a &lt;code&gt;pre-commit&lt;/code&gt; hook in &lt;code&gt;.git/hooks&lt;/code&gt; can run &lt;code&gt;mvn test&lt;/code&gt; and abort the commit if tests fail. As a bonus tip, &lt;code&gt;git checkout -&lt;/code&gt; jumps straight back to the previous branch you were working on without retyping its name, saving time and avoiding typos.&lt;/p&gt;
&lt;h2 id="simplify-your-system-by-challenging-the-status-quo-and-learning-from-other-ecosystems"&gt;&lt;a href="https://www.infoq.com/podcasts/simplify-system-learning-ecosystems/" rel="noopener noreferrer"&gt;Simplify Your System by Challenging the Status-Quo and Learning from Other Ecosystems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this InfoQ podcast, Max Rydahl Andersen—Distinguished Engineer at Red Hat and creator of JBang—recounts how taking a year away from Java helped him see upon returning that the ecosystem had accumulated too much accidental complexity, like &amp;ldquo;a thousand paper cuts&amp;rdquo;: each small feature is useful on its own, but together they become a burden. Quarkus, which he works on, flips traditional Java conventions by shifting most framework processing from runtime to build time, enabling near-instant startup. That speed unlocks a much better developer experience: live reload, continuous testing, Dev Services that automatically spin up containers like PostgreSQL or Kafka, and an interactive chat UI for testing AI services via LangChain4j right inside the Dev UI.&lt;/p&gt;
&lt;p&gt;With JBang, he drew inspiration from Python and Node.js to let developers run Java from a single source file—even downloading a JDK automatically if none is installed; he jokes that if you find any development environment easier to set up, that&amp;rsquo;s a bug in JBang. Andersen also argues that AI cannot replace core software engineering fundamentals and systems thinking, and warns that AI will accelerate CVE exploitation, meaning legacy systems will need much more frequent patching. The overarching takeaway: challenge the status quo and borrow good ideas from other ecosystems to keep systems simple.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/03/24/about-vibe-coding/" rel="noopener noreferrer"&gt;About &amp;ldquo;vibe coding&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea writes a brief reflection on &amp;ldquo;vibe coding&amp;rdquo;—the trend of letting AI write code in place of the developer. After reading &amp;ldquo;Vibe Coding vs Reality,&amp;rdquo; he was relieved to see he wasn&amp;rsquo;t the only skeptic, recounting his own attempt to use Cursor on a Java Maven project where the tool couldn&amp;rsquo;t even rename a class properly: first it renamed the class declaration without renaming the file, and when asked to fix it, it created an empty file with the new name—twice in a row.&lt;/p&gt;
&lt;p&gt;When he shared the experience on Hacker News, the replies were mostly along the lines of &amp;ldquo;haha Java,&amp;rdquo; leaving him wondering whether Cursor was only trained on trendy frontend frameworks or whether its vocal fans simply don&amp;rsquo;t care about real-world enterprise codebases. He ended up uninstalling Cursor and feeling even more skeptical of &amp;ldquo;magical&amp;rdquo; AI coding tools, though he leaves the door open: &amp;ldquo;Next year though? Next year we&amp;rsquo;ll see.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="visual-focused-algorithms-cheat-sheet"&gt;&lt;a href="https://photonlines.substack.com/p/visual-focused-algorithms-cheat-sheet" rel="noopener noreferrer"&gt;Visual-Focused Algorithms Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nick M compiles a visual-first cheat sheet of essential algorithms used in practice, following up on his earlier data structures cheat sheet; each algorithm is explained through everyday analogies and diagrams. The sorting section progresses from Selection Sort and Insertion Sort—simple but O(n²)—to Heap Sort and Merge Sort at O(n log n), Quick Sort with an O(n log n) average case and O(n²) worst case, and Tim Sort, the hybrid of Insertion Sort and Merge Sort used in Python and Java. Searching covers Binary Search at O(log n) alongside DFS and BFS for depth-first and breadth-first graph traversal. The graph section walks through Prim&amp;rsquo;s and Kruskal&amp;rsquo;s algorithms for minimum spanning trees, Dijkstra&amp;rsquo;s and Bellman-Ford for shortest paths (with Bellman-Ford handling negative edge weights), A* using heuristics, plus Union-Find and Ford-Fulkerson.&lt;/p&gt;
&lt;p&gt;Later sections cover string search, data compression and encoding (Huffman coding, LZ compression, Fourier transforms, JPEG compression), optimization (Simplex, Simulated Annealing), machine learning and data science, and security and cryptography algorithms. The post wraps up with coding interview resources like &amp;ldquo;14 Patterns to Ace Any Coding Interview&amp;rdquo; and &amp;ldquo;5 Simple Steps for Solving Dynamic Programming Problems,&amp;rdquo; making it a handy reference for junior developers preparing for interviews.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/81074d22-5821-4aec-bb2d-0a099d06b6ac_1600x840.png" alt="3 Steps to Master Your Software"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/67c39b9a-9a91-4e57-9e24-7714b4f806dd_1280x1349.gif" alt="The Ultimate Software Architect Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fb1b1cd1-eac3-4b66-a391-9ec73f6c37f3_1280x1502.gif" alt="How Two-factor Authentication (2FA) Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3efae3ad-8c45-4fb2-a79f-6b3387b0751e_1280x1601.gif" alt="How Amazon S3 Works?"&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 #14</title><link>https://miti99.com/en/post/2025/04/30/</link><pubDate>Wed, 30 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/30/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #14.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="bloom-filter-a-deep-dive"&gt;&lt;a href="https://www.kirupa.com/data_structures_algorithms/bloom_filter.htm" rel="noopener noreferrer"&gt;Bloom Filter: A Deep Dive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kirupa Chinnathambi explains Bloom filters through a classic real-world problem: checking whether a username is already taken during sign-up on a social network with tens of millions of users. Scanning the database on every keystroke is too slow, while keeping every username string in an in-memory hash table eats up too much RAM. A Bloom filter sits in front of the database as a compact probabilistic gatekeeper: instead of storing the strings themselves, it stores bit &amp;ldquo;fingerprints&amp;rdquo; inside a fixed-size bit array. Each inserted item is run through $k$ independent hash functions, each mapping to an index in the array whose bit is flipped to &lt;code&gt;1&lt;/code&gt;. On lookup, if even a single one of those $k$ bits is &lt;code&gt;0&lt;/code&gt;, the item is guaranteed &lt;em&gt;not&lt;/em&gt; to exist; if all $k$ bits are &lt;code&gt;1&lt;/code&gt;, the item &lt;em&gt;might&lt;/em&gt; exist and you fall back to a database query, because other items may have happened to set those same bits (a false positive).&lt;/p&gt;
&lt;p&gt;The second half walks through the formulas for picking the optimal bit-array size $m$ and number of hash functions $k$ given an expected item count $n$ and target false-positive rate $p$. For 10 million usernames at a 1% false-positive rate ($p = 0.01$), a Bloom filter needs only about 95.85 million bits (~12 MB) and 7 hash functions—whereas an equivalent in-memory hash table would consume 160 MB to 240 MB, or 13x to 20x more memory. Trading a tiny, tunable chance of an extra database lookup for massive memory savings makes the Bloom filter one of the most practical probabilistic data structures in systems engineering.&lt;/p&gt;
&lt;h2 id="rethinking-llm-inference-why-developer-ai-needs-a-different-approach"&gt;&lt;a href="https://www.augmentcode.com/blog/rethinking-llm-inference-why-developer-ai-needs-a-different-approach" rel="noopener noreferrer"&gt;Rethinking LLM inference: Why developer AI needs a different approach&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Augment Code explains why AI coding assistants demand a fundamentally different LLM inference architecture than consumer chatbots: repository-aware coding requires feeding tens of thousands of tokens of codebase context into the model, and suggestion quality keeps climbing well past 10,000 input tokens. Unlike chat workloads (roughly ~100 input tokens to generate hundreds of output tokens), developer AI workloads are heavily &lt;strong&gt;prefill-dominated&lt;/strong&gt;—thousands of context tokens in, only a few dozen completion tokens out—whereas off-the-shelf engines like vLLM and TensorRT-LLM are tuned primarily for decode-heavy workloads. Because of this, Augment optimizes ruthlessly for prefill throughput and time-to-first-token (TTFT). After showing why single-token autoregressive decoding leaves GPUs below 1% compute utilization (memory-bandwidth bound), the post explains &lt;strong&gt;token-level batching&lt;/strong&gt; (known in academia as &lt;em&gt;chunked prefill&lt;/em&gt;), where lightweight decode steps &amp;ldquo;piggyback&amp;rdquo; onto another request&amp;rsquo;s compute-bound prefill batch, sized right at the ridge point between memory-bandwidth bound and FLOPS bound.&lt;/p&gt;
&lt;p&gt;The article also details production systems requirements like reliable request cancellation as a developer types rapidly, alongside low-level GPU optimizations: CUDA Graphs to eliminate CPU launch overhead, FP8 quantization, FlashAttention-3, and custom fused CUDA kernels. Together, these optimizations deliver a time-to-first-token under 300ms for a 10,000-token prompt on Llama 3 70B—a 3x speedup—while sustaining nearly 10 requests per second across an 8x H100 node. It&amp;rsquo;s a great case study in why LLM inference tuning has to match the exact input/output shape of your application.&lt;/p&gt;
&lt;h2 id="floyds-cycle-algorithm-fraud-detection-in-java-systems"&gt;&lt;a href="https://dzone.com/articles/floyds-cycle-algorithm-fraud-detection-java-systems" rel="noopener noreferrer"&gt;Floyd’s Cycle Algorithm: Fraud Detection in Java Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DZone article illustrates how Floyd&amp;rsquo;s Cycle-Finding Algorithm (the &amp;ldquo;tortoise and the hare&amp;rdquo;) can be applied to spot circular money transfers in banking systems. Bank accounts are modeled as vertices and wire transfers as directed edges in a graph; a loop like &lt;code&gt;A → B → C → D → B&lt;/code&gt; forms a cycle, a classic pattern in money laundering (&amp;ldquo;round-tripping&amp;rdquo;) used to obscure the origin of funds. Floyd&amp;rsquo;s algorithm advances two pointers through the sequence—a slow pointer moving one step at a time and a fast pointer moving two steps at a time; if a cycle exists, the two pointers are guaranteed to meet inside the loop. The Java walkthrough provides a &lt;code&gt;TransactionGraph&lt;/code&gt; backed by a &lt;code&gt;HashMap&lt;/code&gt; adjacency list, a &lt;code&gt;FraudDetection&lt;/code&gt; cycle checker, and a test harness with sample transfer data.&lt;/p&gt;
&lt;p&gt;The appeal of Floyd&amp;rsquo;s algorithm is its simplicity, $O(N)$ time complexity, and $O(1)$ auxiliary memory footprint, making it attractive for lightweight real-time checks. However, an important caveat applies: Floyd&amp;rsquo;s tortoise-and-hare algorithm assumes each node has at most &lt;em&gt;one&lt;/em&gt; outgoing edge (a functional graph or linked list). In a general transaction graph where an account sends money to multiple recipients, following only a single outgoing edge per node can miss cycles on other branches—meaning full Depth-First Search (DFS) or Johnson&amp;rsquo;s/Tarjan&amp;rsquo;s strongly connected components algorithms are needed for general multi-branch graphs, and any detected cycle is merely a heuristic flag for deeper investigation rather than proof of fraud on its own. The post also notes applications in network routing loop detection, DNA motif analysis, ML pipelines, and blockchain transaction graphs.&lt;/p&gt;
&lt;h2 id="succinct-data-structures"&gt;&lt;a href="https://blog.startifact.com/posts/succinct/" rel="noopener noreferrer"&gt;Succinct data structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martijn Faassen introduces &lt;strong&gt;succinct data structures&lt;/strong&gt;—a family of data structures he was delighted to discover. Like compression algorithms, they store data in space close to the information-theoretic minimum; unlike standard compression, however, you don&amp;rsquo;t need to decompress them before use—you can run fast queries directly on the compact representation. The foundational building block is a bitvector supporting two constant-time ($O(1)$) operations with tiny memory overhead: &lt;code&gt;rank&lt;/code&gt; (count how many &lt;code&gt;1&lt;/code&gt; bits appear up to index $i$) and &lt;code&gt;select&lt;/code&gt; (find the index of the $n$-th &lt;code&gt;1&lt;/code&gt; bit). From that primitive, a &lt;strong&gt;Wavelet Matrix&lt;/strong&gt; generalizes &lt;code&gt;rank&lt;/code&gt; and &lt;code&gt;select&lt;/code&gt; to larger alphabets like DNA bases or 256-byte text; an &lt;strong&gt;FM-index&lt;/strong&gt; enables compact full-text search that counts and locates substrings rapidly (widely used in bioinformatics); and &lt;strong&gt;balanced parentheses&lt;/strong&gt; bitvectors encode arbitrary trees using just &lt;em&gt;2 bits per node&lt;/em&gt; instead of bulky 64-bit pointers while still supporting fast navigation to parent, child, and sibling nodes.&lt;/p&gt;
&lt;p&gt;Faassen walks through an XML querying prototype he built by combining a balanced-parentheses tree with sparse bitvectors to jump straight to elements matching a specific tag name, and sketches how the same trick could shrink compiler ASTs in memory. He closes with pointers to Rust crates in this space, including &lt;code&gt;vers&lt;/code&gt; (blazing fast with minimal overhead), &lt;code&gt;sucds&lt;/code&gt; (offering sparse bitvectors like &lt;code&gt;SArray&lt;/code&gt;), and &lt;code&gt;fm-index&lt;/code&gt;. Though still relatively niche outside bioinformatics, succinct data structures hold huge promise anywhere fitting a working set into CPU cache or RAM is the key to speed.&lt;/p&gt;
&lt;h2 id="the-art-of-engineering-team-focus-less-is-more"&gt;&lt;a href="https://github.com/resources/insights/engineering-team-focus" rel="noopener noreferrer"&gt;The art of engineering team focus: less is more&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub Resources piece makes a counterintuitive case: if you want your engineering team to ship &lt;em&gt;more&lt;/em&gt;, they need to work on &lt;em&gt;fewer&lt;/em&gt; things at the same time. Unshipped work delivers zero value to users, yet leaders often struggle to say &amp;ldquo;no&amp;rdquo; to stakeholders, slicing the team across half a dozen parallel initiatives under the illusion that everything is moving forward. The antidote starts with making all work visible so leadership confronts the team&amp;rsquo;s true capacity and actively kills or pauses lower-priority tracks; breaking projects into 1–2 week milestones to keep momentum high, shrink pull requests, de-risk deployments, and create natural pivot points; and strictly limiting Work in Progress (WIP), since every context switch can cost up to 23 minutes to regain deep focus while driving up bug rates and burnout.&lt;/p&gt;
&lt;p&gt;The author goes further and recommends &amp;ldquo;stacking&amp;rdquo; engineers onto the single highest-priority initiative until adding another person would literally cause them to trip over one another, and only then staffing the #2 priority. Finally, never plan a team to 100% utilization—leave roughly a 20% capacity buffer to absorb unexpected bugs and production interrupts, because a highway at 100% capacity is a parking lot. Teams with slack in the system consistently ship faster, innovate more, and burn out less.&lt;/p&gt;
&lt;h2 id="performance-optimization-and-how-to-do-it-wrong"&gt;&lt;a href="https://genna.win/blog/convolution-simd/" rel="noopener noreferrer"&gt;Performance optimization, and how to do it wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author, a contributor to the Rust &lt;code&gt;burn&lt;/code&gt; machine learning framework, shares a humbling war story about optimizing direct 2D CPU convolution using SIMD intrinsics. Even after implementing an academic paper&amp;rsquo;s optimal loop ordering and register blocking scheme, the new SIMD kernel ran more than &lt;em&gt;twice as slow&lt;/em&gt; as the naive baseline. Standard profilers like &lt;code&gt;cargo-flamegraph&lt;/code&gt;, &lt;code&gt;samply&lt;/code&gt;, and AMD μProf couldn&amp;rsquo;t pinpoint why, forcing the author to strip the kernel down piece by piece to isolate the regression. The culprits turned out to be a combination of &lt;strong&gt;SIMD register spilling&lt;/strong&gt; (x86 AVX2 provides only 16 YMM registers) and &lt;strong&gt;excessive branching inside the hot inner loop&lt;/strong&gt; to handle boundary padding. Splitting the loop into a branchless fast path for interior pixels and a separate edge path—plus using compile-time monomorphization (const generics) to specialize common cases like zero padding or stride 1—brought massive speedups.&lt;/p&gt;
&lt;p&gt;The biggest plot twist came from the Rust compiler itself: adding one more specialized branch pushed the outer function past LLVM&amp;rsquo;s inlining size threshold, causing the compiler to stop inlining the inner SIMD routines and tanking performance all over again. Adding &lt;code&gt;#[inline(always)]&lt;/code&gt; to the top-level functions immediately restored the speedup. It&amp;rsquo;s a classic lesson in low-level optimization: measure everything, understand your hardware&amp;rsquo;s register file, and never assume the compiler is doing what you think it&amp;rsquo;s doing.&lt;/p&gt;
&lt;h2 id="supercharging-discord-mobile-our-journey-to-a-faster-app"&gt;&lt;a href="https://discord.com/blog/supercharging-discord-mobile-our-journey-to-a-faster-app" rel="noopener noreferrer"&gt;Supercharging Discord Mobile: Our Journey to a Faster App&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord shares a sweeping set of mobile performance improvements for their React Native app, aimed especially at power users in hundreds of servers. First, they virtualized the server list so only on-screen server icons stay mounted in memory, cutting startup memory usage by 14% and cold-start time by 10% for users in 100+ servers. For the chat message list (already a native component), they overhauled view recycling, lazily initialized rarely used message attachments, and pre-populated the recycle pool at startup with common row types—reducing slow frames by up to 60% and trimming memory by ~12%. On Android, they rewrote the emoji picker completely in native Kotlin views to eliminate blank white flashes during fast fling scrolls on budget devices, and switched animated emojis from GIF to WebP to hit a smooth 60 FPS.&lt;/p&gt;
&lt;p&gt;For the channel list, the team actually migrated &lt;em&gt;back&lt;/em&gt; from Shopify&amp;rsquo;s &lt;code&gt;FlashList&lt;/code&gt; to their own in-house &lt;code&gt;FastList&lt;/code&gt; after finding that &lt;code&gt;FlashList&lt;/code&gt; frequently rendered blank cells on low-end Android phones, and went on to build &lt;code&gt;FastestList&lt;/code&gt; backed by Android&amp;rsquo;s native &lt;code&gt;RecyclerView&lt;/code&gt;. On iOS, the media picker now displays a fast low-resolution thumbnail first while streaming in the high-res asset and requests 256×256 previews to hit Apple PhotoKit&amp;rsquo;s fast system cache, eliminating a 4.5-second freeze when opening large camera rolls. Looking ahead to 2025, Discord plans to enable React Native&amp;rsquo;s New Architecture, experiment with Static Hermes, and move core client state logic to Rust.&lt;/p&gt;
&lt;h2 id="git-without-a-forge"&gt;&lt;a href="https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/git-no-forge/" rel="noopener noreferrer"&gt;Git without a forge&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Tatham, creator of PuTTY, explains why he still hosts his open-source projects on plain bare Git repositories on his own server rather than moving to a web forge like GitHub or GitLab. He trusts machines administered by friends more than corporate platforms whose ownership and policies can shift overnight; he has no desire to sysadmin a heavy self-hosted forge instance himself; he dislikes how forges bake in rigid opinions about issue tracking and pull-request workflows; he doesn&amp;rsquo;t want to force drive-by contributors to register yet another web account just to send a patch; and he worries about platform lock-in trapping years of issue and PR discussions outside the Git repository itself. He also candidly admits that sheer inertia plays a part.&lt;/p&gt;
&lt;p&gt;In the second half, Tatham ranks ways contributors can send him patches without a forge, from best to worst: sending a public Git repo URL and branch name he can &lt;code&gt;git fetch&lt;/code&gt; directly (giving all the benefits of a pull request with zero forge lock-in), emailing a &lt;code&gt;git bundle&lt;/code&gt; binary file containing the exact commits, attaching files generated by &lt;code&gt;git format-patch&lt;/code&gt;, sending a raw &lt;code&gt;git diff&lt;/code&gt; (which loses commit messages and base-commit metadata), and dead last, &lt;code&gt;git send-email&lt;/code&gt;, which turns a patch series into a burst of separate emails he has to reassemble by hand. While he acknowledges that public forges help newcomers gauge how welcoming a project is from past PR threads, he remains holding out for a lightweight, decentralized code-review protocol that keeps discussion portable.&lt;/p&gt;
&lt;h2 id="40-thoughts-on-turning-40"&gt;&lt;a href="https://newsletter.pathlesspath.com/p/40-thoughts-on-turning-40-287" rel="noopener noreferrer"&gt;40 Thoughts On Turning 40&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Millerd, author of &lt;em&gt;The Pathless Path&lt;/em&gt;, shares 40 reflections on turning 40, spanning reinvention, work, money, relationships, fatherhood, and happiness. Looking back, he considers walking away from a conventional high-status consulting career into uncertainty the defining decision of his 30s, noting that real personal transformation is slow, messy, and gradual rather than a single cinematic epiphany. On work, he argues that the FIRE movement&amp;rsquo;s dream of &amp;ldquo;escaping work&amp;rdquo; through early retirement misses the point: you don&amp;rsquo;t transcend work by avoiding it, you transcend it by finding &lt;strong&gt;good work&lt;/strong&gt;—work that feels meaningful both in the moment and in hindsight. Everyone should try freelancing or self-employment for at least a year, he suggests, adding that taking a steep pay cut after quitting his corporate job was the fastest way to discover what he actually valued.&lt;/p&gt;
&lt;p&gt;On life outside work, he reflects on how lucky he feels to have met his wife and encourages anyone still looking for a partner not to give up, while calling fatherhood the most humbling experience of his life. His closing thoughts are pithy reminders: following breaking news has never made anyone happier, deep rest is a skill that takes practice, &amp;ldquo;doing less&amp;rdquo; is the most underrated way to get unstuck, and writing in public remains one of the most powerful forces for personal clarity—even if it forces you to confront what you truly want.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/f7fc4f19-ebd8-45a0-9398-469805bb4a26_1280x1532.gif" alt="A Cheatsheet on Comparing Key-Value Stores"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/16fe4308-ed47-451f-a852-c476ecfb4167_1280x1977.jpeg" alt="A Handy Cheatsheet for the Most Popular Cloud Services"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/89a09e07-6548-4c12-87c6-0486c6177ea7_1308x1536.jpeg" alt="Which Database Should I Use on AWS?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=hFURlsMwU7c" rel="noopener noreferrer"&gt;What Is the Most Popular Open-Source AI Stack?&lt;/a&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 #10</title><link>https://miti99.com/en/post/2025/04/05/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #10.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="gaining-years-of-experience-in-a-few-months"&gt;&lt;a href="https://marcgg.com/blog/2025/02/11/high-growth/" rel="noopener noreferrer"&gt;Gaining Years of Experience in a Few Months&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G. Gauthier, former VP of Engineering at Drivy, reflects on uneven learning curves in a career: those rare, intense stretches where you absorb so much so quickly that a few months feel like years of experience. For him, that moment came when Drivy was acquired by Getaround in 2019, forcing him to juggle technical, architectural, communication, management, business, and product challenges simultaneously under high stakes and tight deadlines. He distinguishes this from merely &amp;ldquo;stepping outside your comfort zone&amp;rdquo;: it pushes well past your current capabilities, carries a real risk of failure, and is impossible to sustain indefinitely.&lt;/p&gt;
&lt;p&gt;To frame this, he divides work into four zones: the &lt;strong&gt;Comfort Zone&lt;/strong&gt; (safe, but staying too long leads to stagnation), the &lt;strong&gt;Learning Zone&lt;/strong&gt; (healthy stretch challenges where you should spend most of your career), the &lt;strong&gt;High Growth Zone&lt;/strong&gt; (compressing years of growth into months, unsustainable and not always available on demand), and the &lt;strong&gt;Burnout Zone&lt;/strong&gt; if you stay in high growth too long. He sketches healthy career trajectories that alternate between the Learning and High Growth zones, or use the Comfort Zone briefly to recover after an intense sprint before returning to the Learning Zone. His closing advice: when a rare High Growth opportunity comes along, lean in and make the most of it—but watch your health closely, because none of the career gains matter if you burn out.&lt;/p&gt;
&lt;h2 id="writing-better-commit-messages"&gt;&lt;a href="https://refactoringenglish.com/chapters/commit-messages/" rel="noopener noreferrer"&gt;Writing Better Commit Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this chapter from &lt;em&gt;Refactoring English&lt;/em&gt;, Michael Lynch argues that commit messages are routinely treated as an afterthought, resulting in useless one-liners like &lt;code&gt;&amp;quot;Fix bug&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;Update UI&amp;quot;&lt;/code&gt;. The most important reader of a commit message, he notes, is your code reviewer—followed by teammates, library consumers, future bug investigators, and automated release-note generators. Because of that, you should structure commit messages like a journalist&amp;rsquo;s &amp;ldquo;inverted pyramid,&amp;rdquo; putting the most essential context right at the top and using section headings to break up longer messages.&lt;/p&gt;
&lt;p&gt;The subject line is the most critical piece because it&amp;rsquo;s what shows up in &lt;code&gt;git log --oneline&lt;/code&gt; and GitHub&amp;rsquo;s commit history view; it should describe the &lt;em&gt;impact&lt;/em&gt; of the change (e.g., &lt;code&gt;&amp;quot;Prevent database corruption when users register concurrently&amp;quot;&lt;/code&gt;) rather than the mechanics of the code edit. The body should explain how the change affects end users and, above all, the &lt;em&gt;motivation&lt;/em&gt;: why the change was needed and what constraints shaped the chosen solution. Depending on the situation, you can include breaking-change notices, non-obvious reference links, reasons for adding a new dependency, issue tracker links, testing instructions and limitations, and alternatives considered. Conversely, leave out anything already obvious from the diff, ephemeral review chatter, and temporary preview URLs—and remember that anything essential for ongoing code maintenance belongs in code comments, not buried in commit history.&lt;/p&gt;
&lt;h2 id="the-rotation-program-that-keeps-this-startup"&gt;&lt;a href="https://review.firstround.com/the-rotation-program-that-keeps-this-startups-engineers-learning-and-not-leaving/" rel="noopener noreferrer"&gt;The Rotation Program That Keeps This Startup&amp;rsquo;s Engineers Learning — and Not Leaving&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This First Round Review interview with Krista Moroder, VP of Engineering at Checkr, tells the story of an internal rotation program that drove voluntary attrition in her org down to nearly zero. A former high school teacher, Moroder borrowed an exercise from the faculty lounge: putting stickers next to the names of students who had a strong adult connection at school to spot which kids were falling through the cracks. She adapted that idea into a spreadsheet tracking every engineer, observing that when engineers leave after two or three years, it&amp;rsquo;s usually not just about equity vesting—it&amp;rsquo;s because they stopped learning and got bored, a restlessness only amplified by anxiety over falling behind in the AI wave.&lt;/p&gt;
&lt;p&gt;The program runs in three steps: maintaining a &amp;ldquo;sticker chart&amp;rdquo; spreadsheet with three columns (joined a rotation or cross-functional tiger team, worked on multiple teams, or received training for a new role) with the goal that every engineer has at least one box checked before their third anniversary; matching that list against quarterly company priorities to rotate engineers where they&amp;rsquo;re needed; and holding deliberate check-ins before making any transfer permanent. Roughly half of all rotations end with the engineer staying on the new team permanently, and one temporary AI tiger team evolved into a permanent core team. To persuade managers to let their top performers rotate out, she argues that having an &amp;ldquo;indispensable&amp;rdquo; single point of failure is actually a succession-planning bug, and that the whole engineering org needs to get an A together. The result: roughly 60% of Checkr&amp;rsquo;s Staff+ engineers have been with the company for six years or more.&lt;/p&gt;
&lt;h2 id="judge-your-coworkers"&gt;&lt;a href="https://blog.staysaasy.com/p/judge-your-coworkers" rel="noopener noreferrer"&gt;Judge Your Coworkers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Stay SaaSy post warns against a cultural failure mode the author calls &lt;strong&gt;Mutually Assured Mediocrity&lt;/strong&gt;: when everyone is performing at a mediocre level, they form an unspoken pact never to criticize one another out of fear that their own weaknesses will be exposed in return. The post traces how this creeps in as a company grows: new departments form, &amp;ldquo;you don&amp;rsquo;t understand our job, stay in your lane&amp;rdquo; becomes a defensive shield, leaders avoid holding peers accountable to avoid being judged themselves, and eventually the few people who dare to point out real problems get punished as troublemakers.&lt;/p&gt;
&lt;p&gt;To counter this, the author advocates encouraging employees to form healthy judgments about their coworkers&amp;rsquo; work, governed by three ground rules: never criticize peers publicly—share feedback only privately with your direct manager or in formal peer reviews; keep performance management strictly confidential; and remind everyone that nobody is promised flawless coworkers. Managers should explicitly tell reports early on that they are expected to have opinions on their collaborators&amp;rsquo; effectiveness, and check in on those opinions every 6–12 months. When a report praises someone, it&amp;rsquo;s a coaching moment to calibrate what great work looks like across seniority levels; when they complain, it surfaces hidden performance issues or role misunderstandings early (for example, mistaking a product manager for a project manager). The closing message: failing to hold people accountable is one of the worst disservices a company can do to its employees, and tech has pushed &amp;ldquo;blameless&amp;rdquo; culture way too far.&lt;/p&gt;
&lt;h2 id="my-llm-codegen-workflow-atm"&gt;&lt;a href="https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/" rel="noopener noreferrer"&gt;My LLM Codegen Workflow ATM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Harper Reed shares his current workflow for building software with LLMs, distilled into three stages: hone an idea into a spec, generate an execution plan, and execute in tight loops. For greenfield projects, he has a conversational model interview him one question at a time to turn a rough idea into a detailed &lt;code&gt;spec.md&lt;/code&gt;; next, he feeds that spec to a reasoning model to break it down into incremental steps—each written as a self-contained prompt for a coding agent—saved as &lt;code&gt;prompt_plan.md&lt;/code&gt; alongside a &lt;code&gt;todo.md&lt;/code&gt; checklist to preserve state across sessions. The entire planning phase takes about 15 minutes. For execution, he prefers Claude directly or Aider: paste a prompt, run the test suite, commit if green, or pack the codebase with &lt;code&gt;repomix&lt;/code&gt; and hand it back to the model to debug if red.&lt;/p&gt;
&lt;p&gt;For existing codebases, he pairs &lt;code&gt;repomix&lt;/code&gt; with &lt;code&gt;mise&lt;/code&gt; tasks to bundle repository context, then uses targeted prompts to review code, file GitHub issues, or identify missing test coverage. He admits it&amp;rsquo;s easy to get &amp;ldquo;out over your skis&amp;rdquo; when code is flying by that fast, which is why upfront planning and automated tests are non-negotiable guardrails. He also notes that these workflows are still largely single-player rather than team-friendly, and shares how he uses the idle minutes while waiting on model inference—often by kicking off the spec for the &lt;em&gt;next&lt;/em&gt; project.&lt;/p&gt;
&lt;h2 id="structured-logging-in-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/structured-logging-in-spring-boot.html" rel="noopener noreferrer"&gt;Structured Logging in Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yatin Batra&amp;rsquo;s tutorial on Java Code Geeks walks through setting up structured logging in Spring Boot. Unlike the plain-text log lines Logback emits by default, structured logging formats entries as machine-parseable JSON, making it far easier for log aggregation platforms like the ELK stack or Grafana Loki to parse, search, and filter events. The author shows how to add the &lt;code&gt;logstash-logback-encoder&lt;/code&gt; dependency to &lt;code&gt;pom.xml&lt;/code&gt;, configure &lt;code&gt;logback-spring.xml&lt;/code&gt; under &lt;code&gt;src/main/resources&lt;/code&gt;, and inspect the resulting JSON output from a sample application.&lt;/p&gt;
&lt;p&gt;Moving to advanced topics, the post covers injecting custom contextual fields via MDC (Mapped Diagnostic Context)—such as attaching a &lt;code&gt;userId&lt;/code&gt; to every log event—shipping logs to Logstash, and configuring Promtail to scrape and forward logs into Loki. Finally, the author introduces two standardized schemas: Elastic Common Schema (ECS) for unifying field names across the Elastic ecosystem, and Graylog Extended Log Format (GELF) for shipping structured logs to Graylog, comparing their core fields and trade-offs. This setup is essential for cloud-native deployments where centralized observability is a must.&lt;/p&gt;
&lt;h2 id="secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency"&gt;&lt;a href="https://gainjavaknowledge.medium.com/secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency-8253d57d692b" rel="noopener noreferrer"&gt;Secret Java Stream Hacks That Will Instantly Improve Your Coding Efficiency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Medium post by Gain Java Knowledge highlights several lesser-known Java Stream API tricks for writing cleaner, more expressive pipelines. A standout is &lt;code&gt;Collectors.teeing()&lt;/code&gt;, which lets you pipe a single stream through two separate collectors simultaneously and merge their results—for example, computing both the sum and the average in a single pass instead of iterating twice. The post also covers &lt;code&gt;takeWhile()&lt;/code&gt; (taking elements until a predicate turns false) and &lt;code&gt;dropWhile()&lt;/code&gt; (skipping elements while a predicate remains true) for concise short-circuiting stream slicing.&lt;/p&gt;
&lt;p&gt;Beyond those operators, the author touches on parallel streams, memory efficiency, handling checked exceptions cleanly inside lambdas, and composing multi-stage collectors. Practical tips include picking the most specific collector for the job, avoiding side effects inside stream operations, preferring method references over verbose lambdas where readable, and keeping pipelines short enough to scan easily. Understanding lazy evaluation is also key when weighing stream performance on large datasets.&lt;/p&gt;
&lt;h2 id="death-of-a-thousand-nits-code-review-best-practices"&gt;&lt;a href="https://bitfieldconsulting.com/posts/code-review" rel="noopener noreferrer"&gt;Death of a Thousand Nits: Code Review Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an excerpt from his book &lt;em&gt;Code For Your Life&lt;/em&gt;, John Arundel explores how to make code reviews less adversarial and genuinely useful. His number-one recommendation is &lt;strong&gt;pair reviewing&lt;/strong&gt;: instead of trading walls of text in pull request comments, hop on a quick call or screen-share. Voice tone and facial expressions convey far more nuance than text, a 15-second question can replace days of back-and-forth comment threads, and people are naturally kinder face-to-face.&lt;/p&gt;
&lt;p&gt;When asynchronous written review is unavoidable, every comment should genuinely add value to the code. Leave purely stylistic preferences to automated formatters; if you don&amp;rsquo;t recognize a language construct, look it up yourself first; if you don&amp;rsquo;t understand why the author took a particular approach, ask a genuine question; and even when suggesting an improvement or pointing out a likely bug, frame it as a question rather than a command. Start reviews by calling out what you liked, close with an encouraging note, and drop any trace of condescension. On the receiving end, when hit with a blunt or abrasive review comment, resist getting defensive and look for the kernel of truth inside it—and for pure style nitpicks, either ignore them politely or ask privately what the deeper concern is. Ultimately, the best way to build a kinder code review culture is to model it yourself.&lt;/p&gt;
&lt;h2 id="hash-functions-deep-dive"&gt;&lt;a href="https://www.kirupa.com/data_structures_algorithms/hash_functions_deep_dive.htm" rel="noopener noreferrer"&gt;Hash Functions Deep Dive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kirupa explains hash functions from first principles: a function that takes an arbitrary input—text, a file, or raw binary data—and maps it to a fixed-size output, powering everything from hash tables and password verification to file integrity checks, digital signatures, and deduplication. A good hash function needs eight properties: determinism (the same input always yields the same output), uniform distribution, fast computation (ideally O(1) for table lookups), the avalanche effect (a tiny change in input flips roughly half the output bits), fixed output length, low collision rate, pre-image resistance (one-way), and no correlation between similar inputs.&lt;/p&gt;
&lt;p&gt;To make these properties concrete, the author builds a toy hash function in JavaScript from scratch: summing the character codes of a string modulo a prime table size like 37. That naive version immediately fails on anagrams like &lt;code&gt;&amp;quot;hello&amp;quot;&lt;/code&gt; and &lt;code&gt;&amp;quot;olleh&amp;quot;&lt;/code&gt;, which produce identical sums; multiplying each character code by its positional weight fixes the anagram collision, yet the toy function still flunks nearly every other criterion on the list. The lesson is never to roll your own hash function in production; the author walks through how MD5 satisfies the structural criteria with its 128-bit (32-hex-character) output (noting that MD5 is no longer safe against deliberate collisions and that password storage requires dedicated slow hashes like bcrypt or Argon2). Hash functions sit quietly underneath almost everything we build, from fast in-memory lookups to verifying downloaded ISOs.&lt;/p&gt;
&lt;h2 id="xor-a-deep-dive-into-the-exclusive-or-operation"&gt;&lt;a href="https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/xor/" rel="noopener noreferrer"&gt;XOR: A Deep Dive into the Exclusive OR Operation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Tatham takes a deep dive into the XOR (exclusive OR) operation and its surprisingly rich applications across computer science. At the bit level, XOR outputs &lt;code&gt;1&lt;/code&gt; when its two input bits differ and &lt;code&gt;0&lt;/code&gt; when they match, and is both commutative and associative. Tatham shows that you can view the exact same operation through four equivalent mental models: a &amp;ldquo;not equal&amp;rdquo; bit comparison, a conditional bit-flipper controlled by a mask bit, addition modulo 2 (carryless bit addition), and parity calculation (counting whether the number of &lt;code&gt;1&lt;/code&gt; bits is odd or even).&lt;/p&gt;
&lt;p&gt;Each mental model unlocks classic applications. In cryptography, XORing plaintext with a keystream encrypts and decrypts symmetrically—where the entire security challenge lies in generating an unpredictable keystream, and raw XOR alone provides no message integrity protection against bit-flipping attacks. In retro computer graphics, XORing a sprite onto a framebuffer twice cleanly erases it and restores the original background pixels. Tatham also walks through the classic XOR swap trick, overflow-safe integer averaging, and carryless polynomial arithmetic (used in CRCs and Galois fields), showing how one humble bitwise operator looks completely different depending on the lens you bring to it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/6b437484-1fd8-4b59-ba05-46bb3352b053_2904x2559.jpeg" alt="SOAP vs REST vs GraphQL vs RPC"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3ecf2600-10d8-4180-8328-8d790fbba0cc_1280x1557.gif" alt="SQS vs SNS vs EventBridge vs Kinesis"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/217bf342-bfd4-4088-bba3-b2734f065a20_1280x1280.gif" alt="Top 5 common ways to improve API performance"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-inside-java"&gt;Bonus 2: Interesting videos from &lt;a href="https://inside.java/" rel="noopener noreferrer"&gt;Inside Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://inside.java/2025/02/22/devoxxbelgium-loom-next/" rel="noopener noreferrer"&gt;Project Loom and Virtual Threads: Next Phases&lt;/a&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></channel></rss>