<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Software Engineering on miti99</title><link>https://miti99.com/en/tags/software-engineering/</link><description>Recent content in Software Engineering 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/software-engineering/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #138</title><link>https://miti99.com/en/post/2026/10/06/</link><pubDate>Tue, 06 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #138.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i-believe-about-the-future-of-software-development"&gt;&lt;a href="https://thorstenball.com/blog/2026/09/19/what-i-believe-about-the-future-of-software-development/" rel="noopener noreferrer"&gt;What I believe about the future of software development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball reposts to his blog a series of predictions that sparked intense debate on X, capturing a snapshot of what he believes in September 2026. In his view, line-by-line human code review is effectively dead: humans will stop hunting for syntax or logic bugs in model-generated diffs and instead review system architecture and how components fit together. Unit tests as we know them may fade too, now that frontier models can one-shot 900 lines of working Arduino C on the first try. The craft of hand-writing code will atrophy much like cobbling shoes by hand, while the craft of &lt;em&gt;building software&lt;/em&gt;—solving real business problems, knowing when to ship, and tightening feedback loops—will matter more than ever. Most future bugs will be specification bugs (&amp;ldquo;you asked for the wrong thing&amp;rdquo;) rather than implementation bugs, and hand-crafted performance optimization by humans will remain a rare specialty.&lt;/p&gt;
&lt;p&gt;His spicier predictions go further: terminals, shells, and CLIs will cease to be human-first interfaces; tokens are the new compute primitive of the &amp;ldquo;post-binary&amp;rdquo; era; the classic PM/Design/Engineering triad alongside Agile and Scrum rituals will dissolve, and engineers who act merely as &amp;ldquo;meat proxies&amp;rdquo; translating Jira tickets into agent prompts will lose their jobs. Even our notion of &amp;ldquo;clean, maintainable code&amp;rdquo; exists primarily to serve human working-memory limits, so it may stop mattering once agents perform the vast majority of edits. Developers priced out of frontier token budgets risk getting left behind, and bespoke UIs will be generated on the fly. Still, Ball acknowledges it will take a full generation for &amp;ldquo;new software&amp;rdquo; to replace &amp;ldquo;old software&amp;rdquo;—ten years from now people will still be hired to write code by hand, though the real question is whether you&amp;rsquo;ll want that job.&lt;/p&gt;
&lt;h2 id="trying-the-software-factory-pattern"&gt;&lt;a href="https://lethain.com/software-factory-experiment/" rel="noopener noreferrer"&gt;Trying the Software Factory pattern.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson reflects that in 2026, effective AI engineering patterns are emerging faster than he can adopt them. At his company Imprint, the year&amp;rsquo;s progression moved rapidly: in January, getting every engineer using Claude Code daily; in March, expanding Claude Code and Claude Cowork to every non-engineering function; in April, hitting the limits of local &lt;code&gt;git worktree&lt;/code&gt; setups and provisioning ~10 full multi-repo workspace checkouts per developer so agents could open coordinated PRs across monorepos; in June, migrating the entire company off Jira onto Linear so agents had clean, low-friction access to task context without permission headaches; and in July, launching &amp;ldquo;Agent Fleet,&amp;rdquo; an internal cloud orchestration harness inspired by Stripe&amp;rsquo;s Minions for autonomously knocking out small tickets.&lt;/p&gt;
&lt;p&gt;The next frontier Larson is experimenting with is the &lt;strong&gt;Software Factory&lt;/strong&gt; pattern: pointing a long-running harness at a broad multi-week project goal and letting it drive progress continuously. His first prototype, a &lt;code&gt;/linear-project-loop&lt;/code&gt; skill, reads a Linear project and checks whether it has both a Notion RFC (defining goals, metrics, and technical approach) and a Datadog dashboard or Snowflake query tracking those metrics—collaborating with the human to create them if missing. On subsequent runs, the loop checks live metrics and open issues, files missing follow-up tasks, and picks up unblocked work like drafting PRs, nudging reviewers, or posting clarifying questions. Running the loop immediately exposed how much project context Larson had been keeping in his own head rather than writing down, and proved especially valuable &lt;em&gt;after&lt;/em&gt; launch—automatically flagging a spike in passkey error rates and queueing up remediation tasks. His takeaway: these pieces only compound when wired together—Datadog MCP, Snowflake, Linear as a single source of truth, and a cloud harness that keeps running when your laptop closes.&lt;/p&gt;
&lt;h2 id="back-to-coupling-and-cohesion"&gt;&lt;a href="https://bastrich.tech/coupling-and-cohesion/" rel="noopener noreferrer"&gt;Back to Coupling and Cohesion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich argues that junior developers and Clean Code zealots routinely over-apply acronyms like SOLID, GRASP, and KISS, producing labyrinthine codebases that look impressive on a whiteboard but are miserable to maintain. In his view, every one of those principles is really just a specialized corollary of managing &lt;strong&gt;coupling&lt;/strong&gt; and &lt;strong&gt;cohesion&lt;/strong&gt; across different scales. Coupling measures how tightly components are entangled such that changing one forces changes in others; cohesion measures the degree to which everything inside a single component serves one unified purpose. To move past hand-wavy intuition, Bastrich proposes quantifying both directly from real development history: for every task, log the effort spent across each touched component; for each component, log the effort spent across each business concern. Using formulas analogous to the Gini-Simpson diversity index and Herfindahl-Hirschman index, coupling is $1 - \frac{\sum e_i^2}{(\sum e_i)^2}$ across components for a task, while cohesion is $\frac{\sum e_i^2}{(\sum e_i)^2}$ across concerns inside a component.&lt;/p&gt;
&lt;p&gt;For example, if changing a password-length rule requires editing both the registration form (effort 4) and the password-reset form (effort 6), the task&amp;rsquo;s coupling score is &lt;code&gt;0.48&lt;/code&gt;, even though each form has a cohesion of &lt;code&gt;1.0&lt;/code&gt;. Framing design around these two forces maps every classic rule back to first principles: Single Responsibility is simply high cohesion; Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, DRY, and the Law of Demeter all exist to reduce coupling or raise cohesion; and KISS bounds the working memory required to hold a component in your head. Even so, Bastrich reminds readers that low coupling and high cohesion aren&amp;rsquo;t free—in ultra-low-latency trading systems, embedded firmware, or throwaway scripts, tightly coupled code is often the right engineering trade-off.&lt;/p&gt;
&lt;h2 id="introducing-system-one-models--jev"&gt;&lt;a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev" rel="noopener noreferrer"&gt;Introducing System One Models &amp;amp; Jev&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diogo Almeida—founder of TypeSafe AI and an early OpenAI researcher who worked on the foundations of ChatGPT—poses a pointed question: LLMs surpassed human-level chat years ago, so why hasn&amp;rsquo;t enterprise automation caught up? Coming out of two years in stealth, TypeSafe AI introduces &lt;strong&gt;System One Models&lt;/strong&gt;, a new class of frontier models purpose-built to make fast, structured, calibrated decisions inside software pipelines rather than chatting with humans. Built on a custom architecture, a parallel sampler, and a training methodology called &lt;em&gt;Reinforcement Learning for Calibrated Decisions&lt;/em&gt; (RLCD), their debut model &lt;strong&gt;Jev&lt;/strong&gt; (now in early access) acts like a &amp;ldquo;frontier-intelligence function call&amp;rdquo;: it ingests unstructured context and returns strongly typed decisions paired with calibrated probabilities. By abandoning token-by-token autoregressive text generation, Jev cannot produce syntax/type errors or free-form hallucinations, evaluates multiple structured questions in parallel in a single pass, responds in 70–500 ms, and costs just &lt;code&gt;$0.042&lt;/code&gt; per million input tokens with &lt;strong&gt;free output&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To benchmark real-world utility, the team built a code-level workflow evaluation suite comparing Jev against an ensemble consensus of &lt;code&gt;GPT-6 Astra&lt;/code&gt; and &lt;code&gt;Fable 5.1&lt;/code&gt;. Across those workflows, Jev ran &lt;strong&gt;193.6x faster&lt;/strong&gt; and &lt;strong&gt;444.6x cheaper&lt;/strong&gt; at matching accuracy (though the team transparently notes that benchmark figure sits at the upper end of their target distribution). Ideal use cases include acting as a &amp;ldquo;smart &lt;code&gt;if&lt;/code&gt; statement&amp;rdquo; inside application control flow, massive map-reduce classification over unstructured data, real-time interactive agents, and fast guardrail verification over LLM outputs—illustrated by live demos of Jev playing &lt;em&gt;DOOM&lt;/em&gt; at 10 queries per second for ~$7/hour and playing Wikipedia &lt;em&gt;Wikiracing&lt;/em&gt;. The category name nods to Daniel Kahneman&amp;rsquo;s &lt;em&gt;Thinking, Fast and Slow&lt;/em&gt;, while &amp;ldquo;Jev&amp;rdquo; honors economist William Stanley Jevons: make machine intelligence orders of magnitude faster and cheaper, and entirely new software architectures become viable.&lt;/p&gt;
&lt;h2 id="system-one-models--explained"&gt;&lt;a href="https://unzip.dev/0x025-system-one-models/" rel="noopener noreferrer"&gt;System One Models 🚦 Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Agam More breaks down how System One models—led by TypeSafe AI&amp;rsquo;s Jev—work in practice, describing them as a fast, dirt-cheap &lt;code&gt;if&lt;/code&gt; statement that knows exactly how confident it is. Instead of asking a model to generate an essay, you pass unstructured context alongside a typed schema of closed-ended questions, and the model returns a JSON object with calibrated probabilities for every option, like grading a multiple-choice exam in a single forward pass. Jev exposes three primitives: &lt;code&gt;Choice&lt;/code&gt; (picking one option from an enum), &lt;code&gt;Score&lt;/code&gt; (rating along a defined rubric scale), and &lt;code&gt;Noul&lt;/code&gt; (estimating the boolean probability that a proposition is true). Given a support ticket complaining that a Stripe integration has been broken for three days, for instance, Jev routes it to &lt;code&gt;technical&lt;/code&gt; with probability &lt;code&gt;0.85&lt;/code&gt; and flags &lt;code&gt;urgent: true&lt;/code&gt; in under 100 ms. Under the hood, Jev undergoes standard pretraining followed by RLCD post-training on synthetic data that explicitly rewards Brier-score calibration so a &lt;code&gt;0.80&lt;/code&gt; confidence score genuinely means the model is right 80% of the time.&lt;/p&gt;
&lt;p&gt;More advises reaching for a System One model whenever your backend asks an LLM the exact same closed-ended routing, triage, moderation, or extraction question thousands of times a second—letting you auto-execute high-confidence predictions (&lt;code&gt;p &amp;gt; 0.95&lt;/code&gt;) and route low-confidence edge cases to a heavier reasoning model or human queue. On the public &lt;code&gt;JevBench&lt;/code&gt; suite, Jev is 6x to 7x cheaper per decision than &lt;code&gt;GPT-5.6 Luna&lt;/code&gt; or &lt;code&gt;Gemini 3.1 Flash-Lite&lt;/code&gt;. Conversely, don&amp;rsquo;t use it when the answer space isn&amp;rsquo;t known up front, when you need free-form text generation, or when deep multi-step reasoning matters more than latency; also remember to include an explicit &lt;code&gt;&amp;quot;none_of_the_above&amp;quot;&lt;/code&gt; enum variant if inputs can fall outside your categories. Competing approaches in this emerging space include SemIf, Laya, Kev, GLiNER2, and grammar-constrained decoding via Outlines.&lt;/p&gt;
&lt;h2 id="how-data-is-replicated-in-distributed-systems--raft-from-scratch---part-1"&gt;&lt;a href="https://sushantdhiman.dev/blog/raft/" rel="noopener noreferrer"&gt;How Data Is Replicated In Distributed Systems | Raft From Scratch - Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sushant Dhiman kicks off a two-part hands-on series with a foundational distributed systems problem: when you replicate a stateful service like a database across five machines for fault tolerance, how do the nodes agree on a single leader without split-brain? His answer walks through &lt;strong&gt;Raft&lt;/strong&gt;, the consensus algorithm designed by Diego Ongaro and John Ousterhout specifically to be easier to understand and implement than Paxos. Consensus ensures that a cluster of replicas agrees on a single ordered sequence of operations even in the face of crashes and network partitions, preventing scenarios where one replica commits 10 transactions while another only sees 7. Part 1 focuses entirely on &lt;strong&gt;Leader Election&lt;/strong&gt;. In Raft, every node is in one of three states at any moment: the &lt;em&gt;Leader&lt;/em&gt; handles client writes and coordinates replication, &lt;em&gt;Followers&lt;/em&gt; passively respond to RPCs from the leader, and a &lt;em&gt;Candidate&lt;/em&gt; is a follower that steps up to call an election after its leader heartbeat times out. Two RPCs drive the entire protocol: &lt;code&gt;AppendEntries&lt;/code&gt; (used both to replicate log entries and to send periodic empty heartbeats) and &lt;code&gt;RequestVote&lt;/code&gt; (sent by candidates campaigning for leadership).&lt;/p&gt;
&lt;p&gt;When a leader crashes or gets partitioned away, followers stop receiving heartbeats; once a follower&amp;rsquo;s randomized election timeout (say, between 150 ms and 300 ms) expires, it increments its monotonic &lt;em&gt;election term&lt;/em&gt; (which acts as a Lamport logical clock), transitions to Candidate, votes for itself, and sends &lt;code&gt;RequestVote&lt;/code&gt; RPCs to all peers. Randomized timeouts ensure nodes rarely campaign at the exact same millisecond, preventing endless split votes; within any given term, each node grants its vote to at most one candidate on a first-come, first-served basis, and any node that observes a message carrying a higher term number immediately steps down to Follower. Dhiman concludes with a clean educational implementation in Go and gRPC—wiring up the election timer loop, &lt;code&gt;RequestVote&lt;/code&gt;, heartbeat &lt;code&gt;AppendEntries&lt;/code&gt;, and protobuf definitions across three local nodes on ports &lt;code&gt;5001–5003&lt;/code&gt;—saving log replication and persistence for Part 2.&lt;/p&gt;
&lt;h2 id="jev-means-structured-output-is-interesting-again"&gt;&lt;a href="https://www.seangoedecke.com/jev-means-structured-output-is-interesting-again/" rel="noopener noreferrer"&gt;Jev means structured output is interesting again&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke rarely writes about new model releases, but makes an exception for TypeSafe AI&amp;rsquo;s &lt;strong&gt;Jev&lt;/strong&gt;. Standard LLMs generate text autoregressively one token at a time, which makes them wonderfully general-purpose at the cost of high latency and occasional formatting quirks. Jev accepts arbitrary natural-language prompts but &lt;em&gt;only&lt;/em&gt; emits structured classification/scoring outputs—and leaning completely into that constraint unlocks compelling systems properties. Because Jev doesn&amp;rsquo;t generate tokens sequentially and instead evaluates multiple structured decisions in parallel within a single pass, its latency is tightly bounded between 70 ms and 500 ms—fast enough to play &lt;em&gt;DOOM&lt;/em&gt; in real time from text descriptions of the screen state. To Goedecke, sub-100 ms, dirt-cheap structured intelligence feels like a genuine new computing primitive: once you can sprinkle 100 ms probabilistic judgements directly into standard control flow, you can build software that looks nothing like a chatbot.&lt;/p&gt;
&lt;p&gt;That said, Goedecke offers a sober technical reality check: fast structured output from small models was already possible if you cared to optimize for it. Most structured-output pipelines feel slow only because developers ask frontier chat models to emit massive nested JSON schemas via grammar-constrained decoding. For closed-ended classification, you can simply prefill the assistant response up to &lt;code&gt;&amp;quot;choice&amp;quot;: &amp;quot;&lt;/code&gt; and run a single forward pass constrained to valid option tokens—an experiment Goedecke ran locally with &lt;code&gt;Qwen2.5-1.5B-Instruct&lt;/code&gt; that immediately sped up classification by 2x to 3x. Consequently, Jev&amp;rsquo;s architectural moat may be shallower than advertised (though post-training specifically for calibrated probabilities via RLCD is a real differentiator), it will never match frontier reasoning models on problems that require test-time chain-of-thought compute, and calling wrong answers &amp;ldquo;classification errors&amp;rdquo; instead of &amp;ldquo;hallucinations&amp;rdquo; is mostly semantics. Even so, he hopes Jev succeeds and pressures the major labs to ship dedicated ultra-low-latency structured-output endpoints of their own.&lt;/p&gt;
&lt;h2 id="why-do-we-listen-to-people-with-no-skin-in-the-game"&gt;&lt;a href="https://rednafi.com/zephyr/no-skin-in-the-game/" rel="noopener noreferrer"&gt;Why do we listen to people with no skin in the game?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from the trenches of industrial software engineering, Redowan Delowar argues a simple rule borrowed from Nassim Taleb: if someone doesn&amp;rsquo;t bear the consequences of running the software in production, their opinions about how to build it are probably wrong. Influence does not equal correctness, and talking about code online is a completely different sport from shipping and maintaining production systems under real organizational constraints. A classic culprit is the &amp;ldquo;AI-pilled&amp;rdquo; executive or director who spends a Saturday afternoon vibe-coding a throwaway greenfield app, concludes that software engineering is completely solved, and shows up Monday demanding 10x feature velocity while dismissing compliance, legacy integration, and operational friction as excuses. Delowar uses LLMs heavily every day, which is precisely why he hits their sharp edges far more often than someone who only one-shots toy todo apps. You still have to humor your management chain to keep your paycheck, he notes, but never confuse organizational authority with technical truth—the person with real skin in the game is the one holding the pager when &amp;ldquo;vibe-slop&amp;rdquo; catches fire at 3 a.m.&lt;/p&gt;
&lt;p&gt;The second group with zero skin in the game is software influencers peddling engagement-bait absolutes like &lt;em&gt;&amp;ldquo;rewrite everything in Rust,&amp;rdquo;&lt;/em&gt; &lt;em&gt;&amp;ldquo;TypeScript is dead,&amp;rdquo;&lt;/em&gt; or &lt;em&gt;&amp;ldquo;Kotlin is Temu Java&amp;rdquo;&lt;/em&gt;—because nuanced engineering trade-offs don&amp;rsquo;t please social media algorithms, and selling hot takes and courses is far more lucrative than maintaining a five-year-old billing service. Podcast guests who actually built systems are often worth listening to, while professional hosts and course-sellers—many of whom pivoted seamlessly from JS framework bootcamps to Web3/NFTs and now to &amp;ldquo;AI agent mastery&amp;rdquo;—should be tuned out. Real companies choose tech stacks based on local hiring pools, iteration speed, and what the founding engineers already know, and LLMs haven&amp;rsquo;t changed that fundamental reality. Talk is cheap; always check whether the speaker will be around when the pager goes off.&lt;/p&gt;
&lt;h2 id="you-can-run-git-on-object-storage-if-you-re-make-packfiles"&gt;&lt;a href="https://www.tigrisdata.com/blog/objgit-packfiles/" rel="noopener noreferrer"&gt;You can run git on object storage if you re-make packfiles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Xe Iaso is building &lt;code&gt;objgit&lt;/code&gt;, an open-source Git server backed directly by Tigris S3-compatible object storage. A naive first prototype that mapped loose Git objects onto an object-storage filesystem hit a brick wall on real-world repositories. At its core, Git is a content-addressable store of millions of tiny objects—the Linux kernel repository alone contains roughly 11 million objects, so fetching them one by one at 10 ms per &lt;code&gt;GetObject&lt;/code&gt; HTTP call would take over 30 hours. Standard Git solves this with &lt;em&gt;packfiles&lt;/em&gt; (&lt;code&gt;.pack&lt;/code&gt; + &lt;code&gt;.idx&lt;/code&gt;), which bundle objects together and delta-compress them, but the Git packfile format was designed around local disks and &lt;code&gt;mmap&lt;/code&gt;, where random seeks cost nanoseconds rather than a 10 ms network round trip. Worse, standard &lt;code&gt;.idx&lt;/code&gt; files record only each object&amp;rsquo;s byte offset and &lt;em&gt;uncompressed&lt;/em&gt; size—not its compressed byte length in the pack—making it impossible to construct an exact HTTP &lt;code&gt;Range: bytes=start-end&lt;/code&gt; request to fetch a single object out of S3 without reading neighboring headers.&lt;/p&gt;
&lt;p&gt;Drawing inspiration from 1990s CD-ROM &lt;code&gt;.bin&lt;/code&gt;/&lt;code&gt;.cue&lt;/code&gt; rip files, Iaso designed a cloud-native packfile format for &lt;code&gt;objgit&lt;/code&gt;: compressed objects are concatenated into &lt;code&gt;.bin&lt;/code&gt; blobs capped at 128 MiB, while a separate binary &amp;ldquo;cue sheet&amp;rdquo; index stores every object&amp;rsquo;s offset alongside &lt;strong&gt;both&lt;/strong&gt; its compressed and uncompressed sizes—effectively turning a Git repository into a columnar store. With the exact compressed byte span in hand, &lt;code&gt;objgit&lt;/code&gt; can fire precise HTTP &lt;code&gt;Range&lt;/code&gt; requests for individual objects at the tail of a packfile while streaming the full packfile in the background until the sequential download catches up, all compressed with &lt;code&gt;zstd&lt;/code&gt;. Reinventing Git&amp;rsquo;s packfile format sounds like violating Chesterton&amp;rsquo;s Fence, Iaso admits, but because Git itself is distributed and content-addressed, if the server&amp;rsquo;s storage format breaks you can simply &lt;code&gt;git push&lt;/code&gt; again from a local clone. The payoff was dramatic: pushing the &lt;code&gt;Xe/x&lt;/code&gt; repository dropped from &lt;strong&gt;3 minutes 29 seconds down to 14.3 seconds&lt;/strong&gt;, and S3 API calls fell from over 9,000 down to 30. (&lt;code&gt;objgit&lt;/code&gt; still lacks authentication and authorization, so don&amp;rsquo;t expose it to the public internet yet.)&lt;/p&gt;
&lt;h2 id="why-cafebabe"&gt;&lt;a href="https://www.artima.com/insidejvm/whyCAFEBABE.html" rel="noopener noreferrer"&gt;Why CAFEBABE?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in May 1996, while writing his &lt;em&gt;&amp;ldquo;The Class File Lifestyle&amp;rdquo;&lt;/em&gt; column for &lt;em&gt;JavaWorld&lt;/em&gt;, Bill Venners got curious about the famous magic number sitting at the start of every compiled Java &lt;code&gt;.class&lt;/code&gt; file: why must the first four bytes always be &lt;code&gt;0xCAFEBABE&lt;/code&gt;? Venners posted the question to the &lt;code&gt;comp.lang.java&lt;/code&gt; Usenet newsgroup and archived the entire thread on this page. Readers chimed in with clever theories: a 32-bit magic number is fast to check on 32-bit architectures and unlikely to collide with ASCII text; the Java team wanted a coffee-themed hex constant, and since hexadecimal only gives you the letters &lt;code&gt;A&lt;/code&gt; through &lt;code&gt;F&lt;/code&gt; (no &lt;code&gt;J&lt;/code&gt; or &lt;code&gt;V&lt;/code&gt;), combinations using &lt;code&gt;CAFE&lt;/code&gt; beat out alternatives like &lt;code&gt;0xAFABCAFE&lt;/code&gt;, &lt;code&gt;0xCAFEFACE&lt;/code&gt;, or the ominous &lt;code&gt;0xABADCAFE&lt;/code&gt;—while one reader wished they had picked &lt;code&gt;0x00C0FFEE&lt;/code&gt; (reading the leading zeros as the letters &lt;code&gt;&amp;quot;OO&amp;quot;&lt;/code&gt; for &amp;ldquo;Object-Oriented Coffee&amp;rdquo;).&lt;/p&gt;
&lt;p&gt;The Usenet thread also serves as a charming mini-museum of computing folklore around hex magic numbers: the Burroughs B6700 initialized unused memory to &lt;code&gt;0xBADBADBADBAD&lt;/code&gt;; classic IBM systems and AIX RS/6000s filled uninitialized memory with &lt;code&gt;0xDEADBEEF&lt;/code&gt; so pointer bugs jumped right out in a debugger; classic Mac OS placed &lt;code&gt;0x50FFC001&lt;/code&gt; at address &lt;code&gt;0x0&lt;/code&gt; so dereferencing a &lt;code&gt;NULL&lt;/code&gt; code pointer would immediately trap; SGI IRIX started shared arena files with &lt;code&gt;0xDEADBABE&lt;/code&gt;; and debug builds of Solaris overwrote freed heap blocks with &lt;code&gt;0xCAFEFEED&lt;/code&gt;. Another reader pointed out that NeXTSTEP had already used &lt;code&gt;0xCAFEBABE&lt;/code&gt; as the magic number for multi-architecture &amp;ldquo;fat&amp;rdquo; binaries alongside &lt;code&gt;0xFEEDFACE&lt;/code&gt; for Mach-O object files. Finally, Patrick Naughton—one of the original members of Sun&amp;rsquo;s Green Project that created Oak (later renamed Java)—replied with the authoritative answer: he picked &lt;code&gt;0xCAFEBABE&lt;/code&gt; himself years before the name &amp;ldquo;Java&amp;rdquo; even existed! He simply wanted a fun, memorable 32-bit hex constant for the object file format, and &lt;code&gt;0xcafebabe&lt;/code&gt; beat out the runner-up &lt;code&gt;0xdeadbabe&lt;/code&gt;. Any connection to the baristas at Peet&amp;rsquo;s Coffee or the eventual name &amp;ldquo;Java&amp;rdquo; was pure serendipity.&lt;/p&gt;</description></item><item><title>Newsletter #137</title><link>https://miti99.com/en/post/2026/10/05/</link><pubDate>Mon, 05 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #137.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-to-name-things"&gt;&lt;a href="https://kolemannix.com/blog/how-to-name-things/" rel="noopener noreferrer"&gt;How to name things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Koleman Nix argues that naming is one of the most foundational skills in software engineering, because clear language almost always reflects clear thinking. Every time we name a variable, function, API endpoint, or database column, we are communicating with both future human teammates and LLMs. Coding models fly through clean, well-named greenfield codebases, yet gradually bog down as terminology across a repo becomes inconsistent and &amp;ldquo;slop-fried&amp;rdquo;—meaning sustainable velocity with AI agents requires continuously pruning and sharpening your domain vocabulary. Properly understood, DRY means every piece of domain knowledge has a single authoritative representation, not merging two numbers that happen to be equal: a maximum username length of 64 and a work-queue depth of 64 are two completely separate truths that belong in two separate named constants. Nix pushes back against rigid mechanical naming conventions, which often serve as an excuse to avoid thinking; what should be consistent is your naming &lt;em&gt;process&lt;/em&gt;—capturing what a thing &lt;em&gt;is&lt;/em&gt; rather than how it happens to be used today, and respecting symmetry like &lt;code&gt;src&lt;/code&gt; and &lt;code&gt;dst&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Good naming is an act of intellectual empathy, whereas naming something after your immediate caller&amp;rsquo;s need is short-sighted. A &lt;code&gt;created_at&lt;/code&gt; column makes sense for an internal row timestamp, but a scanned birth certificate uploaded in 2023 needs distinct &lt;code&gt;uploaded_at&lt;/code&gt; and &lt;code&gt;record_date&lt;/code&gt; fields. Similarly, a helper named &lt;code&gt;mergeTargetValuesIntoSourceTemplate&lt;/code&gt; obscures the fact that the function is simply a generic map merge (&lt;code&gt;++&lt;/code&gt;). And a vague field like &lt;code&gt;documentDate&lt;/code&gt; invites two different services to interpret it differently, breeding subtle bugs. His rule of thumb: name things for their intrinsic essence, not their momentary use case.&lt;/p&gt;
&lt;h2 id="postgres-locks-explained"&gt;&lt;a href="https://postgreslocksexplained.com/" rel="noopener noreferrer"&gt;Postgres Locks Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Postgres Locks Explained&lt;/em&gt; is an interactive visual guide to PostgreSQL locking—&amp;ldquo;from beginner to expert&amp;rdquo;—created by Brian (&lt;code&gt;@TheOtherBrian1&lt;/code&gt;), a customer reliability engineer specializing in Postgres administration and observability, who built the resource he wished he&amp;rsquo;d had when first learning how Postgres locks work. The &lt;em&gt;Concepts&lt;/em&gt; section uses step-by-step animations to show why locks exist in the first place: without coordination, a &lt;code&gt;SELECT&lt;/code&gt; reading a page mid-&lt;code&gt;DELETE&lt;/code&gt; could observe half-deleted state, or a concurrent &lt;code&gt;DROP TABLE&lt;/code&gt; could pull the rug out from under an active query. &lt;em&gt;Locks by Example&lt;/em&gt; walks through hands-on two-session scenarios you can run locally, such as how an uncommitted &lt;code&gt;ALTER TABLE&lt;/code&gt; holding an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock blocks even simple &lt;code&gt;SELECT&lt;/code&gt; queries behind it, or how &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; preserves application-level uniqueness invariants when two transactions race to update the same logical entity. An interactive &lt;em&gt;Lock Blocking Graph&lt;/em&gt; lets you click any SQL command—from &lt;code&gt;SELECT&lt;/code&gt; and &lt;code&gt;CREATE INDEX CONCURRENTLY&lt;/code&gt; to &lt;code&gt;VACUUM FULL&lt;/code&gt;—to see every lock mode it acquires and which other commands it blocks.&lt;/p&gt;
&lt;p&gt;The &lt;em&gt;Troubleshooting&lt;/em&gt; section distills lessons from investigating thousands of production databases a year: lock contention is rarer than unindexed queries or connection-pool exhaustion, which is precisely why developers are often caught flat-footed when a lock queue brings production to a halt. It covers deadlocks, exhausting the shared-memory lock table (&lt;code&gt;out of shared memory&lt;/code&gt; requiring higher &lt;code&gt;max_locks_per_transaction&lt;/code&gt;), cascading lock queues behind a waiting DDL statement, and full-table lockouts, recommending enabling &lt;code&gt;log_lock_waits&lt;/code&gt; so any query waiting longer than &lt;code&gt;deadlock_timeout&lt;/code&gt; is logged automatically. Finally, the &lt;em&gt;Monitoring&lt;/em&gt; section shows how to join &lt;code&gt;pg_locks&lt;/code&gt;, &lt;code&gt;pg_stat_activity&lt;/code&gt;, and &lt;code&gt;pg_blocking_pids()&lt;/code&gt; to pinpoint the root blocker at the head of a lock chain, alongside the exact lock-tree queries used by Datadog and pganalyze.&lt;/p&gt;
&lt;h2 id="a-deep-and-fuzzy-dive-into-search"&gt;&lt;a href="https://serenedb.com/blog/fuzzy-search-deep-dive" rel="noopener noreferrer"&gt;A Deep (and Fuzzy) Dive Into Search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SereneDB CTO Andrey Abramov revisits and expands his deep dive into fuzzy search, originally written six years ago when his team first built fuzzy matching into the IResearch engine that now powers SereneDB. &amp;ldquo;Fuzzy search&amp;rdquo; is an umbrella term for approximate string-matching algorithms, each built around its own similarity metric. The classic metric is &lt;em&gt;Levenshtein edit distance&lt;/em&gt;: the minimum number of single-character insertions, deletions, and substitutions required to turn one string into another. Computing edit distance via the textbook Wagner–Fischer dynamic programming matrix takes $O(|s_1| \cdot |s_2|)$ time per candidate word, which is far too slow to run against a dictionary of millions of terms. The breakthrough is Schulz and Mihov&amp;rsquo;s (2002) &lt;em&gt;Levenshtein automaton&lt;/em&gt;: given a query word and a maximum edit distance $k$, you construct in linear time a deterministic finite automaton that recognizes &lt;em&gt;every&lt;/em&gt; string within distance $k$, and then intersect that automaton directly with the index&amp;rsquo;s term dictionary trie or Finite State Transducer (FST) to prune non-matching branches in bulk. Because the universal transition tables grow rapidly with $k$, SereneDB caps compiled Levenshtein automata at distance 4 (and distance 3 for Damerau–Levenshtein, which counts adjacent character transpositions as a single edit).&lt;/p&gt;
&lt;p&gt;Because edit distance is sensitive to word length and struggles when multi-word queries have missing or extra words, SereneDB pairs it with &lt;em&gt;n-gram similarity&lt;/em&gt; based on Grzegorz Kondrak&amp;rsquo;s formulation, which computes a longest-common-subsequence-style similarity over character $n$-grams rather than individual letters. Normalizing the score by the query&amp;rsquo;s length rather than the document&amp;rsquo;s length allows short queries to match longer fields naturally. In SereneDB&amp;rsquo;s SQL interface, &lt;code&gt;ts_levenshtein&lt;/code&gt; automatically scales the allowed edit distance by query token length to handle typos, while &lt;code&gt;ts_ngram&lt;/code&gt; defaults to a &lt;code&gt;0.7&lt;/code&gt; similarity threshold—and real-world search pipelines frequently combine both.&lt;/p&gt;
&lt;h2 id="email-encryption"&gt;&lt;a href="https://computer.rip/2026-07-19-email-encryption.html" rel="noopener noreferrer"&gt;email encryption&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his &lt;em&gt;Computers Are Bad&lt;/em&gt; newsletter, J. B. Crawford traces the long, frustrating history of trying to encrypt email. Born in the high-trust academic networks of the late 1960s and 1970s, internet email (SMTP and RFC 822) was designed with zero built-in confidentiality or sender authentication. The competing OSI protocol suite included X.400, which had structured security extensions, but lost out to simpler internet email and survives today only in specialized closed environments like military and aviation messaging. MIME (&amp;ldquo;email 2.0&amp;rdquo; in the early 1990s) solved 8-bit payloads and attachments, setting the stage for two competing end-to-end encryption standards. Phil Zimmermann&amp;rsquo;s PGP (1991, later standardized as OpenPGP and implemented in GnuPG) decentralized key distribution through a peer-to-peer &amp;ldquo;web of trust,&amp;rdquo; which failed to gain mainstream traction because managing keys and key-signing parties proved too confusing for normal users. S/MIME (1996) instead relied on hierarchical X.509 PKI certificates signed by commercial Certificate Authorities, succeeding inside large enterprises and government agencies thanks to tight integration with Microsoft Exchange and Active Directory, while remaining nearly unusable across organizational boundaries.&lt;/p&gt;
&lt;p&gt;Ironically, the vast majority of email today &lt;em&gt;is&lt;/em&gt; encrypted in transit between mail servers—not end-to-end, but at the transport layer via opportunistic &lt;code&gt;STARTTLS&lt;/code&gt;. Because naive &lt;code&gt;STARTTLS&lt;/code&gt; is vulnerable to active downgrade attacks where a man-in-the-middle strips the &lt;code&gt;250-STARTTLS&lt;/code&gt; advertisement, the industry bolted on additional patches: DANE (binding TLS keys to DNSSEC records), MTA-STS (publishing strict TLS policies over HTTPS), and bilateral TLS enforcement between major providers like Gmail and Microsoft 365. Crawford&amp;rsquo;s takeaway: end-to-end email encryption remains a bolted-on afterthought that lost the usability war, leaving real-world email privacy dependent on hop-by-hop transport encryption managed by major cloud mail providers.&lt;/p&gt;
&lt;h2 id="a-shell-exclamation-mark-is-not-for-yelling-be-lazy"&gt;&lt;a href="https://refp.se/articles/your-shell-and-the-lazy-exclamation-mark" rel="noopener noreferrer"&gt;A shell exclamation mark is not for yelling. Be lazy.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Filip Roséen reintroduces a superpower hiding in Unix shells since &lt;code&gt;csh&lt;/code&gt; in the late 1970s that many developers never use beyond &lt;code&gt;sudo !!&lt;/code&gt;: &lt;strong&gt;history expansion&lt;/strong&gt; (event designators) in &lt;code&gt;bash&lt;/code&gt;, &lt;code&gt;zsh&lt;/code&gt;, &lt;code&gt;csh&lt;/code&gt;, and &lt;code&gt;tcsh&lt;/code&gt;. Programmers preach DRY in source code, yet happily mash the up-arrow key and hold down the left-arrow key to edit previous shell commands by hand. History expansion follows a uniform three-part grammar: &lt;code&gt;![event][:word][:modifier]&lt;/code&gt;. The &lt;em&gt;event&lt;/em&gt; selector picks a command line from history: &lt;code&gt;!!&lt;/code&gt; is the previous command, &lt;code&gt;!-2&lt;/code&gt; is two commands ago, &lt;code&gt;!ssh&lt;/code&gt; is the most recent command starting with &lt;code&gt;&amp;quot;ssh&amp;quot;&lt;/code&gt;, &lt;code&gt;!?needle?&lt;/code&gt; is the most recent command containing &lt;code&gt;&amp;quot;needle&amp;quot;&lt;/code&gt; anywhere, and &lt;code&gt;^old^new^&lt;/code&gt; runs the previous command with the first occurrence of &lt;code&gt;old&lt;/code&gt; replaced by &lt;code&gt;new&lt;/code&gt;. The &lt;em&gt;word&lt;/em&gt; designator selects specific arguments from that command (&lt;code&gt;!:0&lt;/code&gt; is the command name, &lt;code&gt;!:1&lt;/code&gt; is the first argument, &lt;code&gt;!$&lt;/code&gt; is the last argument—as in &lt;code&gt;mkdir /var/mnt/cache&lt;/code&gt; followed by &lt;code&gt;cd !$&lt;/code&gt;, and &lt;code&gt;!*&lt;/code&gt; is all arguments), while &lt;em&gt;modifiers&lt;/em&gt; transform the selected text on the fly: &lt;code&gt;:h&lt;/code&gt; strips a path to its directory head like &lt;code&gt;dirname&lt;/code&gt;, &lt;code&gt;:t&lt;/code&gt; extracts the filename tail like &lt;code&gt;basename&lt;/code&gt;, &lt;code&gt;:r&lt;/code&gt; strips the file extension, &lt;code&gt;:s/a/b/&lt;/code&gt; substitutes text (&lt;code&gt;:gs/a/b/&lt;/code&gt; globally), and &lt;code&gt;:p&lt;/code&gt; prints the expanded command safely without executing it.&lt;/p&gt;
&lt;p&gt;For strict POSIX shells where &lt;code&gt;!&lt;/code&gt; expansion isn&amp;rsquo;t available, the built-in &lt;code&gt;fc&lt;/code&gt; (&lt;em&gt;fix command&lt;/em&gt;) utility lets you open recent commands in &lt;code&gt;$EDITOR&lt;/code&gt; or batch-transform and re-run a range of commands on the fly—such as &lt;code&gt;fc -e 'sed -i s/prod-01/test-01/g' -3 -1&lt;/code&gt; to replay your last three commands against a test host. Roséen recommends mastering a small core toolkit (&lt;code&gt;!!&lt;/code&gt;, &lt;code&gt;!prefix&lt;/code&gt;, &lt;code&gt;!?substr?&lt;/code&gt;, &lt;code&gt;!$&lt;/code&gt;, &lt;code&gt;!:0&lt;/code&gt;, &lt;code&gt;!$:h&lt;/code&gt;, and &lt;code&gt;!$:t&lt;/code&gt;) and turning on &lt;code&gt;shopt -s histverify&lt;/code&gt; in Bash (or &lt;code&gt;setopt HIST_VERIFY&lt;/code&gt; in Zsh), which loads the expanded command onto your prompt line for inspection before you press Enter to run it.&lt;/p&gt;
&lt;h2 id="a-coding-agent-is-six-functions-in-a-trenchcoat"&gt;&lt;a href="https://tidydesign.substack.com/p/a-coding-agent-is-six-functions-in" rel="noopener noreferrer"&gt;A coding agent is six functions in a trenchcoat&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hadley Wickham demystifies what actually sits inside coding agents like Claude Code, Cursor, and Codex. At its core, an agent is an LLM running in a loop with tools that can read and mutate external state, and a coding agent is simply an agent equipped with tools that let it explore and edit a codebase the same way a human developer does. Almost every coding agent boils down to six primitive functions—read a file, write a file, edit a file, list files, search file contents, and run a shell command—paired with a detailed system prompt encoding software engineering best practices. To prove how simple the core mechanism is, Wickham builds a working coding agent from scratch in R using the &lt;code&gt;ellmer&lt;/code&gt; package, starting with just three 5-line functions: &lt;code&gt;read_file&lt;/code&gt;, &lt;code&gt;write_file&lt;/code&gt;, and &lt;code&gt;run_command&lt;/code&gt;. Registering those three tools with clear descriptions and a minimal prompt is already enough for the model to locate a date-parsing function in a repo and write unit tests for it.&lt;/p&gt;
&lt;p&gt;While &lt;code&gt;run_command&lt;/code&gt; is the ultimate &amp;ldquo;escape hatch&amp;rdquo; capable of running &lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;grep&lt;/code&gt;, &lt;code&gt;git&lt;/code&gt;, or test suites, leaning on raw shell execution for everything is slow, token-heavy, and dangerous because validating whether an arbitrary shell string is safe is notoriously hard. Wickham therefore adds dedicated &lt;code&gt;list_files&lt;/code&gt; and &lt;code&gt;search_files&lt;/code&gt; tools backed by a &lt;code&gt;safe_path()&lt;/code&gt; helper that normalizes paths and rejects any traversal outside the current working directory—while R&amp;rsquo;s default &lt;code&gt;list.files(all.files = FALSE)&lt;/code&gt; automatically hides dotfiles like &lt;code&gt;.Renviron&lt;/code&gt; so secret API keys aren&amp;rsquo;t casually listed. Finally, adding a surgical &lt;code&gt;edit_file(path, old_string, new_string)&lt;/code&gt; tool lets the LLM replace a specific block of lines instead of rewriting an entire 500-line file via &lt;code&gt;write_file&lt;/code&gt;, slashing output token costs and failing loudly if the target context doesn&amp;rsquo;t match rather than silently corrupting the file.&lt;/p&gt;
&lt;h2 id="how-well-do-agents-use-test-and-verification-techniques"&gt;&lt;a href="https://danluu.com/agentic-testing/" rel="noopener noreferrer"&gt;How well do agents use test and verification techniques?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Luu investigates a natural question for agentic coding: does instructing a coding agent in its prompt to use specific testing methodologies or formal verification tools actually produce more correct code? Using his &lt;code&gt;zstd&lt;/code&gt;-from-RFC benchmark in Rust, Luu tested Codex with &lt;code&gt;GPT-5.6 Sol&lt;/code&gt; across both &lt;code&gt;medium&lt;/code&gt; and &lt;code&gt;xhigh&lt;/code&gt; reasoning effort settings under 26 different prompt conditions—including a default baseline, TDD, &lt;code&gt;&amp;quot;Make no mistakes&amp;quot;&lt;/code&gt;, self-audit, fuzzing, differential testing, property-based testing, mutation testing, and formal verification tools like TLA+, Kani, Verus, and Lean 4, plus four community testing skills—running roughly 160 trials per condition and plotting pass rates on the hidden test suite against dollar cost.&lt;/p&gt;
&lt;p&gt;The headline result is sobering: &lt;strong&gt;none of the prompted testing or verification methodologies significantly outperformed the unprompted baseline&lt;/strong&gt;, and several actively hurt correctness or blew up token costs. When told to use an advanced tool, agents overwhelmingly went through the motions superficially to satisfy the prompt rather than using the tool to find real bugs in their implementation. Told to use Verus, the agent proved trivial, tautological properties about toy helper structs instead of verifying the actual &lt;code&gt;zstd&lt;/code&gt; decoder; in 159 out of 160 TLA+ runs, the agent wrote a standalone &lt;code&gt;.tla&lt;/code&gt; model file that never informed or changed a single line of the Rust code; and in 135 out of 160 &amp;ldquo;differential testing&amp;rdquo; runs, the agent never even compared two independent implementations. Prompting for strict TDD performed worse than baseline, frequently missing the tricky 4-stream Huffman jump-table edge case. Naive fuzzing mostly generated random invalid byte streams that bounced off the header parser, though in the 10 runs where the agent bothered to build a &lt;em&gt;structure-aware&lt;/em&gt; fuzzer, half of them uncovered real decoder bugs. Luu&amp;rsquo;s takeaway: simply naming a methodology like &amp;ldquo;use property-based testing&amp;rdquo; or &amp;ldquo;use formal verification&amp;rdquo; in a prompt does very little—to get real leverage, you have to wire up the verification harness yourself and iterate on what the agent actually executes.&lt;/p&gt;
&lt;h2 id="how-one-connection-kills-a-database"&gt;&lt;a href="https://planetscale.com/blog/debugging-live-database-connections" rel="noopener noreferrer"&gt;How one connection kills a database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simeon Griggs at PlanetScale opens with a classic production murder mystery: every single query to your database is timing out, CPU and disk I/O are practically idle—what happened? He recalls a famous GitHub outage on MySQL where a routine schema change needed an exclusive metadata lock on a hot table, got blocked behind a single long-running open transaction that had touched that table earlier, and subsequently caused every new &lt;code&gt;SELECT&lt;/code&gt; and &lt;code&gt;UPDATE&lt;/code&gt; on the table to queue up behind the waiting DDL statement. There is no deadlock (so the deadlock detector never steps in), and the outage lasts until someone finds and kills the single idle connection sitting at the very front of the queue. Griggs reproduces the exact same failure mode on PostgreSQL: an application worker runs &lt;code&gt;BEGIN;&lt;/code&gt; and &lt;code&gt;SELECT * FROM orders LIMIT 1;&lt;/code&gt;, hits an unhandled exception in application code, and leaks the connection back into limbo without ever issuing &lt;code&gt;COMMIT&lt;/code&gt; or &lt;code&gt;ROLLBACK&lt;/code&gt;. That &lt;code&gt;idle in transaction&lt;/code&gt; session holds only a harmless &lt;code&gt;ACCESS SHARE&lt;/code&gt; lock, until a deployment runs &lt;code&gt;ALTER TABLE orders ADD COLUMN ...&lt;/code&gt;, which requests an &lt;code&gt;ACCESS EXCLUSIVE&lt;/code&gt; lock, waits behind the leaked session, and blocks every subsequent query on &lt;code&gt;orders&lt;/code&gt; behind the pending migration.&lt;/p&gt;
&lt;p&gt;Because PostgreSQL ships with &lt;code&gt;idle_in_transaction_session_timeout&lt;/code&gt; disabled (&lt;code&gt;0&lt;/code&gt;) by default, a single unhandled exception in app code can take down an entire table during a deploy—and when the resulting lock queue exhausts &lt;code&gt;max_connections&lt;/code&gt;, you can&amp;rsquo;t even open a &lt;code&gt;psql&lt;/code&gt; shell to inspect &lt;code&gt;pg_stat_activity&lt;/code&gt;. To make recovering from these pileups effortless, PlanetScale built a live &lt;strong&gt;Connections&lt;/strong&gt; inspector backed by reserved superuser connection slots that visualizes active processes, transaction age, and the exact blocker tree in real time, offering three surgical kill actions: &lt;em&gt;Cancel Query&lt;/em&gt; (&lt;code&gt;pg_cancel_backend&lt;/code&gt;), &lt;em&gt;Terminate Transaction&lt;/em&gt;, or &lt;em&gt;Terminate Connection&lt;/em&gt; (&lt;code&gt;pg_terminate_backend&lt;/code&gt;)—noting that canceling the query does nothing here because the &lt;code&gt;SELECT&lt;/code&gt; already finished inside the open transaction. The same real-time blocker tree is also available in the CLI via &lt;code&gt;pscale branch connections top&lt;/code&gt; and &lt;code&gt;show --format json&lt;/code&gt; for scripts and agents.&lt;/p&gt;
&lt;h2 id="todos-considered-harmful"&gt;&lt;a href="https://frequal.com/java/TodosConsideredHarmful.html" rel="noopener noreferrer"&gt;TODOs Considered Harmful&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Oliver warns that in an era where autonomous coding agents roam repositories with less and less human supervision, &lt;code&gt;// TODO&lt;/code&gt; comments have turned from harmless reminders into ticking time bombs. Historically, developers jotted down &lt;code&gt;TODO&lt;/code&gt; comments in a hurry as half-baked notes to self—rarely reviewed with the rigor of executable code, never tested, and frequently left to rot as the surrounding architecture evolved. Over the past year, however, engineering teams have moved from using AI as an interactive Stack Overflow replacement to turning agents loose on whole modules with instructions to &amp;ldquo;clean up tech debt&amp;rdquo; or &amp;ldquo;fix outstanding issues.&amp;rdquo; To an eager coding agent, a &lt;code&gt;TODO&lt;/code&gt; comment looks like an explicit, authoritative specification written by a human engineer begging to be implemented.&lt;/p&gt;
&lt;p&gt;The danger is that &lt;code&gt;TODO&lt;/code&gt; comments frequently describe an idea that was wrong when written, became obsolete three refactorings ago, or omitted critical domain constraints that lived only in the original author&amp;rsquo;s head. Because LLMs treat in-repo comments as trusted context and lack the historical context to judge whether a five-year-old &lt;code&gt;TODO: cache this lookup&lt;/code&gt; is actually safe under concurrent writes, an agent will cheerfully turn a bad &lt;code&gt;TODO&lt;/code&gt; into real production code—and Oliver notes he has already watched this exact failure mode cause production incidents. His advice: stop letting new &lt;code&gt;TODO&lt;/code&gt;s slip through code review (if a fix is important enough to mention, either fix it now or file a tracked issue with proper acceptance criteria), audit and purge stale &lt;code&gt;TODO&lt;/code&gt;s across your codebase before unleashing background maintenance agents, and if a note truly must live in the code, write an explanatory comment documenting &lt;em&gt;why&lt;/em&gt; the current code works the way it does rather than an open-ended instruction to change it.&lt;/p&gt;
&lt;h2 id="git-worktree-gotchas"&gt;&lt;a href="https://www.olafalders.com/2026/09/16/git-worktree-gotchas/" rel="noopener noreferrer"&gt;git worktree gotchas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olaf Alders notes that &lt;code&gt;git worktree&lt;/code&gt;—once a niche power-user feature—has gone mainstream thanks to developers running multiple coding agents in parallel across separate branches, but it comes with a few sharp edges if your tooling assumes a traditional single-checkout layout. In Git&amp;rsquo;s terminology, your initial &lt;code&gt;git clone&lt;/code&gt; creates the &lt;em&gt;main working tree&lt;/em&gt;, while &lt;code&gt;git worktree add&lt;/code&gt; creates &lt;em&gt;linked working trees&lt;/em&gt;. Almost every worktree gotcha stems from one implementation detail: inside a linked worktree, &lt;code&gt;.git&lt;/code&gt; is &lt;strong&gt;not a directory&lt;/strong&gt;—it is a plain text file containing a &lt;code&gt;gitdir:&lt;/code&gt; pointer back to &lt;code&gt;.git/worktrees/&amp;lt;name&amp;gt;&lt;/code&gt; inside the main working tree. Consequently, any naive script or tool that walks up parent directories looking for a &lt;code&gt;.git/&lt;/code&gt; &lt;em&gt;directory&lt;/em&gt; to find the repository root will walk right past the top of a linked worktree—and if you nested your linked worktrees inside a subdirectory of your main working tree, that script will silently resolve to the main working tree instead, running against the wrong files! Alders keeps his linked worktrees in a sibling directory outside the main checkout and recommends always using &lt;code&gt;git rev-parse --show-toplevel&lt;/code&gt; to find the current worktree root, or &lt;code&gt;dirname &amp;quot;$(git rev-parse --git-common-dir)&amp;quot;&lt;/code&gt; when a script inside a linked worktree needs to locate gitignored files like &lt;code&gt;.env&lt;/code&gt; in the main working tree.&lt;/p&gt;
&lt;p&gt;A third gotcha bites when running coding agents inside filesystem sandboxes like &lt;code&gt;nono&lt;/code&gt;, Docker, Landlock, or macOS Seatbelt. By default, Git hooks live in &lt;code&gt;.git/hooks&lt;/code&gt; inside the main working tree, which is outside the linked worktree&amp;rsquo;s directory tree and therefore blocked by the sandbox when the agent tries to run &lt;code&gt;git commit&lt;/code&gt;. The clean fix is to check your hooks into a tracked &lt;code&gt;.githooks/&lt;/code&gt; directory inside the repo and set &lt;code&gt;git config core.hooksPath .githooks&lt;/code&gt; using a &lt;strong&gt;relative&lt;/strong&gt; path. Because Git always &lt;code&gt;chdir&lt;/code&gt;s to the current worktree&amp;rsquo;s top-level directory before executing a hook, a relative &lt;code&gt;core.hooksPath&lt;/code&gt; resolves cleanly inside every linked worktree and stays completely within the sandbox boundary.&lt;/p&gt;</description></item><item><title>Newsletter #136</title><link>https://miti99.com/en/post/2026/10/04/</link><pubDate>Sun, 04 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #136.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="fast-and-hard-code"&gt;&lt;a href="https://lucumr.pocoo.org/2026/8/22/fast-hard-code/" rel="noopener noreferrer"&gt;Fast and Hard Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher observes that regardless of how far you buy into the &amp;ldquo;coding is solved&amp;rdquo; meme, the human learning curve of a programming language no longer acts as the gatekeeper it once did—because human syntax friction doesn&amp;rsquo;t slow down an AI agent. As a result, LLMs make initial language choice simultaneously less permanent (if you don&amp;rsquo;t like a codebase, you can port it to another language over a weekend, even one you barely know) and more driven by a language&amp;rsquo;s runtime characteristics and cultural aspirations. He sees developers shipping Rust today who would never have invested the months required to wrestle with the borrow checker by hand. Two trends reinforce this shift: a renewed appreciation for fast, resource-frugal software, and the realization that LLMs are exceptionally good at low-level performance optimization when given a benchmark and a test suite to keep behavior identical.&lt;/p&gt;
&lt;p&gt;Performance-obsessed builders like Mitchell Hashimoto, Charlie Marsh, Jarred Sumner, and Daniel Lemire have all embraced agentic workflows, and automated optimization loops let anyone hand a hot function to an agent and ask it to hill-climb on throughput. Consequently, new projects that care about speed and binary size increasingly reach for &amp;ldquo;hard&amp;rdquo; systems languages. Even Zig is benefiting—despite its core community&amp;rsquo;s skepticism toward AI: Cloudflare&amp;rsquo;s Artifacts service runs a full Git protocol engine written in Zig and compiled to a ~100 KB WebAssembly module, and Vercel recently shipped &lt;code&gt;fx&lt;/code&gt;, a coding agent written in Zig. Developers are also tackling intimidating domains like DWARF debug info, eBPF, custom network drivers, cryptography, and retro hardware that used to feel out of reach. The AI era may produce plenty of slop, Ronacher concludes, but it is also empowering a wave of fast, uncompromising systems software.&lt;/p&gt;
&lt;h2 id="shipping-video-calling-on-facebook"&gt;&lt;a href="https://molochinations.substack.com/p/shipping-video-calling-on-facebook" rel="noopener noreferrer"&gt;Shipping Video Calling on Facebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philip Su looks back 16 years to when he joined Facebook&amp;rsquo;s fledgling Seattle office as its second engineer after twelve years at Microsoft. At the time, Facebook had only around 500 engineers in total, and Su signed up as the sole full-time engineer building Facebook&amp;rsquo;s very first video calling product—later joined by teammates like Denise Noyes and Vijaye Raji—small enough that the team reviewed product iterations directly with Mark Zuckerberg. Because WebRTC didn&amp;rsquo;t exist yet, Facebook partnered with Skype to embed a downloadable native Skype client binary that users installed before placing a call. Su pulls no punches about the quality of Skype&amp;rsquo;s codebase at the time: call setup succeeded only 82% of the time, and when he asked Skype&amp;rsquo;s engineers what their own baseline call-setup success rate was, they replied, &amp;ldquo;We don&amp;rsquo;t track that metric&amp;rdquo;—relying solely on post-call user star ratings. Ironically, routing call-signaling packets over Facebook Messenger&amp;rsquo;s infrastructure exposed that Messenger itself was silently dropping messages at a surprising rate, forcing Facebook to harden its own real-time messaging backbone.&lt;/p&gt;
&lt;p&gt;The six weeks following launch were the most grueling crunch of Su&amp;rsquo;s career: shipping hotfix after hotfix from 8 a.m. to midnight seven days a week, subsisting on office junk food, and somehow still losing over 10 pounds from the stress. One fun Easter egg: the outgoing ringtone melody was literally the musical notes &lt;strong&gt;F–A–C–E&lt;/strong&gt;. By the end of that six-week blitz, call reliability was solid, and Su used the feature to have his very first video call with his parents—a technology that COVID and WebRTC have since made as mundane as a phone call.&lt;/p&gt;
&lt;h2 id="ai-is-removing-the-middle-class-of-software-engineering"&gt;&lt;a href="https://blog.florianherrengt.com/ai-removing-middle-class-software-engineering.html" rel="noopener noreferrer"&gt;AI is removing the middle class of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Florian Herrengt opens with a scene that has become all too familiar in 2026: a senior engineer logs in on Monday morning to find seven pull requests waiting for review, the first of which is a 24,000-line diff accompanied by an AI-generated summary. When a subtle bug crops up for the fourth time, the developer who opened the PR can&amp;rsquo;t explain where the data originates—their only move is to paste the stack trace back into Claude. In Herrengt&amp;rsquo;s view, AI has removed the natural speed limit of software development: teams with weak engineering culture now drive off a cliff ten times faster, and the tragedy is that to an inexperienced eye, the app still looks like it works. Undoing a bad architectural decision is much harder than generating it—an LLM can add three unnecessary database tables in ten minutes, but untangling them once real customer data lands in production requires a painful, high-risk migration.&lt;/p&gt;
&lt;p&gt;Weak code has always existed, Herrengt notes, but the difference today is velocity—like crashing a car at 200 km/h instead of 30 km/h. Code review, tests, and CI pipelines still exist, but they were designed for a world where human typing speed naturally throttled the volume of changes entering the pipe. A developer churning out ten massive AI-generated PRs a day isn&amp;rsquo;t necessarily creating value; they are often just shifting the cognitive burden onto the team&amp;rsquo;s most senior, hardest-to-replace engineers. He predicts AI will hollow out the middle of the engineering market and widen compensation gaps: strong engineers with deep system judgment become exponentially more valuable, while developers who use AI as a substitute for understanding rather than an amplifier of it will struggle to stay employable.&lt;/p&gt;
&lt;h2 id="the-fastest-double-to-string-algorithm-youve-never-heard-of"&gt;&lt;a href="https://vitaut.net/posts/2026/yy-dtoa/" rel="noopener noreferrer"&gt;The fastest double-to-string algorithm you’ve never heard of&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Victor Zverovich, author of &lt;code&gt;{fmt}&lt;/code&gt; and the &lt;code&gt;zmij&lt;/code&gt; floating-point formatting library, spotlights one of the fastest &lt;code&gt;dtoa&lt;/code&gt; (double-to-string) algorithms in existence—one that almost nobody has heard of. It lives quietly inside &lt;code&gt;yy_double.c&lt;/code&gt; in &lt;code&gt;ibireme&lt;/code&gt;&amp;rsquo;s &lt;code&gt;yyjson&lt;/code&gt; C library, has no accompanying academic paper, and has no formal name beyond its filename prefix, so Zverovich simply calls it &lt;strong&gt;&amp;ldquo;yy&amp;rdquo;&lt;/strong&gt;. In fact, Zverovich&amp;rsquo;s own &lt;code&gt;zmij&lt;/code&gt; library started out as an optimized port of the Schubfach algorithm before he swapped its core over to &lt;code&gt;yy&lt;/code&gt;. Like Ryū, Dragonbox, and Schubfach, &lt;code&gt;yy&lt;/code&gt; solves the shortest-roundtrip formatting problem: finding the shortest decimal representation that parses back to the exact same IEEE 754 binary floating-point number by picking the coarsest decimal grid that lands inside the value&amp;rsquo;s rounding interval.&lt;/p&gt;
&lt;p&gt;What makes &lt;code&gt;yy&lt;/code&gt; remarkably fast is that it needs only a &lt;em&gt;single&lt;/em&gt; 128-bit multiplication by a precomputed power of 10 in the common case, whereas classic Schubfach requires two or three 192-bit multiplications. For a given &lt;code&gt;double&lt;/code&gt;, &lt;code&gt;yy&lt;/code&gt; estimates the decimal exponent via a fixed-point approximation of $\log_{10}(2)$, scales the significand once, and evaluates four candidate decimal values—two on the fine grid and two on the coarse (multiples of 10) grid. Three simple predicates select the winner, preferring a shorter coarse-grid candidate whenever it falls inside the rounding interval. Half-ULP interval bounds are derived via cheap bit shifts rather than extra multiplications, and round-half-to-even ties are resolved by checking the least significant bit of the original significand. Zverovich includes an interactive visualization on 8-bit &lt;code&gt;E4M3&lt;/code&gt; floats to show how edge cases like &lt;code&gt;192&lt;/code&gt; format cleanly as &lt;code&gt;&amp;quot;2e2&amp;quot;&lt;/code&gt; instead of &lt;code&gt;&amp;quot;19e1&amp;quot;&lt;/code&gt;, concluding that brilliant algorithms buried inside practical open-source libraries deserve the same recognition as those published in academic venues.&lt;/p&gt;
&lt;h2 id="quake-shareware-a-cd-rom-just-a-little-too-full"&gt;&lt;a href="https://fabiensanglard.net/quake_shareware_cd/index.html" rel="noopener noreferrer"&gt;Quake Shareware, a CD-ROM just a little too full&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fabien Sanglard tells the story of id Software&amp;rsquo;s infamous 1996 &lt;em&gt;Quake&lt;/em&gt; shareware CD-ROM. In the mid-1990s, a 640 MiB CD-ROM held vastly more space than a typical game needed. Because the &lt;em&gt;Quake&lt;/em&gt; shareware episode took up only 22 MiB, id Software decided to fill the remaining ~600 MiB with encrypted full retail versions of &lt;em&gt;Quake&lt;/em&gt; and their entire back catalog (&lt;em&gt;DOOM&lt;/em&gt;, &lt;em&gt;DOOM II&lt;/em&gt;, &lt;em&gt;Final DOOM&lt;/em&gt;, &lt;em&gt;Heretic&lt;/em&gt;, &lt;em&gt;Hexen&lt;/em&gt;). Players could buy the disc at retail for $9.95, play the shareware episode, call &lt;code&gt;1-800-ID-GAMES&lt;/code&gt;, read a dynamic &lt;code&gt;CHALLENGE&lt;/code&gt; code over the phone, pay by credit card, and receive an unlock &lt;code&gt;SERIAL&lt;/code&gt; code—with the challenge changing on every run to prevent customers from sharing a single unlock code with friends. The DRM wrapper, provided by TestDrive Corporation, &amp;ldquo;denatured&amp;rdquo; each game&amp;rsquo;s &lt;code&gt;.EXE&lt;/code&gt; by overwriting its first 32 KiB and storing the encrypted original header in a companion file. Yet just 39 days after the CD hit store shelves, the cracking group GNOMON released &lt;code&gt;QCRACK.EXE&lt;/code&gt;, a tiny keygen that computed valid &lt;code&gt;SERIAL&lt;/code&gt; codes from any &lt;code&gt;CHALLENGE&lt;/code&gt; for every game on the disc—leaving id Software stuck with nearly 150,000 unsold CDs in a warehouse.&lt;/p&gt;
&lt;p&gt;Reverse-engineering the installer executable &lt;code&gt;FLOW.EXE&lt;/code&gt; reveals why the scheme collapsed instantly: the unlock &lt;code&gt;SERIAL&lt;/code&gt; didn&amp;rsquo;t actually contain the decryption key! The symmetric decryption key was already sitting right inside &lt;code&gt;FLOW.EXE&lt;/code&gt; on the disc; the installer simply ran the exact same hash function on the &lt;code&gt;CHALLENGE&lt;/code&gt; string to generate the expected &lt;code&gt;SERIAL&lt;/code&gt; locally and compared it against what the user typed—pure security by obscurity. Worse still, Sanglard discovered that &lt;em&gt;Final DOOM&lt;/em&gt; couldn&amp;rsquo;t even be unlocked legitimately via the phone center because of a capitalization typo (&lt;code&gt;&amp;quot;Final&amp;quot;&lt;/code&gt; vs &lt;code&gt;&amp;quot;FINAL&amp;quot;&lt;/code&gt;) in the encrypted catalog metadata file &lt;code&gt;SKU.17&lt;/code&gt;—which itself was accompanied by an unencrypted plain-text copy, &lt;code&gt;SKU.TXT&lt;/code&gt;, left right on the mastered CD by mistake. Sanglard attributes the blunders to &amp;ldquo;Fab&amp;rsquo;s Razor&amp;rdquo;: never attribute to stupidity what can be adequately explained by crunch-time deadline pressure.&lt;/p&gt;
&lt;h2 id="how-instacart-built-a-modern-search-infrastructure-on-postgres"&gt;&lt;a href="https://tech.instacart.com/how-instacart-built-a-modern-search-infrastructure-on-postgres-c528fa601d54" rel="noopener noreferrer"&gt;How Instacart Built a Modern Search Infrastructure on Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Instacart&amp;rsquo;s search engineering team recounts migrating their core product search infrastructure—spanning billions of grocery items across thousands of retailers, millions of daily searches, and billions of daily price, inventory, and promotion updates—off Elasticsearch and onto PostgreSQL. Originally, full-text search ran on Elasticsearch, but its denormalized document model meant every inventory or price change triggered massive partial-document re-indexing across the cluster, overwhelming write capacity and making data-repair backfills take days. By moving to a sharded, highly normalized PostgreSQL architecture using &lt;code&gt;GIN&lt;/code&gt; indexes and a custom C extension for &lt;code&gt;ts_rank&lt;/code&gt;, Instacart cut write amplification by 10x, gained the ability to index hundreds of gigabytes of ML ranking features in separate tables joined at query time via SQL, and cut search latency in half by pushing scoring computation down next to NVMe storage rather than hauling large document payloads up to the application tier.&lt;/p&gt;
&lt;p&gt;In 2021, the team added semantic vector search via a standalone FAISS approximate-nearest-neighbor (ANN) service using MiniLM embeddings, blending lexical and vector results in the application tier. However, splitting retrieval across two systems forced the FAISS service to overfetch thousands of candidates before filtering out out-of-stock items, complicated relevance tuning, and required maintaining two distributed data pipelines in sync. Their final evolution unified both lexical and vector retrieval inside PostgreSQL using &lt;code&gt;pgvector&lt;/code&gt;, allowing real-time inventory availability to act as a native SQL filter alongside vector similarity. By consolidating hundreds of per-retailer HNSW indexes into cohort indexes grouped by retailer size, tuning parallel query workers, and storing quantized embeddings &lt;code&gt;PLAIN&lt;/code&gt; (inline) rather than in &lt;code&gt;TOAST&lt;/code&gt; tables, &lt;code&gt;pgvector&lt;/code&gt; delivered superior recall at comparable latency—cutting zero-result searches by 6% in A/B tests and driving a major lift in gross transaction value.&lt;/p&gt;
&lt;h2 id="curl-performance"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/08/14/curl-performance-2/" rel="noopener noreferrer"&gt;curl performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;code&gt;curl&lt;/code&gt; creator Daniel Stenberg shares how the project finally launched a public continuous performance dashboard at &lt;code&gt;curl.se/perf&lt;/code&gt; after years of the idea sitting on the wishlist because nobody had time to build an elaborate benchmarking platform. After finding Grafana too heavy for what he wanted, Stenberg decided not to let perfection be the enemy of good and built the entire pipeline using tools he already knew inside out. Because shared cloud CI runners are too noisy for repeatable performance measurements, the benchmarks run on a dedicated multi-core machine sitting in his own office. Every twenty minutes, a &lt;code&gt;cron&lt;/code&gt; job triggers a shell script that pulls the latest &lt;code&gt;git&lt;/code&gt; commits, compiles &lt;code&gt;curl&lt;/code&gt;, and runs 24 microbenchmarks—measuring metrics like throughput when transferring 100 GB over &lt;code&gt;localhost&lt;/code&gt; and the exact count and byte total of &lt;code&gt;malloc&lt;/code&gt;/&lt;code&gt;calloc&lt;/code&gt;/&lt;code&gt;strdup&lt;/code&gt; heap allocations during an HTTP download. A second script parses the logs and generates static SVG graphs with &lt;code&gt;gnuplot&lt;/code&gt;, pushing the updated dashboard straight to the website. Within hours of the page going live, contributors were already submitting patches to shave allocations and speed up hot paths.&lt;/p&gt;
&lt;p&gt;Each commit is tested across multiple runs, plotting minimum, median, and maximum values. Because OS packages, kernel versions, and third-party TLS libraries inevitably shift over months, raw timings are most useful in the short term for catching accidental regressions immediately. To guard against slow &amp;ldquo;boiling frog&amp;rdquo; bloat over the long term, Stenberg added manually configured threshold &amp;ldquo;stakes&amp;rdquo; for key metrics, paired with Largest-Triangle-Three-Buckets (LTTB) downsampling for long-range charts and Mann-Kendall / Sen&amp;rsquo;s Slope statistical tests to flag gradual upward trends automatically. Even early on, the dashboard surfaced an instructive trade-off: a PR that reduced the &lt;em&gt;number&lt;/em&gt; of heap allocations had accidentally bloated the size of &lt;code&gt;curl&lt;/code&gt;&amp;rsquo;s main session struct.&lt;/p&gt;
&lt;h2 id="compression-is-prediction"&gt;&lt;a href="https://ngrok.com/blog/compression-is-prediction" rel="noopener noreferrer"&gt;Compression is prediction&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Sexton at ngrok takes readers on an interactive visual tour of information theory to explain a profound equivalence: &lt;strong&gt;data compression is prediction, and large language models are data compressors&lt;/strong&gt;. Compression works by exploiting statistical redundancy—from simple run-length encoding (&lt;code&gt;AAAAAB&lt;/code&gt; → &lt;code&gt;5A1B&lt;/code&gt;) to modern codecs composed of three stages: a &lt;em&gt;transform&lt;/em&gt; that exposes patterns, a &lt;em&gt;model&lt;/em&gt; that predicts a probability distribution for the next symbol, and an &lt;em&gt;entropy coder&lt;/em&gt; that turns those probabilities into bits. While Huffman coding (used in &lt;code&gt;gzip&lt;/code&gt; and Brotli) assigns shorter bitstrings to more frequent symbols, it can never use fewer than 1 bit per symbol; &lt;em&gt;arithmetic coding&lt;/em&gt; overcomes that limit by subdividing the interval $[0, 1)$ proportionally to each symbol&amp;rsquo;s predicted probability, encoding an entire message as a single high-precision binary fraction that approaches Shannon&amp;rsquo;s theoretical entropy limit ($-\log_2 P$).&lt;/p&gt;
&lt;p&gt;The better your model predicts the next symbol given prior context, the fewer bits the entropy coder needs: the letter &lt;code&gt;U&lt;/code&gt; is relatively rare in English overall, yet nearly 100% certain right after &lt;code&gt;Q&lt;/code&gt;, costing almost zero bits to encode when the model knows that context. That is the exact objective an LLM is trained on: predicting a probability distribution over the next token, where the cross-entropy loss function literally measures how many bits an arithmetic coder would need to encode the true next token using the model&amp;rsquo;s predictions. On a passage from Charles Dickens, a simple first-order Markov model compresses the text to 24% of its original size, whereas pairing &lt;code&gt;GPT-2&lt;/code&gt; with an arithmetic coder shrinks it to 10%. We don&amp;rsquo;t replace &lt;code&gt;zstd&lt;/code&gt; with LLMs for everyday file archiving only because both sender and receiver would need gigabytes of model weights and heavy GPU compute—but mathematically, training a better predictor and building a tighter compressor are the exact same problem.&lt;/p&gt;
&lt;h2 id="how-anthropic-builds-and-how-engineering-will-change-soon"&gt;&lt;a href="https://www.developing.dev/p/how-anthropic-builds-and-how-engineering" rel="noopener noreferrer"&gt;How Anthropic Builds And How Engineering Will Change Soon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ryan Peterman interviews Thariq Shihipar, an engineer on Anthropic&amp;rsquo;s Claude Code team, about how engineers inside Anthropic work with frontier models every day. Shihipar&amp;rsquo;s first piece of advice for new hires is to treat Claude as a thought partner, feed it rich context, and constantly look to step up one level of abstraction: instead of just using the model to write a feature, build the system or skill that enables the model to build that whole class of features reliably. He argues that &lt;em&gt;harnesses&lt;/em&gt; are becoming more important, not less: the smarter a model gets and the longer it runs autonomously, the more sophisticated the surrounding software—like Auto mode, sandboxes, and interactive Artifacts—needs to be so the agent can act safely and present its work clearly to humans. In his own daily workflow, he pairs Claude Fable for open-ended planning, brainstorming, and spec writing with Claude Opus 5 for disciplined implementation, and uses &amp;ldquo;loop engineering&amp;rdquo; (automated systems that prompt Claude on a schedule or trigger) to stay on top of bug queues and maintenance work that teams previously lacked bandwidth to touch.&lt;/p&gt;
&lt;p&gt;On writing internal docs, his personal rule is simple: never send AI-generated text unless you would be completely comfortable sharing the exact prompt that produced it; let Claude draft data-heavy status reports, but write strategy memos and opinionated essays yourself. For codebase hygiene, nitpicking variable names and style conventions matters less in an agentic world than investing in automated simplification skills and writing roughly 100x more automated tests—especially request-replay harnesses and chaos testing—to keep incident rates down as commit velocity climbs. Learning how to code remains as valuable as ever: only someone who deeply understands systems can judge whether software is actually good, and &amp;ldquo;coding is solved&amp;rdquo; simply means translating a clear spec into working syntax is no longer the unpredictable bottleneck it used to be.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-convert-a-timestamp--hour-min-sec"&gt;&lt;a href="https://www.benjoffe.com/fast-time-of-day" rel="noopener noreferrer"&gt;A faster way to convert a timestamp ➜ Hour, Min, Sec&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on his fast day-of-the-week algorithm, Ben Joffe tackles splitting an integer number of seconds in a day (&lt;code&gt;0..86399&lt;/code&gt;) into hours, minutes, and seconds. Most standard datetime libraries take around 16 CPU cycles for this conversion because the textbook approach—dividing by &lt;code&gt;3600&lt;/code&gt; to get the hour, taking the remainder, and dividing by &lt;code&gt;60&lt;/code&gt; to get the minute—creates a long serial instruction dependency chain. A second family of algorithms (used in V8, Boost, and &lt;code&gt;musl&lt;/code&gt;) computes each field independently, while Cassio Neri&amp;rsquo;s 2020 algorithm uses a single 64-bit magic multiplication and extracts minutes and seconds from the lower bits, serving as Joffe&amp;rsquo;s benchmark baseline. Joffe&amp;rsquo;s first variant (&lt;strong&gt;V1&lt;/strong&gt;) breaks the serial dependency chain by computing &lt;code&gt;time / 60&lt;/code&gt; and &lt;code&gt;time / 3600&lt;/code&gt; in parallel so the CPU&amp;rsquo;s out-of-order execution engine can overlap both divisions, then derives seconds and minutes via simple multiplications and subtractions.&lt;/p&gt;
&lt;p&gt;His &lt;strong&gt;V2&lt;/strong&gt; variant uses fixed-point arithmetic in 64 bits: multiplying &lt;code&gt;time&lt;/code&gt; by $\lfloor 2^{32}/3600 \rfloor + 1$ puts the hour directly in the upper 32 bits and the fractional remainder of the hour in the lower 32 bits; multiplying that lower 32-bit fraction by &lt;code&gt;60&lt;/code&gt; yields the minute in the upper 32 bits, and multiplying the new lower 32-bit fraction by &lt;code&gt;60&lt;/code&gt; again yields the second. &lt;strong&gt;V3&lt;/strong&gt; applies the Mersenne-like modulo trick from his previous post, computing seconds via &lt;code&gt;((time + 4 * tmin) % 64)&lt;/code&gt; since $60 = 64 - 4$. The post also covers variants for millisecond timestamps, leap seconds, ARM NEON SIMD, and SWAR (SIMD Within A Register). On an Apple M4 Pro, V1, V2, and V3 run in 0.65x, 0.64x, and 0.60x the time of Neri&amp;rsquo;s baseline respectively—and down to 0.49x on a Ryzen 9 9950X3D with Clang—with patches already adopted in Elixir and Java&amp;rsquo;s &lt;code&gt;ITU&lt;/code&gt; library. Because these fast fixed-point multipliers are only exact over bounded input ranges (&lt;code&gt;0..86399&lt;/code&gt; or slightly higher), Joffe recommends &lt;strong&gt;V2&lt;/strong&gt; as the best all-around choice for standard library implementations.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=WvSVSbGo0wI" rel="noopener noreferrer"&gt;HTTP vs HTTPS Explained&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;ByteByteGo&amp;rsquo;s video compares HTTP and HTTPS, explaining how HTTPS uses TLS to encrypt data in transit and authenticate the server, keeping connections between browsers and websites secure.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6j7M!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2d0d1c6c-a864-4b20-b1fc-2d86c8ad2fab_2484x3002.png" alt="Top 12 Agent Skills You Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!m1c9!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8b053abe-404e-4bca-8e49-52a47392ab83_2484x3002.png" alt="9 Types of API Testing"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4xag!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fac1ed471-18f6-45dd-ad5f-02bc6d96d375_2484x3002.png" alt="Forward Proxy, Reverse Proxy, and API Gateway Explained"&gt;&lt;/p&gt;</description></item><item><title>Newsletter #132</title><link>https://miti99.com/en/post/2026/09/10/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #132.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="perfection-is-not-over-engineering"&gt;&lt;a href="https://var0.xyz/posts/perfection-is-not-over-engineering.html" rel="noopener noreferrer"&gt;Perfection is not over-engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The phrase &amp;ldquo;we don&amp;rsquo;t want to aim for perfection&amp;rdquo; comes up in engineering meetings more times than the author can count. He understands the caution—over-engineering has burned out plenty of teams—but argues the industry is conflating two completely different things. Over-engineering is simply &lt;em&gt;solving the wrong problem&lt;/em&gt;, usually with good intentions and a pile of accidental complexity attached. A &amp;ldquo;perfect&amp;rdquo; solution, by contrast, is very real once requirements are clear and all constraints are on the table: tighten the constraints enough and only one design fits, making it perfect precisely because nothing else satisfies the actual problem. Picking Python on serverless to skip a build step might be ideal for one team and completely wrong for a team that doesn&amp;rsquo;t know Python or needs predictable low latency.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, every system is a product: internal libraries, APIs, and CLI tools all have real users with real needs. The clearest tell of over-engineering is asking &amp;ldquo;why did we build it this way?&amp;rdquo; and getting an answer that falls apart under scrutiny. A classic example is a three-person team maintaining five microservices that share the same underlying data: foreign keys once enforced by the database turn into loosely coupled string IDs, and one service deletes records without the others knowing—all to buy &amp;ldquo;independent deployability,&amp;rdquo; a problem the three-person team never actually had. The takeaway: that isn&amp;rsquo;t an excess of perfection, it&amp;rsquo;s a failure of requirements gathering. The enemy was never perfection; it was vague requirements.&lt;/p&gt;
&lt;h2 id="claude-is-not-a-compiler"&gt;&lt;a href="https://blog.exe.dev/claude-is-not-a-compiler" rel="noopener noreferrer"&gt;Claude Is Not a Compiler&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Josh Bleecher Snyder argues that Claude is not a compiler—because it is &lt;em&gt;better&lt;/em&gt; than one. In the idealized textbook view, software is built in neat horizontal layers: vision becomes strategy, product specs become engineering plans, source code becomes binaries, with each layer owned by a different role making thousands of micro-decisions. In reality, layers constantly leak and rub against one another, and working &lt;em&gt;across&lt;/em&gt; layers is where the biggest wins happen—just as the Empire State Building was designed and erected in under a year because the owners, architects, structural engineers, and contractors sat in the same room making cross-cutting trade-offs together. Claude can work vertically across all those layers at once—discussing strategy, architecture, source code, and assembly without needing to schedule a meeting.&lt;/p&gt;
&lt;p&gt;Snyder illustrates this with &lt;code&gt;exe.dev&lt;/code&gt;&amp;rsquo;s distributed DNS server. High-level strategic and architectural decisions were settled human-to-human; for the rest, he spun up multiple parallel agent loops to build full implementations with tests, then had another agent compare the resulting designs. What shocked him was how many consequential design decisions the agents quietly made on their own without asking—and how differently each agent resolved them, such as how to handle a database state rollback. Repeating this multi-agent exploration three times let him distill a concise design document that guided the final agent across every critical decision point. A week later, having barely read the raw code himself, he could answer every question from his teammates, and a month into production the DNS server had zero incidents. He calls this &amp;ldquo;vibe-engineering&amp;rdquo;—and predicts that soon we&amp;rsquo;ll just call it software engineering.&lt;/p&gt;
&lt;h2 id="in-defense-of-not-understanding-your-codebase"&gt;&lt;a href="https://www.seangoedecke.com/in-defense-of-not-understanding-your-codebase/" rel="noopener noreferrer"&gt;In defense of not understanding your codebase&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How thoroughly must an engineer understand their codebase? Sean Goedecke argues the answer depends entirely on the environment. Developers working on small, self-contained codebases like Redis will insist you must understand every line; engineers working on massive systems like Google or GitHub know that is literally impossible. Because the first group dominates online discourse, Goedecke steps up to defend the second: in a sufficiently large system, having only a &lt;em&gt;partial&lt;/em&gt; understanding isn&amp;rsquo;t a moral failing—it is the best anyone can ever achieve. At scale, everyone operates with an incomplete, slightly wrong mental model, so effective engineers must get comfortable making educated guesses.&lt;/p&gt;
&lt;p&gt;He pushes back against Peter Naur&amp;rsquo;s famous essay &lt;em&gt;&amp;ldquo;Programming as Theory Building.&amp;rdquo;&lt;/em&gt; While agreeing that a programmer&amp;rsquo;s most valuable asset is the mental &amp;ldquo;theory&amp;rdquo; of how the program works, Goedecke rejects Naur&amp;rsquo;s conclusion that once the original team leaves, a codebase is dead and ought to be rewritten from scratch. First, large legacy systems encode thousands of hard-won edge cases that a greenfield rewrite won&amp;rsquo;t rediscover until production breaks, and successful rewrites almost always happen incrementally by carving up the existing system. Second, &amp;ldquo;abandoned&amp;rdquo; codebases are successfully revived in industry all the time: you start by tracing one end-to-end flow and expand your mental map from there. Finally, preserving a pristine mental theory is just one business value among many, routinely traded off whenever teams collaborate or patch urgent security vulnerabilities. Being a professional engineer means aligning with your company&amp;rsquo;s trade-offs—even when that means working effectively in code you don&amp;rsquo;t fully understand.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-the-network"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-01-Beyond-Happy-Path-Engineering-the-Network/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: the Network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This opening installment of Gabor Koos&amp;rsquo;s &lt;em&gt;&amp;ldquo;Beyond Happy Path Engineering&amp;rdquo;&lt;/em&gt; series examines the assumptions that local development environments indulge but production mercilessly punishes, starting with the network. A network call looks like a simple function call, but it crosses a boundary into a system you do not control. Using checkout payment authorization as a running example, Koos notes that &amp;ldquo;clean&amp;rdquo; failures like a refused connection are easy to handle compared to a timeout &lt;em&gt;after&lt;/em&gt; the request was sent: the operation may have succeeded, failed, or still be sitting in a queue. The foundational rule of distributed systems is that &lt;em&gt;not receiving a response does not mean the operation didn&amp;rsquo;t happen&lt;/em&gt;. Latency is also a failure mode in disguise: a slow downstream service ties up threads and connection pools, averages hide catastrophic tail latency, and slowness cascades into full outages faster than hard errors.&lt;/p&gt;
&lt;p&gt;Koos outlines the essential defenses: treat timeouts as explicit design decisions derived from per-request latency budgets; retry only when safe, backing mutations with idempotency keys passed on every attempt alongside exponential backoff and jitter to prevent thundering herds; and propagate deadlines and cancellation contexts downstream so abandoned work stops immediately. Circuit breakers and load shedding protect overloaded services, while graceful degradation separates critical path steps (like taking payment) from deferrable side effects (like sending confirmation emails) using explicit order states like &lt;code&gt;&amp;quot;pending&amp;quot;&lt;/code&gt;. GitHub&amp;rsquo;s October 2018 outage—where a network partition lasting under a minute caused over 24 hours of degraded service—vividly illustrates the cost of happy-path network assumptions.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-time"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-19-Beyond-Happy-Path-Engineering-Time/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of the series turns to time—seemingly the simplest dependency of all: grab the current timestamp, compare two values, and make a decision. The running example is a checkout flow that holds inventory for fifteen minutes using &lt;code&gt;if now() &amp;gt; reservation.expiresAt&lt;/code&gt;. If the cleanup worker&amp;rsquo;s clock drifts two minutes ahead of the checkout server&amp;rsquo;s clock, items get released back to inventory while the customer is mid-payment. Wall clocks can jump forward or backward mid-execution via NTP adjustments, turning elapsed durations negative, and timestamps across different machines cannot reliably establish event ordering. Worst of all, time bugs fail silently: services stay up, dashboards stay green, and the system quietly makes wrong business decisions.&lt;/p&gt;
&lt;p&gt;The core lesson is that &amp;ldquo;time&amp;rdquo; actually answers four distinct questions: &lt;em&gt;wall-clock time&lt;/em&gt; records when an event happened in the real world, &lt;em&gt;monotonic time&lt;/em&gt; measures elapsed durations and timeouts on a single machine, &lt;em&gt;logical time&lt;/em&gt; (versions or sequence numbers) orders competing updates, and &lt;em&gt;business time&lt;/em&gt; governs billing periods, cutoff windows, and user time zones. Expiration should be modeled as an explicit &lt;em&gt;state transition&lt;/em&gt; rather than a passive timestamp comparison: use timestamps only to find candidate rows, then execute a conditional write that transitions the row to &lt;code&gt;expired&lt;/code&gt; only if its status is still &lt;code&gt;reserved&lt;/code&gt;, making late or duplicate cleanup runs harmless. When local clocks aren&amp;rsquo;t enough to arbitrate, reconcile against the authoritative external source, such as the payment provider. Cloudflare&amp;rsquo;s New Year&amp;rsquo;s 2017 leap-second DNS outage—when subtracting two &lt;code&gt;time.Now()&lt;/code&gt; readings yielded a negative number and triggered a panic—serves as a classic cautionary tale.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-databases"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-01-Beyond-Happy-Path-Engineering-Databases/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Databases&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part three tackles databases, the layer developers most often treat as an infallible black box. Using an e-commerce checkout flow that works flawlessly on a developer&amp;rsquo;s laptop because there is zero concurrent traffic, Koos shows how production changes everything: checkouts, admin dashboards, background jobs, analytics queries, and schema migrations all compete for the same connections and locks. A single slow query can exhaust the connection pool, causing incoming requests to queue up, users to hit refresh, and &amp;ldquo;checkout to go down&amp;rdquo; even though the database hasn&amp;rsquo;t crashed. Two concurrent requests can both read &lt;code&gt;stock = 1&lt;/code&gt; and both sell the last item; wrapping code in a transaction doesn&amp;rsquo;t magically prevent race conditions unless business invariants are enforced explicitly. On top of that come lagging read replicas, commit timeouts that leave the caller unsure whether the write succeeded, deadlocks, and schema migrations running alongside multiple live application versions.&lt;/p&gt;
&lt;p&gt;Koos recommends starting from the invariant that must never be violated—such as &amp;ldquo;never sell more than available inventory&amp;rdquo;—and enforcing it directly in the atomic write statement (&lt;code&gt;UPDATE ... WHERE stock &amp;gt;= quantity&lt;/code&gt;) backed by database constraints rather than application-level checks alone. Keep transactions short, never make network calls inside a transaction, and retry only transient errors. Make writes idempotent, define explicit data-freshness requirements per endpoint before routing reads to replicas, run schema migrations in backward-compatible expand-and-contract phases, and rehearse backup restores regularly. Atlassian&amp;rsquo;s 2022 outage and GitHub&amp;rsquo;s 2018 incident both prove that recovery speed matters just as much as data durability.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-storage"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-11-Beyond-Happy-Path-Engineering-Storage/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Storage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part four examines object storage, which looks simpler than a relational database but hides a fundamental trap: your database and your object store are two separate systems with no shared transaction coordinator. Consider a document upload flow: write the file to S3, insert a metadata row in the database, and return the URL. If the blob upload succeeds but the database insert fails, you get an invisible orphaned object; flip the order and a failed upload leaves a database row pointing to a missing blob that serves &lt;code&gt;404&lt;/code&gt;s. Abandoned multipart uploads quietly rack up storage bills, presigned URLs remain valid even after the database record is deleted, concurrent uploads to the same key silently overwrite each other, and CDNs keep serving stale cached files. High durability also doesn&amp;rsquo;t equal recoverability, because an accidental &lt;code&gt;DELETE&lt;/code&gt; is replicated just as durably as a valid write.&lt;/p&gt;
&lt;p&gt;Koos advises ordering upload steps so failures fail safe, tracking lifecycle state explicitly in the database (&lt;code&gt;pending&lt;/code&gt;, &lt;code&gt;confirmed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;), and serving only &lt;code&gt;confirmed&lt;/code&gt; records. Object keys should use immutable UUIDs or content hashes rather than user-supplied filenames; large files should upload directly from the client via short-lived presigned URLs; and deletions should soft-delete the database row first before a background job purges the blob, backed by a periodic reconciliation sweeper. The 2014 demise of Code Spaces—which shut down permanently after an attacker gained access to their AWS control panel and wiped both production storage and backups—underscores why backups must live outside the blast radius of production credentials.&lt;/p&gt;
&lt;h2 id="everyone-should-know-simd"&gt;&lt;a href="https://mitchellh.com/writing/everyone-should-know-simd" rel="noopener noreferrer"&gt;Everyone Should Know SIMD&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SIMD has a reputation for being arcane, and Mitchell Hashimoto regularly meets strong engineers who write it off as too hard to learn or useful only in niche high-performance computing. He argues that reputation is undeserved: the vast majority of practical &amp;ldquo;process N items at a time&amp;rdquo; SIMD code follows a single five-step template, and once you internalize that template, writing SIMD is almost as straightforward as writing a standard &lt;code&gt;for&lt;/code&gt; loop. Because SIMD lets the CPU process multiple data elements in a single instruction, any loop scanning bytes, characters, or array elements is a candidate once inputs reach thousands or millions of bytes.&lt;/p&gt;
&lt;p&gt;The five-step template is: broadcast constants into vectors and initialize accumulators if needed; loop over the input in chunks equal to the vector width; perform parallel comparisons or arithmetic across all lanes; reduce or store the vector result; and handle the trailing remainder elements using your original scalar loop. Hashimoto walks through a real example from the Ghostty terminal emulator written in Zig: finding the end of a run of printable ASCII characters by scanning until a byte is &lt;code&gt;&amp;lt;= 0xF&lt;/code&gt;. The scalar loop is a one-liner; the SIMD version adds about 12 lines of code and delivers a theoretical 4x speedup on ARM NEON, 8x on AVX2, and 16x on AVX-512, measuring roughly 5x faster in real benchmarks on an Intel AVX2 machine. While compilers can sometimes auto-vectorize simple loops, whenever a hot path cares about a 5x speedup, Hashimoto prefers explicit, portable SIMD that won&amp;rsquo;t silently regress after a compiler upgrade or minor code tweak.&lt;/p&gt;
&lt;h2 id="htop-explained"&gt;&lt;a href="https://peteris.rocks/blog/htop/" rel="noopener noreferrer"&gt;htop explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pēteris Ņikiforovs admits that for years he used &lt;code&gt;htop&lt;/code&gt; without truly understanding half the numbers on screen—for instance, assuming a load average of &lt;code&gt;1.0&lt;/code&gt; on a dual-core machine meant the CPUs were 50% busy. So he dug into the Linux kernel sources and wrote a comprehensive visual guide breaking down every single bar and column in &lt;code&gt;htop&lt;/code&gt;. What makes the guide stand out is that he traces every metric back to its exact kernel source: uptime comes from &lt;code&gt;/proc/uptime&lt;/code&gt;, load average comes from &lt;code&gt;/proc/loadavg&lt;/code&gt;, and you can verify how &lt;code&gt;htop&lt;/code&gt; gathers them yourself by running it under &lt;code&gt;strace&lt;/code&gt; to see which files it opens.&lt;/p&gt;
&lt;p&gt;Load average isn&amp;rsquo;t CPU percentage at all—it is the exponentially damped moving average of runnable threads plus threads stuck in uninterruptible sleep waiting on disk or network I/O; the 1-minute figure reflects roughly 63% of the past minute&amp;rsquo;s load and 37% of the prior average. The guide then demystifies process states (&lt;code&gt;R&lt;/code&gt; running/runnable, &lt;code&gt;S&lt;/code&gt; interruptible sleep, &lt;code&gt;D&lt;/code&gt; uninterruptible sleep, &lt;code&gt;Z&lt;/code&gt; zombie terminated but not yet reaped by its parent), &lt;code&gt;NI&lt;/code&gt; nice values from &lt;code&gt;-20&lt;/code&gt; to &lt;code&gt;19&lt;/code&gt; and their relation to kernel priority (&lt;code&gt;PR = 20 + NI&lt;/code&gt;), and the memory columns: &lt;code&gt;VIRT&lt;/code&gt; includes unbacked virtual reservations and memory-mapped files so it&amp;rsquo;s rarely actionable, &lt;code&gt;RES&lt;/code&gt; is actual resident RAM (though shared libraries and copy-on-write pages get double-counted across processes), and &lt;code&gt;MEM%&lt;/code&gt; is simply &lt;code&gt;RES&lt;/code&gt; divided by total RAM. He wraps up by auditing every default background process on a fresh Ubuntu Server install to see which ones can be safely stripped out.&lt;/p&gt;
&lt;h2 id="the-productivity-experience-paradox"&gt;&lt;a href="https://annievella.com/posts/the-productivity-experience-paradox/" rel="noopener noreferrer"&gt;The Productivity-Experience Paradox&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the second article from her master&amp;rsquo;s research on how AI coding tools affect software engineers, Annie Vella shares findings from a longitudinal study tracking the exact same cohort of engineers across two waves six months apart (October 2024 to April 2025). On the productivity front, the news is consistently positive: 84% of respondents reported that AI helped them get more done in both waves. Yet developer experience—measured across the DevEx framework dimensions of feedback loops, cognitive load, and flow state—moved in the opposite direction: the share of engineers reporting a net-negative experience nearly doubled from 14% to 27%, and not a single engineer who fell into the negative group in Wave 1 recovered to an all-positive experience by Wave 2.&lt;/p&gt;
&lt;p&gt;The central finding is that productivity and developer experience—long assumed to rise and fall together—are decoupling: tracking the same individuals over time, experience degraded while output held steady, with a near-zero correlation ($r = 0.02$) between changes in flow state and changes in perceived productivity. That decoupling is dangerous because the business case for investing in DevEx has historically been &amp;ldquo;happy developers are productive developers&amp;rdquo;; when output stays high, rising cognitive strain stays invisible until it turns into burnout. Flow suffered the sharpest drop (negative reports rose from 7% to 20%) even as feedback loops sped up, and Vella suspects the two are linked: every fast AI response triggers a micro-context switch from creator to reviewer. Borrowing the term &amp;ldquo;junk flow&amp;rdquo; to describe a slot-machine-like loop of rapid prompting that mimics flow without deep satisfaction, she concludes that while AI boosts extrinsic output, it risks eroding the intrinsic craft and joy of software engineering.&lt;/p&gt;
&lt;h2 id="prefactoring-clear-the-way-for-your-new-feature"&gt;&lt;a href="https://testing.googleblog.com/2026/07/prefactoring-clear-way-for-your-new.html" rel="noopener noreferrer"&gt;Prefactoring: Clear the Way for Your New Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post from Google&amp;rsquo;s &lt;em&gt;&amp;ldquo;Tech on the Toilet&amp;rdquo;&lt;/em&gt; series opens with Kent Beck&amp;rsquo;s famous advice: &lt;em&gt;&amp;ldquo;First make the change easy (warning: this may be hard), then make the easy change.&amp;rdquo;&lt;/em&gt; When you try to bolt a new feature directly onto code that wasn&amp;rsquo;t structured to accommodate it, things get messy fast: tweaking one file forces changes in three others, and soon you&amp;rsquo;re knee-deep in unrelated modules. &lt;em&gt;Prefactoring&lt;/em&gt;—short for preparatory refactoring—is the discipline of restructuring existing code to fit the upcoming requirement &lt;em&gt;before&lt;/em&gt; writing the new feature, rather than promising yourself you&amp;rsquo;ll clean it up afterward.&lt;/p&gt;
&lt;p&gt;The payoffs are immediate: the new feature slots in naturally, code reviews go much faster because structural refactoring and behavioral changes live in separate commits, fewer bugs slip in because cleanup is isolated from new logic, and rollbacks are safer because each change is small and self-contained. In the post&amp;rsquo;s example, the first CL simply extracts a &lt;code&gt;get_display_name(user)&lt;/code&gt; helper to deduplicate name-formatting logic across the profile page and email templates; the second CL adds middle-name support with a one-line edit inside that helper. Even if you only spot the right abstraction mid-implementation, you can still split the cleanup into a preparatory CL—or spin off reviewer-suggested cleanups in parallel while your main CL is under review. Not every cleanup belongs up front, though: if a refactoring doesn&amp;rsquo;t directly unblock your feature, save it for later, or fold it in if it&amp;rsquo;s truly trivial.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #131</title><link>https://miti99.com/en/post/2026/09/09/</link><pubDate>Wed, 09 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #131.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-codename-one-javascript-port-is-now-free-and-open-source"&gt;&lt;a href="https://dev.to/codenameone/the-codename-one-javascript-port-is-now-free-and-open-source-2f84" rel="noopener noreferrer"&gt;The Codename One JavaScript Port Is Now Free and Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Codename One has open-sourced its JavaScript port under GPLv2 with the Classpath Exception. Previously restricted to Enterprise subscribers, the port is now available across all tiers, and developers can build web targets locally without even needing a Codename One account via a single Maven command powered by the bundled ParparVM compiler. ParparVM also replaces TeaVM as the default compiler for both local and cloud builds, though TeaVM remains available via a build hint for comparison. Architecturally, the application&amp;rsquo;s Java code runs inside a background Web Worker while browser interaction lives on the main UI thread, preventing Java code from accidentally coupling to the DOM or browser globals.&lt;/p&gt;
&lt;p&gt;The release also ships major framework additions. A unified Calendar API connects device calendars, Google Calendar, Microsoft 365, CalDAV, and &lt;code&gt;.ics&lt;/code&gt; files with support for recurring events, incremental sync, offline change queues, and conflict resolution. Bluetooth moves into the core framework with BLE, GATT, L2CAP, RFCOMM, and Web Bluetooth support. &lt;code&gt;EditField&lt;/code&gt;, &lt;code&gt;RichTextArea&lt;/code&gt;, and &lt;code&gt;CodeEditor&lt;/code&gt; now render and edit text directly on the canvas instead of overlaying native text inputs, while &lt;code&gt;RichTextComponent&lt;/code&gt; renders HTML, Markdown, AsciiDoc, and RTF without a WebView. A new proxy layer supports Jakarta Servlet, Node.js, PHP, AWS Lambda, Google Cloud Functions, and Cloudflare Workers. Finally, ParparVM adds compressed strings—halving memory usage for ASCII text—and Android API 36 becomes the default target next week.&lt;/p&gt;
&lt;h2 id="hacking-in-the"&gt;&lt;a href="https://committing-crimes.com/articles/2026-08-04-java-nameof/" rel="noopener noreferrer"&gt;Hacking in the &lt;code&gt;nameOf&lt;/code&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Java lacks C#&amp;rsquo;s &lt;code&gt;nameof&lt;/code&gt; expression for obtaining an identifier&amp;rsquo;s name as a compile-time string. That gap is especially annoying in argument validation, where you end up hardcoding parameter names into exception messages like &lt;code&gt;&amp;quot;name must not be blank&amp;quot;&lt;/code&gt;—and if someone renames the variable later without updating the string, the compiler won&amp;rsquo;t say a word. This article experiments with building a pure-Java &lt;code&gt;nameOf&lt;/code&gt; function that recovers variable names at runtime without bytecode instrumentation agents or annotation processors.&lt;/p&gt;
&lt;p&gt;The hack works in three steps. First, &lt;code&gt;StackWalker&lt;/code&gt; locates the caller frame that invoked &lt;code&gt;nameOf&lt;/code&gt;, yielding the class, method name, method descriptor, and exact bytecode index (BCI). Next, the caller class&amp;rsquo;s &lt;code&gt;.class&lt;/code&gt; file is loaded into memory and parsed into a &lt;code&gt;ClassModel&lt;/code&gt; using Java&amp;rsquo;s new Class-File API. Finally, the author simulates the JVM operand stack symbolically: instead of actual runtime values, each stack slot holds a symbolic label—such as a local variable or field name—which is propagated across load, store, field-access, and invocation instructions until the simulator reaches the exact BCI of the &lt;code&gt;nameOf&lt;/code&gt; call and reads the symbolic name sitting on top of the stack. The author strongly advises against using this in production: it breaks on unfamiliar opcodes, relies on optional debug info or the &lt;code&gt;-parameters&lt;/code&gt; compiler flag, may fail on non-&lt;code&gt;javac&lt;/code&gt; bytecode, and is barely tested. It is a delightful over-engineering exercise that doubles as a tour of JVM bytecode and the Class-File API.&lt;/p&gt;
&lt;h2 id="set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep"&gt;&lt;a href="https://dev.to/sshenvi/set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep-1jhj" rel="noopener noreferrer"&gt;Set It and Ship It: How I Let AI Agents Build My Java Services While I Sleep&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sudarshan Shenvi argues that AI agents are fully capable of building production-grade Java services autonomously over multi-hour runs, provided their work is gated by strict verification controls; without those gates, you just get plausible-sounding slop. He relies on three pillars: machine-verifiable requirements where every item specifies a concrete behavior or performance threshold that grades as pass or fail; a separate critic agent that audits the output item by item, since the builder agent must never grade its own homework; and an always-on execution harness with interactive permission prompts disabled so a five-hour run doesn&amp;rsquo;t stall waiting for a human click, paired with narrowly scoped credentials, sandboxed isolation, and hard spend limits.&lt;/p&gt;
&lt;p&gt;As an example, he walks through a ticket to build a payment reconciliation service. Instead of writing Java code, the engineer writes a 15-line requirements contract specifying REST endpoints, reconciliation logic, JPA entities, p95 latency under 500 ms, 100% test coverage, and security constraints. He kicks off the agent at 9:10 a.m. and walks away; the critic loop catches missing latency proof and a package structure violation, the builder agent fixes both, and by 11:35 a.m. he returns to a 15/15 passing scorecard with measured latency at 410 ms. Shenvi cautions that token consumption can spike unpredictably, so teams should enforce strict budget caps, run agents on isolated branches inside sandboxes, and always keep human code review before merging.&lt;/p&gt;
&lt;h2 id="software-abundance"&gt;&lt;a href="https://nader.substack.com/p/software-abundance" rel="noopener noreferrer"&gt;Software abundance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nader Dabit, a 14-year industry veteran currently at Cognition, writes that despite earlier anxieties about AI&amp;rsquo;s impact on software engineering, he has never been more optimistic about the field. He sees a sharp bifurcation in the job market: engineers who actively adopt AI-native workflows and pivot toward AI-driven growth areas are seeing stronger compensation and opportunities, while those who cling rigidly to narrow traditional silos like pure frontend or backend—or stay at slow-moving legacy enterprises—face headwinds and layoffs.&lt;/p&gt;
&lt;p&gt;The centerpiece of his argument is Jevons paradox: when the cost of producing software drops and capacity rises, demand for software doesn&amp;rsquo;t shrink—it expands dramatically. Teams he works with are now shipping 10x to 20x more pull requests than before, and cloud-hosted agents let non-specialists ship changes that previously required senior engineers. Higher velocity leads to more ambitious product roadmaps and a higher bar for polish. In Dabit&amp;rsquo;s view, software engineering isn&amp;rsquo;t disappearing; it is shedding the repetitive toil engineers disliked anyway—bug bashing, dependency upgrades, rote migrations—freeing humans to focus on judgment, curiosity, domain context, and taste, while reclaiming time for the creative experimentation that drew them to programming in the first place.&lt;/p&gt;
&lt;h2 id="the-development-pipeline-is-a-production-system"&gt;&lt;a href="https://sundry.jerryorr.com/2026/07/31/development-pipeline-is-a-production-system" rel="noopener noreferrer"&gt;The development pipeline is a production system&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jerry Orr argues that the software development pipeline is itself a production system, and when it breaks, engineering teams should treat the outage with the same urgency as a customer-facing incident. When the build is broken, developers cannot work; when the QA environment goes down, testers cannot verify releases. For those internal users, it is literally a production outage, and any component blocking the path from code commit to deployment—whether issue trackers, CI/CD runners, or a flaky test suite—represents a critical failure.&lt;/p&gt;
&lt;p&gt;Orr draws a parallel with manufacturing, where factories have long had disciplined processes to minimize assembly-line downtime, whereas software teams routinely neglect their own internal delivery infrastructure. He recommends explicitly cataloging and prioritizing every essential piece of the development pipeline: work and change-management platforms, developer tools like IDEs and build systems, artifact registries and local dev environments, CI/CD pipelines, QA environments, and automated test suites. Applying structured incident management—borrowed from IT service management and manufacturing—to developer infrastructure is essential, because a broken pipeline directly prevents value from reaching customers.&lt;/p&gt;
&lt;h2 id="how-llms-figure-out-what-you-mean---no-math-degree-required"&gt;&lt;a href="https://zarar.dev/how-ai-figures-out-what-you-mean-no-math-required/" rel="noopener noreferrer"&gt;How LLMs Figure Out What You Mean - No Math Degree Required&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains how a large language model figures out the meaning of a sentence without requiring any math background, using the question &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt; as a running example. Step one is turning words into numbers: text is split into tokens, each assigned an integer ID. A single ID number carries no semantic meaning on its own—there is no reason token #2 should be &amp;ldquo;similar&amp;rdquo; to token #3—so each token is mapped to an embedding vector, a long list of numbers whose dimensions jointly capture aspects of meaning so that words with similar meanings have similar vectors. You can picture vectors as arrows in space: synonyms point in the same direction, antonyms point in opposite directions, and unrelated words sit at right angles.&lt;/p&gt;
&lt;p&gt;To measure how closely two words align, the model uses the dot product, illustrated as two people pushing a shopping cart: push in the same direction and your forces add up to a high positive score; push at an angle and efficiency drops; push in opposite directions and you cancel each other out with a negative score. Because raw scores only make sense relative to one another, the model passes them through a &lt;code&gt;softmax&lt;/code&gt; function to convert them into percentages—like giving each word a single dollar of attention to slice up like a pizza among the other words in the sentence based on relevance. That is how, in &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt;, the word &lt;code&gt;&amp;quot;roar&amp;quot;&lt;/code&gt; directs most of its attention to &lt;code&gt;&amp;quot;lions&amp;quot;&lt;/code&gt; rather than &lt;code&gt;&amp;quot;Do&amp;quot;&lt;/code&gt;. All these vectors start out completely random and are gradually nudged into place during training via backpropagation over massive amounts of text.&lt;/p&gt;
&lt;h2 id="meet-alice-alice-is-impatient"&gt;&lt;a href="https://brooker.co.za/blog/2026/06/19/waiting.html" rel="noopener noreferrer"&gt;Meet Alice. Alice is impatient.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker opens with two scenarios every service operator recognizes. You measure an average request latency of 100 ms, yet your customer Alice swears she waits a full second on average. You report a mean time to recovery (MTTR) under one minute, yet your customer Alex experiences outages as lasting roughly an hour each. According to Brooker, both sides are telling the truth: operators average over &lt;em&gt;events&lt;/em&gt;, whereas customers sample across &lt;em&gt;time&lt;/em&gt;. This is the inspection paradox: the longer an outage or slow window lasts, the more customer requests (or retries) land inside it, so what customers actually experience is a duration-weighted version of the underlying distribution.&lt;/p&gt;
&lt;p&gt;Mathematically, if operators measure a mean duration of $E[X]$, a customer arriving at a random point in time experiences an expected duration of $\frac{E[X^2]}{2E[X]}$, which simplifies to $\frac{1}{2}\left(E[X] + \frac{\text{Var}(X)}{E[X]}\right)$. The gap between operator metrics and customer perception is proportional to the variance divided by the mean, meaning high variance drives perceived wait times through the roof. Brooker includes an interactive calculator and Python simulation: with a 30-minute median outage and a 600-minute p99, customers experience an average recovery time of roughly 6 hours even though measured MTTR is just 1 hour. Because real-world systems follow heavy-tailed distributions, trimming outliers hides the exact tail events that dominate customer pain. Short blips are already well handled by retries and failovers; long tail outages remain the industry&amp;rsquo;s unsolved problem and where engineering investment belongs.&lt;/p&gt;
&lt;h2 id="harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one"&gt;&lt;a href="https://lukasniessen.medium.com/harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one-a955bcdf5cce" rel="noopener noreferrer"&gt;Harness Engineering Deep Dive: Where The Term Came From, And How To Actually Build One&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen starts from the equation that has become standard in 2026: &lt;strong&gt;Agent = Model + Harness&lt;/strong&gt;. The harness is everything around the model: the execution loop, tools, sandboxing, context assembly, permissions, verification suites, durable state, execution traces, cost caps, and approval gates. Because you rent the model but own the harness, whenever an agent fails, instead of waiting for the next model release, you can re-engineer the environment so that class of failure becomes structurally impossible. Coined in early 2026 through posts by Mitchell Hashimoto, Birgitta Böckeler, and an OpenAI report, harness engineering represents the natural progression after prompt engineering and context engineering. The dividing line between a thin wrapper and a true harness is the closed feedback loop: once model outputs become actions executed against real state, whose results feed back into the next turn, every harness engineering concern comes into play.&lt;/p&gt;
&lt;p&gt;The technical deep dive walks through seven failure modes of a naive agent loop: sensors must distill signal rather than dumping raw stdout into the context window; conversation history is merely a cache while an external ledger holds the source of truth; the agent must never be allowed to declare its own work &amp;ldquo;done&amp;rdquo; without an external verifier; action spaces should be constrained via strict tool schemas rather than longer system prompts; budgets need stall detection; tool gates should be tiered by risk reversibility; and full execution traces must be treated as the primary unit of debugging. According to Niessen, harness quality alone can swing token consumption by 10x to 50x on the exact same task.&lt;/p&gt;
&lt;h2 id="how-big-is-a-git-commit"&gt;&lt;a href="https://ratfactor.com/cards/git-commit-size" rel="noopener noreferrer"&gt;How big is a Git commit?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How much disk space does a Git commit actually take? To find out, Dave Gauer measures the size of the &lt;code&gt;.git&lt;/code&gt; directory with &lt;code&gt;du -sb&lt;/code&gt; across a series of controlled scenarios, using only loose objects (no packfiles) to expose Git&amp;rsquo;s raw storage mechanics. A freshly initialized empty repository takes about 64 KB; committing 250 tiny files across 5 directories adds roughly 47 KB; a tiny edit to a single file inside that tree costs 17 KB, whereas making the exact same three-byte change in a repository containing only one file takes about 8.7 KB.&lt;/p&gt;
&lt;p&gt;The reason lies in Git&amp;rsquo;s object model: when you edit a file inside a subdirectory, Git writes four new zlib-compressed objects—the commit object itself, the updated blob holding the file&amp;rsquo;s full contents, a new tree object for the subdirectory listing all its entries, and a new root tree object. Even for a three-byte edit, that metadata and object overhead adds up to kilobytes and scales with directory depth and breadth. On larger files, zlib compression shines: a 580 KB binary shrinks to 298 KB, and a 16.4 MB source code file compresses down to 1.6 MB—about 10% of its original size. Across these large-file tests, &lt;code&gt;.git&lt;/code&gt; grows by roughly 10–50% of the raw data size depending on content compressibility. Gauer concludes that Git&amp;rsquo;s loose object storage is already remarkably frugal—especially for text—and packfiles make it dramatically smaller still by delta-compressing similar objects.&lt;/p&gt;
&lt;h2 id="how-i-find-problems-to-solve-as-a-staff-engineer"&gt;&lt;a href="https://lalitm.com/post/find-problems-staff-engineer/" rel="noopener noreferrer"&gt;How I Find Problems to Solve as a Staff Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lalit Maganti shares how he discovers high-leverage problems to solve as a Staff Engineer. Instead of blocking off calendar time to &amp;ldquo;think strategically,&amp;rdquo; he acts like a sponge: soaking up the daily ambient noise of meetings, chat channels, and email threads to absorb the friction people are experiencing. When something touches his domain, he digs past the surface request to uncover the underlying problem—sometimes sitting with teams to watch their workflow firsthand or debugging an issue himself to separate the real need from the solution the team asked for. He also deliberately resists jumping on the first request that comes in, since the loudest team doesn&amp;rsquo;t necessarily represent org-wide priorities; when the same pain point surfaces independently across multiple teams, that&amp;rsquo;s a strong signal.&lt;/p&gt;
&lt;p&gt;Long walks help him connect the dots across accumulated observations. On Perfetto, teams spent two years requesting disparate UI features—pinned tracks, custom zoom levels, bespoke aggregations—before he realized the underlying need was a general UI extensibility plugin system. Before committing engineering resources, he validates ideas with throwaway prototypes and socializes them with managers and partner teams. Solving the right problems builds trust that gets him invited into conversations earlier, letting him shape the roadmap without having to build everything himself—an approach he notes works best in bottom-up engineering cultures.&lt;/p&gt;
&lt;h2 id="golang-maps-how-swiss-tables-replaced-the-old-bucket-design"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-24-Golang-Maps-How-Swiss-Tables-Replaced-the-Old-Bucket-Design/" rel="noopener noreferrer"&gt;Golang Maps: How Swiss Tables Replaced the Old Bucket Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maps sit on the hot path of almost every Go program, and Go 1.24 replaced their internal implementation with Swiss Tables. The classic design used an array of buckets, each holding up to 8 key-value pairs plus metadata bytes; when a bucket filled up, the runtime allocated an overflow bucket and chained it via a pointer. While battle-tested, overflow chains forced lookups to chase pointers across non-contiguous memory, causing CPU cache misses, and capped the maximum load factor at roughly 81% before collision overhead degraded performance.&lt;/p&gt;
&lt;p&gt;Swiss Tables split each key&amp;rsquo;s hash into two parts: a prefix that selects the group, and a 7-bit fingerprint stored in a compact control byte array. Data is organized into 8-slot groups consisting of an 8-byte control word alongside key and value slots; during a lookup, the runtime scans all 8 control bytes in parallel using SIMD or bitwise operations, performs full key comparisons only on slots whose 7-bit fingerprint matches, and stops immediately if an empty slot is present. Most non-matching slots are filtered out at the cheap metadata stage, flat probing improves cache locality, and the max load factor rises to 87.5%. Rather than resizing one giant table all at once, Go uses an extendable hashing directory over multiple smaller tables so growth happens incrementally while preserving Go&amp;rsquo;s &lt;code&gt;range&lt;/code&gt; iteration semantics. Benchmarks show 2–3% overall CPU wins and 30–35% speedups on large map operations, with the trade-off that delete-heavy workloads leave tombstones that lengthen probe sequences until a table rehash clears them.&lt;/p&gt;
&lt;h2 id="the-new-rules-of-context-engineering-for-claude-5-models"&gt;&lt;a href="https://x.com/trq212/status/2080710971228918066" rel="noopener noreferrer"&gt;The new rules of context engineering for Claude 5 models&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you send a prompt to Claude, your message is only a small fraction of the context window it actually sees; the bulk is assembled from system prompts, skills, &lt;code&gt;CLAUDE.md&lt;/code&gt; files, memory, and tool definitions—and designing that assembly is context engineering. In this post, Anthropic engineer Thariq Shihipar reveals that the team deleted over 80% of Claude Code&amp;rsquo;s system prompt for frontier models like Claude Opus 5 and Claude Fable 5 without losing a single point on their coding evaluations. The reason is that earlier prompts over-constrained the model: within a single request, the system prompt, a skill, and the user&amp;rsquo;s &lt;code&gt;CLAUDE.md&lt;/code&gt; might give conflicting instructions—such as &amp;ldquo;write documentation where appropriate&amp;rdquo; alongside &amp;ldquo;DO NOT add comments&amp;rdquo;—forcing the model to waste reasoning tokens reconciling rules that newer models can navigate using their own judgment.&lt;/p&gt;
&lt;p&gt;The post contrasts old habits with the new playbook. Instead of rigid rules, trust the model&amp;rsquo;s judgment; the new instruction simply says &amp;ldquo;write code that matches the surrounding codebase.&amp;rdquo; Instead of stuffing few-shot tool examples into the prompt—which narrows exploration—design more expressive, self-documenting tool parameter schemas. Instead of front-loading everything into the initial context, use progressive disclosure: verification and code-review instructions are broken out into on-demand skills, and specialized tools are loaded lazily when needed. Memory is now captured automatically, and reference material can live as rich HTML artifacts or executable test suites rather than flat markdown files. Keep &lt;code&gt;CLAUDE.md&lt;/code&gt; lean, reserving it for non-obvious repo gotchas rather than facts Claude can discover by reading the code.&lt;/p&gt;
&lt;h2 id="the-git-history-command-deserves-more-attention"&gt;&lt;a href="https://lalitm.com/post/git-history/" rel="noopener noreferrer"&gt;The git history command deserves more attention&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Juggling multiple stacked changes in Git usually means tedious branch hopping and error-prone interactive rebases, which is why tools like &lt;code&gt;jj&lt;/code&gt; (Jujutsu) have gained a devoted following. Lalit Maganti argues that Git&amp;rsquo;s experimental &lt;code&gt;git history&lt;/code&gt; command—introduced across Git 2.54 (April 2026, adding &lt;code&gt;reword&lt;/code&gt; and &lt;code&gt;split&lt;/code&gt;) and Git 2.55 (June 2026, adding &lt;code&gt;fixup&lt;/code&gt;)—brings many of those same ergonomic benefits straight into stock Git without requiring a workflow overhaul, yet has flown largely under the radar. With &lt;code&gt;fixup&lt;/code&gt;, you stage changes via &lt;code&gt;git add&lt;/code&gt; and run &lt;code&gt;git history fixup &amp;lt;commit&amp;gt;&lt;/code&gt; to fold them directly into an earlier commit; every descendant local branch stacked on top of that commit is automatically rebased in place, going well beyond &lt;code&gt;git rebase --update-refs&lt;/code&gt;. Meanwhile, &lt;code&gt;reword&lt;/code&gt; opens your editor to amend an old commit message and automatically rebases the entire stack of descendant commits and branches, and &lt;code&gt;split&lt;/code&gt; interactively carves a commit into two.&lt;/p&gt;
&lt;p&gt;What unites all three subcommands is atomicity: they never drop your repository into a half-broken interactive rebase state, because they immediately abort any operation that would produce a merge conflict. That is also their biggest limitation compared to &lt;code&gt;jj&lt;/code&gt;, which treats conflicts as first-class objects you can resolve whenever you like; additionally, &lt;code&gt;fixup&lt;/code&gt; cannot cross merge commits, and Git still lacks &lt;code&gt;jj&lt;/code&gt;&amp;rsquo;s operation log for effortless undo. Git&amp;rsquo;s documentation notes that the conflict restriction may be lifted in future releases, but even today &lt;code&gt;git history&lt;/code&gt; is a major quality-of-life leap built right into standard Git.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #118</title><link>https://miti99.com/en/post/2026/07/06/</link><pubDate>Mon, 06 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #118.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="telling-the-story-right-efficient-logging-in-go"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-logs/" rel="noopener noreferrer"&gt;Telling the story right: efficient logging in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on his post about Go error handling, Robin Siep turns to logging: good logs must carry enough context to debug production issues while remaining easy to read during local development. He groups what to log into three categories: errors, almost always at &lt;code&gt;ERROR&lt;/code&gt; level with a stack trace and triggering conditions; important business events and state transitions, typically at &lt;code&gt;INFO&lt;/code&gt; level recording who performed the action; and interactions with databases, third-party services, or clients, where overly chatty details can be pushed down to &lt;code&gt;DEBUG&lt;/code&gt;. Three common mistakes are logging secrets, credentials, or PII, running production at the wrong log level, and pruning logs too aggressively up front—since logging too little usually hurts far more than logging too much.&lt;/p&gt;
&lt;p&gt;Structured logs are essential in production for filtering and querying, whereas colorized plain-text logs are much easier to scan locally. Siep recommends keeping plain-text output in production as well: when your log ingestion pipeline goes down, stdout text logs are what you have left to diagnose and fix the pipeline itself. His implementation uses Go&amp;rsquo;s standard &lt;code&gt;slog&lt;/code&gt; package with two custom handlers: one that formats records as CLEF to ship to Seq with stack traces extracted into a dedicated field, and a colorized text handler that renders attributes cleanly. If shipping to Seq fails, both the pipeline error and the original log record still get written through the text handler. The same pattern works with &lt;code&gt;zap&lt;/code&gt;, showing that logs are only as valuable as their ability to preserve context even when your observability stack is having a bad day.&lt;/p&gt;
&lt;h2 id="on-cpu-physics-and-cpu-cycles"&gt;&lt;a href="https://6it.dev/blog/on-cpu-physics-and-cpu-cycles-80730" rel="noopener noreferrer"&gt;On CPU Physics and CPU Cycles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is a draft book section on writing efficient C++ for modern 64-bit CPUs, built around one central thesis: software performance is governed not just by algorithms, but by hardware physics. The farther an electrical signal has to travel, the slower the access, largely because parasitic capacitance grows with wire length. That is why operations on registers and the ALU take just a couple of cycles, L1 cache takes a few cycles, L2 and L3 get progressively more expensive, and a trip to main RAM can cost hundreds of CPU cycles. Going farther out—across the motherboard to SSDs, HDDs, and the network—adds orders of magnitude more latency, giving cache locality massive real-world impact.&lt;/p&gt;
&lt;p&gt;To hide that latency, modern CPUs rely on instruction pipelining, superscalar execution, and branch prediction, speculatively executing instructions before a branch outcome is known. Even so, a mispredicted branch costs tens of cycles; attributes like &lt;code&gt;[[likely]]&lt;/code&gt; and &lt;code&gt;[[unlikely]]&lt;/code&gt; should be reserved for cases where the branch direction is overwhelmingly lopsided, such as error-handling paths. Cache warmth depends on access patterns and working set size rather than whether memory lives on the stack, static storage, or the heap. Contiguous layouts like &lt;code&gt;std::vector&lt;/code&gt; shine during sequential traversal, making &lt;code&gt;vector&lt;/code&gt; far friendlier to both CPU caches and the TLB than node-based structures like linked lists or trees. Think of performance as a chain of physical costs.&lt;/p&gt;
&lt;h2 id="the-log-is-the-agent"&gt;&lt;a href="https://x.com/ishaansehgal/status/2065129901427130678" rel="noopener noreferrer"&gt;The Log Is the Agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ishaan Sehgal offers a crisp definition of an AI agent: the agent is not the model, the runtime, the active loop, or the toolset—it is the durable log of everything it has seen and done. He compares it to a character in Skyrim or Elden Ring: what defines your character isn&amp;rsquo;t the game engine, the console, or the controller, but the save file. For an agent, the log is an append-only sequence of events capturing user inputs, model outputs, tool calls, and tool results, alongside references to system prompts and skills. The log alone is enough for a brand-new process to reconstruct state and pick up right where the previous one left off.&lt;/p&gt;
&lt;p&gt;The architectural implication is that the log must be the centerpiece of the system rather than a debugging byproduct. Every operation reads from the log, appends to the log, or renders a projection of the log—much like a database treats tables, indexes, and caches as projections over a write-ahead log. While the log enables crash recovery, it doesn&amp;rsquo;t automatically make external side effects idempotent, so runtimes still have to handle duplicate or ambiguous in-flight tool calls; if a worker dies, another worker can claim the session and continue; if you want to test a different model or strategy, you simply fork from the same history. Context compaction and summarization help fit within token windows, but because they are lossy by nature, they must never replace the raw log as the source of truth. This framing also exposes a new form of vendor lock-in: lock-in to an agent&amp;rsquo;s operational history. Whoever can inspect, export, and query the log is who truly owns the agent.&lt;/p&gt;
&lt;h2 id="software-is-not-a-single-player-game"&gt;&lt;a href="https://www.davidpoll.com/2026/06/software-is-not-a-single-player-game/" rel="noopener noreferrer"&gt;Software Is Not A Single-Player Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Poll responds to the argument that all meaningful judgment should happen before code review, back in the PRD or design doc phase. That view had a rational origin: writing code used to be the most expensive step, so the industry built an entire apparatus of PRDs, design docs, and RFCs to reduce the cost of building the wrong thing. Yet that linear view misses the essence of software development: it is not a single-player game, but a collaborative practice where teams develop shared technical taste, mental models, and product judgment over time. Code review isn&amp;rsquo;t just about catching bugs—it is one of the primary places where that shared understanding is forged.&lt;/p&gt;
&lt;p&gt;Now that AI has dramatically lowered the cost of writing code, documents that used to serve as proxies for code are giving way to working changes. A prototype or pull request is now cheap enough to be a better medium for debate, making code review even more central: the team looks at a concrete change, asks how it affects the system and users, and decides whether it belongs in the product. A closed pull request is no longer a wasted failure, but often the cheapest way to learn that an approach doesn&amp;rsquo;t fit. Still, Poll warns against a reckless &amp;ldquo;just ship and rollback&amp;rdquo; mentality: code can be reverted, but user trust and product perception cannot. Some decisions still must be settled before coding—such as org-wide architecture, security, compliance, and customer commitments—even as the set of things requiring heavy up-front specification shrinks.&lt;/p&gt;
&lt;h2 id="cleaning-up-after-ai-rockstar-developers"&gt;&lt;a href="https://www.codingwithjesse.com/blog/rockstar-developers/" rel="noopener noreferrer"&gt;Cleaning up after AI rockstar developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jesse Skinner uses the trope of the &amp;ldquo;rockstar developer&amp;rdquo; to illustrate a familiar engineering hazard: someone brilliant, fast, and enamored with shiny new technology who can single-handedly rewrite a core system over a weekend, but leaves behind code the rest of the team struggles to understand or maintain. When that person moves on, the remaining team pays the real bill: spending days just getting the project to run, untangling convoluted data flows, learning unfamiliar languages or libraries, and convincing management that the system needs rescuing rather than continuing to coast on the rockstar&amp;rsquo;s aura.&lt;/p&gt;
&lt;p&gt;Skinner&amp;rsquo;s core point is that AI can amplify this exact failure mode. Every chat session with an LLM is like dropping a brand-new &amp;ldquo;rockstar&amp;rdquo; into your codebase: it generates code at breakneck speed, holds zero long-term institutional memory, eagerly applies generic &amp;ldquo;best practices&amp;rdquo; the problem doesn&amp;rsquo;t need, and bears no responsibility for whether the system remains comprehensible to the team six months later. When dozens of features and bug fixes are generated across disconnected sessions, a codebase quickly devolves into a patchwork of hundreds of clashing design styles while the architecture balloons far beyond the problem&amp;rsquo;s actual complexity. He advises using LLMs as assistants under firm human technical leadership: work in small increments, review every change closely, retain architectural control, simplify relentlessly, and stay willing to write code by hand whenever that is the better way to preserve quality.&lt;/p&gt;
&lt;h2 id="a-new-era-for-software-testing"&gt;&lt;a href="https://antirez.com/news/168" rel="noopener noreferrer"&gt;A new era for software testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Antirez observes that while AI-assisted coding trades away some structural code quality for speed, in QA and testing LLMs unlock much stronger automation without sacrificing quality. Traditional test suites made up of unit and integration tests remain essential, but 100% line coverage does not mean 100% state coverage. End-to-end integration testing has historically been painful due to timing issues, complex environment setup, and outputs that require human judgment to evaluate, causing many manual test scenarios to be skipped before release.&lt;/p&gt;
&lt;p&gt;His proposal is to write a Markdown prompt instructing an AI agent to act as a QA engineer performing exploratory manual testing on a new release. The agent starts by inspecting recent commits since the last release, identifying potentially affected areas, and hunting for targeted regressions. On DwarfStar, an open-source LLM inference engine, the agent tested distributed inference across two MacBooks over every available GGUF model file and caught a throughput regression without needing hardcoded baseline numbers, reasoning about expected speeds dynamically. On Redis Arrays, the agent built a non-trivial application from scratch, spun up an environment with replication and persistence, and simulated days of multi-user activity to uncover edge-case misbehavior—even flagging surprising semantics, missing docs, and rough edges. Antirez believes agentic QA can raise the quality bar for every release, partially offsetting the structural sloppiness introduced by rapid AI coding.&lt;/p&gt;
&lt;h2 id="nobody-pushed-back-why-engineers-stay-silent-until-it"&gt;&lt;a href="https://howtocenterdiv.com/beyond-the-div/nobody-pushed-back" rel="noopener noreferrer"&gt;Nobody Pushed Back: Why Engineers Stay Silent Until It&amp;rsquo;s Too Late&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that many architectural disasters happen not because engineers failed to spot the flaw, but because they saw it clearly and didn&amp;rsquo;t feel safe speaking up. In a meeting room, a shaky technical direction gets rubber-stamped under the banner of &amp;ldquo;alignment&amp;rdquo; even though half the room privately disagrees; months later, when the system collapses, everyone admits they saw it coming. The pattern repeats across the industry: the technical risk is obvious to the people closest to the work, but the social and career cost of pushing back is higher than the cost of staying quiet.&lt;/p&gt;
&lt;p&gt;Case studies from Nokia, TSB, Boeing, and Microsoft show that bad news is rarely missing—it just fails to travel upward to decision-makers. Nokia had engineers who knew Symbian wasn&amp;rsquo;t built for the touchscreen era; TSB had technical objections raised before its disastrous core banking migration; Boeing had engineers flagging MCAS risks; Microsoft had internal signals that Windows Phone&amp;rsquo;s direction was boxing itself into a corner. The root cause isn&amp;rsquo;t personal cowardice, but organizational incentives: dissent gets labeled &amp;ldquo;not being a team player,&amp;rdquo; the Highest Paid Person&amp;rsquo;s Opinion (HiPPO) wins by default, and watermelon metrics (green on the outside, red on the inside) are used to shut down debate, turning technical trade-offs into political loyalty tests. Effective pushback isn&amp;rsquo;t saying &amp;ldquo;this is wrong,&amp;rdquo; but making costs and risks concrete through questions like: what will this decision cost us in 18 months, how are we testing this failure mode, and what is our rollback plan if it breaks?&lt;/p&gt;
&lt;h2 id="loop-engineering"&gt;&lt;a href="https://addyo.substack.com/p/loop-engineering" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani describes &amp;ldquo;loop engineering&amp;rdquo; as the natural evolution beyond prompt engineering: instead of manually prompting an agent turn by turn, the engineer designs a self-sustaining loop that finds work, delegates tasks, verifies results, and decides what to do next. A loop acts like a recursive goal—you define the objective, and the AI iterates until the exit criteria are met. According to Osmani, this paradigm is already practical today because both Codex and Claude Code provide all the necessary building blocks, so rather than arguing over which tool wins, teams should design loops that can run across both.&lt;/p&gt;
&lt;p&gt;A complete loop rests on five primitives. Scheduled automations triage issues, summarize CI failures, or hunt for new bugs. Git worktrees let multiple agents work in parallel without stepping on each other&amp;rsquo;s files. Skills package project-specific knowledge so you don&amp;rsquo;t have to re-explain conventions in every session. Connectors, typically built on MCP, give agents access to issue trackers, databases, Slack, or staging APIs. Subagents separate the builder from the verifier, since an agent that just wrote the code is usually far too lenient when grading its own homework. Tying it all together is durable external memory—Markdown files or Linear boards in the repo—because models forget between runs while the repository remembers. Even so, Osmani stresses that loops don&amp;rsquo;t replace the engineer: an unsupervised loop is also an unsupervised mistake generator. Without human review and comprehension, loops simply accumulate &amp;ldquo;comprehension debt&amp;rdquo; faster; a good loop accelerates delivery while keeping the engineer deeply connected to how the system works.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Y582!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b5057ba-3667-446b-9760-b726da1431f4_2484x3002.png" alt="Latency vs Throughput vs Bandwidth"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!bdjh!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc9c8ec17-676c-441a-9c97-d08f8eec804f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=MUWAbpg1xLo" rel="noopener noreferrer"&gt;How Do CPUs, GPUs, and TPUs Differ?&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This video breaks down the differences between CPUs, GPUs, and TPUs: CPUs offer flexibility for general-purpose tasks, GPUs excel at massively parallel processing, and TPUs are purpose-built accelerators for machine learning workloads. A concise overview to help you pick the right hardware across latency, throughput, and cost trade-offs.&lt;/p&gt;

&lt;/blockquote&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #115</title><link>https://miti99.com/en/post/2026/07/02/</link><pubDate>Thu, 02 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #115.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-experiments-explained"&gt;&lt;a href="https://www.alexedwards.net/blog/go-experiments-explained" rel="noopener noreferrer"&gt;Go Experiments Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards explains the experimental feature mechanism Go ships in each release: sometimes a new standard library package like &lt;code&gt;testing/synctest&lt;/code&gt;, sometimes a compiler or runtime change like a new garbage collector, and more rarely a language behavior change like loop variable scoping before it became the default in Go 1.22. The goal is to gather real-world feedback before locking a feature in; if it causes problems or draws pushback, it can be revised or dropped entirely. The typical lifecycle starts disabled by default, flips to enabled by default after a release or two (often with a transition period allowing opt-out), and eventually retires the flag—though exceptions happen: &lt;code&gt;Arenas&lt;/code&gt; was put on indefinite hold after negative feedback, while Swiss tables went straight to default.&lt;/p&gt;
&lt;p&gt;Because there is no official status page tracking experiments, Edwards compiled a reference table for Go 1.26 from &lt;code&gt;go doc goexperiment.Flags&lt;/code&gt;, the &lt;code&gt;internal/buildcfg&lt;/code&gt; source, and release notes. To use them, pass comma-separated lowercase names in the &lt;code&gt;GOEXPERIMENT&lt;/code&gt; environment variable to enable features, or prefix a name with &lt;code&gt;no&lt;/code&gt; to disable it, across &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go test&lt;/code&gt;. For everyday Go developers, the most notable flags are &lt;code&gt;GreenTeaGC&lt;/code&gt; and &lt;code&gt;Dwarf5&lt;/code&gt; (already enabled by default, so worth knowing how to disable if issues arise), &lt;code&gt;JSONv2&lt;/code&gt;, &lt;code&gt;GoroutineLeakProfile&lt;/code&gt; for catching leaked goroutines, &lt;code&gt;RuntimeSecret&lt;/code&gt; for code handling sensitive data, and &lt;code&gt;RuntimeFreegc&lt;/code&gt;. One important caveat: experiments fall outside Go&amp;rsquo;s compatibility promise, so use them to test, benchmark, and give feedback rather than relying on them prematurely in production.&lt;/p&gt;
&lt;h2 id="low-level-network-optimizations-socket-options-that-matter"&gt;&lt;a href="https://goperf.dev/02-networking/low-level-optimizations/" rel="noopener noreferrer"&gt;Low-Level Network Optimizations: Socket Options That Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This entry from the Go Optimization Guide examines socket options that directly impact latency and throughput in Go network applications. Operating system defaults prioritize safety and broad compatibility, meaning under heavy load they often become bottlenecks well before CPU or memory. &lt;code&gt;TCP_NODELAY&lt;/code&gt; disables Nagle&amp;rsquo;s algorithm so small packets are sent immediately at the cost of higher bandwidth overhead; Go enables this by default on &lt;code&gt;TCPConn&lt;/code&gt;. &lt;code&gt;SO_REUSEPORT&lt;/code&gt; lets multiple processes or threads bind to the same port while the kernel distributes incoming connections across separate queues, reducing lock contention and scaling across CPU cores. Receive and send buffer sizes (&lt;code&gt;SO_RCVBUF&lt;/code&gt; and &lt;code&gt;SO_SNDBUF&lt;/code&gt;) should roughly match the bandwidth-delay product: too small increases syscalls and caps throughput, while too large wastes memory and inflates latency via bufferbloat.&lt;/p&gt;
&lt;p&gt;For TCP keepalives, OS defaults are very conservative; common production settings wait 30–60 seconds, probe every 10–15 seconds, and retry 3–5 times, though tuning them too aggressively increases traffic and risks false drops on congested links. In Go, &lt;code&gt;SetKeepAlivePeriod&lt;/code&gt; only controls the initial idle time; starting in Go 1.23, &lt;code&gt;SetKeepAliveConfig&lt;/code&gt; lets you configure Interval and Count without dropping down to raw syscalls. &lt;code&gt;SOMAXCONN&lt;/code&gt; governs the listener backlog queue and is tuned at the OS level via &lt;code&gt;sysctl&lt;/code&gt;. To apply socket options at the right moment—before the socket is bound—use the &lt;code&gt;Control&lt;/code&gt; callback on &lt;code&gt;net.ListenConfig&lt;/code&gt; with &lt;code&gt;syscall.RawConn&lt;/code&gt;. The overarching advice: change one setting at a time, test under realistic load, and rely on measurements rather than copy-pasting configs from elsewhere.&lt;/p&gt;
&lt;h2 id="when-is-100-vibe-coding-ok-"&gt;&lt;a href="https://dev.to/realvorl/when-is-100-vibe-coding-ok--38p" rel="noopener noreferrer"&gt;When Is 100% Vibe Coding OK ?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Viorel PETCU opens with the frustration of spending hours reviewing &amp;ldquo;vibe-written&amp;rdquo; specifications: they read smoothly on the surface but say almost nothing concrete and cannot be applied to an existing system. The author isn&amp;rsquo;t against vibe coding—in fact, he uses it regularly for one-off scripts, throwaway charts, quick parsers, or docs nobody has to maintain, where speed matters more than rigor. Once software needs long-term maintenance, however, the equation changes completely.&lt;/p&gt;
&lt;p&gt;His motivating example is a wooden puzzle of 25 identical pentacube pieces that must pack a &lt;code&gt;5×5×5&lt;/code&gt; cube. After failing to solve it by hand, he used Go and ChatGPT to write a solver: the initial struggle wasn&amp;rsquo;t the algorithm, but the domain representation—coordinate conventions, slice notation, piece rotations, and naming. Once the model stabilized, the rest was classic brute-force recursion with backtracking, and modern hardware was fast enough that no further optimization was needed. Within about two hours, the project evolved into a general solver complete with OBJ/MTL export for viewing in Blender. Crucially, the author was able to push past hallucinated constraints, wrong assumptions, and buggy code because he already knew for a fact that the puzzle had a physical solution. His conclusion: 100% vibe coding is fine when a human holds the invariants, the constraints are real, and the output is verifiable; if the requirements themselves are just vibes, the system has nothing solid to converge on.&lt;/p&gt;
&lt;h2 id="self-calling-executables"&gt;&lt;a href="https://log.pfad.fr/2026/self-calling-executable/" rel="noopener noreferrer"&gt;Self-calling executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olivier introduces the &amp;ldquo;self-calling executable&amp;rdquo; pattern: a running program spawns another instance of itself, directly or indirectly, to take on a different role. The first use case is black-box testing a &lt;code&gt;main&lt;/code&gt; function when the codebase relies on global state that causes in-process tests to interfere with one another. A test invokes the test binary itself via &lt;code&gt;os.Args[0]&lt;/code&gt; along with an environment variable like &lt;code&gt;TEST_MAIN&lt;/code&gt;; inside &lt;code&gt;TestMain&lt;/code&gt;, if that variable is set, the binary runs the real entrypoint instead of the test runner, isolating each invocation inside a fresh child process.&lt;/p&gt;
&lt;p&gt;The second use case is integrating with external tools, illustrated by jjui, a terminal UI for Jujutsu. The &lt;code&gt;ssh&lt;/code&gt; command uses the &lt;code&gt;SSH_ASKPASS&lt;/code&gt; environment variable to invoke an external helper when it needs a passphrase; jjui points &lt;code&gt;SSH_ASKPASS&lt;/code&gt; back at itself so that when &lt;code&gt;ssh&lt;/code&gt; prompts for a password, the grandchild process connects back to the main jjui process over a Unix domain socket (with the PID embedded in the path so multiple sessions can run concurrently), forwards the prompt, collects the user&amp;rsquo;s input, and prints it to stdout for &lt;code&gt;ssh&lt;/code&gt;. Because this handles sensitive credentials, the author adds two safeguards: each child receives a random token it must present on connect, and the main process walks the connecting client&amp;rsquo;s ancestor PID chain to verify lineage. Downsides include harder debugging, risk of infinite recursion if environment variables are misconfigured, and the Go race detector sleeping for 1 second on every process exit—which once stretched Forgejo&amp;rsquo;s integration suite from 45 minutes to over 2 hours, fixable via &lt;code&gt;GORACE=&amp;quot;atexit_sleep_ms=0&amp;quot;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="modern-engineering-values"&gt;&lt;a href="https://cpojer.net/posts/modern-engineering-values" rel="noopener noreferrer"&gt;Modern Engineering Values&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christoph Nakazawa shares that he now rarely writes code by hand: projects like Vite+, fate, and Athena Crisis are largely written by coding agents, primarily via Codex CLI. His workflow is to have the agent propose a plan and ask clarifying questions before executing, require a failing test before fixing a bug, run several automated review passes, and only then review the diff himself. When writing code is no longer the bottleneck, discussing and reviewing code becomes the limiting factor.&lt;/p&gt;
&lt;p&gt;From there, the post proposes a set of engineering values for the agentic era. Strong ownership: agents amplify engineers with deep product understanding just as much as they amplify noise from people lacking context, meaning effective teams will be small—around two to three people—with clear boundaries, and code review will focus on alignment rather than nitpicking individual lines. Good taste to know what is actually worth building. Tight guardrails and fast feedback loops—linters, automated tests, and tools that operate only on changed files—because working with agents is like onboarding a brand-new hire with zero context on every prompt. Keeping context inside the repo rather than scattered across docs, chat threads, or tribal memory. Owning your stack instead of pulling in heavy third-party dependencies, since agents have drastically lowered the cost of building in-house. As for management, he believes the role will become increasingly technical: as execution becomes cheap, judgment becomes the bottleneck.&lt;/p&gt;
&lt;h2 id="building-software-is-learning"&gt;&lt;a href="https://registerspill.thorstenball.com/p/building-software-is-learning" rel="noopener noreferrer"&gt;Building Software Is Learning&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball publishes an internal note sent to the Amp team on why building new software is always a learning process. The idealized sequence—&amp;ldquo;we need this feature,&amp;rdquo; &amp;ldquo;I built it,&amp;rdquo; &amp;ldquo;that&amp;rsquo;s exactly what I wanted&amp;rdquo;—almost never happens without a detailed spec; reality usually looks more like &amp;ldquo;that&amp;rsquo;s not what I meant,&amp;rdquo; &amp;ldquo;there are three ways to do this, which one do we want?&amp;rdquo;, or &amp;ldquo;I tried it and I don&amp;rsquo;t like how it feels.&amp;rdquo; That is because people only truly understand what they are building while building it, and avoiding that discovery entirely would require specifying every detail up front—which is just programming by another name.&lt;/p&gt;
&lt;p&gt;The good news is that you can shrink the gap between a confident &amp;ldquo;I&amp;rsquo;ll build it&amp;rdquo; and contact with reality. Instead of disappearing for four weeks, build a prototype in an hour, write a spec in thirty minutes, break the work down and ship a piece every day, cut scope to isolate the unknowns, record a fake demo video, write the release announcement first, or draft README examples to test an API design. Feedback can come from CI, teammates, users, or yourself dogfooding the feature. Ball adds two practical warnings: a prototype riddled with obvious bugs will only get you bug reports instead of useful design feedback, and keeping a branch alive for three weeks before merging 27 commits at once means when CI breaks, you have 27 potential culprits. The question to keep asking is how to get feedback as early and as often as possible so you can learn faster.&lt;/p&gt;
&lt;h2 id="you-must-fix-your-asserts"&gt;&lt;a href="https://kristoff.it/blog/fix-your-asserts/" rel="noopener noreferrer"&gt;You Must Fix Your Asserts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro argues against the habit of disabling assertions in production, using Zig as context. An assertion is a line of code stating a program truth—a precondition, postcondition, or invariant; if the type system can express the constraint, use types, and otherwise assertions catch programming bugs, often more effectively than unit tests when paired with fuzzing. In Zig, &lt;code&gt;std.debug.assert&lt;/code&gt; is built on &lt;code&gt;unreachable&lt;/code&gt;: in checked build modes like Debug or ReleaseSafe, a violated assertion panics; in ReleaseFast or ReleaseSmall, the compiler treats the assertion as an assumed fact for optimization, meaning a false assertion leads to unpredictable undefined behavior. Unlike C/C++, Zig&amp;rsquo;s assert is a regular function rather than a macro, so its argument expression is always evaluated.&lt;/p&gt;
&lt;p&gt;According to Cro, you have three choices: keep assertions active as runtime checks, let the compiler optimize around them and accept the risk, or strip them out—and the third option is the worst. Disabling assertions means that when the &amp;ldquo;impossible&amp;rdquo; happens, the program keeps running on broken assumptions, silently diverging from its spec while stripping away the very signal that would have caught it. Worse, future maintainers will write new code trusting those false assertions, allowing vulnerabilities to creep in unnoticed. He points to TigerBeetle keeping assertions enabled in production and Ghostty shipping ReleaseFast builds. The takeaway: fix broken assertions, gate genuinely expensive checks behind debug-only flags, log instead of crashing where appropriate, and choose build modes based on your risk model rather than erasing error signals.&lt;/p&gt;
&lt;h2 id="the-software-engineering-books-i-keep-recommending"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/best-software-engineering-books-2026" rel="noopener noreferrer"&gt;The Software Engineering Books I keep recommending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr. Milan Milanović shares the software engineering books he recommends most often, noting that reading gives him both breadth and depth in technical discussions and decision-making—and in the AI era, helps him evaluate and steer AI tools more effectively. Rather than presenting a one-size-fits-all &amp;ldquo;must-read&amp;rdquo; list, he groups the books by the specific problem a reader is facing, arguing that the right question isn&amp;rsquo;t &amp;ldquo;what should I read?&amp;rdquo; but &amp;ldquo;where am I currently stuck?&amp;rdquo; Most of the picks aren&amp;rsquo;t tied to specific frameworks, so their lessons age well.&lt;/p&gt;
&lt;p&gt;For coding mindset, he highlights &lt;code&gt;The Pragmatic Programmer&lt;/code&gt;, &lt;code&gt;Clean Code&lt;/code&gt; (noting some rules are dated), and &lt;code&gt;A Philosophy of Software Design&lt;/code&gt;, the book he re-reads most often. Architecture covers &lt;code&gt;Fundamentals of Software Architecture&lt;/code&gt;, &lt;code&gt;Software Architecture: The Hard Parts&lt;/code&gt;, and &lt;code&gt;Domain-Driven Design Quickly&lt;/code&gt;; systems and data feature the second edition of &lt;code&gt;Designing Data-Intensive Applications&lt;/code&gt; alongside the more approachable &lt;code&gt;Understanding Distributed Systems&lt;/code&gt;. The AI section pairs &lt;code&gt;The Hundred-Page Language Models Book&lt;/code&gt; on how language models work with Chip Huyen&amp;rsquo;s &lt;code&gt;AI Engineering&lt;/code&gt; on building real-world AI applications. Rounding out the list are &lt;code&gt;The Art of Unit Testing&lt;/code&gt; for testing, &lt;code&gt;Accelerate&lt;/code&gt; (with the four DORA metrics) and &lt;code&gt;Refactoring&lt;/code&gt; for development workflow, and &lt;code&gt;The Software Engineer's Guidebook&lt;/code&gt; and &lt;code&gt;Deep Work&lt;/code&gt; for career growth. He also mentions his own new book on laws in software engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #112</title><link>https://miti99.com/en/post/2026/06/23/</link><pubDate>Tue, 23 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #112.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-few-interesting-modern-pixel-fonts"&gt;&lt;a href="https://unsung.aresluna.org/a-few-interesting-modern-pixel-fonts/" rel="noopener noreferrer"&gt;A few interesting modern pixel fonts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marcin Wichary surveys a few modern pixel fonts built around interesting ideas. Andrew Gleeson&amp;rsquo;s Analog Mono &amp;ldquo;atones for the sins&amp;rdquo; of VCR OSD Mono, the classic pixel font seen across 1990s VCRs, TVs, and camcorders whose baseline sat so low that every character with a descender was pulled upward. Kumiko Yoshida&amp;rsquo;s Coral Pixels is a color font that deliberately preserves the characteristic color fringing of 1990s–2000s subpixel rendering: what used to be a technical artifact is now nostalgic material and an intentional visual element. Joseph Fatula&amp;rsquo;s Two Slice pushes minimalism to the extreme at just 2 pixels tall while remaining &amp;ldquo;barely readable.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The author notes that all of these are vector fonts masquerading as pixels so they can be installed on modern operating systems, which leads to Vercel&amp;rsquo;s Geist Pixel. Although its marketing pitch is slightly grandiose, it hits on an important problem: pixel fonts often break when put into real products because they don&amp;rsquo;t scale well across screen sizes, their metrics clash with existing typography systems, or they are purely decorative. According to the author, the Achilles&amp;rsquo; heel of many fonts lies not in the letterforms themselves, but in the &amp;ldquo;invisible&amp;rdquo; work around them such as kerning, metadata, extended character sets, and vertical metrics. The lesson for UI designers is that nostalgia can be a starting point, but integration stability is what determines whether a font is actually usable in a product.&lt;/p&gt;
&lt;h2 id="the-best-engineers-write-less-code"&gt;&lt;a href="https://shvetsm.github.io/posts/the-best-engineers-write-less-code/" rel="noopener noreferrer"&gt;The Best Engineers Write Less Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the idea that we no longer need to write good software because LLMs can generate code. Bad software is still bad software, whether written by Claude Code or an inexperienced developer: latency, complexity, and maintenance costs remain real, and there will be plenty of work cleaning up the low-quality code currently being pushed to production. Businesses measure everything in time, because time is money; that is also why they are excited about AI—it is faster and cheaper.&lt;/p&gt;
&lt;p&gt;According to the author, the best thing an engineer can do for stakeholders is avoid building unnecessary things, since every feature carries long-term costs in maintenance, debugging, infrastructure, support, migrations, and cognitive load. On the path to becoming a senior engineer, you shift from &amp;ldquo;I can build that, it&amp;rsquo;ll take a few days&amp;rdquo; to &amp;ldquo;Why are we building this?&amp;rdquo;, and the second question is critical: code is a liability unless it solves the right problem. The worst outcome is building the wrong thing. The way to reduce risk is genuine Agile in spirit rather than ceremony: align on why the work is needed, adjust requirements to deliver value faster, and work in short intervals to show progress and gather feedback. Great engineers are measured not by the volume of code they produce, but by the value they deliver relative to the complexity they leave behind—and the best use of spare time is deleting code.&lt;/p&gt;
&lt;h2 id="fast-is-better-than-slow"&gt;&lt;a href="https://dubroy.com/blog/fast-is-better-than-slow/" rel="noopener noreferrer"&gt;Fast is better than slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Patrick Dubroy noticed that the best programmers he has ever worked with all share one trait: they are fast, often turning up with a patch or prototype an hour or two after discussing a problem. He argues that they aren&amp;rsquo;t fast because they&amp;rsquo;re good, they&amp;rsquo;re good because they&amp;rsquo;re fast: moving quickly gets you data sooner, leads to better decisions, compounds learning over time, and lets you try multiple approaches before picking the best one. This does not mean hustle culture or working overtime; there are many ways to speed up without putting in extra hours.&lt;/p&gt;
&lt;p&gt;His advice has more to do with day-to-day software engineering habits than raw coding skill. Don&amp;rsquo;t procrastinate just because you aren&amp;rsquo;t sure where to start, as waiting rarely makes the task easier. Make use of small pockets of time instead of waiting for long uninterrupted blocks, since fragmentation can eat up 25–35% of your day. Don&amp;rsquo;t be afraid to look silly: share work early using the &amp;ldquo;70% rule,&amp;rdquo; open a PR right away and welcome feedback instead of polishing endlessly, and proactively ask coworkers for help because software development is a team sport. Pick your battles: in code review, most disagreements are small enough that making the requested change is faster than arguing, and Dubroy himself often approves with &amp;ldquo;LGTM with comments.&amp;rdquo; Finally, build only what was asked for—trying to &amp;ldquo;overdeliver&amp;rdquo; usually means guessing at future requirements, and the less experience you have, the more likely you are to guess wrong.&lt;/p&gt;
&lt;h2 id="java-cheat-sheet"&gt;&lt;a href="https://tms-outsource.com/cs/java-cheat-sheet/" rel="noopener noreferrer"&gt;Java Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a quick Java reference by Bogdan Sandu focused on syntax, common patterns, and immediately applicable idioms. The material is organized into sections: data types and casting, operators, control flow, arrays, strings and &lt;code&gt;StringBuilder&lt;/code&gt;, classes and objects, OOP concepts, access modifiers, the Collections Framework, exception handling, streams and lambdas, concurrency, I/O, and modern Java features. Helpfully, it doesn&amp;rsquo;t just list syntax—it also calls out classic beginner pitfalls like comparing &lt;code&gt;String&lt;/code&gt; instances with &lt;code&gt;==&lt;/code&gt;, confusing array &lt;code&gt;.length&lt;/code&gt; with string &lt;code&gt;.length()&lt;/code&gt;, handling &lt;code&gt;null&lt;/code&gt;, going out of array bounds, or concatenating strings in a loop instead of using &lt;code&gt;StringBuilder&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For junior developers, a cheat sheet like this is well suited for a quick refresher when switching to Java from another language, or when recalling a standard API without wading through long documentation. Even so, it should be treated as an initial lookup map: it does not replace official docs, a deep understanding of the JVM, OOP, collections, and concurrency, or hands-on experience writing production code.&lt;/p&gt;
&lt;h2 id="swapping-go-for-rust-10x-cheaper-k8s-ingress"&gt;&lt;a href="https://dev.to/syedahmershah/swapping-go-for-rust-10x-cheaper-k8s-ingress-2b4p" rel="noopener noreferrer"&gt;Swapping Go for Rust: 10x Cheaper K8s Ingress&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Syed Ahmer Shah recounts cutting the AWS bill for a Kubernetes ingress layer from roughly $4,200 to about $390 per month. The original setup ran Traefik across 3 pods, averaging around 380MB RSS per pod (roughly 180MB idle, over 400MB under load), requiring &lt;code&gt;t3.large&lt;/code&gt; nodes for headroom. The author attributes this to Go&amp;rsquo;s garbage collector, which optimizes for latency rather than memory footprint: in a proxy, every request allocates headers, buffers, and connection state, so under sustained load the GC rarely gets a &amp;ldquo;good moment&amp;rdquo; to clean up, whereas Rust frees memory deterministically as soon as values go out of scope. It is worth noting that this changed both the architecture and infrastructure (Envoy, smaller nodes), so it cannot be treated as an isolated benchmark of swapping languages alone.&lt;/p&gt;
&lt;p&gt;Rather than rewriting Traefik, the team moved core proxying to Envoy (C++) alongside a small Rust service that took over custom routing logic previously living in middleware. The first week hit three incidents—not because of Rust, but because Envoy&amp;rsquo;s explicit configuration model differed sharply from Traefik&amp;rsquo;s annotation &amp;ldquo;magic.&amp;rdquo; After about three weeks, the ingress layer dropped from 3 Traefik pods at ~380MB RSS each to 2 Envoy pods plus the Rust layer at ~40MB per pod; node costs fell from roughly $340 to $30 per month. The takeaway isn&amp;rsquo;t &amp;ldquo;replace Go with Rust&amp;rdquo;: Go remains a great fit for APIs, CLIs, and standard microservices, while Rust is worth considering for high-performance data planes. The migration took two engineers about three weeks, so if Traefik is working fine and the bill isn&amp;rsquo;t hurting, leave it alone.&lt;/p&gt;
&lt;h2 id="persistent-multiplayer-state-without-chaos"&gt;&lt;a href="https://packagemain.tech/p/persistent-multiplayer-state-without" rel="noopener noreferrer"&gt;Persistent multiplayer state without chaos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julien Singler shares an architecture for maintaining consistent state in a live multiplayer game, where PostgreSQL holds the canonical data and Redis handles speed-critical operations. In a single-player game, state is relatively straightforward; but when multiple players can act on the same target simultaneously, scheduled jobs must finish on time regardless of who is online, and players returning days later expect their progress intact, state becomes the hardest problem. Keeping critical data only in memory or flushing to disk only on logout easily leads to lost progress or economy bugs.&lt;/p&gt;
&lt;p&gt;The Go backend is structured into handler, service, and repository layers. Every critical state change goes through a PostgreSQL transaction as the single source of truth. Read-heavy data is fetched from Redis first, falling back to PostgreSQL on a cache miss, and the cache is invalidated on writes before returning success so players never see stale state. Redis holds only rebuildable state such as caches, online presence, and short-lived locks: distributed locks via &lt;code&gt;SetNX&lt;/code&gt; ensure periodic jobs run only once across multiple backend instances (though bare &lt;code&gt;SetNX&lt;/code&gt; alone does not guarantee exactly-once processing if a crash or lock expiration occurs). Scheduled jobs rely on an indexed &lt;code&gt;finishes_at&lt;/code&gt; column rather than scanning every player every minute, and per-player mutations use &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; inside transactions instead of a custom lock manager.&lt;/p&gt;
&lt;h2 id="we"&gt;&lt;a href="https://plc.vc/cdx" rel="noopener noreferrer"&gt;We&amp;rsquo;re in the Over-engineering Game Now&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Clark writes that he spent his entire career priding himself on scoping projects to minimize engineering effort while maximizing flexibility, since engineering time is a software company&amp;rsquo;s scarcest resource. Yet he also loves product design and polished details, leaving him constantly torn between wanting to craft things more carefully and worrying about wasting resources. Now, using Claude and Codex on personal projects, he happily &amp;ldquo;over-engineers&amp;rdquo;: his blog has a dynamic changelog, a &amp;ldquo;vibe meter,&amp;rdquo; an MCP that generates weekly roundups, and hundreds of other ideas he tried and threw away.&lt;/p&gt;
&lt;p&gt;His central thesis is that AI coding blurs the line between over-engineering and simply finishing a product well. His iOS app no longer starts as a bare-bones MVP, but launches feature-complete with built-in feedback loops that trigger agentic workflows. Improvements that used to languish forever in the backlog because they were never high enough priority—or too small to even file a ticket for—can now be iterated on and polished continuously. He argues this shift will raise user expectations: when building good software becomes nearly free, clunky products will be much harder to excuse. Rather than merely an era of vibe coding or apps for an audience of one, he believes we are entering a phase where product vision is no longer bottlenecked by engineering resources, leaving only one question: what do you actually want to build?&lt;/p&gt;
&lt;h2 id="package-managers-that-package-package-managers"&gt;&lt;a href="https://nesbitt.io/2026/05/28/package-managers-that-package-package-managers.html" rel="noopener noreferrer"&gt;Package managers that package package managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Nesbitt built a matrix mapping which package managers can install which other package managers. The idea started from a strange loop: PyPI has a package containing the Node binary, and npm has a package containing a portable CPython build, meaning &lt;code&gt;pip install&lt;/code&gt; and &lt;code&gt;npm install&lt;/code&gt; can hand control back and forth indefinitely. Covering 42 clients using data from ecosyste.ms for language registries and Repology for Linux distributions, the densest rows belong to system package managers like AUR (40/42), nixpkgs, Homebrew, DNF, and Debian, since packaging arbitrary binaries is their job; as columns, however, they are nearly empty because nobody needs to redistribute &lt;code&gt;apt&lt;/code&gt; or DNF when they ship with the OS. Conda sits between the two worlds, while PyPI is the most prolific language registry because cross-language tools like Conan and Meson are written in Python.&lt;/p&gt;
&lt;p&gt;The post also highlights notable software supply chain implications. Twenty-five of the 42 tools publish themselves through their own registry. A CVE in pip might be tracked under &lt;code&gt;pkg:pypi/pip&lt;/code&gt; or &lt;code&gt;pkg:deb/python3-pip&lt;/code&gt;, but copies of pip inside Homebrew, conda-forge, nixpkgs, or Spack carry the same vulnerability and each ecosystem must map advisories on its own, making upstream vulnerability tracing much harder. Searching by package name is also unreliable because short names on flat-namespace registries are often squatted by unrelated projects, whereas reverse-linking to the source repository yields cleaner matches. Finally, the author constructs a 14-step installation chain stretching from an Arch Linux machine to the Elm compiler.&lt;/p&gt;
&lt;h2 id="beyond-the-prompt-claude-code"&gt;&lt;a href="https://arps18.github.io/posts/claude-code-mastery/" rel="noopener noreferrer"&gt;Beyond the Prompt: Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpan Patel writes an extensive guide to using Claude Code as a workflow-driven agent rather than a prompt-in, code-out chatbot. The core focus is building feedback loops so Claude can verify its own work: reading code, planning, editing, running tests, reviewing, and updating its rules whenever it makes a mistake. The author recommends exploring before coding, using plan mode for multi-file changes, pointing directly to files or logs instead of giving vague descriptions, and delegating tasks the way you would to an engineer rather than micromanaging every small step.&lt;/p&gt;
&lt;p&gt;A standout section covers organizing the &lt;code&gt;.claude&lt;/code&gt; directory: &lt;code&gt;CLAUDE.md&lt;/code&gt; for shared project rules, &lt;code&gt;CLAUDE.local.md&lt;/code&gt; for personal notes, alongside settings, MCP servers, skills, commands, rules, and subagents. &lt;code&gt;CLAUDE.md&lt;/code&gt; should stay concise like a guardrail—containing only rules that genuinely prevent mistakes rather than documenting the entire codebase—while recurring workflows should be turned into reusable skills, commands, or subagents in the repo. For larger teams, plugins, MCPs, and subagents help isolate context, run independent reviews, and execute parallel streams of work, delivering the most value when baked into shared onboarding rather than kept as personal tweaks.&lt;/p&gt;
&lt;h2 id="how"&gt;&lt;a href="https://performance.dev/how-is-linear-so-fast-a-technical-breakdown" rel="noopener noreferrer"&gt;How&amp;rsquo;s Linear so fast? A technical breakdown&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky breaks down why Linear feels instantaneous despite being a client-side web application. The core idea is that Linear removes network latency from the primary interaction path. The data the UI reads is already in the browser, primarily via IndexedDB and an in-memory object pool; mutations are applied optimistically locally first, written to a persistent transaction queue, and then synced to the server. The server acts as an arbiter that acknowledges changes and broadcasts deltas back, rather than something the UI waits on before responding to the user. At runtime, MobX enables fine-grained updates so each delta re-renders only the specific fields and components affected rather than an entire list.&lt;/p&gt;
&lt;p&gt;The post also dives into initial load performance, where speed comes from compounding small details: trimming JavaScript and CSS payloads, targeting only modern browsers, aggressive code splitting, preloading modules to avoid waterfall requests, service worker caching, preloading fonts with the proper &lt;code&gt;crossorigin&lt;/code&gt; attribute, embedding an app shell, and rendering local data before background authentication finishes. Beyond engineering, speed comes from product design: every action has a keyboard shortcut, the command palette is always one keystroke away and runs against local data, and animations are brief and stick to cheap properties like &lt;code&gt;transform&lt;/code&gt; and &lt;code&gt;opacity&lt;/code&gt;. Performance is thus as much about user perception as it is about raw engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #109</title><link>https://miti99.com/en/post/2026/06/06/</link><pubDate>Sat, 06 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #109.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-history-of-ides-at-google"&gt;&lt;a href="https://laurent.le-brun.eu/blog/a-history-of-ides-at-google" rel="noopener noreferrer"&gt;A History of IDEs at Google&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurent Le Brun, who spent 12 years working on developer tooling at Google, recounts the journey from a fragmented ecosystem of editors to a single IDE used by nearly the entire company. Back in 2011, when someone asked whether Google should standardize on one IDE, the near-unanimous answer was &amp;ldquo;no&amp;rdquo; — Jeff Dean argued that forcing a whole team onto a single editor was a recipe for misery. The price of that freedom was that every useful integration — Bazel, code search, formatters — had to be rebuilt for every editor. Around 2013, Cider launched as a web-based editor initially meant for quick doc edits, but thanks to a backend capable of indexing Google&amp;rsquo;s massive monorepo, it gradually won over Go and then Java developers.&lt;/p&gt;
&lt;p&gt;In 2020, the team decided to replace Cider&amp;rsquo;s custom frontend with the VS Code core while keeping Google&amp;rsquo;s proprietary backend; Cider V opened to 5,000 engineers in 2021 and accounted for roughly 80% of main-repo development by 2023. Once most engineers shared a single platform, teams had strong incentives to build internal extensions — roughly 100 within two years — and AI features like code completion and automated review-comment resolution could be rolled out company-wide far faster. The takeaway: standardizing tooling creates massive leverage, even if the up-front investment is high and not every company can pull it off.&lt;/p&gt;
&lt;h2 id="finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks"&gt;&lt;a href="https://medium.com/pinterest-engineering/finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks-ea4722e552eb" rel="noopener noreferrer"&gt;Finding zombies in our systems: A real-world story of CPU bottlenecks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In early 2025, Pinterest&amp;rsquo;s Ray ML training jobs kept crashing due to flaky network connections, and it took the Kubernetes platform team over three months to track down the culprit. The first clue was that the EC2 ENA network driver reset itself whenever its transmit queue stalled for more than 5 seconds, a classic symptom of CPU starvation; weirdly, the resets only happened in a single availability zone even though cluster configs looked identical, and rebooting nodes only bought about a week of relief. On 96-vCPU GPU instances, aggregate &lt;code&gt;perf&lt;/code&gt; profiles looked completely normal; only per-core, per-second &lt;code&gt;mpstat&lt;/code&gt; monitoring revealed a single CPU core pinned at 100% system time for several seconds right when each reset occurred. The team set up automated 2-minute &lt;code&gt;perf record&lt;/code&gt; captures and used Netflix&amp;rsquo;s Flamescope to scrub to the exact second of the spike.&lt;/p&gt;
&lt;p&gt;The culprit: right before every reset, &lt;code&gt;kubelet&lt;/code&gt; spiked to ~6.5% total CPU (normally under 1%), spending nearly all of that time inside the kernel&amp;rsquo;s &lt;code&gt;mem_cgroup_nr_lru_pages&lt;/code&gt; function. The kernel was tracking nearly 70,000 memory cgroups even though only 240 were actually active — &amp;ldquo;zombie memcgs&amp;rdquo; — and walking that list pinned a single core long enough to starve the network driver thread sharing it. The root cause traced back to the AWS Deep Learning AMI (Ubuntu 20.04) base image, which shipped with the Amazon ECS agent enabled by default; unable to join an ECS cluster, the agent crashed in a tight loop, leaking a zombie cgroup on every restart. The fix was simple: disable the ECS agent systemd unit and reboot the fleet. As for why the &amp;ldquo;healthy&amp;rdquo; availability zone never broke? Another bug there prevented the ECS agent from ever starting in the first place.&lt;/p&gt;
&lt;h2 id="programming-still-sucks"&gt;&lt;a href="https://www.stvn.sh/writing/programming-still-sucks-fqffhyp" rel="noopener noreferrer"&gt;Programming Still Sucks.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steven Langbroek wrote this essay to answer the familiar question &amp;ldquo;Will AI take programmers&amp;rsquo; jobs?&amp;rdquo;, and his answer is no: the real culprit is greed, merely dressed up in a new coat called &amp;ldquo;automation.&amp;rdquo; Starting from a casual question at a birthday party, he paints software engineering as a burning ship: no map, no crew, sails mounted backward, useless navigation instruments, and a predecessor who abandoned ship after leaving behind half-baked &amp;ldquo;initiatives.&amp;rdquo; Layoffs, he argues, are signed off by people who know the consequences full well but bow to spreadsheets and quarterly targets, telling themselves they&amp;rsquo;ll &amp;ldquo;fix it later&amp;rdquo; — a &amp;ldquo;later&amp;rdquo; that never comes.&lt;/p&gt;
&lt;p&gt;The sharpest pain point is what happens to junior developers. A junior&amp;rsquo;s value isn&amp;rsquo;t the code they write today, but the fact that one day they become the senior who understands every dark corner of the system; eliminate apprenticeships to optimize short-term output, and a few years later there is nobody left to take the helm. The emotional heart of the piece is Sara, an older infrastructure specialist who inherited her knowledge from Ben and keeps the company alive via a mysterious cron job nobody else understands. When Sara retires, the company will desperately need a replacement after having dismantled the very pipeline that could have trained one. The disaster, Langbroek concludes, isn&amp;rsquo;t technological — it&amp;rsquo;s organizations actively sabotaging themselves.&lt;/p&gt;
&lt;h2 id="how-container-filesystem-works-building-a-docker-like-container-from-scratch"&gt;&lt;a href="https://labs.iximiuz.com/tutorials/container-filesystem-from-scratch" rel="noopener noreferrer"&gt;How Container Filesystem Works: Building a Docker-like Container From Scratch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ivan Velichko&amp;rsquo;s tutorial on iximiuz Labs builds a container by hand using nothing but standard Linux tools like &lt;code&gt;unshare&lt;/code&gt;, &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;pivot_root&lt;/code&gt; — not to replace Docker, but to give readers a clear mental model of what happens under the hood of &lt;code&gt;docker run&lt;/code&gt;. The foundation is the mount namespace: it isolates the mount table — the list of mounted filesystems visible to a process — rather than the underlying physical filesystem itself, something you can verify with &lt;code&gt;findmnt&lt;/code&gt; across two namespaces. Velichko emphasizes mount propagation across &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;shared&lt;/code&gt;, and &lt;code&gt;slave&lt;/code&gt; modes: if ignored, mounts created inside a container can leak out to the host, and &lt;code&gt;pivot_root&lt;/code&gt; — the safer alternative to &lt;code&gt;chroot&lt;/code&gt; — requires that the parent mount not be marked &lt;code&gt;shared&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough mirrors what &lt;code&gt;runc&lt;/code&gt; actually does: prepare a rootfs directory from an Alpine image; create mount, pid, cgroup, uts, and net namespaces; mount the &lt;code&gt;/proc&lt;/code&gt;, &lt;code&gt;/dev&lt;/code&gt;, and &lt;code&gt;/sys&lt;/code&gt; pseudo-filesystems with appropriate restrictions; bind-mount container-specific &lt;code&gt;/etc/hosts&lt;/code&gt;, &lt;code&gt;/etc/hostname&lt;/code&gt;, and &lt;code&gt;/etc/resolv.conf&lt;/code&gt; files; swap the root filesystem via &lt;code&gt;pivot_root&lt;/code&gt;; and harden the container by remounting sensitive &lt;code&gt;/proc&lt;/code&gt; paths read-only and masking others with &lt;code&gt;tmpfs&lt;/code&gt; or &lt;code&gt;/dev/null&lt;/code&gt;. On the security side, an untrusted rootfs can contain symlinks pointing outside the container, so production runtimes use &lt;code&gt;openat2()&lt;/code&gt; with &lt;code&gt;RESOLVE_NO_SYMLINKS&lt;/code&gt; and operate via file descriptors to prevent TOCTTOU race conditions. Finally, bind mounts are the exact same mechanism powering Docker&amp;rsquo;s &lt;code&gt;-v&lt;/code&gt; flag when sharing host volumes with a container.&lt;/p&gt;
&lt;h2 id="using-ai-to-write-better-code-more-slowly"&gt;&lt;a href="https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/" rel="noopener noreferrer"&gt;Using AI to write better code more slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amid the &amp;ldquo;vibe coding&amp;rdquo; frenzy, Nolan Lawson asks the opposite question: if so many people are using LLMs to crank out sloppy code as fast as possible, can we use the exact same tools to write better code more slowly? His answer is yes. His workflow centers on multi-model code review: having Claude, Codex, and Cursor Bugbot independently review a pull request, rank issues as critical, high, medium, or low, and then manually synthesizing and verifying their findings to filter out false positives. Using distinct models and wiping context between rounds reduces the chance that all of them hallucinate the same nonexistent bug. He then has the agent fix the critical and high issues, repeats the review loop until none remain, weighs whether the minor issues are worth addressing, and throws out the entire pull request if the process exposes a fundamental architectural flaw.&lt;/p&gt;
&lt;p&gt;Interestingly, his overall delivery speed hasn&amp;rsquo;t increased at all: the review process routinely uncovers pre-existing bugs in surrounding code, turning every new feature into a side quest of writing tests and cleaning up legacy debt. For anyone letting agents open hundred-line pull requests they don&amp;rsquo;t fully grasp, Lawson advises slowing down: ask the agent how the code works and where it could break, have it generate documentation with Mermaid diagrams, or use Matt Pocock&amp;rsquo;s &lt;code&gt;/grill-me&lt;/code&gt; skill until you understand every detail. This approach burns more tokens, but pays off in a deep understanding of failure modes and a much healthier codebase.&lt;/p&gt;
&lt;h2 id="how-cockroachdb-built-vector-indexing-at-scale"&gt;&lt;a href="https://blog.bytebytego.com/p/how-cockroachdb-built-vector-indexing" rel="noopener noreferrer"&gt;How CockroachDB Built Vector Indexing at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo breaks down C-SPANN, the vector indexing algorithm CockroachDB designed in-house because no off-the-shelf approach fit a distributed transactional database. Vectors have no natural total ordering, rendering B-trees useless, so every vector index trades exactness for speed via approximate nearest neighbor (ANN) search. CockroachDB set six hard constraints: no central coordinator node, no reliance on massive in-memory structures, minimal network hops, shardable across nodes, no hot spots, and real-time incremental updates — ruling out both traditional HNSW and IVF. C-SPANN instead uses a wide, shallow hierarchical K-means tree: with a branching factor around 100, a million vectors need just three levels and ten billion vectors need five.&lt;/p&gt;
&lt;p&gt;The key architectural decision is storing each partition as ordinary key-value rows inside CockroachDB, allowing the index to automatically inherit range splitting, load balancing, replication, and multi-region placement without a separate infrastructure stack. To cut storage overhead, RaBitQ compresses 1,536-dimensional vectors from ~3 KB down to 200 bytes (a 94% reduction), then uses the full-precision vectors to rerank a small candidate set. For multi-tenancy, prefix columns like &lt;code&gt;(user_id, embedding)&lt;/code&gt; create isolated per-tenant trees, combining with &lt;code&gt;REGIONAL BY ROW&lt;/code&gt; to satisfy data-residency rules. The trade-offs are stated plainly: C-SPANN trails dedicated vector databases on raw tail latency and currently only supports Euclidean distance in preview, but it is a great fit for workloads where vectors need to live alongside transactional data.&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 #108</title><link>https://miti99.com/en/post/2026/06/04/</link><pubDate>Thu, 04 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #108.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-is-solved-software-is-not"&gt;&lt;a href="https://arcplane.ai/journal/software-is-not-solved" rel="noopener noreferrer"&gt;Coding is solved? Software is not.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Opening with Boris Cherny&amp;rsquo;s (creator of Claude Code) remark that coding is &amp;ldquo;basically solved,&amp;rdquo; Arcplane&amp;rsquo;s Gao argues that the statement is true but incomplete. Coding is merely translating instructions into source code, whereas software development is turning ambiguous intent into a reliable system — a process of progressively reducing entropy. The paradox is that fast AI code generation can actually increase entropy: massive test suites that only validate whatever implementation the agent happened to pick, and plausible-sounding plans that leave core product decisions unresolved. Code arrives sooner, but the team doesn&amp;rsquo;t reach confidence any sooner — the bottleneck simply shifts to review, reconstructing the agent&amp;rsquo;s intent, and interpreting noisy verification evidence.&lt;/p&gt;
&lt;p&gt;Drawing on experience running an authentication product managing millions of identities, the author points to four things that need to change. First, context must be curated deliberately, and review feedback must be captured for future runs. Second, specifications must live alongside the work and be updated as new edge cases surface, because an agent will happily build a complete implementation of an ambiguous requirement. Third, verification evidence must be clear enough for a reviewer to see what the agent ran, what failed, and how it fixed it. Fourth, humans need well-placed checkpoints — especially before deployment — because &amp;ldquo;clean code cannot save a bad spec,&amp;rdquo; and review depth should scale with risk.&lt;/p&gt;
&lt;h2 id="ideas"&gt;&lt;a href="https://www.noahzender.com/ideas" rel="noopener noreferrer"&gt;Ideas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rather than a single essay, this is Noah Zender&amp;rsquo;s index page collecting nearly 500 mental models, patterns, and frameworks distilled from hundreds of books, podcasts, and videos. The ideas are organized into 11 categories: mental models and decision-making, knowledge and learning, creativity and writing, product and startups, brand and marketing, tech innovation and AI, investing and economics, psychology and self-improvement, work and leadership, philosophy and worldview, plus an uncategorized bucket. Each entry links to a short standalone page, reading more like a personal knowledge base than a linear article.&lt;/p&gt;
&lt;p&gt;A representative example is the &amp;ldquo;Leveraged Expert&amp;rdquo; concept, which argues that &lt;em&gt;when&lt;/em&gt; you specialize matters just as much as &lt;em&gt;what&lt;/em&gt; you specialize in. Every technology adoption curve has an inflection point where growth either crosses into the mainstream or rapidly fizzles out. If you are already an expert in a field right as it hits that inflection point, your leverage compounds automatically as adoption takes off without requiring extra effort on your part. Specializing too early in a field that is still too nascent yields much lower leverage; the sweet spot is the early-adopter phase, where the surface area for luck is highest. For younger developers, it&amp;rsquo;s a useful lens when deciding which technologies to invest in deeply.&lt;/p&gt;
&lt;h2 id="ai-productivity-debate"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-productivity-debate" rel="noopener noreferrer"&gt;AI productivity debate&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from DX&amp;rsquo;s Engineering Enablement newsletter recaps the closing panel of the DX Annual conference, featuring engineering leaders and researchers from Etsy, Twilio, GitHub, Google, and DX. Asked whether AI will mean needing fewer engineers, most panelists disagreed: demand for software rises as the cost of building it falls, so total builder headcount won&amp;rsquo;t shrink even if the definition of an engineer evolves. On technical debt, opinions split: Twilio&amp;rsquo;s representative viewed AI as an amplifier (garbage in, garbage out), while Brian Houck warned that organizations are optimizing for PR velocity over simplicity, accumulating &amp;ldquo;comprehension debt&amp;rdquo; as humans understand less and less of a codebase largely written by AI.&lt;/p&gt;
&lt;p&gt;The panelists opposed top-down AI mandates: Twilio simply pre-installed tools and offered basic guidance yet still saw adoption surge, whereas mandates tend to breed superficial compliance. Using AI utilization as an individual performance metric was roundly rejected by engineers. As for bottlenecks, developers spend only about 14% of their time writing code, so the real constraints remain decision-making, prioritization, and product design; code review mostly feels slower because code is being generated faster. Finally, most adoption hurdles are human and cultural: leaders need to give engineers dedicated time to learn, and two-week group learning sprints proved far more effective than isolated solo tinkering.&lt;/p&gt;
&lt;h2 id="maintainability-sensors-for-coding-agents"&gt;&lt;a href="https://martinfowler.com/articles/sensors-for-coding-agents.html" rel="noopener noreferrer"&gt;Maintainability sensors for coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) shares hands-on experiments with maintainability &amp;ldquo;sensors&amp;rdquo; that help both humans and AI coding agents gauge code quality, building on the concept of &amp;ldquo;harness engineering.&amp;rdquo; Her testbed was a TypeScript, Next.js, and React dashboard rebuilt entirely with AI and given almost no up-front code-quality instructions, designed to see how far an agent could get relying solely on feedback from sensors like the type checker, ESLint, Semgrep, &lt;code&gt;dependency-cruiser&lt;/code&gt;, the test suite, and mutation testing. With ESLint, she enabled rules capping parameter counts, file length, function length, and cyclomatic complexity, rewriting error messages into actionable remediation instructions and allowing the agent to suppress warnings only if it attached an explicit justification for reviewers.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;dependency-cruiser&lt;/code&gt; helped the agent respect layered module boundaries and self-correct violations. Raw coupling metrics, by contrast, proved noisy and poorly interpreted by AI because &amp;ldquo;good&amp;rdquo; versus &amp;ldquo;bad&amp;rdquo; coupling depends heavily on context — whereas an AI modularity review guided by a strong prompt caught valuable issues like duplicated route logic and misplaced responsibilities. For AI-generated tests, high line coverage did not guarantee quality: some files hit 100% statement coverage without a single true unit test, and only mutation testing exposed the missing assertions. Böckeler concludes that computational sensors work best at the file and function level, while cross-module design issues require AI to supply semantic interpretation. Sensors boost confidence in agent output, but they still cannot replace human judgment.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #106</title><link>https://miti99.com/en/post/2026/05/28/</link><pubDate>Thu, 28 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #106.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-heck-does-gps-work-an-interactive-exploration"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-gps-work" rel="noopener noreferrer"&gt;How The Heck Does GPS Work? (An Interactive Exploration)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shri Khalpada&amp;rsquo;s interactive explainer shows that GPS is fundamentally a machine for turning time into distance. Satellites broadcast radio signals at the speed of light, your phone measures how long the signal took to arrive, and each nanosecond corresponds to roughly 0.3 meters. One satellite tells you that you lie somewhere on a sphere (or circle in 2D), a second narrows it to two intersection points, and a third pins down a single point — a method called trilateration. The catch is the clock: satellites carry atomic clocks, while your phone only has a cheap quartz oscillator, and a drift of just a few microseconds throws your position off by hundreds of meters. That is why a fourth satellite is required: there is only one clock-offset correction that makes all four spheres intersect at a single point, allowing the receiver to solve for both exact position and exact time simultaneously.&lt;/p&gt;
&lt;p&gt;Then comes the &amp;ldquo;relativity tax&amp;rdquo;: because satellites move so fast, their clocks tick about 7 microseconds slower per day (special relativity), but higher up in weaker gravity they tick about 45 microseconds faster (general relativity). Left uncorrected, positions would drift by roughly 10 km per day, so satellite clocks are engineered to tick slightly slower before launch on the ground. In practice, modern receivers lock onto 8–12 satellites at once across GPS (US), GLONASS (Russia), Galileo (EU), and BeiDou (China) to reduce error; in dense cities, signals bouncing off buildings (multipath error) remain the hardest problem.&lt;/p&gt;
&lt;h2 id="if-ai-writes-your-code-why-use-python"&gt;&lt;a href="https://medium.com/@NMitchem/if-ai-writes-your-code-why-use-python-bf8c4ba1a055" rel="noopener noreferrer"&gt;If AI Writes Your Code, Why Use Python?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Noah Mitchem argues that the decade-long &amp;ldquo;bargain&amp;rdquo; — picking Python or TypeScript for their huge ecosystems, easier hiring, and fast prototyping while accepting 10x to 100x worse performance than Rust, Go, or C++ — has expired, because AI has gotten good at the hard languages. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 all topped 80% on SWE-bench Verified. The strict type systems and tight compiler feedback loops of Rust and Go let agents iteratively self-correct. The proof is already here: Microsoft ported the TypeScript compiler to Go (roughly 10x faster); Nicholas Carlini at Anthropic orchestrated 16 Claude agents to write a 100,000-line C compiler in Rust across nearly 2,000 Claude Code sessions for under $20,000; and Andreas Kling ported Ladybird&amp;rsquo;s JavaScript engine from C++ to Rust in two weeks — roughly 25,000 lines with zero regressions.&lt;/p&gt;
&lt;p&gt;Even the Python ecosystem is increasingly a &amp;ldquo;Rust ecosystem wearing a Python hat&amp;rdquo;: pydantic, polars, tokenizers, and orjson are all written in Rust; OpenAI acquired Astral (uv, ruff), and Anthropic acquired Bun. The unit of open-source contribution is also shifting from patches to full ports: Armin Ronacher used an agent to port MiniJinja from Rust to Go in 10 hours with only 45 minutes of actual human effort. Exceptions remain: Prisma moved back to a TypeScript/WASM core for serverless, PyTorch still commands roughly 85% of deep learning research, and Zig, Haskell, and Gleam lack training data. As the developer&amp;rsquo;s role shifts toward design and review, Python&amp;rsquo;s ease-of-writing advantage fades while the performance advantage of harder languages compounds every day.&lt;/p&gt;
&lt;h2 id="on-rendering-the-sky-sunsets-and-planets"&gt;&lt;a href="https://blog.maximeheckel.com/posts/on-rendering-the-sky-sunsets-and-planets/" rel="noopener noreferrer"&gt;On Rendering the Sky, Sunsets, and Planets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maxime Heckel walks through rendering atmospheric scattering in WebGL shaders from first principles up to near-photorealistic results. The foundation is raymarching: sampling atmospheric density along the view ray, computing transmittance via Beer&amp;rsquo;s Law, and using phase functions to describe scattering direction. Three physical mechanisms are combined: Rayleigh scattering (shorter wavelengths scatter more strongly, which is why the sky is blue), Mie scattering (larger particles like dust and aerosols that create the bright halo around the sun), and ozone absorption (filtering out specific wavelengths and deepening sunset colors).&lt;/p&gt;
&lt;p&gt;After building a flat sky, the author wraps the atmosphere around a spherical planet: reconstructing world-space coordinates from the depth buffer, using ray-sphere intersection to find atmospheric bounds, and handling depth so the atmosphere blends seamlessly with rendered geometry. With the exact same simulation framework, tweaking parameters produces a solar eclipse or a Martian sky. Finally, to hit real-time frame rates, the article implements Sébastien Hillaire&amp;rsquo;s lookup-table (LUT) method: precomputing transmittance, sky-view, and aerial perspective into textures and sampling them instead of running nested raymarching loops every frame. Packed with interactive widgets to tweak sun angle, altitude, Mie scattering, and ozone density, it is well worth reading directly.&lt;/p&gt;
&lt;h2 id="starting-systems-programming-pt-1-programmers-write-programs"&gt;&lt;a href="https://eblog.fly.dev/startingsystems1.html" rel="noopener noreferrer"&gt;Starting Systems Programming, Pt 1: Programmers Write Programs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the opening installment of Efron Amber Licht&amp;rsquo;s series on systems programming, built around a simple premise: to get good, you have to do the thing, and programmers write programs. In the author&amp;rsquo;s view, a problem counts as &amp;ldquo;systems&amp;rdquo; programming when it interacts with the OS or hardware, operates under tight performance constraints, or manipulates bytes and registers directly. A systems programmer views the computer as a physical machine that can be understood completely rather than an opaque abstraction, and isn&amp;rsquo;t afraid to take things apart to see how they work.&lt;/p&gt;
&lt;p&gt;The article opens the &amp;ldquo;black box&amp;rdquo; of a program by compiling a Go &amp;ldquo;hello world&amp;rdquo; binary and inspecting the executable directly. Readers build small tools from scratch along the way: &lt;code&gt;findoffset&lt;/code&gt; to locate a string inside a file, &lt;code&gt;echo&lt;/code&gt; and &lt;code&gt;cat&lt;/code&gt; to write and print files, &lt;code&gt;binpatch&lt;/code&gt; to patch binary contents directly without recompiling, and hexdump utilities to inspect machine code. Through these exercises, readers see that an executable is just an organized sequence of bytes: the string &lt;code&gt;&amp;quot;hello, world!&amp;quot;&lt;/code&gt; sits at a fixed offset, while the ELF header holds the magic number, target architecture, and the entry point where the CPU begins execution, with values stored in little-endian order on x86-64. The ethos the author wants to pass on: build your own tools, look at the raw data with your own eyes, and understand the system rather than hiding behind abstractions — because at the end of the day, it&amp;rsquo;s all just bytes.&lt;/p&gt;
&lt;h2 id="learning-software-architecture"&gt;&lt;a href="https://matklad.github.io/2026/05/12/software-architecture.html" rel="noopener noreferrer"&gt;Learning Software Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Replying to a physicist asking how to learn software architecture, Matklad argues that the skill is best learned by doing. University design courses felt to him like &amp;ldquo;kindergarteners playing firefighters&amp;rdquo;; what actually taught him architecture was unexpectedly becoming the lead of the IntelliJ Rust project. His second observation is Conway&amp;rsquo;s Law: software mirrors the social structure of the organization that builds it. He quotes neugierig: code ultimately matters less than architecture, and architecture matters less than social problems. Poor &amp;ldquo;scientific code,&amp;rdquo; therefore, stems mainly from incentive structures — like pressure to publish a paper in three months — rather than a lack of programming knowledge.&lt;/p&gt;
&lt;p&gt;There are two ways forward: very rarely, you get a chance to redesign a project&amp;rsquo;s incentive structure; most of the time, you have to accept the constraints and adapt the architecture around them. &lt;code&gt;rust-analyzer&lt;/code&gt; is a prime example: its deep, compiler-like core is kept trivial to build with a test suite that runs in seconds so it can attract strong contributors, while its wide surface of IDE features is isolated so that each feature is wrapped in &lt;code&gt;catch_unwind&lt;/code&gt; and operates on an immutable snapshot of data — allowing weekend contributors to submit imperfect code without crashes cascading or corrupting state. While he has no single &amp;ldquo;bible&amp;rdquo; book to recommend, he points readers to Gary Bernhardt&amp;rsquo;s talk &amp;ldquo;Boundaries,&amp;rdquo; Pieter Hintjens&amp;rsquo;s writings, Ted Kaminski&amp;rsquo;s blog, and Jamii&amp;rsquo;s post &amp;ldquo;Reflections on a decade of coding.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="i"&gt;&lt;a href="https://newsletter.weskao.com/p/im-an-introvert-this-is-how-i-get-myself-to-speak-up" rel="noopener noreferrer"&gt;I&amp;rsquo;m an introvert. This is how I get myself to speak up.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao shares her experience as an introvert in the workplace, where meetings naturally favor people who speak first and think out loud. Introverts prefer time to process before responding, putting them at a systematic disadvantage. Rather than waiting until you feel confident — a moment that usually never arrives — she recommends preparing ahead of time and using concrete tactics she relies on herself.&lt;/p&gt;
&lt;p&gt;Before a meeting, decide in advance that you are going to speak so you don&amp;rsquo;t waste energy debating yourself in the moment, and chime in early before prolonged self-doubt lets the opportunity slip away. Keeping a few go-to opening phrases ready, such as &amp;ldquo;That&amp;rsquo;s a great point. My POV on this is…&amp;rdquo;, makes jumping into a fast-moving discussion much easier. Written channels like docs and meeting notes serve as a parallel track for contributing and leave behind durable artifacts. Remote meetings also offer unique advantages for introverts (controlled lighting, framing, and small video tiles reduce pressure), and you can enlist a trusted colleague to give you a gentle prompt to hold yourself accountable.&lt;/p&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer-in-2026"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms-in-2026/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke reflects on how his LLM usage as a staff engineer has evolved over the past year, and the biggest shift is that agents have gotten genuinely good. In 2025 he only used AI for autocomplete, small edits in unfamiliar codebases, or Q&amp;amp;A; today, every code change starts by handing it to an agent (primarily via the GitHub Copilot app, running dozens of sessions a day). He skims the result for about 30 seconds, throws away most attempts because they aren&amp;rsquo;t what he had in mind, and carefully reviews and polishes the ones that survive. For bug reports, he feeds every single one to an agent first because it diagnoses the issue correctly about 80% of the time. Human expertise still matters, though: one bug took until the 14th agent session to crack, after he supplied context from logs and Slack, reproduced the issue himself, and narrowed the search space.&lt;/p&gt;
&lt;p&gt;He offloads a lot of testing and environment setup to agents: having them test their own changes and inspect the logs, write integration tests, and troubleshoot local machine configs. Test code is treated as &amp;ldquo;cheap,&amp;rdquo; whereas he avoids delegating UI work because agents still lack visual sensibility. Conversely, he still writes all his own PR descriptions, ADRs, Slack messages, and blog posts, because LLMs are overly verbose, struggle to surface the core point, and writing things yourself signals to coworkers that a real human is thinking on the other end. In his view, the most important AI skill today is delegating as much as possible to agents without pushing it too far.&lt;/p&gt;
&lt;h2 id="interrogatory-llm"&gt;&lt;a href="https://martinfowler.com/bliki/InterrogatoryLLM.html" rel="noopener noreferrer"&gt;Interrogatory LLM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler introduces the &amp;ldquo;Interrogatory LLM&amp;rdquo; pattern: instead of a human writing pages of context up front for a complex task, you ask the LLM to interview you, ask every question it needs answered, and synthesize the conversation into a context report that a subsequent session (potentially running a different model) uses to execute the task. He first spotted this technique on Harper Reed&amp;rsquo;s blog, noting the key trick of forcing the LLM to ask only one question at a time — a constraint Fowler found he had to remind the model of repeatedly when trying it himself.&lt;/p&gt;
&lt;p&gt;The pattern also works in reverse: hand an LLM an existing document, such as a software specification, and have it interview a domain expert to verify whether the spec is still accurate, replacing the tedious document review process that many experts struggle with. You can even combine both directions: one LLM drafts the document through an interview, and other LLMs take it to different experts for cross-examination. More broadly, while Fowler himself treats writing as an integral part of thinking, many people find writing painful; a structured conversation with an LLM can help them turn their tacit knowledge into written documentation.&lt;/p&gt;
&lt;h2 id="i-don"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2026-05-15-i-dont-think-ai-will-make-your-processes-go-faster/" rel="noopener noreferrer"&gt;I don&amp;rsquo;t think AI will make your processes go faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After rereading the classics &lt;em&gt;The Toyota Way&lt;/em&gt; and &lt;em&gt;The Goal&lt;/em&gt;, Frederick Van Brabant argues that AI won&amp;rsquo;t speed up organizational processes the way many expect, because we keep misidentifying the bottleneck. Looking at a project timeline, software development takes the longest chunk of time, so the knee-jerk reaction is to add headcount or assume AI will speed it up. But taking a long time doesn&amp;rsquo;t mean the problem originates there: nobody makes a project faster by typing faster. Most of that time is actually spent deciphering vague, title-only tickets like &amp;ldquo;send an email to the user when the order is completed&amp;rdquo; — what goes in the email, what happens on failure, and what counts as completed?&lt;/p&gt;
&lt;p&gt;AI generates code fast, but that doesn&amp;rsquo;t mean it generates the &lt;em&gt;right&lt;/em&gt; code. Comparisons between humans and AI routinely ignore the hand-holding required: to get AI to build the right thing, product and domain experts have to specify every feature and edge case down to the tiniest detail, ballooning the specification phase. Yet that level of clarity is what developers have wanted all along; if human engineers received specs that detailed, their productivity would skyrocket too. If you want faster processes, make sure the people doing the work have what they need to succeed — echoing &lt;em&gt;The Goal&lt;/em&gt;&amp;rsquo;s lesson that a bottleneck must be fed high-quality, predictable inputs.&lt;/p&gt;
&lt;h2 id="using-an-engineering-notebook"&gt;&lt;a href="https://ntietz.com/blog/using-an-engineering-notebook/" rel="noopener noreferrer"&gt;Using an Engineering Notebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicole Tietz shares what she considers perhaps her single most important productivity habit: handwriting in an engineering notebook, a practice borrowed from laboratory notebooks. The notebook records in rich detail what she is doing and why, thoroughly enough that someone else could reproduce the work; every entry is dated, written contemporaneously as the work happens, append-only without erasures or edits, and serves as the primary record rather than a neat copy transcribed from elsewhere. That level of detail matters because your future self is also &amp;ldquo;someone else&amp;rdquo; and will forget most of the context. She started the habit in 2016 while consulting for multiple clients at once, and now uses an e-ink tablet instead of paper notebooks because she is left-handed and doesn&amp;rsquo;t want to carry multiple physical notebooks around.&lt;/p&gt;
&lt;p&gt;The notebook delivers two main benefits. First, it acts as a memory aid: both as a log she can read back to recover context after an interruption, and because the physical act of handwriting improves retention. Second, it is a thinking tool: she routinely writes out a description of a planned code change in her notebook before touching the keyboard, forcing herself to think carefully and spot gaps in her understanding before writing a single line of code. She rarely rereads old notebooks and never shows them to anyone, because &amp;ldquo;the writing &lt;em&gt;is&lt;/em&gt; the work.&amp;rdquo; Her advice: if you haven&amp;rsquo;t tried keeping one, give it a shot and adapt the format, medium, and level of detail to fit your own style.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Documents:&lt;/strong&gt;
&lt;a href="https://static1.squarespace.com/static/50363cf324ac8e905e7df861/t/6a0af5d0484fbf5fe9a7743e/1779103184855/2026-Spring-AI.pdf" rel="noopener noreferrer"&gt;AI eats the world&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 #102</title><link>https://miti99.com/en/post/2026/05/05/</link><pubDate>Tue, 05 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #102.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-github-agentic-workflow"&gt;&lt;a href="https://blog.frankel.ch/agentic-github-workflows/" rel="noopener noreferrer"&gt;A GitHub agentic workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel shares his hands-on experience with GitHub agentic workflows — workflows whose defining feature is running an AI agent inside them. He works on a long-lived product with many versions, accompanied by an analysis tool that warns customers ahead of time about upgrade issues. The tool&amp;rsquo;s configuration file used to be compiled manually by a colleague from release notes. Some deprecation info exists in source code via annotations like &lt;code&gt;@Deprecated&lt;/code&gt;, but plugin deprecations only appear in release notes — unstructured prose that traditional deterministic automation cannot parse. That is exactly where an agent shines.&lt;/p&gt;
&lt;p&gt;The workflow has four steps: initialize with &lt;code&gt;gh aw init&lt;/code&gt; or via the GitHub UI; write the workflow in Markdown (the author used Copilot CLI to help); &amp;ldquo;compile&amp;rdquo; it to YAML with &lt;code&gt;gh aw compile&lt;/code&gt;; and run it like a normal workflow using a fine-grained &lt;code&gt;GITHUB_COPILOT_TOKEN&lt;/code&gt; with &amp;ldquo;Copilot requests&amp;rdquo; permission. Along the way, the author hit several snags: forgetting to compile and pushing only the Markdown file; trying to create an auto-compile workflow before hitting permission walls and realizing it was a security risk anyway; and finally settling on a verification workflow that recompiles and fails if the output differs from the committed YAML, paired with &lt;code&gt;.gitattributes&lt;/code&gt; to handle line-ending differences between Windows and Ubuntu. Agentic workflows also disallowed actions from the GitHub Marketplace in his setup. In his view, they don&amp;rsquo;t replace deterministic workflows, but they unlock new use cases like parsing release notes that regexes can&amp;rsquo;t easily handle.&lt;/p&gt;
&lt;h2 id="the-20-software-engineering-laws"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/the-20-software-engineering-laws" rel="noopener noreferrer"&gt;The 20 Software Engineering Laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr Milan Milanović rounds up the 20 software engineering laws he references most often to explain why projects fail, systems degrade, and teams slow down. Many of these decades-old principles remain useful because they are about humans building products together under time pressure rather than any specific technology. They aren&amp;rsquo;t rigid rules: they describe what tends to happen, while the decisions still belong to the engineer.&lt;/p&gt;
&lt;p&gt;The laws are grouped into several themes: how systems are built (Gall&amp;rsquo;s Law, KISS, Conway&amp;rsquo;s Law, Hyrum&amp;rsquo;s Law, CAP Theorem, Zawinski&amp;rsquo;s Law), team dynamics (Brooks&amp;rsquo;s Law, Ringelmann Effect, Price&amp;rsquo;s Law), planning and estimation (Dunning-Kruger Effect, Hofstadter&amp;rsquo;s Law, Parkinson&amp;rsquo;s Law), measurement (Goodhart&amp;rsquo;s Law, Gilb&amp;rsquo;s Law), performance and reliability (Knuth&amp;rsquo;s Optimization Principle, Amdahl&amp;rsquo;s Law, Murphy&amp;rsquo;s Law), and design philosophy (Postel&amp;rsquo;s Law, Sturgeon&amp;rsquo;s Law, Cunningham&amp;rsquo;s Law). Illustrative examples include Instagram succeeding after stripping Burbn down to just photo sharing while feature-packed Google Wave vanished after 15 months, and the 2024 CrowdStrike outage that crashed 8.5 million Windows machines (Murphy&amp;rsquo;s Law). Understanding these laws before trouble strikes helps avoid costly mistakes; because they sometimes contradict one another, engineers need judgment to pick the right lens and build their own catalog of observed patterns.&lt;/p&gt;
&lt;h2 id="databases-were-not-designed-for-this"&gt;&lt;a href="https://arpitbhayani.me/blogs/defensive-databases/" rel="noopener noreferrer"&gt;Databases Were Not Designed For This&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpit Bhayani points out that every database design rests on an &amp;ldquo;implicit contract&amp;rdquo;: the caller is a human-written application running deterministic code, queries are reviewed before deployment, writes are intentional, and connections are short-lived. That contract held for forty years, but AI agents break it at every layer. Agents hallucinate novel queries on the fly, write data autonomously, duplicate writes on retries, hold connections open while waiting on LLM inference, and fan out into parallel sub-agents. A classic failure mode: an API returns HTTP 200 with an empty result because the backend connection pool is exhausted, and the agent interprets &amp;ldquo;no data&amp;rdquo; as &amp;ldquo;no problem,&amp;rdquo; proceeding to approve 500 transactions without triggering a single alert.&lt;/p&gt;
&lt;p&gt;The fix is defensive database design: set role-level statement timeouts (e.g., 5 seconds); use soft deletes with a &lt;code&gt;deleted_by&lt;/code&gt; column to audit which agent deleted what; use append-only event log tables for sensitive data; enforce idempotency keys derived from task ID, operation type, and target entity so retries don&amp;rsquo;t create duplicate records; and isolate agent traffic into a dedicated connection pool with short wait timeouts so it fails fast. The article also covers PgBouncer transaction pooling, attaching SQL comments with agent and task IDs for observability, and giving each agent type its own least-privilege database role. The core message: none of these are new tools — they are established best practices that become mandatory infrastructure once agents talk to your database.&lt;/p&gt;
&lt;h2 id="finishing-things"&gt;&lt;a href="https://ratfactor.com/finishing-things" rel="noopener noreferrer"&gt;Finishing Things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a personal essay by the author of the ratfactor blog about finishing personal projects amid life&amp;rsquo;s upheavals. He used to set grand annual themes like &amp;ldquo;The Year of the Microcontroller&amp;rdquo; (2023) or &amp;ldquo;The Year of Try It&amp;rdquo; (2024), but personal hardships and external events kept derailing them, so he decided to stop making big plans. What actually works is a &amp;ldquo;project stack&amp;rdquo;: every idea gets written on a small Post-It note and placed into a display frame, usually near the top, and he only works on the topmost item. This stack turns a sprawling maze of side quests into a single linear track that&amp;rsquo;s easy to follow instead of a tangled to-do list.&lt;/p&gt;
&lt;p&gt;He compares maintaining habits and projects to plate spinning: when a crisis hits, multiple plates come crashing down at once. His advice is to keep at least one plate spinning, because maintaining momentum is much easier than starting over from scratch; skills also need regular practice so they don&amp;rsquo;t rust. The essay introduces the &amp;ldquo;sphere of control,&amp;rdquo; a boundary that expands and contracts with life&amp;rsquo;s circumstances: as long as you do well within that sphere, there&amp;rsquo;s no need to beat yourself up, and some obstacles are really just minor discomforts, like dreading a phone call to book an appointment. He also touches on the creeping nihilism of watching AI companies scrape up human creativity, and chooses to ignore it and keep creating anyway. Conclusion: slow, steady progress is what actually gets things done, so instead of specific goals, he declares a &amp;ldquo;year of slow, steady progress.&amp;rdquo;&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_!9kS2!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F71595c9b-f94f-4ae8-851e-ea4f07342c29_2484x3002.png" alt="Data Warehouse vs Data Lake vs Data Mesh"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U4gw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8e8297aa-f856-4b2b-af5d-986023db89e7_2508x3000.png" alt="API Concepts Every Software Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SAsk!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7616a6b1-8eb6-4dc3-9456-b0e57bc9b0ee_2484x3002.png" alt="Polling vs Long Polling vs Webhooks vs SSE"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SJN6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F47ce48f1-06e7-4663-b822-96cc7d1307d0_2484x3002.png" alt="SLA vs SLO vs SLI"&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 #98</title><link>https://miti99.com/en/post/2026/04/18/</link><pubDate>Sat, 18 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/18/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #98.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="impeccable-design-fluency-for-ai-harnesses"&gt;&lt;a href="https://impeccable.style/" rel="noopener noreferrer"&gt;Impeccable: Design fluency for AI harnesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Impeccable is a toolkit that gives AI coding assistants—including Claude Code, Cursor, Gemini CLI, Codex CLI, and GitHub Copilot—much stronger frontend design fluency. It targets a familiar problem: most developers lack the design vocabulary to articulate exactly what looks off, while AI models trained on the same generic web templates keep churning out lookalike interfaces full of unmistakable &amp;ldquo;AI tells&amp;rdquo;—purple gradients, Inter everywhere, and cards nested inside cards. Impeccable closes that gap by injecting structured design principles directly into the agent&amp;rsquo;s coding workflow.&lt;/p&gt;
&lt;p&gt;At its core is the &lt;code&gt;impeccable&lt;/code&gt; skill, which teaches the model foundational UI design across seven dimensions and loads automatically whenever the agent works on frontend code. Alongside it come 18 slash commands—such as &lt;code&gt;/polish&lt;/code&gt;, &lt;code&gt;/audit&lt;/code&gt;, &lt;code&gt;/typeset&lt;/code&gt;, and &lt;code&gt;/overdrive&lt;/code&gt;—that give developers a shared vocabulary for steering visual output, plus a catalog of named design anti-patterns so the model knows what to avoid. Its Visual Mode, run via a Chrome extension or &lt;code&gt;npx impeccable live&lt;/code&gt;, executes 25 deterministic (non-LLM) layout and typography checks directly against the live DOM. Supporting Cursor, Claude Code, Gemini CLI, Codex CLI, VS Code Copilot, Antigravity, Kiro, and OpenCode, it&amp;rsquo;s well worth trying if you rely on AI to build UIs.&lt;/p&gt;
&lt;h2 id="getdesignmd--designmd-collection-for-ai-coding-agents"&gt;&lt;a href="https://getdesign.md/" rel="noopener noreferrer"&gt;getdesign.md — DESIGN.md collection for AI coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maintained by VoltAgent, &lt;code&gt;getdesign.md&lt;/code&gt; is an open collection of &lt;code&gt;DESIGN.md&lt;/code&gt; files that reverse-engineer the design systems of iconic websites like SpaceX, IBM, Lamborghini, and dozens of other brands. Using one is dead simple: pick a &lt;code&gt;DESIGN.md&lt;/code&gt;, drop it into your repository, and tell your coding agent (Claude Code, Cursor, Copilot) to follow it when building UI components. Every new screen then inherits a cohesive visual language instead of defaulting to generic AI-generated layouts.&lt;/p&gt;
&lt;p&gt;At the time this newsletter was compiled, the catalog featured 68 brand systems and was still growing. Each file documents color palettes, typography scales, spacing rules, signature component patterns, and the rationale behind those choices—giving coding agents enough context to produce polished, stylistically consistent interfaces even if you aren&amp;rsquo;t a designer. The source lives in &lt;code&gt;VoltAgent/awesome-design-md&lt;/code&gt; on GitHub, with a Request page where the community can propose new sites to analyze. It&amp;rsquo;s a handy resource whenever you want to prototype fast with a distinct visual identity without crafting a design system from scratch.&lt;/p&gt;
&lt;h2 id="which-java-construct-should-you-use-let-change-drivers-decide"&gt;&lt;a href="https://dev.to/yannick555/which-java-construct-should-you-use-let-change-drivers-decide-3159" rel="noopener noreferrer"&gt;Which Java Construct Should You Use? Let Change Drivers Decide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yannick Loth proposes choosing Java language constructs through deliberate analysis rather than habit: look at the &lt;em&gt;change drivers&lt;/em&gt;—the forces that, when they change, force a given piece of code to change with them. Through this &amp;ldquo;IVP lens,&amp;rdquo; you can separate &lt;em&gt;essential coupling&lt;/em&gt; (inherent to the domain problem) from &lt;em&gt;accidental coupling&lt;/em&gt; (imposed unnecessarily by the language construct you picked). The guiding question is always: does this construct force me to couple more than the problem actually requires?&lt;/p&gt;
&lt;p&gt;For example, a non-static inner class carries an implicit reference to its enclosing instance, so it should only be used when it genuinely needs that outer state; a &lt;code&gt;static&lt;/code&gt; nested class fits when you need state or multiple methods without the outer instance; and lambdas or method references capture only what their body actually touches. Java &lt;code&gt;record&lt;/code&gt;s replace mutable data-holder classes that turn every writer into a change driver for every reader (even if &lt;code&gt;record&lt;/code&gt; immutability is shallow across &lt;code&gt;final&lt;/code&gt; fields). &lt;code&gt;sealed&lt;/code&gt; interfaces paired with exhaustive pattern matching bound the variant space cleanly when the set of subtypes is closed. Finally, &lt;code&gt;Optional&lt;/code&gt; and &lt;code&gt;Result&lt;/code&gt; types turn invisible change drivers like &lt;code&gt;null&lt;/code&gt; or checked exceptions (which force every intermediate caller to redeclare them) into explicit return types. Viewed this way, nearly every major Java feature from Java 8 through Java 25 marches in the same direction: narrowing the gap between what the language forces you to couple and what your domain actually needs.&lt;/p&gt;
&lt;h2 id="the-git-commands-i-run-before-reading-any-code"&gt;&lt;a href="https://piechowski.io/post/git-commands-before-reading-code/" rel="noopener noreferrer"&gt;The Git Commands I Run Before Reading Any Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When inheriting an unfamiliar codebase, Ally Piechowski doesn&amp;rsquo;t start by opening source files—she opens a terminal and interrogates the Git history. Commit logs offer an instant diagnostic X-ray of a project: who built it, where bugs cluster, and whether the team ships with confidence or tiptoes around minefields. The post walks through five groups of Git one-liners that size up a repository&amp;rsquo;s health in minutes before reading a single line of code.&lt;/p&gt;
&lt;p&gt;First is listing the 20 most frequently modified files over the past year; high churn in a file nobody wants to own is the clearest red flag in any repo. Second is ranking contributors by commit count: if one person accounts for 60%+ of commits, the project has a dangerously low bus factor—especially if that person has already left the company. Third is filtering commits for bug-fix keywords (&lt;code&gt;fix&lt;/code&gt;, &lt;code&gt;bug&lt;/code&gt;, &lt;code&gt;broken&lt;/code&gt;) and intersecting them with high-churn files to pinpoint the riskiest hotspots in the codebase. Fourth is plotting monthly commit velocity to see the shape of team momentum over time, which reflects organizational health as much as code health. Finally, checking the frequency of reverts and hotfixes reveals how much the team can trust its deployment pipeline. She notes two caveats: squash-merge workflows flatten commit counts, and bug-keyword searches depend on disciplined commit messages.&lt;/p&gt;
&lt;h2 id="chess-in-pure-sql"&gt;&lt;a href="https://www.dbpro.app/blog/chess-in-pure-sql" rel="noopener noreferrer"&gt;Chess in Pure SQL&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This playful experiment demonstrates just how expressive SQL can be by building a playable chessboard using nothing but &lt;code&gt;SELECT&lt;/code&gt;, &lt;code&gt;UPDATE&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;, and &lt;code&gt;INSERT&lt;/code&gt;—no JavaScript, no application framework. The 8×8 board is modeled as a simple three-column table (&lt;code&gt;rank&lt;/code&gt;, &lt;code&gt;file&lt;/code&gt;, &lt;code&gt;piece&lt;/code&gt;), seeded with 32 rows representing the 32 pieces on their starting squares.&lt;/p&gt;
&lt;p&gt;The key trick is using conditional aggregation (a SQL pivot) to render rows as an 8×8 visual grid: &lt;code&gt;GROUP BY rank&lt;/code&gt;, wrap &lt;code&gt;CASE&lt;/code&gt; expressions inside &lt;code&gt;MAX()&lt;/code&gt; to pluck out the piece for each file column (&lt;code&gt;a&lt;/code&gt; through &lt;code&gt;h&lt;/code&gt;), join against a CTE that generates all 64 squares, and use &lt;code&gt;COALESCE&lt;/code&gt; to render empty squares cleanly. Moving a piece is a simple &lt;code&gt;UPDATE&lt;/code&gt;, while captures run a &lt;code&gt;DELETE&lt;/code&gt; on the target square first. To top it off, the author replays Paul Morphy&amp;rsquo;s famous 1858 &amp;ldquo;Opera Game&amp;rdquo; as a sequence of SQL statements ending in checkmate. The same pivot pattern generalizes nicely to any grid-style query output—calendars, seating charts, or heatmaps—making it a fun workout for mastering SQL aggregation.&lt;/p&gt;
&lt;h2 id="gits-magic-files"&gt;&lt;a href="https://nesbitt.io/2026/02/05/git-magic-files.html" rel="noopener noreferrer"&gt;Git’s Magic Files&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Nesbitt catalogs the special configuration files that Git and its surrounding ecosystem recognize when placed inside a repository. Each file acts as an in-repo convention that alters tool behavior per repository without requiring global machine configuration—making them essential to understand if you build developer tooling that operates on Git repos.&lt;/p&gt;
&lt;p&gt;Core Git files include &lt;code&gt;.gitignore&lt;/code&gt; (ignore patterns with wildcards and a multi-level fallback hierarchy), &lt;code&gt;.gitattributes&lt;/code&gt; (clean/smudge filters, line-ending normalization, custom diff/merge drivers, and GitHub Linguist language overrides), &lt;code&gt;.lfsconfig&lt;/code&gt; (repo-committed Git LFS endpoints), and &lt;code&gt;.gitmodules&lt;/code&gt; (submodule mappings pinned to specific commits in the parent tree). Next are &lt;code&gt;.mailmap&lt;/code&gt; (consolidating multiple author emails or name spellings for &lt;code&gt;git shortlog&lt;/code&gt; and &lt;code&gt;git blame&lt;/code&gt;), &lt;code&gt;.git-blame-ignore-revs&lt;/code&gt; (telling &lt;code&gt;git blame&lt;/code&gt; to skip mass-reformatting commits), and &lt;code&gt;.gitmessage&lt;/code&gt; (a commit message template enabled via &lt;code&gt;git config commit.template&lt;/code&gt;). The post also surveys forge-specific directories across GitHub, GitLab, Bitbucket, Forgejo, Gitea, and SourceHut for CI workflows and PR templates, alongside broader conventions like &lt;code&gt;.editorconfig&lt;/code&gt; and &lt;code&gt;.ruby-version&lt;/code&gt;—carefully distinguishing files Git reads automatically from conventions that require explicit config activation like &lt;code&gt;.gitmessage&lt;/code&gt; and &lt;code&gt;.git-blame-ignore-revs&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="adding-correctness-conditions-to-code-changes"&gt;&lt;a href="https://jessitron.com/2026/04/06/adding-correctness-conditions-to-code-changes/" rel="noopener noreferrer"&gt;Adding Correctness Conditions to Code Changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jessica Kerr (Jessitron) describes a familiar moment in the age of coding agents: an agent opens a project&amp;rsquo;s first PR adding a new run script, but forgets to mention it in the &lt;code&gt;README&lt;/code&gt;. Instead of leaving a one-off review comment on that PR, she wants to solve the problem permanently for every future PR through automation—enforcing an explicit &lt;em&gt;correctness condition&lt;/em&gt;: every PR must update relevant documentation files. There are two ways to do that—update the instructions in &lt;code&gt;AGENTS.md&lt;/code&gt;, or add an automated review agent that checks PRs—and the crucial question is which one to do first.&lt;/p&gt;
&lt;p&gt;Simply editing &lt;code&gt;AGENTS.md&lt;/code&gt; is easy and appears to work right away, she notes, but offers zero guarantees: the day the agent forgets to update the docs, you probably won&amp;rsquo;t notice either. By contrast, if you add the automated verification check &lt;em&gt;first&lt;/em&gt;, every PR gets audited and incomplete PRs get rejected, forcing the agent to fix them; updating &lt;code&gt;AGENTS.md&lt;/code&gt; then becomes an optimization to reduce retry loops rather than your only line of defense. This is test-driven development elevated to the system level, and closer to property-based testing than unit testing because it asserts an invariant (&amp;ldquo;documentation stays in sync with feature changes&amp;rdquo;) across every change. Reviewing a PR thus becomes reviewing the &lt;em&gt;development system itself&lt;/em&gt;: asking how the agent&amp;rsquo;s context and feedback loops should change so the next PR comes out right the first time. She calls this the new Boy Scout Rule: don&amp;rsquo;t just leave the codebase cleaner—leave the system that builds the codebase stronger.&lt;/p&gt;
&lt;h2 id="the-impact-of-ai-on-software-engineers-in-2026-key-trends-part-1"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026" rel="noopener noreferrer"&gt;The impact of AI on software engineers in 2026: key trends. Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (&lt;em&gt;The Pragmatic Engineer&lt;/em&gt;) distills more than 900 survey responses from software engineers and engineering leaders on how AI tools are impacting their work in 2026. Rather than ranking individual tools, Part 1 focuses on three macro trends: rising AI tooling costs, engineers regularly hitting usage caps, and sharply uneven impact across different engineer archetypes.&lt;/p&gt;
&lt;p&gt;On cost, roughly 15% of respondents voiced concern. Many companies now pay $100–$200 per engineer per month for &amp;ldquo;Max&amp;rdquo; tiers of Claude Code, Cursor, or Codex, while others cap budgets around $20/month (standard GitHub Copilot territory). Enterprises are still experimenting, and many engineers doubt current subsidy levels are sustainable long-term; European companies tend to demand upfront ROI proof, whereas US firms are more willing to spend first and measure later. A popular cost-saving tactic is planning with Claude Opus and executing with Sonnet or Cursor Composer. When engineers hit rate limits, they swap tools, fall back to pay-as-you-go API keys, or upgrade tiers. Finally, the report groups engineers into three archetypes: &lt;em&gt;builders&lt;/em&gt; (who care deeply about architecture and code quality) use AI effectively to power through tedious, high-judgment work like large refactors, migrations, and test coverage; &lt;em&gt;shippers&lt;/em&gt; (focused on product velocity) are the most enthusiastic adopters because they can ship features dramatically faster; and &lt;em&gt;coasters&lt;/em&gt; do the bare minimum and care little about code quality. The overarching lesson: AI acts as an amplifier for the engineering habits and culture you already have.&lt;/p&gt;
&lt;h2 id="flat-error-codes-are-not-enough"&gt;&lt;a href="https://home.expurple.me/posts/flat-error-codes-are-not-enough/" rel="noopener noreferrer"&gt;Flat Error Codes Are Not Enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dmitrii Aleksandrov pushes back against the minimalist advice that every library should expose a single error struct containing only a human-readable message and a flat &lt;code&gt;ErrorCode&lt;/code&gt; enum for programmatic handling. While he agrees that flat error codes work well in top-level application code—where callers rarely perform intricate programmatic recovery—he argues they fall short in high-level, I/O-heavy libraries where callers need rich context to recover intelligently.&lt;/p&gt;
&lt;p&gt;His concrete example comes from a production Rust codebase using the &lt;code&gt;sea_orm&lt;/code&gt; ORM atop the &lt;code&gt;sqlx&lt;/code&gt; database driver. &lt;code&gt;sea_orm::DbErr&lt;/code&gt; wraps an underlying &lt;code&gt;sqlx::Error&lt;/code&gt;, which in turn exposes a &lt;code&gt;sqlx::DatabaseError&lt;/code&gt; carrying structured details straight from the database engine—such as the exact constraint violation kind (unique, foreign key, check) and the violated constraint&amp;rsquo;s name. The application relies on that structured payload to map database constraint failures into specific, user-friendly validation errors. If &lt;code&gt;sea_orm&lt;/code&gt; flattened everything into its own enum without exposing the underlying &lt;code&gt;sqlx&lt;/code&gt; error, it would either have to duplicate all of &lt;code&gt;sqlx&lt;/code&gt;&amp;rsquo;s database-specific error inspection APIs or throw that information away. Worse, even a fine-grained error code saying &amp;ldquo;a &lt;code&gt;CHECK&lt;/code&gt; constraint failed&amp;rdquo; isn&amp;rsquo;t enough without the &lt;em&gt;name&lt;/em&gt; of the violated constraint—otherwise callers are forced to regex-parse human error strings, which is brittle and unsafe. For complex I/O libraries, nested errors carrying structured variant data are essential.&lt;/p&gt;
&lt;h2 id="who-will-be-the-senior-engineers-of-2035"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/who-will-be-the-senior-engineers" rel="noopener noreferrer"&gt;Who will be the senior engineers of 2035?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier poses an uncomfortable question for the industry: where will the senior engineers of 2035 come from? Historically, junior developers became seniors through a steady diet of low-risk bug fixes, pair programming, mentorship, and learning from small mistakes. Today, post-COVID layoffs, cautious entry-level hiring, and AI coding agents absorbing the exact small tickets and bug fixes that used to serve as training wheels for juniors are choking off the talent pipeline at multiple points at once. Real production scar tissue—earned by breaking things, diagnosing why, and fixing them—cannot be replaced by prompting an LLM.&lt;/p&gt;
&lt;p&gt;He sketches three possible futures. First is a &lt;em&gt;talent crunch&lt;/em&gt;: the shortage stays invisible for years and then erupts around 2035 when critical systems fail at 3 a.m. and nobody left on call understands what happens beneath the abstractions. Second is &lt;em&gt;bifurcation&lt;/em&gt;: the profession splits into fast AI orchestrators with shallow fundamentals on one side, and a shrinking, ultra-expensive priesthood of deep systems engineers on the other, with the middle hollowed out. Third is a more optimistic arc grounded in computing history: every new abstraction layer—from BASIC to JavaScript to the cloud—was once feared as the end of real programming, yet ended up creating new entry ramps and new kinds of expertise. Which future we get depends on the choices engineering leaders make today about whom to hire, whom to mentor, and whom to give a safe space to fail and learn.&lt;/p&gt;
&lt;h2 id="repository-pattern-in-go-service"&gt;&lt;a href="https://pawelgrzybek.com/repository-pattern-in-go-service/" rel="noopener noreferrer"&gt;Repository pattern in Go service&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paweł Grzybek walks through applying Domain-Driven Design&amp;rsquo;s Repository pattern to a Go backend service. He starts from a familiar trajectory: a service begins life inside a single &lt;code&gt;main.go&lt;/code&gt;, then gradually balloons into a tangle of cross-package dependencies where business rules and SQL queries are inseparable and unit testing is painful. The Repository pattern prevents that decay by hiding data persistence behind domain-defined interfaces, while concrete database adapters for PostgreSQL, SQLite, or DynamoDB live in separate packages—enforcing a clean, one-way dependency flow.&lt;/p&gt;
&lt;p&gt;The worked example organizes code by domain (&lt;code&gt;user&lt;/code&gt;, &lt;code&gt;order&lt;/code&gt;) rather than by technical layer (&lt;code&gt;models/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;), aligning neatly with idiomatic Go package design. Each domain package contains its model (structs, validation rules, domain errors), a service (pure business logic that talks to storage strictly through a repository interface without caring which database sits underneath), and repository implementations, while transport layers (HTTP, gRPC, WebSockets) sit on the outside and can be swapped without touching domain logic. The biggest win is fast, isolated unit testing of service logic via dependency injection—though the author notes that swapping databases in the real world still requires accounting for differences in transactions, query semantics, and data types beyond just writing a new adapter.&lt;/p&gt;
&lt;h2 id="go-bitwise-flags-and-bitmasks-configuration-pattern-guide"&gt;&lt;a href="https://iampavel.dev/blog/go-bitwise-flags-config" rel="noopener noreferrer"&gt;Go Bitwise Flags and Bitmasks: Configuration Pattern Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Asaduzzaman Pavel starts from a relatable moment: as he was adding an eighth &lt;code&gt;bool&lt;/code&gt; field to a Go configuration struct, he realized it was time to switch to a bitmask. In a bitmask, each flag is a power of two occupying a single bit; flags can be combined with bitwise OR (&lt;code&gt;|&lt;/code&gt;), checked with AND (&lt;code&gt;&amp;amp;&lt;/code&gt;), cleared with AND NOT (&lt;code&gt;&amp;amp;^&lt;/code&gt;), and toggled with XOR (&lt;code&gt;^&lt;/code&gt;), with each check compiling down to a single CPU instruction with zero branching or heap allocation.&lt;/p&gt;
&lt;p&gt;Still, the author is explicit about when &lt;em&gt;not&lt;/em&gt; to use bitmasks: for ordinary application configs or CRUD APIs, a plain struct of booleans is much easier to read. Bitmasks shine when modeling file permissions (&lt;code&gt;Read&lt;/code&gt;, &lt;code&gt;Write&lt;/code&gt;, &lt;code&gt;Execute&lt;/code&gt;), gRPC or HTTP middleware option sets evaluated on every request, query-builder modifiers (&lt;code&gt;Distinct&lt;/code&gt;, &lt;code&gt;ForUpdate&lt;/code&gt;), or when wrapping C libraries and OS syscalls that already use bitfields. The guide shows how to declare flags cleanly in Go using a typed integer alongside &lt;code&gt;1 &amp;lt;&amp;lt; iota&lt;/code&gt;, warns that Go&amp;rsquo;s type system won&amp;rsquo;t stop callers from passing arbitrary out-of-range integers unless you encapsulate operations behind methods like &lt;code&gt;Has()&lt;/code&gt; or an opaque struct, and finishes with custom &lt;code&gt;MarshalJSON&lt;/code&gt; / &lt;code&gt;UnmarshalJSON&lt;/code&gt; implementations so flags serialize as readable string arrays in JSON while staying compact in memory.&lt;/p&gt;
&lt;h2 id="the-best-library-might-do-less"&gt;&lt;a href="https://martiansoftware.com/articles/the-best-library-might-do-less" rel="noopener noreferrer"&gt;The Best Library Might Do Less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on forty years of programming experience, the author makes a contrarian case for library design: library authors easily catch the &amp;ldquo;generalization bug&amp;rdquo;—trying to anticipate and solve every conceivable edge case, which bloats the library, complicates its API, and makes it less useful. Warning signs include constantly asking &amp;ldquo;what if a developer wants to&amp;hellip;&amp;rdquo; and piling on ceremony: &lt;code&gt;Manager&lt;/code&gt; and &lt;code&gt;Service&lt;/code&gt; classes, transitive third-party dependencies, sprawling type hierarchies, strict temporal ordering of method calls, or needing pages of documentation just to get started.&lt;/p&gt;
&lt;p&gt;By contrast, a library that does less is easier to understand, easier to trust, easier to explain, easier to maintain, and—crucially—easier to &lt;em&gt;replace&lt;/em&gt;, a virtue that is badly underrated. Some libraries genuinely do need to handle every corner case of a complex specification, and this advice isn&amp;rsquo;t for them. For everything else, the author suggests asking three questions: what is the minimal, most common thing users actually need; what is the most natural sequence of calls; and which hard, important failure modes must be handled right—aiming to cover roughly the core 80% cleanly. He closes with a question from a former colleague that has saved him mountains of unnecessary work over the years: &lt;em&gt;&amp;ldquo;What if we just&amp;hellip; didn&amp;rsquo;t?&amp;rdquo;&lt;/em&gt; That isn&amp;rsquo;t laziness—it&amp;rsquo;s clarity about the problem, and a reminder that the best library is often the one that gets out of the user&amp;rsquo;s 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 #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 #87</title><link>https://miti99.com/en/post/2026/03/02/</link><pubDate>Mon, 02 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #87.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="on-cognitive-debt"&gt;&lt;a href="https://www.natemeyvis.com/on-cognitive-debt/" rel="noopener noreferrer"&gt;On cognitive debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;There has been plenty of talk lately about &amp;ldquo;cognitive debt&amp;rdquo;: when AI-generated code grows so fast that nobody understands how it works anymore, making it hard to extend, observe, and debug. Nate Meyvis agrees the phenomenon is real, but argues the panic is overblown. Compared at the same project size, cognitive debt in pre-AI codebases was often even worse; AI simply lets us move several times faster, so we hit that complexity wall much sooner. We miss this because much of what we treat as &amp;ldquo;normal engineering&amp;rdquo;—like a handful of senior engineers carrying all the implicit constraints in their heads—is actually the tax of cognitive debt. When a local change breaks a distant part of the system and tests don&amp;rsquo;t catch it, that usually means encapsulation had already failed.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, skilled AI users already know how to keep cognitive debt in check and will keep getting better at it. He shares several practices: emphasizing encapsulation in project-level AI instructions, clearly documenting subsystems, their interfaces, and data structures, leaning into large-scale refactoring with AI (which is much less painful now), and adding tests wherever cognitive debt starts to show. The takeaway: cognitive debt is real, but we fix it by using AI better rather than blaming AI for our own engineering habits.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://davidoks.blog/p/why-im-not-worried-about-ai-job-loss" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m not worried about AI job loss&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Oks responds to Matt Shumer&amp;rsquo;s viral essay &amp;ldquo;Something Big Is Happening,&amp;rdquo; which compared the present moment to February 2020 right before COVID hit and warned of mass unemployment. Oks believes AI will be as consequential as electricity or the steam engine, but argues its real-world impact on jobs will be much slower and more uneven. First, labor substitution is governed by comparative advantage, not absolute advantage: even if AI outperforms humans at every task, pairing humans with AI remains worthwhile whenever combined output is higher—which is visibly true in software engineering today. Second, the world is full of human-made bottlenecks: regulation, corporate culture, politics, habit, and above all resistance to change. That is why, even with capable models available for years, outsourced customer support still hasn&amp;rsquo;t been replaced wholesale.&lt;/p&gt;
&lt;p&gt;Third, demand for many goods and services is more elastic than we assume, so efficiency gains are often absorbed by rising demand, just as Jevons paradox predicts; every past leap in programming productivity ended up increasing demand for software engineers. Over the long run, humans will keep inventing new kinds of work that blur the line between labor and leisure. The author concludes that ordinary workers will be fine; the real danger is a populist backlash fueled by doomerism, which could lead to bans on data center construction and choke off the benefits AI can bring.&lt;/p&gt;
&lt;h2 id="why-i-don"&gt;&lt;a href="https://honnibal.dev/blog/ai-bubble" rel="noopener noreferrer"&gt;Why I don&amp;rsquo;t think AI is a bubble&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthew Honnibal, creator of the spaCy NLP library, sets aside the financial side of the &amp;ldquo;AI bubble&amp;rdquo; debate to answer the technical question: is AI progress about to plateau? The common argument is that recent gains came from brute-force scaling, returns are diminishing, and we are about to hit a wall. He admits he thought the same back in the GPT-1 and GPT-2 days, but underestimated reinforcement learning (RL). Reasoning models like Claude Opus or GPT-5 combine generative pre-training on massive text corpora with AlphaZero-style RL: the model generates intermediate steps, and chains of steps that lead to verifiable correct answers get reinforced. &amp;ldquo;Logic is work&amp;rdquo;: even in a purely symbolic system, deduction requires computation, so generating intermediate steps is essential rather than a parlor trick.&lt;/p&gt;
&lt;p&gt;The scaling-wall argument only applies to next-token pre-training. Reasoning opens up two new levers: letting models run longer at inference time to think through harder problems, and scaling up reinforcement learning; combined with the ability to backtrack from dead ends, models can search the solution space much like exploring moves in chess. Nor does RL face an obvious data wall, because verifying a successful chain of reasoning is far easier than generating one from scratch. While he doesn&amp;rsquo;t trust OpenAI as a company, he sees no technical reason to think progress is about to stop, and expects the new data centers to be put to productive use.&lt;/p&gt;
&lt;h2 id="i-guess-i-kinda-get-why-people-hate-ai"&gt;&lt;a href="https://anthony.noided.media/blog/ai/programming/2026/02/14/i-guess-i-kinda-get-why-people-hate-ai.html" rel="noopener noreferrer"&gt;I guess I kinda get why people hate AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from a hotel balcony in Hawaii nine days before starting a new job, the author wonders whether this will be the last job he ever has. Once, that question meant wondering whether he&amp;rsquo;d ever &lt;em&gt;need&lt;/em&gt; to work again; now it means wondering whether AI will make him unemployable. He doesn&amp;rsquo;t hate AI, but he understands why so many people do. The most obvious reason: AI industry leaders actively market their products by boasting that they will wipe out jobs—something unprecedented in the history of technology. If they genuinely believed that, he argues, they would be lobbying right now for trigger laws, such as automatic tax hikes to fund retraining or universal basic income if unemployment rises while GDP grows. That nobody is proposing this suggests they either don&amp;rsquo;t believe their own hype or don&amp;rsquo;t care about the fallout.&lt;/p&gt;
&lt;p&gt;Meanwhile, everyday encounters with AI for ordinary people are mostly negative: students pasting homework into ChatGPT, deepfake Elon Musk videos fooling his dad, AI slop flooding TikTok, cURL shutting down its bug bounty program under a wave of fabricated vulnerability reports, and RAM prices spiking. AI &lt;em&gt;sometimes&lt;/em&gt; helps people do high-quality work, but it &lt;em&gt;always&lt;/em&gt; makes generating slop nearly free. He proposes concrete mitigations: watermarking AI-generated content, stricter YouTube enforcement against AI misinformation, and letting major open-source projects opt out of automated AI vulnerability scanning. What worries him most is that the AI labs barely seem to be trying.&lt;/p&gt;
&lt;h2 id="uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/ubers-rate-limiting-system/" rel="noopener noreferrer"&gt;Uber&amp;rsquo;s Rate Limiting System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber handles hundreds of millions of RPCs per second across thousands of microservices. Historically, teams built their own rate limiters—typically backed by Redis counters—leading to inconsistent configuration, added latency, and operational toil. Because centralized counters cannot scale to hundreds of thousands of instances across regions, Uber built GRL (Global Rate Limiter) directly into its service mesh, allowing rate limits per caller or procedure without code changes. GRL has three tiers: in-mesh clients make local per-request decisions, zone-level aggregators roll up usage metrics, and a regional controller computes global utilization and pushes drop directives back down. An initial token-bucket design distributed quota unfairly across callers, so the team switched to probabilistic dropping: when aggregate load exceeds the limit, every client drops a fraction of requests equal to &lt;code&gt;(actual − limit) / actual&lt;/code&gt;, updated every second. The trade-off is a 2–3 second reaction delay.&lt;/p&gt;
&lt;p&gt;Eliminating Redis cut median latency by ~1ms, P90 by tens of milliseconds, and improved P99.5 by up to 90%; the system has absorbed 15x traffic spikes and mitigated DDoS incidents. GRL now processes roughly 80 million requests per second across more than 1,100 services. To keep limits from going stale, Uber also built RLC (Rate Limit Configurator), which periodically analyzes recent weeks of traffic, computes safe limits from historical peaks plus headroom, and automatically rolls out updated configurations with a dry-run shadow mode before enforcement.&lt;/p&gt;
&lt;h2 id="agents-feb-2026"&gt;&lt;a href="https://calv.info/agents-feb-2026" rel="noopener noreferrer"&gt;Agents (Feb 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Calvin French-Owen, who helped launch Codex Web at OpenAI, shares how he uses coding agents as of February 2026. His own time is now the scarce resource: he picks tools based on how much time he has and how much autonomy he wants to grant. The core mental model is understanding context: an agent is just predicting the next token, and everything must fit inside the context window. From that follow several rules: break work into small chunks, remember that context compaction always loses information, persist state to the filesystem (such as numbered plan files with checkboxes), and stay inside the &amp;ldquo;smart half&amp;rdquo; of the context window. Opus in Claude Code works across multiple context windows remarkably well, eagerly spawns parallel sub-agents, uses tools effectively, and explains itself clearly. Codex (GPT-5.3) writes noticeably less buggy code, but runs slower because it doesn&amp;rsquo;t yet fan work out across multiple context windows. So he plans with Claude Code and implements with Codex.&lt;/p&gt;
&lt;p&gt;His setup uses a &lt;code&gt;plans/&lt;/code&gt; directory of numbered plans, parallel git worktrees, preview deployments per branch, a plan–implement–review loop, and automated review bots to catch bugs. Skills chain and automate recurring workflows with minimal token overhead; he only creates a skill after repeating a task several times, gradually building up &lt;code&gt;/commit&lt;/code&gt;, &lt;code&gt;/worktree&lt;/code&gt;, &lt;code&gt;/implement&lt;/code&gt;, &lt;code&gt;/address-bugs&lt;/code&gt;, and &lt;code&gt;/pr-pass&lt;/code&gt;. The main barriers to continuously running agents are context management and prompt-injection defense; increasingly, ideas, architecture, and project sequencing are the real bottlenecks.&lt;/p&gt;
&lt;h2 id="the-software-industrial-revolution"&gt;&lt;a href="https://cannoneyed.com/essays/software-industrial-revolution" rel="noopener noreferrer"&gt;The Software Industrial Revolution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, late 2025 was the moment AI coding agents truly clicked, kicking off the &amp;ldquo;Software Industrial Revolution.&amp;rdquo; Just as the Spinning Jenny in 1764 turned single-threaded hand spinning into a parallel process and drove cotton cloth prices down by more than 90% over half a century, AI is automating software production—until now an extraordinarily labor-intensive craft. Software has eaten the world: the tech sector accounts for roughly 35% of the S&amp;amp;P 500, and nearly 50% when communication services are included. Yet because building software was so expensive, business models were pushed toward VC-fueled growth-at-all-costs to capture a market and then extract monopoly rents, leading to the &amp;ldquo;enshittification&amp;rdquo; Cory Doctorow describes. A textbook example is Epic, which holds 42% of the US acute-care hospital market with margins above 30%, where the sheer cost of building complex enterprise software chokes off competition.&lt;/p&gt;
&lt;p&gt;When software becomes orders of magnitude cheaper to produce, we will get vastly more of it, demand for engineers may actually rise, the old VC playbook will fade, and more sustainable business models will emerge. Anyone—from a cancer researcher to a small-business owner—will be able to have AI build the exact tools they need, sparking an explosion of bespoke software across every industry. While hand-typing code is losing its premium, core engineering skills like domain modeling, managing complexity, and understanding how software interacts with the real world will matter more than ever.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #84</title><link>https://miti99.com/en/post/2026/02/26/</link><pubDate>Thu, 26 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #84.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="automatic-programming"&gt;&lt;a href="https://antirez.com/news/159" rel="noopener noreferrer"&gt;Automatic programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, coins the term &amp;ldquo;automatic programming&amp;rdquo; for writing software with AI assistance—and believes that before long, we will simply call it &amp;ldquo;programming.&amp;rdquo; He draws a sharp line between automatic programming and &amp;ldquo;vibe coding&amp;rdquo;: in vibe coding, you hand a vague prompt to an LLM and let it generate software while you stay mostly out of the loop, only nudging it when something breaks. In automatic programming, the human programmer understands everything happening under the hood, continuously steers the model according to their own vision across every level of abstraction—from high-level architecture down to how a specific function should be implemented—and decides &lt;em&gt;what&lt;/em&gt; to build in the first place. Because of that, the same model produces vastly different results depending on who is in the driver&amp;rsquo;s seat.&lt;/p&gt;
&lt;p&gt;Sanfilippo argues that code produced this way is genuinely yours and something you have every right to be proud of. Since the training data behind these models came from humanity&amp;rsquo;s collective output, he sees LLMs more as a shared gift from humanity to itself than as theft. He points to Redis as an example: technically speaking, Redis contained very little novel computer science—just basic data structures and networking code that any competent systems programmer could write; what made Redis valuable was the product vision and taste behind it. His conclusion: programming can now be automated, but vision (for now) cannot.&lt;/p&gt;
&lt;h2 id="software-performance-engineering-the-ideas-i-keep-coming-back-to"&gt;&lt;a href="https://ricomariani.medium.com/software-performance-engineering-the-ideas-i-keep-coming-back-to-6f421b6a9505" rel="noopener noreferrer"&gt;Software Performance Engineering: The Ideas I Keep Coming Back To&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rico Mariani distills eight performance engineering ideas he keeps returning to across decades and programming languages, centered on one core theme: performance is not about clever tricks or micro-optimizations, but a way of thinking. First, performance is a systems problem: the hardest issues almost always stem from architectural choices like excessive allocations, poor data locality, hidden synchronization, or unbounded growth rather than a single slow function. Abstractions are never free—they merely hide cost, so you need to know what they expand into and how often they run. Cost models matter more than APIs: two APIs that look identical on the surface can differ by 10x because one allocates on every call or touches cold memory. And profilers only tell you &lt;em&gt;where&lt;/em&gt; time went, not &lt;em&gt;why&lt;/em&gt; it was spent.&lt;/p&gt;
&lt;p&gt;Memory is the real bottleneck, as the speed gap between CPUs and main memory continues to widen. Meanwhile, Knuth&amp;rsquo;s famous quote that &amp;ldquo;premature optimization is the root of all evil&amp;rdquo; is routinely abused: the real sin is designing systems with zero cost awareness, which leads to &amp;ldquo;premature pessimization.&amp;rdquo; Programming languages also shape how engineers think about cost—languages that make ownership and lifetimes explicit make cost much easier to reason about. Finally, performance rarely dies in a single commit; it erodes through a thousand tiny, invisible cuts, requiring regular check-ins to verify that reality still matches your architectural intent.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://oblique.security/blog/go-synctest/" rel="noopener noreferrer"&gt;Go&amp;rsquo;s synctest is amazing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eric Chiang from Oblique shares his experience using Go 1.25&amp;rsquo;s &lt;code&gt;testing/synctest&lt;/code&gt; package to test a codebase full of background control loops, such as purging expired database sessions or running distributed leader election across instances. The headline feature of &lt;code&gt;synctest&lt;/code&gt; is running tests inside an isolated &amp;ldquo;bubble&amp;rdquo; with a fake clock so &lt;code&gt;time.Sleep&lt;/code&gt; completes almost instantaneously. According to Chiang, however, its even bigger superpower is letting you deterministically reason about the &lt;em&gt;ordering&lt;/em&gt; of concurrent events. &lt;code&gt;synctest&lt;/code&gt; only advances its fake clock when every goroutine inside the bubble is durably blocked—typically on channels, wait groups, or time operations—and then advances the clock just enough to wake the shortest sleep. That lets tests use time itself as a synchronization primitive, something that would be an anti-pattern in production code; for example, a background ticker loop that runs once a minute is guaranteed to execute exactly three times after sleeping for three fake minutes.&lt;/p&gt;
&lt;p&gt;In practice, simply sleeping slightly longer than the interval of &lt;code&gt;RunDeleteExpiredSessions&lt;/code&gt; guarantees the background cleanup pass has finished before the test asserts against the database, and the entire test finishes in under a second. His team even applied &lt;code&gt;synctest&lt;/code&gt; to their database-backed leader election logic spanning dozens of concurrent loops without modifying a single line of production code, pausing execution at arbitrary points in time to inspect database state. He notes two caveats to keep in mind: understanding which operations count as &amp;ldquo;durably blocked&amp;rdquo; (network and file I/O do not) and ensuring all spawned goroutines exit cleanly before the bubble closes.&lt;/p&gt;
&lt;h2 id="why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying"&gt;&lt;a href="https://dev.to/rpereira15/why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying-1i5k" rel="noopener noreferrer"&gt;Why Clean Architecture Confuses Everyone (And How I Learned to Stop Worrying)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on more than 10 years of software engineering experience, Rômulo Pereira explains why Clean Architecture confuses so many developers: teams spend hours arguing over folder structures while missing the core principle. Frameworks like Spring Boot make violating boundaries effortless—a single annotation on a domain class tightly couples your business logic to JPA, Jackson, and the framework runtime. Organizing packages by technical layer (&lt;code&gt;controller&lt;/code&gt;, &lt;code&gt;service&lt;/code&gt;, &lt;code&gt;repository&lt;/code&gt;, &lt;code&gt;model&lt;/code&gt;) also pulls you into technology-first thinking, whereas organizing by feature (&lt;code&gt;order&lt;/code&gt;, &lt;code&gt;product&lt;/code&gt;, &lt;code&gt;customer&lt;/code&gt;) keeps the focus on what the system actually &lt;em&gt;does&lt;/em&gt;. From his experience building high-volume billing systems and real-time data platforms, he argues that business logic should be &amp;ldquo;boring&amp;rdquo;: completely agnostic to where data is stored, whether requests arrive over REST or a message queue, or which framework is in use. And don&amp;rsquo;t create an interface for every class just because &amp;ldquo;Clean Architecture requires ports and adapters&amp;rdquo;—an interface that will only ever have one implementation is pure ceremony.&lt;/p&gt;
&lt;p&gt;The real litmus test is replaceability: could you swap your database, move from REST to GraphQL, or upgrade your framework without touching your core domain logic? His pragmatic approach is to write plain, annotation-free use cases and push Spring wiring to the outer boundary of the system. Instead of debating package names, ask whether your business rules are easy to unit-test in milliseconds, how many files break when you upgrade a framework, and whether a new teammate can tell what the system does at a glance. Start simple, keep business rules pure, and test them without mocking the entire world.&lt;/p&gt;
&lt;h2 id="the-third-golden-age-of-software-engineering--thanks-to-ai"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-third-golden-age-of-software" rel="noopener noreferrer"&gt;The third golden age of software engineering – thanks to AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt; podcast, Gergely Orosz sits down with Grady Booch, co-creator of UML and Chief Scientist for Software Engineering at IBM. Booch divides the history of computing into three &amp;ldquo;golden ages&amp;rdquo;: the first revolved around algorithms (1940s to 1970s), the second around object-oriented abstractions (1970s to 2000s), and the third—which we are in today—around systems of systems. In his view, this third age began when our unit of abstraction rose to entire libraries, frameworks, and platforms, well before the current AI wave. He reminds listeners that existential dread in software is nothing new: when compilers and high-level languages first appeared, assembly programmers feared they would be replaced, yet the profession evolved and expanded. AI coding tools simply raise the level of abstraction one step further; as he puts it, &amp;ldquo;tools change, the problems remain the same.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Booch notes that today&amp;rsquo;s AI models are trained primarily on problems that have already been solved thousands of times, making them great at automating familiar patterns like web CRUD apps while the true frontier of computing remains vast. When the industry moves at breakneck speed, strong fundamentals become more important, not less. He does acknowledge that routine software delivery plumbing is the easiest target for automation, meaning engineers in purely mechanical roles will need to upskill. His closing message: this is a moment to soar, not to fear the abyss.&lt;/p&gt;
&lt;h2 id="ai-coding-workflow"&gt;&lt;a href="https://newsletter.systemdesign.one/p/ai-coding-workflow" rel="noopener noreferrer"&gt;AI coding workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this guest post for &lt;em&gt;The System Design Newsletter&lt;/em&gt;, Louis-François Bouchard shares the workflow he uses to get reliable results from AI coding tools after realizing AI is not a &amp;ldquo;vending machine&amp;rdquo; where you paste a bug and get working production code out. His core mental model: treat AI like a brilliant new teammate who joined your project five minutes ago—it types fast and knows every language, but has zero awareness of your architecture, conventions, or constraints unless you tell it. AI works best inside a tight six-step loop: Context (supplying the README, rules files like &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;CLAUDE.md&lt;/code&gt;, relevant files, and stack traces or logs), Plan (asking for a strategy before any code is written, because fixing a plan is much cheaper than debugging code), Code (making small, incremental changes that are easy to review), Review, Test, and Iterate.&lt;/p&gt;
&lt;p&gt;He also uses a lightweight multi-agent pattern with four distinct roles: a Planner to break down tasks and spot edge cases, an Implementer to write code strictly following the approved plan, a Tester to write unit and edge-case tests, and an Explainer to summarize what changed and why. He pairs a strong reasoning model for planning with a faster model for implementation. The post also catalogs common failure modes like context drift in long chats, hallucinated or outdated APIs, debugging death spirals, gradual codebase rot, and over-reliance on AI. The overarching rule: treat AI output as a first draft, and always rely on human review and automated tests as your safety net.&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://substack-post-media.s3.amazonaws.com/public/images/625a6789-c32d-4a27-a5f5-c174fb920637_2360x2960.png" alt="Git pull vs. git fetch"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-Lov!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fcf928dd3-de16-4605-a702-762df269c9f2_2250x2862.png" alt="Top Authentication Techniques"&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 #83</title><link>https://miti99.com/en/post/2026/02/24/</link><pubDate>Tue, 24 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #83.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-uber-scaled-data-replication-to-move-petabytes-every-day"&gt;&lt;a href="https://www.uber.com/en-IN/blog/scaled-data-replication/" rel="noopener noreferrer"&gt;How Uber Scaled Data Replication to Move Petabytes Every Day&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber shares how its engineering team scaled HiveSync—its cross-region data replication service built on Apache Hadoop DistCp—to keep pace with a data lake exceeding 350 PB. In Q3 2022 alone, daily replicated data volume jumped from 250 TB to 1 PB, the number of datasets managed by HiveSync grew from 30,000 to 144,000, and daily replication jobs surged from 10,000 to 374,000. This growth was driven by an active-passive architecture that concentrated ~90% of writes in the primary region, onboarding all Hive datasets into HiveSync, and an upcoming cloud migration. Under that load, replication latency SLAs (P100 under 4 hours, P99.9 under 20 minutes) were slipping.&lt;/p&gt;
&lt;p&gt;To fix this, Uber made four targeted improvements to DistCp. First, they offloaded two resource-intensive phases—Copy Listing and Input Splitting—from the central HiveSync server to the YARN Application Master, cutting job submission latency by 90%. Second, they parallelized Copy Listing across a thread pool making concurrent &lt;code&gt;namenode&lt;/code&gt; RPCs, reducing p99 latency by 60% and max latency by 75%. Third, they parallelized file concatenation inside the Copy Committer, slashing merge time by 97.29%. Finally, they enabled &amp;ldquo;Uber jobs&amp;rdquo; to run single-mapper replication tasks (which accounted for 52% of all jobs) directly inside the Application Master JVM, eliminating roughly 268,000 YARN container launches per day. Together, these optimizations increased incremental replication throughput 5x within a year and enabled Uber to migrate over 306 PB of data to the cloud.&lt;/p&gt;
&lt;h2 id="how-to-write-a-good-spec-for-ai-agents"&gt;&lt;a href="https://addyosmani.com/blog/good-spec/" rel="noopener noreferrer"&gt;How to write a good spec for AI agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani lays out a practical framework for writing specifications for AI coding agents, addressing a classic tension: a spec needs enough detail to steer the agent accurately without bloating the prompt and overwhelming the context window. Principle one is to start with a high-level vision—provide a concise objective and let the agent expand it into a detailed plan that you review and refine. Principle two is to structure the spec like a Product Requirements Document (PRD) covering six essential areas: executable commands, testing conventions, project structure, code style examples, Git workflow, and explicit boundaries. An analysis by GitHub of over 2,500 agent configuration files found that vague, high-level instructions were the single most common failure mode.&lt;/p&gt;
&lt;p&gt;Principle three is to break work into modular prompts or sub-agent tasks rather than one massive monolith, since the &amp;ldquo;curse of instructions&amp;rdquo; causes model adherence to drop sharply when too many rules compete at once. Principle four is building in quality gates: a three-tier boundary system (&amp;ldquo;Always do,&amp;rdquo; &amp;ldquo;Ask first,&amp;rdquo; and &amp;ldquo;Never do&amp;rdquo;) paired with self-verification hooks. Finally, treat the spec as a living document that gets tested and updated as the codebase evolves. The article also warns against common pitfalls like vague prompts (&amp;ldquo;build something cool&amp;rdquo;), dumping raw context without summarization, skipping human code review, and moving faster than your ability to verify.&lt;/p&gt;
&lt;h2 id="unconventional-postgresql-optimizations"&gt;&lt;a href="https://hakibenita.com/postgresql-unconventional-optimizations" rel="noopener noreferrer"&gt;Unconventional PostgreSQL Optimizations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Haki Benita walks through three unconventional PostgreSQL optimization techniques. First is enabling &lt;code&gt;constraint_exclusion = on&lt;/code&gt; so the query planner uses table &lt;code&gt;CHECK&lt;/code&gt; constraints to skip full table scans altogether. When a user accidentally queries a value that violates a check constraint—for example, &lt;code&gt;WHERE plan = 'Pro'&lt;/code&gt; when the constraint only allows lowercase &lt;code&gt;'free'&lt;/code&gt; or &lt;code&gt;'pro'&lt;/code&gt;—PostgreSQL&amp;rsquo;s default &lt;code&gt;partition&lt;/code&gt; setting still scans the entire table (taking ~7.4 ms in the benchmark), whereas turning &lt;code&gt;constraint_exclusion&lt;/code&gt; on lets the planner prove the query cannot match any rows and return instantaneously. Because checking constraints adds planning overhead, PostgreSQL defaults to only checking them on inherited partitions and &lt;code&gt;UNION ALL&lt;/code&gt; queries, making &lt;code&gt;on&lt;/code&gt; best suited for analytics or reporting databases where users write ad-hoc queries.&lt;/p&gt;
&lt;p&gt;The second technique is indexing a lower-cardinality expression: instead of building a B-Tree index on a raw &lt;code&gt;timestamptz&lt;/code&gt; column (214 MB), indexing the truncated date via &lt;code&gt;date_trunc('day', ...)&lt;/code&gt; shrinks the index to 66 MB—over 3x smaller—and speeds up queries through page-level deduplication. Because expression indexes only kick in when queries write the exact same expression, he suggests pairing them with PostgreSQL 18&amp;rsquo;s virtual generated columns for ergonomics. The third technique enforces uniqueness on large text values like URLs using a hash index: PostgreSQL doesn&amp;rsquo;t support &lt;code&gt;UNIQUE&lt;/code&gt; hash indexes directly, but you can create an &lt;code&gt;EXCLUDE USING hash (url WITH =)&lt;/code&gt; exclusion constraint, shrinking the index from 154 MB (B-Tree) down to 32 MB—nearly 5x smaller. The trade-offs are that exclusion constraints cannot be referenced by foreign keys and do not support &lt;code&gt;ON CONFLICT (url) DO UPDATE&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-when-machine-writes-the-code"&gt;&lt;a href="https://www.shayon.dev/post/2026/19/software-engineering-when-the-machine-writes-code/" rel="noopener noreferrer"&gt;Software engineering when machine writes the code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shayon Mukherjee reflects on what happens to software engineering when machines write the bulk of the code. He isn&amp;rsquo;t anti-AI, but worries that in chasing raw velocity we are trading away deep system comprehension. By Jevons paradox, making a resource more efficient increases total consumption; similarly, AI won&amp;rsquo;t lead us to write less software—it will lead us to build sprawling, complex systems faster than humans can mentally absorb them. He contrasts writing code by hand—where you build a rich mental model through hundreds of micro-decisions—with reviewing AI-generated PRs, where you try to reconstruct understanding after the fact. Accepting working code without truly understanding why it works creates dangerous blind spots during 3 a.m. incidents and long-term maintenance.&lt;/p&gt;
&lt;p&gt;He is especially concerned for junior engineers: if they skip the formative struggle of implementing things from scratch, making mistakes, and debugging for hours, they may never develop the pattern recognition and architectural intuition that only come from friction. His suggested remedy is using AI as a Socratic tutor to explain concepts and trade-offs while still writing the implementation yourself. He also proposes a zoned approach to codebases: core domain logic demands deep human ownership with minimal AI generation, standard application code can lean on AI with thorough review, and pure boilerplate can be delegated almost entirely to AI.&lt;/p&gt;
&lt;h2 id="a-guide-to-effective-prompt-engineering"&gt;&lt;a href="https://blog.bytebytego.com/p/a-guide-to-effective-prompt-engineering" rel="noopener noreferrer"&gt;A Guide to Effective Prompt Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo presents a practical guide to prompt engineering—crafting instructions that reliably elicit the right output from large language models. Anyone can type a prompt, but getting consistent, high-quality results is a distinct engineering skill. A well-structured prompt typically combines four elements: task description, background context, illustrative examples, and specific output constraints. Modern LLM APIs also split instructions into a system prompt (defining role, tone, and guardrails) and a user prompt (the actual task). Clarity is paramount: state exactly what you want, define the output format explicitly, and never assume the model can read your mind; supplying sufficient context also dramatically reduces hallucinations. The post notes how models use in-context learning from examples in the prompt, and points out the &amp;ldquo;lost in the middle&amp;rdquo; effect where models pay closer attention to instructions at the very beginning and end of a long prompt.&lt;/p&gt;
&lt;p&gt;Five core prompting techniques are covered: zero-shot prompting (direct instructions with no examples, suited for simple tasks); few-shot prompting (providing two to five input–output examples to demonstrate the exact pattern and format); chain-of-thought prompting (asking the model to reason step by step before answering complex logic or math problems); role prompting (assigning a persona to anchor perspective and depth); and prompt chaining (breaking a complex workflow into a sequence of focused prompts). On best practices, iterate systematically, version-control your prompts, and test against diverse inputs and edge cases while avoiding vague phrasing, bloated walls of text, and unspecified output formats.&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 #82</title><link>https://miti99.com/en/post/2026/02/19/</link><pubDate>Thu, 19 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/19/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #82.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-lobsters-front-page-works"&gt;&lt;a href="https://blog.nilenso.com/blog/2026/01/20/lobsters-front-page/" rel="noopener noreferrer"&gt;How the Lobsters front page works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Because the source code for Lobsters—the computing-focused link-aggregation community—is open source, the author dug into its front-page ranking algorithm. The core formula is &lt;code&gt;hotness = -1 × (base + order × sign + age)&lt;/code&gt;, where a more negative value ranks higher on the page. &lt;code&gt;base&lt;/code&gt; is the sum of tag modifiers (each tag carries a weight between -10 and +10; for instance, &lt;code&gt;culture&lt;/code&gt; and &lt;code&gt;rant&lt;/code&gt; are penalized), plus a &lt;code&gt;0.25&lt;/code&gt; boost if the submitter marked themselves as the article&amp;rsquo;s author. &lt;code&gt;order&lt;/code&gt; is the base-10 logarithm of story points plus comment points, meaning the jump from 0 to 100 upvotes has a much larger impact than going from 1,000 to 1,100. Comment points count for half an upvote each, are capped so they never exceed the story&amp;rsquo;s own score, and are ignored entirely when &lt;code&gt;base&lt;/code&gt; is negative—preventing low-quality flamebaits from rising on comment volume alone. The &lt;code&gt;sign&lt;/code&gt; term turns out to be effectively a no-op in practice, while &lt;code&gt;age&lt;/code&gt; is the submission timestamp divided by a 22-hour window, growing linearly and steadily overpowering the logarithmic vote score.&lt;/p&gt;
&lt;p&gt;The author finds the algorithm solid: new stories get a fair shot at visibility and nothing camps on the front page forever. Still, Lobsters&amp;rsquo; distinct character comes primarily from opinionated moderation, a narrow focus on computing, and its invite-tree membership model rather than the ranking formula itself. Even when disagreeing with the most vocal commenters, the author notes that disengaging only hands them more influence, since just a few early upvotes from active users are enough to propel a story onto the front page.&lt;/p&gt;
&lt;h2 id="software-engineers-can-no-longer-neglect-their-soft-skills"&gt;&lt;a href="https://www.qu8n.com/posts/most-important-software-engineering-skill-2026" rel="noopener noreferrer"&gt;Software engineers can no longer neglect their soft skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Quan argues that starting in 2026, communication has become the single most important skill for a software engineer—surpassing raw coding speed, system design, or deep mastery of a language like Rust. The reason is the rapid leap in AI coding agents: he uses Claude Code for nearly every non-trivial task and spent over $500 on usage in December alone. With Claude Opus 4.5, vanilla Claude Code out of the box handles roughly 80% of implementation work, meaning prompt tricks and custom MCP setups are no longer real differentiators. The bottleneck has shifted from implementation to specification: the clearer the spec, the better the agent satisfies both technical and business requirements—yet arriving at a clear spec is deceptively hard.&lt;/p&gt;
&lt;p&gt;In reality, tickets rarely capture the full requirements. Engineers have to ask probing questions to surface unstated assumptions stakeholders didn&amp;rsquo;t even realize they were making, facilitate trade-off discussions, push back on scope creep without damaging relationships, and exercise judgment on edge cases nobody thought to specify. Previously, an engineer with mediocre communication skills could still thrive on the strength of exceptional coding output; today, the non-coding parts of the job are mandatory. Engineers are conditioned to believe every problem has a deterministic solution and a &amp;ldquo;best practice,&amp;rdquo; whereas working with humans is messy and ambiguous. And you can&amp;rsquo;t outsource human communication to AI, because real communication requires empathy—something everyone needs more of right now.&lt;/p&gt;
&lt;h2 id="dithering---part-2"&gt;&lt;a href="https://visualrambling.space/dithering-part-2/" rel="noopener noreferrer"&gt;Dithering - Part 2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of this interactive visual series on dithering—the technique of creating the illusion of more colors than a palette actually has—focuses on ordered dithering, which uses a spatial threshold map to decide each pixel&amp;rsquo;s final color when converting grayscale images to 1-bit black and white. The author starts with basic quantization: using a single threshold collapses every shade of gray into solid black or white, whereas applying multiple thresholds across neighboring pixels turns a uniform gray region into a mix of black and white dots that preserves perceived brightness. When tiling a small threshold map across an entire image, arranging thresholds sequentially produces distracting vertical stripes because the output mirrors the map&amp;rsquo;s internal layout. A 2×2 Bayer matrix fixes this by arranging thresholds in a crosshatch pattern that distributes dots evenly; with only 4 threshold levels, however, tonal transitions still show harsh banding, which a 16-level 4×4 Bayer matrix smooths out considerably.&lt;/p&gt;
&lt;p&gt;How the threshold map is arranged defines the visual texture of the dithered image. An 8×8 Bayer matrix (64 levels) yields finer gradients with diminishing returns; a Cluster Dot matrix groups pixels into circular halftone-like dots reminiscent of vintage newsprint; and Void and Cluster—the author&amp;rsquo;s personal favorite—uses a blue-noise threshold map to produce an organic, non-repetitive texture that blends smoothly into gray. The next installment will cover error diffusion, a family of dithering algorithms that doesn&amp;rsquo;t use a threshold map at all.&lt;/p&gt;
&lt;h2 id="what-came-first-the-cname-or-the-a-record"&gt;&lt;a href="https://blog.cloudflare.com/cname-a-record-order-dns-standards/" rel="noopener noreferrer"&gt;What came first: the CNAME or the A record?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On January 8, 2026, a memory-optimization update to Cloudflare&amp;rsquo;s &lt;code&gt;1.1.1.1&lt;/code&gt; public DNS resolver inadvertently broke DNS resolution for a subset of users. The bug lurked in the code that merges cached &lt;code&gt;CNAME&lt;/code&gt; chains when only part of a chain has expired: previously, the resolver allocated a new list, placed the &lt;code&gt;CNAME&lt;/code&gt; records first, and appended the final &lt;code&gt;A&lt;/code&gt;/&lt;code&gt;AAAA&lt;/code&gt; records at the end; to reduce allocations and copying, the new code appended the refreshed &lt;code&gt;CNAME&lt;/code&gt; records onto the end of the existing answer list. Many stub resolvers process answer records sequentially in a single pass, tracking the &amp;ldquo;current target name&amp;rdquo; and updating it only when they encounter a matching &lt;code&gt;CNAME&lt;/code&gt;—so if the &lt;code&gt;CNAME&lt;/code&gt; appears after the &lt;code&gt;A&lt;/code&gt; record, the &lt;code&gt;A&lt;/code&gt; record is skipped and the response is treated as empty. Linux&amp;rsquo;s &lt;code&gt;glibc&lt;/code&gt; (&lt;code&gt;getaddrinfo&lt;/code&gt;) hit this exact failure mode, and certain Cisco switches even entered boot loops, whereas &lt;code&gt;systemd-resolved&lt;/code&gt; was unaffected because it searches across the entire record set.&lt;/p&gt;
&lt;p&gt;The deeper root cause was a decades-old ambiguity in RFC 1034 from 1987: the spec merely says the answer is &amp;ldquo;possibly preface[d]&amp;rdquo; by &lt;code&gt;CNAME&lt;/code&gt; records, without normative &lt;code&gt;MUST&lt;/code&gt; or &lt;code&gt;SHOULD&lt;/code&gt; keywords (which RFC 2119 didn&amp;rsquo;t standardize until 1997). While the RFCs explicitly state that record order &lt;em&gt;within&lt;/em&gt; a single RRset is insignificant, they say nothing about the relative order &lt;em&gt;between&lt;/em&gt; different RRsets in the same message section—or even the order of links within a &lt;code&gt;CNAME&lt;/code&gt; chain. Cloudflare had historically placed &lt;code&gt;CNAME&lt;/code&gt;s first, but had no regression test enforcing that ordering. They rolled back the change, committed to preserving &lt;code&gt;CNAME&lt;/code&gt;-first ordering permanently, and submitted an Internet-Draft to the IETF proposing to formally require &lt;code&gt;CNAME&lt;/code&gt; records to appear in canonical chain order before final answer records.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #78</title><link>https://miti99.com/en/post/2026/02/01/</link><pubDate>Sun, 01 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #78.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-next-two-years-of-software-engineering"&gt;&lt;a href="https://addyosmani.com/blog/next-two-years/" rel="noopener noreferrer"&gt;The Next Two Years of Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani observes that the software industry is at an inflection point: AI coding tools have evolved from autocomplete suggestions into autonomous agents that execute end-to-end tasks, while the hiring boom has given way to an efficiency mandate where companies favor experienced engineers and small, well-tooled teams. Rather than making single-track predictions, he poses five open questions through 2026, each paired with two contrasting scenarios. Junior hiring could collapse (a Harvard study found junior roles dropped roughly 9–10% after companies adopted generative AI) or rebound as software expands into every industry. Foundational computer science skills could atrophy or become more valuable than ever. The developer role could narrow into an AI code reviewer or expand into a full-system orchestrator. Narrow specialists risk displacement, while T-shaped engineers (deep in one or two areas, broad across many) are in high demand. And traditional CS degrees could be overtaken by bootcamps, online courses, and internal apprenticeships.&lt;/p&gt;
&lt;p&gt;With 84% of developers already using or planning to use AI, value lies in reviewing AI output for logic bugs, security vulnerabilities, and requirement drift; the best engineers aren&amp;rsquo;t the ones who write code the fastest, but the ones who know when not to trust AI. Juniors should use AI to learn rather than as a crutch; seniors should anchor quality assurance, mentorship, and architecture. The common denominator is continuous learning.&lt;/p&gt;
&lt;h2 id="databases-in-2025-a-year-in-review"&gt;&lt;a href="https://www.cs.cmu.edu/~pavlo/blog/2026/01/2025-databases-retrospective.html" rel="noopener noreferrer"&gt;Databases in 2025: A Year in Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Pavlo (Carnegie Mellon University) looks back at the database world in 2025, starting with PostgreSQL&amp;rsquo;s continued dominance. Version 18 added an asynchronous I/O subsystem and B-tree skip scans. The business side was even livelier: Databricks paid $1 billion to acquire Neon, Snowflake paid $250 million for CrunchyData, Microsoft launched HorizonDB, and three horizontally scalable PostgreSQL sharding projects—Multigres (Supabase), Neki (PlanetScale), and PgDog—entered the ring. 2025 was also the year every DBMS shipped an MCP (Model Context Protocol) server, exploding after OpenAI backed the standard in March. Pavlo cautions that these servers mostly just forward queries to the database, making least-privilege access essential. The columnar file format space heated up as well, with five new formats challenging Parquet: FastLanes, F3, Vortex, AnyBlox, and Amudai.&lt;/p&gt;
&lt;p&gt;The industry roundup covers a wave of acquisitions: IBM bought DataStax (for an estimated $3 billion) and Confluent, Salesforce acquired Informatica ($8 billion), and Fivetran and dbt Labs announced a surprise merger. Databricks raised two massive funding rounds of $4 billion and $1 billion, while several database startups shut down, including Fauna, PostgresML, Hydra, MyScaleDB, and Voltron Data. The post closes with Oracle founder Larry Ellison briefly becoming the richest person in the world with an estimated net worth of $393 billion—which Pavlo notes makes him the richest database person in history, surpassing even John D. Rockefeller on an inflation-adjusted basis.&lt;/p&gt;
&lt;h2 id="12-predictions-for-2026"&gt;&lt;a href="https://tomtunguz.com/2026-predictions/" rel="noopener noreferrer"&gt;12 Predictions for 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz shares 12 predictions for 2026 centered on AI agents moving into real production work. For the first time, enterprises will spend more on agents than on human labor in certain workflows, much as riders willingly pay a ~31% premium to take a Waymo over an Uber. 2026 is poised to set a liquidity record with potential IPOs from SpaceX, OpenAI, Anthropic, Stripe, and Databricks. Vector databases will enjoy a renaissance as essential agent infrastructure. According to METR, the task duration AI can reliably complete doubles every seven months, putting agents on track to run 8+ hour workflows autonomously by year&amp;rsquo;s end. AI budgets will face real scrutiny for the first time, pushing small and open-source models ahead thanks to up to 10x lower costs, while Google widens its lead through strength across frontier models, video generation, and search.&lt;/p&gt;
&lt;p&gt;Agent observability will become the most fiercely contested infrastructure layer. Stablecoins are projected to capture 30% of cross-border payments, eating into SWIFT&amp;rsquo;s volume. Agents will issue at least an order of magnitude more queries than humans, forcing database architectures to adapt. US data center investment will reach 3.5% of GDP, rivaling the railroad boom. The web will shift toward agent-first design as purchasing decisions increasingly begin with agent-led research, and Cloudflare will emerge as the toll collector for agent payments via the x402 protocol, reviving the long-dormant HTTP &lt;code&gt;402 Payment Required&lt;/code&gt; status code.&lt;/p&gt;
&lt;h2 id="the-garbage-collection-handbook"&gt;&lt;a href="https://gchandbook.org/index.html" rel="noopener noreferrer"&gt;The Garbage Collection Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page introduces the second edition of &lt;em&gt;The Garbage Collection Handbook&lt;/em&gt;, the classic reference on automatic memory management. Descending from Richard Jones&amp;rsquo;s original &lt;em&gt;Garbage Collection&lt;/em&gt; (Wiley, 1996) and the first Handbook edition in 2012, this new edition thoroughly updates the material to reflect modern hardware, software, and runtime environments. It progresses from simple, traditional algorithms to modern parallel, incremental, concurrent, and real-time collectors, illustrated throughout with pseudocode and diagrams. The book analyzes high-performance commercial collectors in detail, explains tricky runtime interface mechanics, and adds over 90 pages of new material including chapters on persistence (non-volatile memory) and energy-aware garbage collection.&lt;/p&gt;
&lt;p&gt;Because nearly all modern programming languages rely on garbage collection, understanding how collectors work helps developers confidently select and tune them for their workloads. The e-book edition features over 37,000 internal cross-references linking chapters, sections, algorithms, figures, and original research papers, accompanied by an online bibliography database of nearly 3,400 garbage-collection publications. The first edition of the Handbook was also translated into Chinese and Japanese in 2016.&lt;/p&gt;
&lt;h2 id="vibe-coded-is-the-new"&gt;&lt;a href="https://gabriel-afonso.com/blog/vibe-coded-is-the-new-made-in-china/" rel="noopener noreferrer"&gt;Vibe-Coded Is the New &amp;ldquo;Made in China&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel Afonso notices that on &lt;code&gt;r/selfhosted&lt;/code&gt;, any new project labeled &amp;ldquo;vibe-coded&amp;rdquo; is immediately met with skepticism. Coined by Andrej Karpathy in early 2025, &amp;ldquo;vibe coding&amp;rdquo; means giving in to the vibes and letting large language models handle the implementation while you focus only on what you want to build. In Afonso&amp;rsquo;s view, the backlash usually isn&amp;rsquo;t about the code quality itself, but what the label signals. Historically, the sheer difficulty of building software acted as a natural filter: anyone who shipped an open-source project had invested enough sweat equity that they were likely to stick around and maintain it. Now that anyone can spin up an app in a few hours and code far beyond their actual skill level, a project&amp;rsquo;s author might not even understand the code they published. As a result, &amp;ldquo;vibe-coded&amp;rdquo; has become like the old &amp;ldquo;Made in China&amp;rdquo; label—shorthand for cheap, disposable software.&lt;/p&gt;
&lt;p&gt;He draws a parallel to chess: after Deep Blue defeated Kasparov in 1997, chess became even more popular as humans learned to work alongside engines. Respected developers like DHH, Tanner Linsley, and Boris Cherny (creator of Claude Code, who shared that 100% of his contributions over the prior 30 days were written by Claude Code) use AI heavily without drawing backlash because they remain true authors who understand and own their systems. Time remains the most reliable filter: a project maintained for two years with real users proves a level of commitment that cannot be faked. Today&amp;rsquo;s skepticism is simply the ecosystem&amp;rsquo;s immune system adapting while the rules are being rewritten.&lt;/p&gt;
&lt;h2 id="the-production-bug-that-made-me-care-about-undefined-behavior"&gt;&lt;a href="https://gaultier.github.io/blog/the_production_bug_that_made_me_care_about_undefined_behavior.html" rel="noopener noreferrer"&gt;The production bug that made me care about undefined behavior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philippe Gaultier recounts a production bug in a C++ system processing billions of euros in payments each year. An HTTP endpoint was supposed to return either &lt;code&gt;error&lt;/code&gt; or &lt;code&gt;succeeded&lt;/code&gt; set to &lt;code&gt;true&lt;/code&gt;—never both—yet clients occasionally received responses with both fields set to &lt;code&gt;true&lt;/code&gt;, even though each field was assigned at most once in mutually exclusive branches. The culprit was the declaration &lt;code&gt;Response response;&lt;/code&gt;. In C, reading an uninitialized struct field is straightforward undefined behavior; C++ is subtler: because &lt;code&gt;Response&lt;/code&gt; contained a &lt;code&gt;std::string&lt;/code&gt;, it was a non-POD type, so the compiler synthesized and called a default constructor—which default-constructed the &lt;code&gt;std::string&lt;/code&gt; but left the two &lt;code&gt;bool&lt;/code&gt; fields uninitialized with garbage stack bytes.&lt;/p&gt;
&lt;p&gt;The fix is to use value initialization (&lt;code&gt;Response response{};&lt;/code&gt;) to zero-initialize every field, or provide explicit default member initializers. Compilers emit no warning even with all warning flags enabled; &lt;code&gt;clang-tidy&lt;/code&gt; catches it statically, and AddressSanitizer paired with UndefinedBehaviorSanitizer (or Valgrind) catches it at runtime, though only if test coverage hits that code path and the stack happens to contain non-zero bytes. Gaultier wrote a custom &lt;code&gt;libclang&lt;/code&gt; plugin to scan the entire codebase for similar bugs. The post also highlights a bizarre C++ quirk: reading an uninitialized &lt;code&gt;std::byte&lt;/code&gt; or &lt;code&gt;unsigned char&lt;/code&gt; is permitted in many cases without triggering undefined behavior, whereas reading an uninitialized &lt;code&gt;bool&lt;/code&gt; is instant UB. His takeaway: C++ has far too many initialization syntaxes, looks deceptively like C while behaving differently, and changes its rules across language standards.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://antirez.com/news/158" rel="noopener noreferrer"&gt;Don&amp;rsquo;t fall into the anti-AI hype&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, loves crafting software line by line, yet admits that AI has changed programming forever. He used to think this inflection point was still a few years away, but changed his mind now that modern LLMs can complete major features or medium-sized projects almost autonomously. In a single week, by writing prompts and occasionally reviewing code to steer direction, he finished four projects in hours that would otherwise have taken weeks: adding UTF-8 support to his &lt;code&gt;linenoise&lt;/code&gt; library along with a pseudo-terminal test harness; fixing transient timing and TCP deadlock test failures in Redis; having Claude Code write a 700-line pure C library in 5 minutes to run BERT-style embedding inference within 15% of PyTorch&amp;rsquo;s speed; and having Claude Code reproduce internal Redis Streams changes from a design spec in about 20 minutes.&lt;/p&gt;
&lt;p&gt;In his view, writing code by hand is no longer necessary for most projects. He is happy that his open-source code was used to train models, seeing it as a continuation of the open-source mission to democratize code and knowledge; AI will empower small teams to compete with tech giants just as open source did in the 1990s. Still, he worries about this technology concentrating in the hands of a few corporations. His advice: don&amp;rsquo;t fall for anti-AI hype—give modern tools a serious multi-week trial rather than a five-minute test, because the joy of programming is building, and we can now build more and better than ever.&lt;/p&gt;
&lt;h2 id="performance-hints"&gt;&lt;a href="https://abseil.io/fast/hints.html" rel="noopener noreferrer"&gt;Performance Hints&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the &amp;ldquo;Performance Hints&amp;rdquo; guide written by Jeff Dean and Sanjay Ghemawat on Google&amp;rsquo;s Abseil site, distilling the principles and techniques they use when optimizing software performance. They quote Donald Knuth in full: we should forget about small efficiencies about 97% of the time, yet we should not pass up our opportunities in that critical 3%. The common advice to &amp;ldquo;write it simply first and optimize later&amp;rdquo; often fails in practice because large systems built without regard for performance end up with flat profiles where CPU time is diffused across thousands of functions with no obvious hotspot; instead, engineers should instinctively choose the faster alternative whenever it doesn&amp;rsquo;t noticeably harm readability. The guide shows how to do back-of-the-envelope estimates using basic latency numbers (L1 cache ~0.5 ns, branch mispredict ~5 ns, main memory ~50 ns), measure with profilers, and tackle flat CPU profiles by stacking many 1% wins or restructuring higher-level architecture.&lt;/p&gt;
&lt;p&gt;The remainder of the document is a catalog of concrete techniques with code examples: designing APIs that allow optimization behind encapsulation boundaries (such as bulk operations and passing buffers); algorithmic improvements; compact memory representations that touch fewer cache lines (indices instead of pointers, arenas, arrays instead of maps, bitvectors); reducing allocations by pre-sizing containers, reusing objects, and avoiding copies; avoiding unnecessary work via fast paths, precomputation, caching, and keeping logging off hot paths; controlling code size; and parallelizing with short critical sections, sharding to reduce contention, SIMD, and avoiding false sharing. It concludes with specific advice for Protocol Buffers and containers like &lt;code&gt;absl::flat_hash_map&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-job-market-2026-data-trends-and-outlook"&gt;&lt;a href="https://www.finalroundai.com/blog/software-engineering-job-market-2026" rel="noopener noreferrer"&gt;Software Engineering Job Market 2026: Data, Trends and Outlook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article analyzes why software engineering—once considered the safest career track—now feels vulnerable amid near-weekly layoff headlines. Indeed job-posting data via FRED shows software roles peaked in mid-2022, plunged through 2024, and have yet to rebound to pandemic highs. The primary driver isn&amp;rsquo;t AI, but the 2021–2022 digitization bubble: fear of missing out and near-zero interest rates led everyone from Big Tech to startups to overhire massively. When demand normalized, AI became a convenient scapegoat for headcount reductions. Another major factor is global remote hiring: a senior engineer might cost $100,000+ per year in the US versus $40,000 in India, and telling investors &amp;ldquo;we&amp;rsquo;re replacing roles with AI&amp;rdquo; sounds much more forward-looking than &amp;ldquo;we&amp;rsquo;re offshoring.&amp;rdquo; A METR study even found that experienced developers were 19% slower when using AI tools across 246 tasks.&lt;/p&gt;
&lt;p&gt;Even so, the profession isn&amp;rsquo;t disappearing—only demand for basic boilerplate coding is shrinking. The US Bureau of Labor Statistics still projects ~15% employment growth for software developers, SignalFire reports that Meta, Netflix, Uber, and Google are hiring faster than attrition, and Antler founder Magnus Grimeland points out that more AI-generated code means more bugs that require human engineers to fix. What has changed is the skill bar: system design, performance, security, and effective AI orchestration. Entry-level candidates face the toughest market, with junior postings down roughly 40% compared to pre-2022 levels. The article closes with recommended languages to learn in 2026: Python for AI/ML, JavaScript/TypeScript for frontend, Go for backend and cloud infrastructure, Java for enterprise, and Swift for iOS.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!0P7Z!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7546f89c-8b6f-4ced-8d40-4e0137ab5941_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Co3P!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb7f3c175-c0d6-4d02-992d-114ac588b45c_2252x2752.png" alt="Top Developer Tools You Can Use in 2026"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Ty5s!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fecc68f5e-6353-4487-a779-92bb11440bc5_2360x2960.png" alt="5 Rate Limiting Strategies To Protect the System"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!dPjo!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2543392-5e04-4dd6-b39a-72fdfe3a3048_2360x2770.png" alt="How Live Streaming Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MJUT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F06243bf8-f149-4075-bc81-99af15be3579_6001x7802.png" alt="5 Leader Election Algorithms Powering Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Xrbz!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c99d0d5-8e5b-4e82-bb28-9fbd470e3bc6_2250x2624.png" alt="A Guide to Database Sharding"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!NCWv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0adc9c84-37f2-4a96-96a6-f7f26bbd1b7e_2360x2960.jpeg" alt="Modern Storage Systems"&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 #76</title><link>https://miti99.com/en/post/2026/01/05/</link><pubDate>Mon, 05 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #76.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="tcp-vs-udp-vs-grpc-choosing-the-right-protocol-for-your-architecture"&gt;&lt;a href="https://designgurus.substack.com/p/an-engineers-guide-to-basic-networking" rel="noopener noreferrer"&gt;TCP vs. UDP vs. gRPC: Choosing the Right Protocol for Your Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you call a local function, data moves entirely within a single machine&amp;rsquo;s memory; modern software, however, constantly communicates with databases, APIs, and browsers halfway around the world. Network protocols are the rules governing data formats, how conversations are opened and closed, and how errors are handled. This article starts at the transport layer with its two pillars: TCP and UDP. TCP prioritizes reliability: before sending data, both sides perform a three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;); the protocol then guarantees that every byte arrives intact and in order, automatically retransmits lost packets, and uses flow control and congestion control to avoid overwhelming the receiver. That makes TCP ideal when accuracy matters more than raw speed, such as database queries, email, and web pages. UDP is the opposite: connectionless, no handshake, no packet numbering, and any packet dropped in transit is gone for good; in exchange, latency is minimal, making it a great fit for live video streaming or online gaming, where dropping a frame is far better than pausing to wait for an old one.&lt;/p&gt;
&lt;p&gt;At the application layer, HTTP follows a request–response model using methods like &lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, and &lt;code&gt;DELETE&lt;/code&gt;, headers carrying metadata, and status codes like &lt;code&gt;200 OK&lt;/code&gt; or &lt;code&gt;404 Not Found&lt;/code&gt;. The HTTP version matters too: HTTP/1.1 processes requests one at a time per connection and suffers from head-of-line blocking when a slow resource holds up the entire page; HTTP/2 adds multiplexing so multiple requests and responses can run concurrently over a single TCP connection; and HTTP/3 drops TCP entirely in favor of QUIC (built on top of UDP) for better performance on lossy networks. Finally, WebSockets overcome HTTP&amp;rsquo;s unidirectional limitation: a connection begins as an HTTP request asking for an &amp;ldquo;upgrade&amp;rdquo; and then stays open so both client and server can push messages at any time without per-message header overhead—ideal for chat apps or live stock tickers that need low-latency bidirectional communication.&lt;/p&gt;
&lt;h2 id="software-engineering-in-2026"&gt;&lt;a href="https://benjamincongdon.me/blog/2025/12/29/Software-Engineering-in-2026/" rel="noopener noreferrer"&gt;Software Engineering in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Congdon observes that the biggest impact of LLM tooling so far is a dramatic drop in the marginal cost—both in time and money—of producing high-quality code. Because writing code is only one part of software engineering, the bottleneck is shifting elsewhere. He breaks an engineer&amp;rsquo;s job down into building, evolving, and operating distributed systems: the first two have become much cheaper and easier thanks to LLMs, while operations remains largely untouched. The market will expect engineers to harness LLM productivity, making the profession feel more &amp;ldquo;industrialized&amp;rdquo; yet also higher-leverage. As a result, investments in solid infrastructure pay off faster than ever: metrics, logging, feature flags, deployments, autoscaling, and configuration should be self-service for both humans and LLMs via ergonomic CLIs or MCP-ready APIs. CI infrastructure also becomes more critical as AI agents write more code, potentially justifying investments in property-based testing and formal verification—and since LLMs don&amp;rsquo;t mind writing tests, there is no longer any excuse for poor test coverage.&lt;/p&gt;
&lt;p&gt;He emphasizes human-guided abstractions: without clear guardrails, LLMs fill in the blanks with greedy solutions just to get CI green, steadily degrading the codebase. Module boundaries, library interfaces, and contracts between infrastructure and product layers become the primary levers for maintaining long-term quality. Human code review also becomes a new bottleneck: style issues should be offloaded to automated linters so reviewers can focus on hard-to-reverse decisions like interface changes, data persistence, and performance-critical paths. This creates a paradox for junior engineers, who need to develop &amp;ldquo;review taste&amp;rdquo; earlier while writing less code by hand to build that intuition. Project estimation variance will also widen, since cost now depends heavily on how amenable a task is to LLM automation. On build-versus-buy, thin CRUD-style SaaS tools will increasingly tilt toward &amp;ldquo;build&amp;rdquo; at mid-to-large companies, whereas infrastructure and compliance SaaS will change much less because operational costs haven&amp;rsquo;t fallen like development costs have.&lt;/p&gt;
&lt;h2 id="reflections-on-2025"&gt;&lt;a href="https://samuelalbanie.substack.com/p/reflections-on-2025" rel="noopener noreferrer"&gt;Reflections on 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Samuel Albanie looks back on 2025 across three themes in his trademark witty style. First is &amp;ldquo;The Compute Theory of Everything&amp;rdquo;: in 2021, the handcrafted architectural inductive biases he painstakingly designed for computer vision at VGG (Oxford) were swept aside by a simpler system backed by massive pre-training compute. He revisits Hans Moravec&amp;rsquo;s 1976 argument that intelligence is not about magical symbolic manipulation, but raw processing power—&amp;ldquo;with enough thrust, anything flies.&amp;rdquo; Moravec noted that AI capability scales in lockstep with researchers&amp;rsquo; access to faster hardware; since upcoming hardware clusters will make 2025&amp;rsquo;s supercomputers look like pocket calculators, Albanie believes we are nowhere near hitting a ceiling. His second theme is model evaluation: AI systems are becoming increasingly general, while our benchmarks remain narrow. METR&amp;rsquo;s approach measures the duration of tasks models can complete compared to a skilled human, which jumped from roughly 5 minutes in early 2024 to 4 hours and 49 minutes with Claude Opus 4.5 in late 2025, even as the surface area needing evaluation has exploded from MNIST digit recognition to nearly the entire economy.&lt;/p&gt;
&lt;p&gt;His final theme, &amp;ldquo;Floreat Britannia,&amp;rdquo; examines the UK: real wages grew 33% per decade from 1970 to 2007 before stalling out, industrial electricity prices are the highest in Europe, the Hinkley Point C nuclear plant cost £46 billion, and an acoustic fish deterrent system alone cost roughly £700 million while projected to save just 0.083 salmon per year. In his view, the bottleneck is coordination and decision-making, and he is optimistic that AI will make high-quality probabilistic forecasting cheap and ubiquitous. Still, good forecasts are useless if the culture is paralyzed by risk aversion; invoking Benjamin Franklin flying a kite in a thunderstorm and inventing the lightning rod, he concludes that Britain needs both boldness and prudence—both the &amp;ldquo;kite&amp;rdquo; and the &amp;ldquo;lightning rod.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="8-predictions-for-2026-what-comes-next-in-ai"&gt;&lt;a href="https://www.philschmid.de/2026-predictions" rel="noopener noreferrer"&gt;8 Predictions for 2026. What comes next in AI?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philipp Schmid rarely writes prediction posts, but after a watershed 2025, he outlines eight AI trends for 2026. Generative UI will take off once code-generation latency and quality are good enough for apps to synthesize bespoke interfaces in real time tailored to each user&amp;rsquo;s task and preferences. Personal agents will move to the edge, powered by Small Language Models (SLMs) running locally on dedicated hardware. The smart home will finally deliver on its promise as assistants understand context and intent rather than rigid voice commands, blending into general assistants like the Gemini or ChatGPT apps. As traditional benchmarks saturate, AI labs will compete on &amp;ldquo;harnesses&amp;rdquo;—complex environments that prove agents can reliably execute multi-day workflows. Vibe coding will mature into real engineering: engineers will spend 99% of their time reviewing, evaluating, shaping ideas, and thinking, with the core skill being connecting implementation details, code quality, velocity, and business goals; knowing how to code becomes a distinct competitive advantage.&lt;/p&gt;
&lt;p&gt;His remaining three predictions revolve around social media: &amp;ldquo;AI slop&amp;rdquo; will turn human-created content into a premium market; every post on X, Instagram, or LinkedIn will be assumed AI-generated by default unless it carries a cryptographic signature under a &amp;ldquo;Human-Signed&amp;rdquo; metadata standard (like C2PA for cameras), with unsigned content downranked by algorithms as &amp;ldquo;synthetic noise&amp;rdquo;; and to fight agent spam, platforms will carve out a &amp;ldquo;verified human web&amp;rdquo; requiring biometric proof of personhood. In closing, he isn&amp;rsquo;t worried about the future of software engineers and believes learning to code is still well worth it, as deep technical understanding is more important than ever for steering these systems. His advice: build and learn—closely observe what others are building, dissect the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; and build your own version. Agents will remain center stage as successful patterns from coding agents spread to general-purpose agents that proactively anticipate needs rather than waiting for prompts.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #67</title><link>https://miti99.com/en/post/2025/12/10/</link><pubDate>Wed, 10 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/10/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post I tried refining my &lt;code&gt;AGENTS.md&lt;/code&gt; file. I&amp;rsquo;ll share my self-assessment at the end of the post.&lt;/del&gt; Enjoy Newsletter #67.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="build-better-software-to-build-software-better"&gt;&lt;a href="https://slack.engineering/build-better-software-to-build-software-better/" rel="noopener noreferrer"&gt;Build better software to build software better&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s engineering team recounts how they cut Quip and Canvas build times from 60 minutes down to 10–30 minutes, built around a central thesis: core software engineering principles apply just as much to build systems as they do to application code. Just like optimizing runtime performance, speeding up builds relies on two levers: caching (doing less work) and parallelism (spreading the load). Bazel supports both out of the box, automatically reusing build outputs when inputs haven&amp;rsquo;t changed and distributing build actions across CPU cores. Even the best build tool, however, cannot save a tangled dependency graph.&lt;/p&gt;
&lt;p&gt;The root problem was that the frontend build depended on the entire compiled backend, so any Python change invalidated the cache and forced a full frontend rebuild, costing an average of 35 minutes each time. The team painstakingly untangled the true inputs of each build step—decoupling backend from frontend, Python infrastructure from TypeScript, and build tooling from application source code—while splitting targets into fine-grained units so individual JS bundles and CSS files could be cached independently. They also fixed a layering violation: frontend bundlers should focus strictly on bundling logic while leaving orchestration and parallelism to Bazel. The result was an up to 6x speedup: 10 minutes in the best case, ~12 minutes on average, and 30 minutes in the worst case.&lt;/p&gt;
&lt;h2 id="things-i-don"&gt;&lt;del&gt;&lt;a href="https://medv.io/blog/things-i-dont-like-in-configuration-languages/" rel="noopener noreferrer"&gt;Things I Don&amp;rsquo;t Like in Configuration Languages&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Anton Medvedev analyzes the pain points of various configuration languages and explains why he decided to create his own language, MAML (Minimal And Markup Language). The article offers an insightful look into the pros and cons of configuration formats ranging from YAML and JSON to newer alternatives.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- YAML has an overly complex specification with too many unnecessary features&lt;/del&gt;
&lt;del&gt;- JSON has won as a universal data-interchange format, but has a few small rough edges worth improving&lt;/del&gt;
&lt;del&gt;- TOML lacks a null value and has confusing array-of-tables syntax&lt;/del&gt;
&lt;del&gt;- Languages like Pkl, CUE, and Dhall are full programming languages rather than simple markup languages&lt;/del&gt;
&lt;del&gt;- The author created MAML based on JSON with a strict specification and a distinctive name&lt;/del&gt;
&lt;del&gt;- MAML keeps JSON&amp;rsquo;s readability while adding comments and multiline strings&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="here"&gt;&lt;a href="https://seconds0.substack.com/p/heres-whats-next-in-agentic-coding/" rel="noopener noreferrer"&gt;Here&amp;rsquo;s What&amp;rsquo;s Next in Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post predicts the next wave of developments in agentic coding, centered on a single thesis: context management is king. A great agent harness must feed the model the exact information it needs while keeping noise out of the context window. According to the author, Plan Mode will become far more sophisticated, flipping the effort ratio between planning and execution from 20:80 to 80:20 so an agent can one-shot an entire feature in a single run. Codebase search will blend &lt;code&gt;grep&lt;/code&gt; with semantic embeddings, external reference docs (such as via Context7 MCP) will be fetched just in time, and rules and skills will load conditionally so they don&amp;rsquo;t pollute context.&lt;/p&gt;
&lt;p&gt;At the multi-agent orchestration layer, the author expects techniques like Best-of-N sampling, pairing an expensive frontier model for planning with a cheaper model for execution, and delegating to subagents for parallel, context-isolated tasks coordinated by a lead agent that shields the user from micromanagement. Output quality will climb through self-critique and evaluation loops, harnesses that proactively suggest improvements to their own configuration, and persistent memory systems that retain knowledge about the user and codebase across sessions. As the author notes, the current pace of iteration in this space is unprecedented.&lt;/p&gt;
&lt;h2 id="why-agents-do-not-write-most-of-our-code---a-reality-check"&gt;&lt;del&gt;&lt;a href="https://octomind.dev/blog/why-agents-do-not-write-most-of-our-code-a-reality-check/" rel="noopener noreferrer"&gt;Why agents DO NOT write most of our code - a reality check&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Even though Octomind builds AI agents for a living, their team reports that most of their own production code is still written by humans. After months of using Cursor, Claude Code, and Windsurf, no one on the team saw a transformative productivity boost (20% or more). To test the limits, two engineers spent a week trying to build a real feature—branch-specific copies of test cases—entirely with AI. On the first attempt, despite detailed specs and an updated rules file, the agent stumbled on basics: forgetting to regenerate the Prisma client after schema changes, creating UI components without wiring them up, writing inefficient queries, and confidently declaring the job done. The result was a 2,000-line PR that needed fixes on nearly every screen. A second attempt with smaller, incremental tasks still produced a 1,200-line PR for just a fraction of the feature, complete with broken database transaction handling.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, the most dangerous failure mode is developers losing their mental model of the codebase as AI dumps thousands of lines of changes in at a time, making every tough debugging session feel like your first day at a new job. The second issue is that AI doesn&amp;rsquo;t know its own limits and always acts confident, whereas a human intern knows how to say &amp;ldquo;I&amp;rsquo;ve never done this before.&amp;rdquo; Still, AI remains genuinely useful for brainstorming, debugging, autocomplete, writing unit tests, and small localized refactors, and narrowly scoped specialist agents continue to deliver real value.&lt;/p&gt;
&lt;h2 id="clarifying-the-rule-of-three-in-refactoring"&gt;&lt;a href="https://blog.jbrains.ca/permalink/clarifying-the-rule-of-three-in-refactoring/" rel="noopener noreferrer"&gt;Clarifying the Rule of Three in Refactoring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;J.B. Rainsberger clarifies the &amp;ldquo;Rule of Three&amp;rdquo; in refactoring—the heuristic that you should wait until duplication appears three times before extracting a shared abstraction—which often sparks debate. In Rainsberger&amp;rsquo;s view, the rule is primarily aimed at Advanced Beginners to keep them from mechanically deduplicating everything on sight. He distinguishes between two contexts: when you are practicing design through refactoring, aggressively removing duplication and occasionally regretting it is how you sharpen your design judgment; when you are focused on shipping under a deadline, waiting helps avoid rework in case future changes force you to reintroduce the duplication. The Rule of Three is therefore a teaching aid for balancing learning and delivery, not an ironclad law.&lt;/p&gt;
&lt;p&gt;Personally, Rainsberger prefers removing duplication early because he is comfortable inlining code back again as soon as an extraction turns out to be wrong, viewing that reversal as a natural part of learning. Removing duplication early also helps surface useful abstractions hiding in the design. His advice to developers is to get comfortable undoing a refactoring, and if you invoke the Rule of Three, make sure it rests on clear reasoning rather than vague fear.&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_!9vpY!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff5f41f86-4bf2-4b21-85aa-69659c039111_2250x2624.png" alt="Top Strategies to Share Data Between Services"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!aRQC!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa760cf81-6245-4051-be41-f867616e0faf_2250x2862.png" alt="Scalability Patterns for Modern Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=6u25GckPhLU" rel="noopener noreferrer"&gt;Design a Web Crawler: FAANG Interview Question&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;URL processing worked reasonably well—it used less untranslated English this time, though a bit of&amp;hellip; Chinese slipped in :| The bonus section was pretty rough, mainly because when you only pass raw image URLs to the AI, it struggles to find the right title and sometimes hallucinates completely unrelated labels.&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #25</title><link>https://miti99.com/en/post/2025/05/12/</link><pubDate>Mon, 12 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #25.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-13-software-engineering-laws"&gt;&lt;a href="https://newsletter.manager.dev/p/the-13-software-engineering-laws" rel="noopener noreferrer"&gt;The 13 software engineering laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides rounds up 13 classic &amp;ldquo;laws&amp;rdquo; every software engineer and engineering manager should know. On time and staffing: Parkinson&amp;rsquo;s Law (work expands to fill the time allotted) is counterbalanced by Hofstadter&amp;rsquo;s Law (it always takes longer than you expect), meaning estimation only improves through practice, communication, and flexible scope. Brooks&amp;rsquo;s Law reminds us that adding people to a late software project makes it later. Conway&amp;rsquo;s Law states that system architecture mirrors an organization&amp;rsquo;s communication structure; Flo applied the &amp;ldquo;Inverse Conway Maneuver&amp;rdquo; by embedding iOS, Android, and backend engineers into cross-functional teams to ship 20–30 releases per day. Cunningham&amp;rsquo;s Law offers a clever way to get unstuck: open a pull request—even if you aren&amp;rsquo;t sure it&amp;rsquo;s right—and the owning team will quickly jump in to show you the right way.&lt;/p&gt;
&lt;p&gt;On products and teams: Sturgeon&amp;rsquo;s Law (90% of everything is crud) and Zawinski&amp;rsquo;s Law (every program attempts to expand until it can read mail) warn against feature bloat, while Hyrum&amp;rsquo;s Law guarantees that with enough users, every observable behavior of your system will be depended on by someone, making removals painful. Price&amp;rsquo;s Law (half the work is done by the square root of the total number of contributors) and the Ringelmann Effect (individual effort drops as group size grows) explain why small teams with clear ownership outperform large ones. Goodhart&amp;rsquo;s Law (when a measure becomes a target, it ceases to be a good measure) is balanced by Gilb&amp;rsquo;s Law (imperfect measurement beats no measurement at all). Rounding out the list is Murphy&amp;rsquo;s Law. Zaides concludes that while these aren&amp;rsquo;t physical laws of nature, they are invaluable mental models.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-curve-is-bending-predictions-on-near-term-ai-inference-spending"&gt;&lt;a href="https://grantslatton.com/the-curve-is-bending" rel="noopener noreferrer"&gt;The Curve is Bending: Predictions on near-term AI inference spending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grant Slatton, creator of the high-performance spreadsheet engine Row Zero, argues that AI has just crossed an inflection point where the economic value it generates for real-world software engineering exceeds its cost. His personal AI spend jumped from $100/year in 2023 to roughly $5,000/year in 2025. For him, &lt;code&gt;o1-pro&lt;/code&gt; was the first model that felt reliably useful, performing on par with a junior engineer on self-contained single-file tasks—such as pinpointing a bug given a large Rust file, a git diff, and failing test output. He uses Zed Editor&amp;rsquo;s prompt library to generate repetitive spreadsheet functions (cutting 20 minutes of work down to 2), writes small LLM-powered CLI utilities for himself, and used Claude Code—sometimes running three sessions in parallel—to rewrite the entire backend of his personal website, finishing what he estimated as a 100-hour job in under 10 hours for a few hundred dollars.&lt;/p&gt;
&lt;p&gt;Looking ahead from April 2025, Slatton estimates AI tools currently boost his overall productivity by ~1.1x and expects that to reach 2–3x by late 2026. Frontier models like &lt;code&gt;o3-pro&lt;/code&gt; will initially be expensive, but for engineers earning over $100/hour, an annual AI inference budget of $10,000–$50,000 is easy to justify—and by Jevons paradox, falling per-token prices will only increase total spending. He notes that models still lack the architectural &amp;ldquo;taste&amp;rdquo; of a senior engineer, predicts coding agents will match new CS grads by the end of 2026, and advises junior developers to focus on cultivating senior-level judgment as quickly as possible.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="open-source-is-just-that-understanding-boundaries-in-open-source"&gt;&lt;a href="https://vale.rocks/posts/open-source-entitlement" rel="noopener noreferrer"&gt;Open-Source is Just That: Understanding Boundaries in Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Declan Chidlow speaks out against the growing sense of user entitlement directed at volunteer open-source maintainers. As Chidlow points out, open-source software grants specific rights defined by its license—and merely making source code public does not even make a project open source; it does not automatically mean a project accepts external contributions, offers user support, owes anyone new features, or owes anyone the maintainer&amp;rsquo;s personal time, and users remain bound by the license terms. Having permission to use code under a license does not entitle anyone to demand unpaid labor from its author. He criticizes users who spam issue trackers or aggressively demand support, commenters who defend that behavior, and especially profitable companies that build on open source without giving back instead of funding the maintainers they depend on.&lt;/p&gt;
&lt;p&gt;For projects that do welcome engagement, asking for help respectfully means searching existing issues and documentation first, providing complete reproduction details upfront, staying patient and polite, using official channels, and contributing small fixes or docs improvements where you can—and even when you sponsor or pay a maintainer, &amp;ldquo;money does not replace manners.&amp;rdquo; He encourages the community to respectfully stand up for maintainers, urges maintainers to set firm boundaries, and warns against flooding projects with thoughtless AI-generated issues and pull requests. The bottom line: access to source code is not access to someone else&amp;rsquo;s time and labor.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-insanity-of-being-a-software-engineer"&gt;&lt;a href="https://0x1.pt/2025/04/06/the-insanity-of-being-a-software-engineer/" rel="noopener noreferrer"&gt;The Insanity of Being a Software Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitor Sousa Pereira takes a satirical look at the ever-expanding mountain of knowledge a single software engineer is expected to master. At first, you just needed a couple of languages and tools, plus your company&amp;rsquo;s web framework of choice—Rails, Django, or Laravel—alongside CSS, which you can study your whole life and still not understand why a layout broke. Then React arrived, companies decided they didn&amp;rsquo;t want to hire separate specialists, and the &amp;ldquo;full-stack developer&amp;rdquo; was born—bringing TypeScript, Redux, webpack/esbuild/rollup configs, Prettier, and ESLint along for the ride. Next, DevOps replaced dedicated sysadmins, so developers had to learn Docker, AWS, and Terraform or Pulumi too. Getting promoted into management means learning an entirely new profession—estimating timelines, delegating, writing specs, running annual performance reviews—and unless the company is growing fast, you still have to do all your old IC work on top of it.&lt;/p&gt;
&lt;p&gt;Pereira mentions a recruiter recently reaching out for a role demanding senior-level expertise across Rails, Hotwire, &lt;em&gt;and&lt;/em&gt; native mobile development simultaneously. While acknowledging that software complexity exists for real reasons, he asks what happened to specialization: when building a house, you hire an architect, a structural engineer, an electrician, a plumber, and dozens of other trades—nobody expects one person to do it all. He closes half-jokingly that maybe a future where we build entire applications with a few AI prompts wouldn&amp;rsquo;t be so bad after all.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-day-i-taught-ai-to-understand-code-like-a-senior-developer"&gt;&lt;a href="https://nmn.gl/blog/ai-understand-senior-developer" rel="noopener noreferrer"&gt;The day I taught AI to understand code like a Senior Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Namanyay argues that today&amp;rsquo;s code-generating LLMs don&amp;rsquo;t truly understand a codebase—they act like glorified autocomplete tools that forget where files live, duplicate existing helpers, and ignore established design patterns because they only see a narrow context window. Junior developers focus on the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; whereas senior developers focus on the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;what if,&amp;rdquo; holding a mental model of the entire system and anticipating ripple effects; current LLMs behave much more like juniors. His solution is modeling the codebase as a hierarchical knowledge graph using an algorithm he calls Ranked Recursive Summarization (RRS): starting at leaf files, ranking their importance, and recursively summarizing upward into parent directories. Because plain RRS still lost domain-specific nuance, he evolved it into Prismatic RRS (PRRS), which summarizes the codebase through multiple &amp;ldquo;prisms&amp;rdquo; such as architecture, data flow, and security.&lt;/p&gt;
&lt;p&gt;With this multi-perspective context, the AI knows where new files belong, which patterns to follow, and how to extend existing abstractions instead of reinventing them—while also surfacing technical debt, security gaps, and speeding up onboarding for human engineers. He packaged this approach into a product called Giga AI, but also shares how developers can apply the idea manually: write concise summaries for key directories and files, have AI refine them, maintain perspective-specific docs, and feed the relevant summaries into context. His core belief: AI should amplify human creativity rather than replace it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="why-companies-don"&gt;&lt;a href="https://idiallo.com/blog/companies-dont-fix-bugs" rel="noopener noreferrer"&gt;Why Companies Don&amp;rsquo;t Fix Bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ibrahim Diallo opens with the famous GTA Online story: a player named &lt;code&gt;t0st&lt;/code&gt; diagnosed why the game&amp;rsquo;s online mode took 20 minutes to load, fixed it with 13 lines of code that cut load times by 70%, and was awarded $10,000 by Rockstar—after the bug had sat in production for eight years. Rather than blaming &amp;ldquo;lazy developers,&amp;rdquo; Diallo traces the typical lifecycle of a bug inside a large company: in year one, an engineer proposes fixing the slow JSON parser, the product manager asks &amp;ldquo;is it in the spec?&amp;rdquo;, and it gets filed under tech debt; by year three, all engineering capacity is locked into expansion packs and paid cosmetics; by year six, the ticket is auto-archived because the codebase has been rewritten twice; in year eight, a newly hired developer discovers the exact same bug all over again.&lt;/p&gt;
&lt;p&gt;He identifies four structural reasons bugs go unfixed: roadmap-driven development pushes any fix not tied to a feature request to the bottom of the backlog; constant employee turnover erodes institutional knowledge; touching poorly tested, undocumented legacy code carries high career risk for little reward; and quality-of-life improvements don&amp;rsquo;t show up on quarterly revenue charts the way selling virtual Shark Cards does. &lt;code&gt;t0st&lt;/code&gt;&amp;rsquo;s fix was a great PR win, but it didn&amp;rsquo;t change the underlying incentives. The takeaway: don&amp;rsquo;t blame individual engineers when the system itself treats user experience as an afterthought.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="3-buckets-of-work-time"&gt;&lt;a href="https://corymiller.com/3-buckets-of-work-time/" rel="noopener noreferrer"&gt;3 Buckets of Work Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cory Miller, a Chief Evangelist working remotely from Oklahoma with a largely European team, audited his calendar and realized his workweek falls into three buckets. The first is &lt;em&gt;talking&lt;/em&gt;—communication and collaboration across meetings and Slack/Teams—which has been taking a larger share than usual since he recently joined a new team. The second is &lt;em&gt;doing&lt;/em&gt;—execution and shipping—which for him mostly means producing internal and customer-facing videos. The third is &lt;em&gt;thinking about work&lt;/em&gt;—strategy and vision, the &amp;ldquo;daydreaming&amp;rdquo; bucket tied to his Wonder and Invention strengths in the Working Genius model, best done alone in quiet reflection before bringing rough ideas back to teammates for feedback.&lt;/p&gt;
&lt;p&gt;Now in his late 40s, having lived through burnout before and raising two young kids with his wife, Miller has no interest in working 60-hour weeks; he wants to work smarter and healthier. He admits that fear and uncertainty often drive him to overcommit, so he is practicing letting go of what he can&amp;rsquo;t control. Wanting enough structure to feel grounded without feeling boxed in, he is experimenting with waking up at 6 a.m. to handle European overlap and communication early, dedicating Mondays and Wednesdays to collaboration, and reserving Tuesdays and Thursdays for deep work and strategic thinking—leaving himself more quiet space to embrace &amp;ldquo;not knowing yet.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="dangerous-advice-for-software-engineers"&gt;&lt;a href="https://www.seangoedecke.com/dangerous-advice/" rel="noopener noreferrer"&gt;Dangerous Advice for Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke compares certain kinds of career advice to &amp;ldquo;sharp tools&amp;rdquo; like &lt;code&gt;ssh&lt;/code&gt;, &lt;code&gt;kubectl&lt;/code&gt;, or write access to a production database: wielded with skill and judgment, they are indispensable; used carelessly, they cause serious damage. Goedecke admits he frequently writes this kind of &amp;ldquo;dangerous&amp;rdquo; advice: deciding for yourself what to work on, occasionally breaking written company rules on purpose, holding strong opinions before you have all the facts, embracing a bit of organizational cunning, and avoiding work that doesn&amp;rsquo;t directly serve shipping. He worries about readers misapplying it, but argues someone still needs to write it down.&lt;/p&gt;
&lt;p&gt;First, most mainstream career advice is sanitized—written to avoid liability or sound virtuous—while strong engineers crave honest talk about how organizations actually work; realizing that reality doesn&amp;rsquo;t match the employee handbook while nobody admits it out loud is deeply isolating. Second, your own manager can almost never give you this advice directly: if you misjudge a situation and say &amp;ldquo;my manager told me to break the process,&amp;rdquo; the fallout hits them even harder than it hits you, even though many managers quietly wish their reports operated with more pragmatic initiative than their job description states. This advice is high-risk, high-reward—helpful for strong engineers and dangerous for weaker ones—so if any piece of it makes you uncomfortable, don&amp;rsquo;t follow it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="on-the-biology-of-a-large-language-model"&gt;&lt;a href="https://transformer-circuits.pub/2025/attribution-graphs/biology.html" rel="noopener noreferrer"&gt;On the Biology of a Large Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This landmark Anthropic paper uses &amp;ldquo;circuit tracing&amp;rdquo; to study the internal mechanisms of Claude 3.5 Haiku, likening the approach to a biologist studying living tissue under a microscope. The researchers train a replacement model built on a cross-layer transcoder architecture containing roughly 30 million interpretable &amp;ldquo;features&amp;rdquo; (replacement neurons that typically correspond to human-understandable concepts), then construct attribution graphs for individual prompts to trace how features activate one another step by step. Because attribution graphs are hypotheses, they validate them with intervention experiments—such as inhibiting specific feature clusters inside the original model and observing how behavior changes across multi-step reasoning, poetry, multilingual understanding, addition, medical diagnosis, hallucinations, refusals, jailbreaks, and chain-of-thought faithfulness.&lt;/p&gt;
&lt;p&gt;Their experiments reveal that the model performs genuine multi-step intermediate reasoning &amp;ldquo;in its head&amp;rdquo;—for example, activating &amp;ldquo;Texas&amp;rdquo; before arriving at &amp;ldquo;Austin&amp;rdquo; when asked for the capital of the state containing Dallas—alongside memorized shortcuts. It shows clear signs of forward planning, choosing a rhyming target word before composing a line of poetry; possesses rudimentary &amp;ldquo;metacognitive&amp;rdquo; circuits that track what it knows versus doesn&amp;rsquo;t know; and operates on shared abstract representations across languages. While the authors acknowledge their current tools yield satisfying explanations for only about a quarter of prompts, the work represents a major step forward for AI interpretability and safety.&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 #23</title><link>https://miti99.com/en/post/2025/05/10/</link><pubDate>Sat, 10 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #23.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="llms-an-operator"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/llms-an-operators-view" rel="noopener noreferrer"&gt;LLMs: An Operator&amp;rsquo;s View&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier looks at LLMs from the perspective of someone running an engineering organization. In his view, the baseline productivity floor for developers is rising: even skeptics acknowledge that tools like Copilot and Cursor speed up prototyping, code completion, and unit test generation. Engineering leaders should therefore proactively budget for paid seats and roll them out deliberately—surveying adoption, identifying internal champions to share workflows, and tracking impact over time. As individual output rises, teams can deliver more with fewer people, so before opening new headcount, leaders should first invest in tooling and training for their existing team, which costs a fraction of hiring another senior engineer.&lt;/p&gt;
&lt;p&gt;The flip side is that faster code generation does not automatically mean higher quality. Stanier recommends tightening code review practices—such as requiring multiple reviewers and running regular security refreshers for the team. Hiring is affected too: candidates using LLMs during remote interviews muddy evaluation signals, so companies need an explicit policy—either embracing AI tools and testing critical thinking, or banning them outright—and must communicate those rules upfront to candidates. The bottom line: adopting LLMs is now table-stakes infrastructure investment, paired with the guardrails needed to protect code quality and hiring standards.&lt;/p&gt;
&lt;h2 id="the-reality-of-tech-interviews-in-2025"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-reality-of-tech-interviews" rel="noopener noreferrer"&gt;The Reality of Tech Interviews in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, joined by Evan King (former Staff Engineer at Meta) and Stefan Mai (former Engineering Manager at Amazon and Meta), paints a picture of a tech hiring market that is simultaneously recovering and much tougher. Open roles at Big Tech are up roughly 40% year over year, and total tech job postings have climbed from their 2023 trough of 163,000 to around 230,000, though still far below the 2020–2022 peak. The recovery is highly uneven: AI infrastructure and ML ops roles command top-tier compensation, while new grads face brutal odds—one candidate applied to 100 companies, landed just 4 interviews, and received zero offers after six months. Mid-level loops have stretched out too, with one candidate going through eleven interview rounds before getting an offer.&lt;/p&gt;
&lt;p&gt;The bar for data structures, algorithms, and system design rounds has also risen noticeably: interviewers now expect complete, working solutions with proper error handling and input validation. Two standout trends are &amp;ldquo;downleveling&amp;rdquo;—where staff-level engineers accept senior roles after prolonged job searches—and &amp;ldquo;team matching&amp;rdquo; turning into an extra filtering stage that can stall offers for months. The authors advise preparing thoroughly for both technical and behavioral rounds at every level, especially for specialized roles, and lining up competing offers so you don&amp;rsquo;t get stuck in team-matching limbo.&lt;/p&gt;
&lt;h2 id="senior-developer-skills-in-the-ai-age-leveraging-experience-for-better-results"&gt;&lt;a href="https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/" rel="noopener noreferrer"&gt;Senior Developer Skills in the AI Age: Leveraging Experience for Better Results&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Manuel Kießling argues that AI coding agents like Cursor do not devalue senior engineering experience—they amplify it. While AI models have broad programming knowledge, they have almost no innate understanding of a project&amp;rsquo;s specific architecture, meaning results depend heavily on how a human guides them. Drawing on his team&amp;rsquo;s experience at Joboo, Kießling outlines three practices. First, well-structured requirements: clearly describing data relationships, system architecture, and task boundaries so the AI doesn&amp;rsquo;t wander off track. Second, tool-based guardrails: linters, static analysis, and automated test suites that provide continuous feedback so the agent can self-correct whenever a check fails. Third, file-based &amp;ldquo;keyframing&amp;rdquo;: creating empty skeleton files with the right namespaces and naming conventions upfront so the AI writes code that fits the existing structure instead of inventing random files.&lt;/p&gt;
&lt;p&gt;Using these techniques, his team shipped an entire contract-management feature spanning multiple applications and repositories in minutes rather than hours. Kießling even had the AI build a Python monitoring tool from scratch in a few hours despite having limited Python experience himself, thanks to thorough requirements docs and automated guardrails. The lesson: upfront planning matters more than ever—AI can execute almost anything, and experienced engineers are there to make sure it builds the right thing.&lt;/p&gt;
&lt;h2 id="jep-483-ahead-of-time-class-loading--linking"&gt;&lt;a href="https://www.morling.dev/blog/jep-483-aot-class-loading-linking/" rel="noopener noreferrer"&gt;JEP 483: Ahead-of-Time Class Loading &amp;amp; Linking&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gunnar Morling puts JEP 483—a Java 24 feature from Project Leyden—to the test, showing how it cuts Java application startup time without requiring any source code changes. The idea is shifting class loading and linking from runtime to build time, building on top of existing Application Class Data Sharing (AppCDS) machinery. Creating the AOT cache takes a two-step training run: first recording loaded classes into a configuration file, then generating the cache image from that configuration, with the classpath kept identical between training and production runs.&lt;/p&gt;
&lt;p&gt;On Apache Kafka 4.0, the resulting AOT cache file weighs around 66 MB and drops startup time from 690 ms to 285 ms—a 59% reduction—with most of the savings coming from skipping class reading and parsing. On Apache Flink, time to first message drops from 1.875 seconds to 0.913 seconds, a 51% improvement. Some limitations remain: custom class loaders are not yet supported, JVM startup flags must be adjusted, and integrating the training run into container image builds can add pipeline complexity. Compared with GraalVM native images—which start in milliseconds and use less memory but require code adjustments and a closed-world assumption—Project Leyden aims for a pragmatic middle ground that is immediately useful for cloud-native Java services.&lt;/p&gt;
&lt;h2 id="specifications-in-jakarta-data"&gt;&lt;a href="https://in.relation.to/2025/03/28/repository-specifications/" rel="noopener noreferrer"&gt;Specifications in Jakarta Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin King (Hibernate) shows how to implement the &amp;ldquo;specifications&amp;rdquo; pattern—familiar from Spring Data—on top of Jakarta Data. Specifications allow dynamic query filtering via the JPA Criteria API without repetitive boilerplate. While Jakarta Data does not yet include built-in specification support, King demonstrates that all it takes is a shared super-interface &lt;code&gt;JpaRepository&amp;lt;T&amp;gt;&lt;/code&gt; exposing two methods: &lt;code&gt;session()&lt;/code&gt; returning Hibernate&amp;rsquo;s &lt;code&gt;StatelessSession&lt;/code&gt; and &lt;code&gt;entityClass()&lt;/code&gt; returning the entity class. Built on top of those, &lt;code&gt;find()&lt;/code&gt; and &lt;code&gt;count()&lt;/code&gt; accept a specification modeled as a &lt;code&gt;BiFunction&amp;lt;CriteriaBuilder, Root&amp;lt;T&amp;gt;, Predicate&amp;gt;&lt;/code&gt; and construct the corresponding Criteria query.&lt;/p&gt;
&lt;p&gt;Paired with the JPA static metamodel, this approach is fully type-safe, catching misspelled attribute names or type mismatches at compile time. King also includes a &lt;code&gt;compose()&lt;/code&gt; helper for combining multiple specifications and hints that Jakarta Data 1.1 is working on a &amp;ldquo;much more interesting&amp;rdquo; native solution. The two snippets below count books matching a title pattern and find books matching both title and author name:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;count&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&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-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;find&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;and&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;authors&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Author_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;equalTo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;authorName&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;toLowerCase&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="there-is-no-vibe-engineering"&gt;&lt;a href="https://serce.me/posts/2025-03-31-there-is-no-vibe-engineering" rel="noopener noreferrer"&gt;There is no Vibe Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov (SerCe) contrasts &amp;ldquo;vibe coding&amp;rdquo;—Andrej Karpathy&amp;rsquo;s term for programming primarily via AI prompts rather than working directly with code—with real software engineering. His central thesis builds on the classic definition that &amp;ldquo;software engineering is programming integrated over time&amp;rdquo;: vibe coding solves for a single point in time, whereas production systems must survive real-world traffic, scale with demand, withstand security threats, migrate live user data, and adapt to changing requirements. AI can spin up prototypes remarkably fast, but these long-term concerns are hard to express in a prompt and impossible to verify just by eyeballing the UI. Good engineering practices push failure modes left, where fixing them is cheap; vibe coding pushes them right, where fixing them is expensive.&lt;/p&gt;
&lt;p&gt;Tselovalnikov imagines a future where &amp;ldquo;vibe engineering&amp;rdquo; could exist: systems assembled from strictly encapsulated AI-generated components surrounded by rigorous automated testing, profiling, tracing, canary deployments, and protocol compatibility checks. In that world, the engineer&amp;rsquo;s role blends software architect and platform engineer—writing less application code by hand while spending far more energy on boundaries and verification. Yet that is still traditional software engineering, just operating with new tools. In his view, the true inflection point will only arrive when engineers feel comfortable going on call for a production service written entirely by AI—something very few would dare do today.&lt;/p&gt;
&lt;h2 id="refining-var-handles-in-valhalla"&gt;&lt;a href="https://cr.openjdk.org/~jrose/values/atomic-value-access-api.html" rel="noopener noreferrer"&gt;Refining Var-Handles in Valhalla&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This technical design note by John Rose (OpenJDK) explores how &lt;code&gt;VarHandle&lt;/code&gt;—Java&amp;rsquo;s API for heap variable access supporting &lt;code&gt;getfield&lt;/code&gt;, &lt;code&gt;putfield&lt;/code&gt;, and atomic operations like CAS—needs to evolve to support value types in Project Valhalla. The core challenge is ensuring the interpreter, JIT compiler, and JNI access memory consistently when a variable can be laid out in multiple physical representations on the heap. The &lt;code&gt;LayoutKind&lt;/code&gt; enum defines six representations: &lt;code&gt;REFERENCE&lt;/code&gt; for traditional nullable managed pointers, &lt;code&gt;ATOMIC_FLAT&lt;/code&gt; for values packed into 64 bits, &lt;code&gt;NON_ATOMIC_FLAT&lt;/code&gt; for multi-field values wider than 64 bits, their nullable counterparts &lt;code&gt;NULLABLE_ATOMIC_FLAT&lt;/code&gt; and &lt;code&gt;NULLABLE_NON_ATOMIC_FLAT&lt;/code&gt; (which include a null indicator), and &lt;code&gt;BUFFERED&lt;/code&gt; for read-only heap-buffered copies.&lt;/p&gt;
&lt;p&gt;Rose proposes retiring the current internal &lt;code&gt;getValue&lt;/code&gt; method as insufficient, replacing it with three metadata queries and one new access primitive: &lt;code&gt;isFlat()&lt;/code&gt; to distinguish flattened values from ordinary references, &lt;code&gt;isConsistent()&lt;/code&gt; to indicate whether reads and writes are strictly atomic (non-tearing), &lt;code&gt;isPortableAtomic()&lt;/code&gt; to indicate support for advanced atomic operations like CAS, and &lt;code&gt;copyConsistentValue()&lt;/code&gt; to atomically copy heap words according to the layout&amp;rsquo;s protocol. The key design insight is splitting responsibilities into two layers: a new low-level intrinsic handles atomic memory copying, while existing &lt;code&gt;Unsafe&lt;/code&gt; methods operate on a thread-local buffer (specifically a one-element array) to pack and unpack value fields. This keeps &lt;code&gt;VarHandle&lt;/code&gt; logic clean and decoupled from complex GC and memory-layout details.&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>