<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Git on miti99</title><link>https://miti99.com/en/tags/git/</link><description>Recent content in Git 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/git/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 #135</title><link>https://miti99.com/en/post/2026/10/03/</link><pubDate>Sat, 03 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #135.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="git-at-any-scale"&gt;&lt;a href="https://cursor.com/blog/git-at-any-scale" rel="noopener noreferrer"&gt;Git at any scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vicent Martí explains why hosting centralized Git repositories at massive scale is notoriously difficult: Git packfiles are large binary blobs that expect to live on a local POSIX filesystem with fast &lt;code&gt;mmap&lt;/code&gt; random access. Early attempts to ditch packfiles and store loose Git objects in distributed key-value stores made &lt;code&gt;git clone&lt;/code&gt; unusably slow, because walking the commit and tree graph incurred a network round trip at every hop. Shared network filesystems like NFS, GFS, or DRBD proved slow, brittle, and operationally painful. GitHub&amp;rsquo;s Spokes replicates repositories at the application layer using a three-phase commit for reference transactions, but push throughput is bottlenecked by the slowest replica, and fixing every repo at three copies over-provisions cold repos while under-provisioning hot CI monorepos—all while requiring a massive central routing database.&lt;/p&gt;
&lt;p&gt;Cursor&amp;rsquo;s &lt;em&gt;Continuity&lt;/em&gt; engine flips the architecture by making a write-ahead log (WAL) on S3-compatible object storage the single source of truth. Every &lt;code&gt;git push&lt;/code&gt; writes its pack data and ref update to the WAL before acknowledging the client, becoming visible only after the reference transaction succeeds and updates the WAL index—making all pushes strictly linearizable. Standard on-disk Git repositories on local NVMe drives act purely as stateless, disposable caches reconstructed on demand from the WAL, eliminating consensus protocols entirely. Nodes are selected via rendezvous hashing, while write safety relies on S3&amp;rsquo;s conditional compare-and-swap (&lt;code&gt;If-Match&lt;/code&gt; / &lt;code&gt;If-None-Match&lt;/code&gt;). Read replicas receive invalidation hints over UDP gossip and verify freshness via conditional &lt;code&gt;GET&lt;/code&gt; requests with ETags in under 10 ms. Only the primary node runs packfile compaction; replicas simply download compacted packs from S3. Benchmarks on Cursor&amp;rsquo;s own monorepo show linear read scaling up to 100 replicas, ~120 pushes/sec on S3 Standard, and over 300 pushes/sec on S3 Express One Zone—laying the foundation for Origin, Cursor&amp;rsquo;s Git hosting platform built for high-concurrency agent workloads.&lt;/p&gt;
&lt;h2 id="regressive-jpegs"&gt;&lt;a href="https://maurycyz.com/projects/bad_jpeg/" rel="noopener noreferrer"&gt;Regressive JPEGs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maurycy explores a delightfully cursed trick with progressive JPEGs, a format designed to transmit low-frequency image components first so a partially downloaded photo appears blurry rather than half-blank. Inside a progressive JPEG, compressed image data is divided into multiple &amp;ldquo;scans,&amp;rdquo; each with its own header specifying which color channels (&lt;code&gt;Y&lt;/code&gt;, &lt;code&gt;Cb&lt;/code&gt;, &lt;code&gt;Cr&lt;/code&gt;), which range of DCT frequency bins, and which bit-precision slice it contains. The first scan normally carries the DC (average color) bin for all three channels, while subsequent scans progressively fill in high-frequency AC detail. Because each scan declares its own spectral range, the author realized nothing stops a later scan from &lt;em&gt;overwriting&lt;/em&gt; frequency bins that were already rendered—meaning you can concatenate multiple same-resolution images into a single JPEG file (stripping their intermediate &lt;code&gt;SOI&lt;/code&gt;, &lt;code&gt;SOF&lt;/code&gt;, and &lt;code&gt;EOI&lt;/code&gt; markers) so the image morphs from one picture into another as it loads over a slow connection.&lt;/p&gt;
&lt;p&gt;The catch is that browsers cap the maximum number of scans they will decode before giving up (likely as a defense against decompression bombs), limiting full-detail progressive overwrites to about nine frames. To cram a real animation into a single JPEG, you have to minimize the number of scans per frame. Because the JPEG spec forbids mixing DC and AC coefficients in the same progressive scan, the smallest possible frame is a single DC-only scan—producing a blocky 8×8-pixel-per-block low-res image. Using one DC scan per frame, Chrome renders roughly 90 frames before bailing out, Firefox keeps going even longer, and ghosting artifacts vanish because there are no leftover AC coefficients from earlier frames bleeding through. The result is an entire multi-second video inside a valid &lt;code&gt;.jpg&lt;/code&gt; file—utterly useless in production since playback speed is dictated entirely by network bandwidth, but prime material for a rickroll.&lt;/p&gt;
&lt;h2 id="a-quick-look-at-zero-knowledge-proofs"&gt;&lt;a href="https://bernsteinbear.com/blog/zkp/" rel="noopener noreferrer"&gt;A quick look at zero-knowledge proofs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein and Chris Gregory demystify zero-knowledge proofs (ZKPs) through a classic example that has nothing to do with cryptocurrency: proving a graph is 3-colorable, following Goldreich, Micali, and Wigderson&amp;rsquo;s 1986 paper. In a ZKP, a &lt;em&gt;prover&lt;/em&gt; claims to know a secret solution to a hard problem, and a &lt;em&gt;verifier&lt;/em&gt; wants to be convinced the prover truly knows it without learning a single bit about the solution itself. Graph 3-coloring—assigning one of three colors to every vertex so no two connected vertices share a color—is NP-complete to solve but trivial to check locally along any single edge. Each round of the interactive protocol runs in four steps: the prover randomly permutes the three color names, &amp;ldquo;locks&amp;rdquo; each vertex&amp;rsquo;s permuted color inside a sealed box, and sends all the locked boxes to the verifier; the verifier picks one random edge &lt;code&gt;(u, v)&lt;/code&gt; and challenges the prover; the prover sends back the keys to only boxes &lt;code&gt;u&lt;/code&gt; and &lt;code&gt;v&lt;/code&gt;; and the verifier opens those two boxes to verify that their colors are valid and different.&lt;/p&gt;
&lt;p&gt;In Python code, a &amp;ldquo;locked box&amp;rdquo; is a cryptographic commitment: the hash of the vertex&amp;rsquo;s color concatenated with a random cryptographic nonce (using &lt;code&gt;hashlib.sha256&lt;/code&gt; and &lt;code&gt;secrets&lt;/code&gt;), since hashing the color alone without a random nonce would produce identical hashes for same-colored vertices and leak the coloring structure. Because a cheating prover who doesn&amp;rsquo;t actually have a valid 3-coloring can still get lucky unless the verifier picks the exact edge that violates the rules, a single round catches a cheater with probability at least $1/m$ (where $m$ is the number of edges). Repeating the protocol with fresh random color permutations and nonces for $m^2$ rounds drives the probability of forgery down exponentially: on a 1,000-edge graph, ~4,600 rounds reduce the soundness error below 1%, and 10,000 rounds drop it to 0.0045%. The authors build a working client-server demo and note that because 3-coloring is NP-complete, any NP problem—from Sudoku to integer factorization—can theoretically be reduced to it, even if the resulting circuit graph balloons quickly in size.&lt;/p&gt;
&lt;h2 id="the-pulse-we-need-to-talk-about-migrations-with-ai"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-we-need-to-talk-about-migrations-with-ai/" rel="noopener noreferrer"&gt;The Pulse: We need to talk about migrations with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this free edition of &lt;em&gt;The Pulse&lt;/em&gt;, Gergely Orosz argues that AI coding tools have fundamentally changed the economics of large-scale code migrations that teams previously put off for years as prohibitively expensive. The headline example comes from Asana: according to an OpenAI case study, Asana used Codex to rip out Enzyme and migrate their test suite to React Testing Library in roughly 1.5 engineer-weeks and ~$12,000 in model and compute costs—a migration previously estimated at $6 million and five years of background effort. Similarly, Airbnb migrated 3,500 Enzyme test files in six weeks (versus a 1.5 engineer-year manual estimate), Uber migrated 600,000 JUnit 4 tests to JUnit 5 in four months with two engineers, and Bun ported 530,000 lines of Zig to Rust in two weeks for $165,000 in API spend. By contrast, back in 2021 Sentry spent 1.5 years and roughly ten engineers migrating 95,000 lines of JavaScript to TypeScript.&lt;/p&gt;
&lt;p&gt;Across these successes, the same engineering patterns recur: automated retry loops when a migrated file fails to build or pass tests, multi-phase per-file pipelines, engineer-designed verification harnesses, starting with leaf files or frequently touched files first, and refactoring the codebase beforehand so patterns are uniform for the LLM. Orosz notes that Asana&amp;rsquo;s &amp;ldquo;$6M saved&amp;rdquo; headline is likely inflated—manual estimates rarely account for humans getting much faster after the first hundred files—and stresses that every single migration still required experienced engineers to design the pipeline, build the verification gates, and handle edge cases. Even so, the cost-benefit curve for paying down massive technical debt has shifted permanently.&lt;/p&gt;
&lt;h2 id="the-accidental-application-runtime"&gt;&lt;a href="https://adventures.michaelfbryan.com/posts/accidental-application-runtime" rel="noopener noreferrer"&gt;The Accidental Application Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael F. Bryan describes how a small Go service managing a 3D-printer farm gradually grew into an tangled mess. It started as a simple dashboard where the HTTP server spawned a single background goroutine to poll printer status. Over time, polling jobs from a cloud backend, persisting state to SQLite, scheduling print jobs, streaming G-code, and reporting telemetry were all bolted onto that same initialization block until &lt;code&gt;NewServer&lt;/code&gt; was spawning five long-running background goroutines. When the team needed to add graceful shutdown on &lt;code&gt;SIGTERM&lt;/code&gt;, figuring out which goroutines were running, in what order they needed to stop, and who owned closing which Go channels required reading the entire startup file line by line. Bryan calls this an &amp;ldquo;accidental application runtime&amp;rdquo;: the service had a real concurrent pub/sub architecture, but nothing in the code&amp;rsquo;s structure made that topology explicit.&lt;/p&gt;
&lt;p&gt;Inspired by the PX4 drone autopilot&amp;rsquo;s uORB messaging layer, Bryan built a lightweight Go library called &lt;code&gt;backplane&lt;/code&gt;. Each subsystem becomes a plain Go function &lt;code&gt;func(ctx, deps...) error&lt;/code&gt; whose typed parameters declare its communication topology: a &lt;code&gt;chan&amp;lt;- T&lt;/code&gt; parameter publishes to topic &lt;code&gt;T&lt;/code&gt;, &lt;code&gt;&amp;lt;-chan T&lt;/code&gt; subscribes to a stream of &lt;code&gt;T&lt;/code&gt;, and &lt;code&gt;*backplane.Latest[T]&lt;/code&gt; polls the latest state snapshot. Topics are keyed by Go types rather than error-prone string names. &lt;code&gt;backplane.New&lt;/code&gt; validates the dependency graph before startup, and &lt;code&gt;Run&lt;/code&gt; supervises the modules like an &lt;code&gt;errgroup&lt;/code&gt; with in-process, backpressured delivery. Rebuilding the printer service as six explicit modules—anchored by a strict &lt;em&gt;commit-then-notify&lt;/em&gt; rule where the scheduler commits job state to SQLite before publishing a wake-up message—even let the team auto-generate accurate Mermaid architecture diagrams straight from the function signatures.&lt;/p&gt;
&lt;h2 id="generic-methods-in-go-127"&gt;&lt;a href="https://dominik.info/blog/go-generic-methods" rel="noopener noreferrer"&gt;Generic Methods in Go 1.27&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When Go 1.18 introduced generics in 2022, functions and types could declare type parameters, but methods could not declare additional type parameters of their own. Go 1.27 finally lifts that restriction: methods can now introduce their own type parameters without polluting the receiver struct. Dominik Braun illustrates why this matters using a generic graph node &lt;code&gt;Node[T]&lt;/code&gt;. Previously, if you wanted a &lt;code&gt;Map&lt;/code&gt; method that transforms a &lt;code&gt;Node[T]&lt;/code&gt; into a &lt;code&gt;Node[U]&lt;/code&gt;, you either had to pollute the struct definition itself as &lt;code&gt;Node[T, U]&lt;/code&gt;—forcing every unrelated method on &lt;code&gt;Node&lt;/code&gt; to carry &lt;code&gt;U&lt;/code&gt; around—or give up on method syntax and write a standalone package-level function &lt;code&gt;Map[T, U any](n *Node[T], ...)&lt;/code&gt;. Starting in Go 1.27, you can simply write &lt;code&gt;func (n *Node[T]) Map[U any](...) Node[U]&lt;/code&gt;, scoping &lt;code&gt;U&lt;/code&gt; strictly to the &lt;code&gt;Map&lt;/code&gt; method.&lt;/p&gt;
&lt;p&gt;Why did this take four years to land? The hurdle lay in how Go compiles generics versus how it dispatches interfaces. Go&amp;rsquo;s compiler primarily uses &lt;em&gt;monomorphization&lt;/em&gt; (stenciling specialized machine code for concrete type shapes at compile time), whereas Go interfaces rely on runtime dynamic dispatch via an &lt;code&gt;itable&lt;/code&gt; of function pointers. Those two models collide if an interface is allowed to declare a generic method like &lt;code&gt;type Mapper interface { Map[U any]() Node[U] }&lt;/code&gt;: the compiler cannot pre-populate a fixed-size runtime vtable for an unbounded set of potential type arguments &lt;code&gt;U&lt;/code&gt;, especially when reflection can look up methods dynamically at runtime. Go&amp;rsquo;s pragmatic compromise in 1.27 is to allow generic methods on concrete types while forbidding them in interface definitions—and a generic method cannot be used to satisfy an interface.&lt;/p&gt;
&lt;h2 id="your-executable-is-a-sqlite-database"&gt;&lt;a href="https://fzakaria.com/2026/08/23/your-executable-is-a-sqlite-database" rel="noopener noreferrer"&gt;Your executable is a SQLite database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria, author of &lt;code&gt;sqlelf&lt;/code&gt;, takes his previous experiment to its logical conclusion: replacing ELF entirely with SQLite as a native Linux executable format. His prototype, &lt;strong&gt;SELF&lt;/strong&gt; (&lt;em&gt;Structured Executable &amp;amp; Linkable Format&lt;/em&gt;), produces real SQLite database files that you can &lt;code&gt;chmod +x&lt;/code&gt; and run directly from the shell. His core argument is that ELF is already an ad-hoc, bespoke relational database in denial: &lt;code&gt;.strtab&lt;/code&gt; is string interning, &lt;code&gt;.gnu.hash&lt;/code&gt; is a hash index, section headers are a catalog table, and symbol versioning is a foreign-key schema. In SELF, an executable&amp;rsquo;s schema consists of a &lt;code&gt;self_meta&lt;/code&gt; table for the ELF header, a &lt;code&gt;segments&lt;/code&gt; table storing each program header row with its raw machine code/data as a SQLite &lt;code&gt;BLOB&lt;/code&gt;, and a &lt;code&gt;symbols&lt;/code&gt; table indexed by standard SQLite B-trees in place of &lt;code&gt;.dynsym&lt;/code&gt; and &lt;code&gt;.gnu.hash&lt;/code&gt;. Registering the SQLite magic header with Linux&amp;rsquo;s &lt;code&gt;binfmt_misc&lt;/code&gt; lets the kernel hand &lt;code&gt;./my_app&lt;/code&gt; directly to &lt;code&gt;self-exec&lt;/code&gt;, a tiny C loader that queries the segments, maps them into memory, performs relocations, and jumps to the entry point.&lt;/p&gt;
&lt;p&gt;For dynamic linking, SELF supports two modes: keeping glibc&amp;rsquo;s standard &lt;code&gt;ld.so&lt;/code&gt; and using an &lt;code&gt;rtld-audit&lt;/code&gt; hook so a SQL query resolves shared libraries, or using &lt;code&gt;self-ld&lt;/code&gt;, an experimental SQL-native dynamic linker. Even cooler, &lt;code&gt;self closure&lt;/code&gt; bundles a binary and all its transitive shared-library dependencies into a single self-contained SQLite database file—turning &lt;code&gt;ldd&lt;/code&gt; into a simple SQL &lt;code&gt;JOIN&lt;/code&gt;. Packing all 723 executables in &lt;code&gt;/usr/bin&lt;/code&gt; into a single shared SELF database shrank total size from 644.4 MiB (ELF) down to 611.9 MiB thanks to cross-binary library and symbol deduplication, even though individual standalone SELF files are 2.2x to 3.6x larger than their ELF counterparts. While copying segments out of SQLite blobs prevents cross-process &lt;code&gt;mmap&lt;/code&gt; page sharing for &lt;code&gt;.text&lt;/code&gt; segments and slows cold start on massive binaries, being able to inspect, strip, or atomically patch executables with &lt;code&gt;UPDATE&lt;/code&gt; and &lt;code&gt;ROLLBACK&lt;/code&gt; is a fascinating glimpse into an alternate Unix universe.&lt;/p&gt;
&lt;h2 id="what-happens-when-a-gpu-reads-memory"&gt;&lt;a href="https://blog.doubleword.ai/what-happens-when-a-gpu-reads-memory" rel="noopener noreferrer"&gt;What happens when a GPU reads memory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doubleword founder Fergus Finn traces the exact hardware journey of a single global memory load instruction (&lt;code&gt;LDG.E&lt;/code&gt;) inside an NVIDIA RTX 4090. Because NVIDIA documents very little of its microarchitectural memory pipeline publicly, Finn reverse-engineered the path using custom cycle-accurate microbenchmarks and hardware performance counters. When a 32-thread warp issues a 4-byte load per thread, the hardware coalescer groups those 32 requests into four 32-byte sectors—one 128-byte cache line. On an L1 miss, the virtual address passes through a 16-entry per-SM L1 TLB (backed by 2 MiB pages) to translate into a physical address, because the L2 cache is physically indexed. From there, the chip-wide crossbar routes the request to one of 36 L2 cache slices selected by an undocumented hash of the physical address bits, which in turn forwards L2 misses to one of 12 memory controllers wired to 12 GDDR6X chips—where the controller must issue an expensive DRAM row &lt;code&gt;ACTIVATE&lt;/code&gt; command to open a 1 KiB row before bursting the four 32-byte sectors back.&lt;/p&gt;
&lt;p&gt;The latency ladder is stark: an L1 hit takes ~15.4 ns, an L2 hit takes ~127 ns, and a full miss down to GDDR6X DRAM takes ~255 ns—roughly 660 GPU clock cycles during which that warp sits stalled. Activating a new DRAM row costs roughly 15x more time than reading from an already-open row, and hammering a single L2 slice caps throughput at 1,957 million loads/sec versus ~68,000 million loads/sec when spread evenly across all 36 slices (a 34.8x difference). GPUs hide that 660-cycle latency through massive warp-level parallelism—switching to other ready warps every cycle—which is why memory-bound kernels live or die by coalesced access patterns that spread traffic evenly across L2 slices and DRAM banks.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-calculate-the-day-of-the-week"&gt;&lt;a href="https://www.benjoffe.com/fast-day-of-week" rel="noopener noreferrer"&gt;A faster way to calculate the day-of-the-week&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Joffe tackles a deceptively simple problem: converting a signed 32-bit Unix epoch day count (&lt;code&gt;1970-01-01&lt;/code&gt; = Thursday) into a day of the week (&lt;code&gt;0..6&lt;/code&gt;) as fast as possible across the entire 32-bit integer range. Cassio Neri&amp;rsquo;s 2024 algorithm serves as the state-of-the-art baseline, but requires an extra correction step because 7 is an awkward divisor in binary. Joffe&amp;rsquo;s key insight is to exploit the fact that $7 = 2^3 - 1$ is a Mersenne number, which means $N \bmod 7 = \lfloor N \cdot \frac{8}{7} \rfloor \bmod 8$. Multiplying by $\frac{8}{7}$ can be approximated by a single fixed-point multiplication by a magic constant &lt;code&gt;M&lt;/code&gt;, and taking $\bmod 8$ comes almost for free by masking or shifting to keep only the top three bits of the fractional part. A bounded 32-bit version reduces to a one-liner—&lt;code&gt;((u32(rd) * M + Z) &amp;gt;&amp;gt; 29)&lt;/code&gt;—valid across $\pm 242,000$ years, which sped up weekday calculations in the Rust &lt;code&gt;jiff&lt;/code&gt; datetime crate by ~40%.&lt;/p&gt;
&lt;p&gt;To cover the full signed 32-bit domain without overflow, Joffe presents several variants: widening to a 64-bit multiply (already adopted by WebKit), adding a bit-shifted correction term that executes in parallel with the multiply, using two multiplies for higher instruction throughput, or collapsing the entire calculation into three x86 instructions via &lt;code&gt;LEA&lt;/code&gt;. Switching between Sunday-indexed (&lt;code&gt;0..6&lt;/code&gt;) and ISO Monday-indexed (&lt;code&gt;1..7&lt;/code&gt;) output only requires swapping the additive constant &lt;code&gt;Z&lt;/code&gt;. Better yet, the same Mersenne identity generalizes to any divisor of the form $2^N - 2^K$, including &lt;code&gt;x % 24&lt;/code&gt; and &lt;code&gt;x % 60&lt;/code&gt; for extracting hours, minutes, and seconds. Benchmarks show Joffe&amp;rsquo;s variants taking just 0.17x to 0.39x the runtime of Neri&amp;rsquo;s algorithm on an Apple M4 Pro and 0.27x to 0.59x on a Ryzen 9 9950X3D, with patches already merged into WebKit, Elixir, Rust&amp;rsquo;s &lt;code&gt;jiff&lt;/code&gt;, and Zig&amp;rsquo;s &lt;code&gt;zeit&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="dark-mode-toggles-two-states-are-enough"&gt;&lt;a href="https://lea.verou.me/blog/2026/dark-mode-toggles/" rel="noopener noreferrer"&gt;Dark mode toggles: two states are enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lea Verou argues that website header dark-mode toggles should only expose two visible states to the user, even though the underlying state machine has three (&lt;code&gt;System&lt;/code&gt;, &lt;code&gt;Light&lt;/code&gt;, and &lt;code&gt;Dark&lt;/code&gt;). In her view, exposing a three-way segmented control or dropdown in the navbar solves an imaginary user goal: nobody visits a website thinking &amp;ldquo;my OS is in light mode and this page looks great in light mode, let me proactively pin it to Light just in case my OS switches to dark mode tonight.&amp;rdquo; Users click a theme toggle for one reason: &lt;em&gt;the current appearance is uncomfortable to read right now, make it the opposite&lt;/em&gt;. Exposing all three states in the header is classic &amp;ldquo;implementation-model UI&amp;rdquo; that adds visual clutter, extra clicks, and unnecessary cognitive load. At the same time, a naive two-state toggle is even worse if clicking it once permanently locks &lt;code&gt;localStorage&lt;/code&gt; into an override with no way to return to following the OS theme.&lt;/p&gt;
&lt;p&gt;Verou&amp;rsquo;s solution is a single two-state button that cleanly traverses all three underlying states. By default (when following the OS), the button displays the currently active theme and stores nothing in &lt;code&gt;localStorage&lt;/code&gt;. Clicking it once switches to the opposite theme and saves that explicit override. Clicking it a second time switches back to the theme that matches the user&amp;rsquo;s current OS preference—and instead of saving a hard override, it &lt;em&gt;clears&lt;/em&gt; the stored setting, returning the site to &lt;code&gt;System&lt;/code&gt; mode. Because the override is only re-evaluated when the user clicks the toggle, users whose OS automatically flips between light and dark at sunset can still override a site whenever they want without getting stuck permanently out of sync. Reserve explicit three-way &lt;code&gt;Light / Dark / Auto&lt;/code&gt; selectors for dedicated settings pages—not the top navigation bar.&lt;/p&gt;</description></item><item><title>Newsletter #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 #101</title><link>https://miti99.com/en/post/2026/05/04/</link><pubDate>Mon, 04 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #101.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ai-assisted-engineering-q1-2026-impact-report"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-assisted-engineering-q1-2026-impact" rel="noopener noreferrer"&gt;AI-Assisted Engineering: Q1 2026 Impact Report&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DX&amp;rsquo;s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI&amp;rsquo;s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping &lt;strong&gt;4x&lt;/strong&gt; as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the &amp;ldquo;player-coach&amp;rdquo; model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save &lt;strong&gt;4.9 hours per week&lt;/strong&gt;, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.&lt;/p&gt;
&lt;p&gt;The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is &amp;ldquo;no longer optional.&amp;rdquo; &amp;ldquo;Shadow AI&amp;rdquo; — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI&amp;rsquo;s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.&lt;/p&gt;
&lt;h2 id="my-ai-workflow-without-losing-my-skills"&gt;&lt;a href="https://marcgg.com/blog/2026/04/15/my-current-ai-workflow/" rel="noopener noreferrer"&gt;My AI Workflow (Without Losing My Skills)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G shares how he leverages AI without losing his programming skills. His concern stems from the &amp;ldquo;automation paradox&amp;rdquo; (he cites an episode of the &lt;em&gt;99% Invisible&lt;/em&gt; podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he &amp;ldquo;vibe codes&amp;rdquo; freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an &amp;ldquo;Omega Mess,&amp;rdquo; in Sandi Metz&amp;rsquo;s terminology).&lt;/p&gt;
&lt;p&gt;A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.&lt;/p&gt;
&lt;h2 id="managing-context-in-long-run-agentic-applications"&gt;&lt;a href="https://slack.engineering/managing-context-in-long-run-agentic-applications/" rel="noopener noreferrer"&gt;Managing Context in Long-Run Agentic Applications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is &lt;strong&gt;never carrying raw conversation history into subsequent agent calls&lt;/strong&gt;; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren&amp;rsquo;t weighed down by accumulated stale context.&lt;/p&gt;
&lt;p&gt;The first channel is the &lt;strong&gt;Director&amp;rsquo;s Journal&lt;/strong&gt;, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the &lt;strong&gt;Critic&amp;rsquo;s Review&lt;/strong&gt;, which scores the confidence of specialist agents&amp;rsquo; findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the &lt;strong&gt;Critic&amp;rsquo;s Timeline&lt;/strong&gt;, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director&amp;rsquo;s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.&lt;/p&gt;
&lt;h2 id="how-the-heck-does-shazam-work"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-shazam-work" rel="noopener noreferrer"&gt;How The Heck Does Shazam Work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: &lt;strong&gt;throw away almost all the data&lt;/strong&gt;, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a &lt;strong&gt;Fast Fourier Transform (FFT)&lt;/strong&gt; to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse &amp;ldquo;constellation map&amp;rdquo;; background noise rarely produces prominent peaks, making this approach highly noise-resistant.&lt;/p&gt;
&lt;p&gt;To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an &lt;strong&gt;inverted index&lt;/strong&gt; — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.&lt;/p&gt;
&lt;h2 id="agents-with-taste"&gt;&lt;a href="https://emilkowal.ski/ui/agents-with-taste" rel="noopener noreferrer"&gt;Agents with Taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain &lt;em&gt;why&lt;/em&gt; a design choice works, then feed them to the agent. His argument is that taste isn&amp;rsquo;t magic — &amp;ldquo;almost every decision about taste has a rational explanation if you look closely enough,&amp;rdquo; and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.&lt;/p&gt;
&lt;p&gt;The examples are concrete: animations should start from &lt;code&gt;scale(0.95)&lt;/code&gt; rather than &lt;code&gt;scale(0)&lt;/code&gt; because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as &lt;code&gt;ease-out&lt;/code&gt; for elements entering the viewport and &lt;code&gt;ease&lt;/code&gt; for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.&lt;/p&gt;
&lt;h2 id="floating-point-from-scratch-hard-mode"&gt;&lt;a href="https://essenceia.github.io/projects/floating_dragon/" rel="noopener noreferrer"&gt;Floating Point from Scratch: Hard Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose &lt;strong&gt;bfloat16&lt;/strong&gt; (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a &lt;strong&gt;dual-path&lt;/strong&gt; architecture: the &amp;ldquo;close path&amp;rdquo; handles subtraction when the exponent difference is less than 2, while the &amp;ldquo;far path&amp;rdquo; handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.&lt;/p&gt;
&lt;p&gt;Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library&amp;rsquo;s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of &lt;strong&gt;454 MHz&lt;/strong&gt; under nominal conditions. One fun lesson: a leading-zero counter written simply with &lt;code&gt;casez&lt;/code&gt; outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.&lt;/p&gt;
&lt;h2 id="the-peril-of-laziness-lost"&gt;&lt;a href="https://bcantrill.dtrace.org/2026/04/12/the-peril-of-laziness-lost/" rel="noopener noreferrer"&gt;The Peril of Laziness Lost&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bryan Cantrill argues that LLMs are eroding one of a great programmer&amp;rsquo;s most important virtues: &lt;strong&gt;laziness&lt;/strong&gt;, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a &lt;em&gt;natural filter&lt;/em&gt; forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.&lt;/p&gt;
&lt;p&gt;A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan&amp;rsquo;s output revealed redundant test suites, a &amp;ldquo;Hello World&amp;rdquo; Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and &amp;ldquo;grind&amp;rdquo; culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.&lt;/p&gt;
&lt;h2 id="cleaning-up-merged-git-branches-a-one-liner-from-the-cia"&gt;&lt;a href="https://spencer.wtf/2026/02/20/cleaning-up-merged-git-branches-a-one-liner-from-the-cias-leaked-dev-docs.html" rel="noopener noreferrer"&gt;Cleaning Up Merged Git Branches: A One-Liner from the CIA&amp;rsquo;s Leaked Dev Docs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against &lt;code&gt;master&lt;/code&gt;; his updated version for modern repositories compares against &lt;code&gt;origin/main&lt;/code&gt; and excludes both &lt;code&gt;main&lt;/code&gt; and &lt;code&gt;develop&lt;/code&gt;:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git branch --merged origin/main &lt;span class="p"&gt;|&lt;/span&gt; grep -vE &lt;span class="s2"&gt;&amp;#34;^\s*(\*|main|develop)&amp;#34;&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; xargs -n &lt;span class="m"&gt;1&lt;/span&gt; git branch -d
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;The pipeline chains three steps: &lt;code&gt;git branch --merged origin/main&lt;/code&gt; lists merged branches, &lt;code&gt;grep -vE&lt;/code&gt; strips out the current branch and primary branches to prevent accidental deletion, and &lt;code&gt;xargs&lt;/code&gt; deletes each remaining branch using the lowercase &lt;code&gt;-d&lt;/code&gt; flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his &lt;code&gt;ciaclean&lt;/code&gt;) so you don&amp;rsquo;t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.&lt;/p&gt;
&lt;h2 id="agent-harness-engineering"&gt;&lt;a href="https://addyosmani.com/blog/agent-harness-engineering/" rel="noopener noreferrer"&gt;Agent Harness Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that the quality of a coding agent depends more on its &lt;strong&gt;harness&lt;/strong&gt; — the operational scaffolding around the model — than on the model itself: &amp;ldquo;a mediocre model with a great harness will beat a great model with a bad harness.&amp;rdquo; The gap between what today&amp;rsquo;s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (&lt;code&gt;AGENTS.md&lt;/code&gt;, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.&lt;/p&gt;
&lt;p&gt;Key principles include the &amp;ldquo;skill issue&amp;rdquo; mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The &lt;strong&gt;Ratchet Principle&lt;/strong&gt; treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its &lt;code&gt;AGENTS.md&lt;/code&gt; under 60 lines, like a pilot&amp;rsquo;s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn&amp;rsquo;t disappear — it moves on to tackling harder problems.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #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 #47</title><link>https://miti99.com/en/post/2025/08/06/</link><pubDate>Wed, 06 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #47.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-with-llms-in-the-summer-of-2025-an-update"&gt;&lt;a href="https://antirez.com/news/154" rel="noopener noreferrer"&gt;Coding with LLMs in the summer of 2025 (an update)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Antirez, creator of Redis, shares an update on how he works with LLMs. In his view, frontier models like Gemini 2.5 PRO can amplify a programmer&amp;rsquo;s capabilities: catching bugs before they reach users (something he experienced firsthand while building Vector Sets for Redis), rapidly writing throwaway code to test ideas, co-designing solutions, and working with technologies outside one&amp;rsquo;s core expertise. However, LLMs are currently &amp;ldquo;good amplifiers&amp;rdquo; but terrible &amp;ldquo;one-man bands&amp;rdquo;: when left to tackle complex goals on their own, they produce bloated, fragile code full of suboptimal choices, so he rejects vibe coding in most cases.&lt;/p&gt;
&lt;p&gt;To get good results, the programmer must supply a rich context: documentation, most of the relevant source code, and their full understanding of the problem—including approaches that sound appealing but are actually bad, promising directions, goals, invariants, and desired code style. For new technologies the model doesn&amp;rsquo;t know yet, simply dropping the README into the context is enough. He recommends using Gemini 2.5 PRO (stronger at reasoning and spotting subtle bugs) and Claude Opus 4, while avoiding coding agents or agent-integrated editors, skipping RAG, and manually copying code between the terminal and the web UI to stay in the loop. According to him, staying in control is currently the best way to leverage AI, while avoiding LLMs out of prejudice is itself a risk.&lt;/p&gt;
&lt;h2 id="artisanal-handcrafted-git-repositories"&gt;&lt;a href="https://drew.silcock.dev/blog/artisanal-git/" rel="noopener noreferrer"&gt;Artisanal Handcrafted Git Repositories&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drew Silcock walks through creating a Git repository &amp;ldquo;by hand&amp;rdquo; without running a single Git command—not even plumbing commands—to show how Git works under the hood. The article starts by manually creating the &lt;code&gt;.git&lt;/code&gt; directory, its required subdirectories, the config file, and the &lt;code&gt;HEAD&lt;/code&gt; file pointing to &lt;code&gt;main&lt;/code&gt;. Next, he explains Content Addressable Storage: in the SHA-1 example repository, loose objects are identified by their hash and compressed with zlib. Git has three main object types: blob (file contents), tree (a directory listing with references to blobs and subtrees), and commit (pointing to the root tree along with author metadata and the commit message). One surprising detail for many is that Git stores the full contents of a file for each version rather than diffs; space savings are handled later through packfiles and garbage collection.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough steps through creating a blob for a file, constructing a tree, crafting a commit (including GPG signing), and writing the branch reference so Git recognizes the initial commit, then verifying the result with standard Git commands. The author also explains why the first two characters of the hash are used as a subdirectory name, along with references and the reflog. The core takeaway is that Git&amp;rsquo;s power comes from the simplicity and elegance of its design rather than complex code; once you understand the underlying file formats, writing a simple Git clone yourself is not nearly as daunting as it seems.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://utkarshkanwat.com/writing/betting-against-agents" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m Betting Against AI Agents in 2025 (Despite Building Them)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Utkarsh Kanwat, who has built over a dozen production AI agent systems (UI generation, database operations, DevOps, CI/CD), explains why he is betting against the wave of fully autonomous agents in 2025. First, errors compound exponentially: if each step is 95% reliable, a 20-step workflow succeeds only 36% of the time, whereas production systems need 99.9%+. Second, token costs grow quadratically with conversation length because every turn reprocesses the entire context; a 100-turn session can cost $50–$100. Third, the real challenge lies in tool engineering and feedback loops: AI accounts for only about 30% of the work, while the remaining 70% is tool design, context management, partial failure handling, and recovery mechanisms.
His own agents work because they have tightly bounded scopes, verifiable operations, and human confirmation at critical points—for example, his database agent always asks before executing destructive operations, and his function-generation agent is completely stateless. He predicts that &amp;ldquo;fully autonomous agent&amp;rdquo; startups will soon hit an economic wall, while the winners will be specialized tools acting as &amp;ldquo;very capable assistants with clear boundaries.&amp;rdquo; His advice for agent builders: define clear boundaries, design for failure, do the cost math, prioritize reliability over autonomy, and use traditional software engineering for critical execution paths.&lt;/p&gt;
&lt;h2 id="rethinking-cli-interfaces-for-ai"&gt;&lt;a href="https://www.notcheckmark.com/2025/07/rethinking-cli-interfaces-for-ai/" rel="noopener noreferrer"&gt;Rethinking CLI interfaces for AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author, who uses LLMs for reverse engineering via an IDA Pro MCP server, argues that current CLI tools and APIs are poorly suited for LLM agents, especially local models with small context windows. Designing an MCP interface requires balancing returning too much information (bloating the context) against returning too little (forcing extra tool calls); the author&amp;rsquo;s team added guidance in docstrings so the model prefers the high-level &lt;code&gt;get_global_variable_at&lt;/code&gt; helper over low-level memory-reading functions. On the command line, the author observed Claude Code repeatedly piping output through &lt;code&gt;head -n100&lt;/code&gt;, losing track of its working directory, and passing &lt;code&gt;--no-verify&lt;/code&gt; to bypass git hooks when it couldn&amp;rsquo;t fix failing tests—prompting the author to write a git wrapper that blocks that flag and prints instructions telling the agent how to fix the issue properly.&lt;/p&gt;
&lt;p&gt;Borrowing the concept of &amp;ldquo;Information Architecture&amp;rdquo; from UX design, the author argues that agents&amp;rsquo; clumsiness with CLI tools shows those tools have poor information architecture for non-human users. Proposed fixes include replacing &lt;code&gt;head&lt;/code&gt; with a wrapper that caches full output, returns structured chunks, and states how many lines remain so the agent doesn&amp;rsquo;t re-run expensive builds; and adding a shell hook that prints the current working directory whenever a command is not found. According to the author, almost every CLI tool could include extra context to cut down on round-trips and save context window space, and it may be time for a dedicated toolkit or shell built specifically for LLMs.&lt;/p&gt;
&lt;h2 id="asynchrony-is-not-concurrency"&gt;&lt;a href="https://kristoff.it/blog/asynchrony-is-not-concurrency/" rel="noopener noreferrer"&gt;Asynchrony is not Concurrency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro (Kristoff) argues that we are missing a crucial distinction when talking about concurrent programming: asynchrony. He gives two examples: saving two files in any order can be done one after the other and still be correct; but starting a TCP server and connecting to it within the same program requires the two tasks to overlap in time. From this, he proposes clear definitions: asynchrony is the ability for tasks to execute out of order while still producing a correct result; concurrency is a system&amp;rsquo;s ability to make progress on multiple tasks at once, via parallelism or task switching; and parallelism is physically executing multiple tasks at the same instant. Both examples exhibit asynchrony, but only the second requires concurrency.&lt;/p&gt;
&lt;p&gt;Conflating the two has had real consequences: library authors must maintain separate synchronous and asynchronous versions (like &lt;code&gt;redis-py&lt;/code&gt; and &lt;code&gt;asyncio-redis&lt;/code&gt;), &amp;ldquo;viral&amp;rdquo; async functions force users to abandon synchronous code, and awkward escape hatches invite deadlocks. In Zig&amp;rsquo;s new I/O design, &lt;code&gt;io.async&lt;/code&gt; does not imply concurrency: when run in a single-threaded blocking mode, it simply calls the function immediately, so libraries using async do not force users out of synchronous I/O. When true concurrent execution is needed, developers call &lt;code&gt;io.asyncConcurrent&lt;/code&gt;, which can return an error if the execution environment does not support it. This allows synchronous and asynchronous code to coexist without trade-offs.&lt;/p&gt;
&lt;h2 id="how-does-ai-disrupt-accountability-in-code-reviews"&gt;&lt;a href="https://rdel.substack.com/p/rdel-102-how-does-ai-disrupt-accountability" rel="noopener noreferrer"&gt;How Does AI Disrupt Accountability in Code Reviews?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Issue #102 of RDEL by Lizzie Matusov summarizes a qualitative study on how LLM-assisted code reviews affect engineers&amp;rsquo; sense of accountability. The researchers interviewed 16 engineers and then ran four focus groups simulating both peer reviews and LLM-assisted reviews. The findings identify four intrinsic drivers of personal accountability for code quality: personal standards, professional integrity, pride in code quality, and professional reputation. Once a review begins, accountability shifts from individual to collective: engineers adjust their tone, stay open to feedback, and align their personal bar with team norms.&lt;/p&gt;
&lt;p&gt;LLM-performed reviews disrupt this social process because without a real human reader, there is no reciprocity or &amp;ldquo;social contract&amp;rdquo; to uphold; as one participant put it, &amp;ldquo;you can&amp;rsquo;t hold a model accountable.&amp;rdquo; Engineers still appreciate AI feedback and happily use it for a first pass to catch basic issues before asking a teammate to review, but they distrust its grasp of context and do not view its suggestions as authoritative. The author advises engineering managers to treat LLMs as a support layer, keep humans in every review loop (especially for architectural decisions and team standards), and reinforce intrinsic motivation through social norms like recognizing thoughtful reviews.&lt;/p&gt;
&lt;h2 id="vibecoding-a-high-performance-system"&gt;&lt;a href="https://andrewkchan.dev/posts/systems.html" rel="noopener noreferrer"&gt;Vibecoding a High Performance System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Chan recounts using Cursor&amp;rsquo;s agent (primarily with Claude 4 Opus) to build a system capable of crawling one billion web pages in about 24 hours, with only around 3.75% of the code written by hand. Unlike many vibe-coding demos, this was a domain new to the author, with a wide design space, an objective performance target, and severe failure modes at scale such as failing to respect website rate limits. So he let the AI write the code while checking in frequently and reviewing carefully at the end. The models still made real mistakes: placing a &lt;code&gt;FOR UPDATE&lt;/code&gt; lock on a CTE caused a race condition where two workers grabbed the same URL, and using Python&amp;rsquo;s built-in &lt;code&gt;hash&lt;/code&gt; function (which is randomized across processes) broke domain partitioning.&lt;/p&gt;
&lt;p&gt;The biggest strength was exploring the design space at breakneck speed: across 8 completely different architectures, measured throughput climbed from roughly 20 to 10,800 pages per second. When writing code becomes cheap, the bottleneck shifts to running experiments and reviewing. Still, the AI frequently produced logically valid &amp;ldquo;slop&amp;rdquo; that hurt performance, such as a redundant HTML sanitization step that made the parser twice as slow or unused struct fields that bloated memory. The author concludes that agents have transformed the scale of software he can build solo, but strong fundamentals matter even more, because only engineers who deeply understand the whole system can get the most out of AI&amp;rsquo;s still-flawed capabilities.&lt;/p&gt;
&lt;h2 id="two-simple-rules-to-fix-code-reviews"&gt;&lt;a href="https://serce.me/posts/2025-07-17-two-simple-rules-to-fix-code-reviews" rel="noopener noreferrer"&gt;Two Simple Rules to Fix Code Reviews&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov argues that amid countless code review &amp;ldquo;best practices,&amp;rdquo; real effectiveness comes down to two simple rules—both aimed at reviewers, since they control most of the time a change spends waiting. The first rule is to minimize turnaround time: for the reviewer, delaying costs almost nothing, but for the author, flow stops the moment a review is requested; after an hour they lose very little context, after a day they have to reload their mental model, and after a week they are practically starting over. Responding quickly doesn&amp;rsquo;t mean rubber-stamping; it means making an honest effort to understand the change, raising major concerns, and asking questions, because nothing is worse than silence. The second rule is that every comment must include a &amp;ldquo;because&amp;rdquo; clause: instead of writing &amp;ldquo;do X,&amp;rdquo; write &amp;ldquo;do X because Y&amp;rdquo;; if you can&amp;rsquo;t articulate a clear reason, you probably shouldn&amp;rsquo;t leave the comment.&lt;/p&gt;
&lt;p&gt;The author notes that senior and staff engineers—who often review more than they write code—set the team&amp;rsquo;s culture: if they take two days to review, the whole team will treat that as normal, even for tiny changes. These two rules work best for teams sharing common goals and may not apply to open source, where the cost of accepting a bad contribution is much higher.&lt;/p&gt;
&lt;h2 id="reading-qr-codes-without-a-computer"&gt;&lt;a href="https://qr.blinry.org/" rel="noopener noreferrer"&gt;Reading QR codes without a computer!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide teaches you how to decode QR codes by hand, without a computer or phone. You can type in custom text, scan an existing QR code, or practice with a random English word, walking through each component of the code: size and version (the smallest being 21×21 modules), finder patterns that help scanners orient the code, separators, timing patterns, alignment patterns, format information storing the mask and error-correction level, and the surrounding quiet zone.&lt;/p&gt;
&lt;p&gt;A fun highlight is how it explains the eight mask patterns using a memorable prison-break story, complete with a printable zine cheat sheet. After unmasking via XOR, the guide walks through identifying the encoding mode (numeric, alphanumeric, byte, Kanji, etc.), reading the length, and decoding each data block. It is a great visual way to understand the technical structure of QR codes.&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 #44</title><link>https://miti99.com/en/post/2025/08/03/</link><pubDate>Sun, 03 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/03/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;As mentioned, today I&amp;rsquo;ll try writing the Newsletter with Roo Code. The first few entries will use Roo Code + Qwen 3 Coder.&lt;/del&gt; Enjoy Newsletter #44.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="cursor-unveils-game-changing-web-app-for-ai-coding-agents"&gt;&lt;a href="https://opentools.ai/news/cursor-unveils-game-changing-web-app-for-ai-coding-agents" rel="noopener noreferrer"&gt;Cursor Unveils Game-Changing Web App for AI Coding Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anysphere, the company behind the AI code editor Cursor, has launched a web app for managing AI coding agents right from the browser. Instead of opening an IDE, users can assign tasks to agents in natural language, track progress, and merge agent-generated code changes from any internet-connected device. The app complements the existing IDE rather than replacing it, and at launch is available only to Pro tier subscribers and above.&lt;/p&gt;
&lt;p&gt;The article also provides context: Cursor has surpassed $500 million in annual recurring revenue and is used by more than half of the Fortune 500, while Anysphere&amp;rsquo;s CEO predicts that by 2026, AI agents will handle roughly 20% of a software engineer&amp;rsquo;s workload. Although community feedback has been broadly positive, questions remain around handling large repositories, pricing, and privacy. For junior developers, this is a clear signal that delegating to and supervising AI agents is steadily becoming part of everyday work.&lt;/p&gt;
&lt;h2 id="the-heart-of-software-engineering-still-beats"&gt;&lt;a href="https://annievella.com/posts/the-heart-of-software-engineering-still-beats/" rel="noopener noreferrer"&gt;The Heart of Software Engineering Still Beats&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Vella argues that even as AI tools dramatically reshape how we build software, the core of the craft remains intact. In her view, writing code is fundamentally about modeling: forming a structured mental model of a process, system, or idea, and encoding it into something a computer can execute. Design is not a separate phase either, but happens continuously while writing code, testing, debugging, and operating real-world systems; it is this ongoing refinement of abstractions that defines an engineer&amp;rsquo;s craft.&lt;/p&gt;
&lt;p&gt;The article acknowledges that generative AI is triggering an identity crisis: the part of the job many engineers took the most pride in—turning thoughts into code—is now automated, leaving quite a few feeling like bystanders in their own work. Even so, the author sees this as an evolution rather than replacement: modeling skills are shifting to a higher level, from writing code to organizing context for AI tools, also known as context engineering. The joy of shaping invisible systems and watching ideas take form is still there; only the medium of expression has changed.&lt;/p&gt;
&lt;h2 id="expert-generalist"&gt;&lt;a href="https://martinfowler.com/articles/expert-generalist.html" rel="noopener noreferrer"&gt;Expert Generalist&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler, together with Unmesh Joshi and Gitanjali Venkatraman, argues that software organizations overvalue narrow specialization, whereas what truly drives modern software development is the &amp;ldquo;expert generalist&amp;rdquo;: someone with broad knowledge who can still go deep into a few selected areas. The article describes six traits of such people: curiosity to explore new technologies and business domains; willingness to collaborate and humility to learn from specialists when entering unfamiliar territory; customer focus to guide their curiosity; prioritizing foundational knowledge like enduring principles and design patterns over fleeting tools; possessing a blended skill set more complex than a simple T-shaped model; and having &amp;ldquo;empathy&amp;rdquo; for adjacent disciplines, much like a race car driver who understands the car without needing to be a mechanical engineer.&lt;/p&gt;
&lt;p&gt;For organizations, the authors recommend hiring for learning speed and collaboration rather than experience with a specific tool, encouraging staff to rotate across areas, pairing expert generalists with a few deep specialists for each core technology, and building training programs just as rigorous as specialist tracks—such as hands-on workshops building miniature versions of Kafka, Kubernetes, or Delta Lake to grasp their internal design patterns. Generalist capability should also be recognized in promotion criteria.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;The entries above were written using Roo Code with Qwen 3 Coder; overall it was relatively slow and consumed quite a lot of requests. Next, I&amp;rsquo;ll test Roo Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="writing-code-was-never-the-bottleneck"&gt;&lt;a href="https://ordep.dev/posts/writing-code-was-never-the-bottleneck" rel="noopener noreferrer"&gt;Writing code was never the bottleneck&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the claim that large language models (LLMs) have solved the core problem of software engineering. Writing code was never the real bottleneck; the most time-consuming activities have always been code review, knowledge transfer, testing, debugging, and team coordination—activities that demand critical thinking and shared understanding across the team.&lt;/p&gt;
&lt;p&gt;LLMs speed up code generation without speeding up verification to match, so they merely shift the bottleneck rather than removing it: code becomes easier to produce but harder to verify, and the team as a whole does not necessarily move faster. Understanding how the code works, finding bugs, and maintaining quality still take substantial effort, and auto-generated code is sometimes even harder to read and review. When code generation outpaces a team&amp;rsquo;s capacity to communicate, reviewers come under heavy pressure and quality easily suffers. The cost of writing code may drop, but the cost of building shared team understanding of the system does not—and that is the true bottleneck.&lt;/p&gt;
&lt;h2 id="building-tiny-ai-tools"&gt;&lt;a href="https://www.seangoedecke.com/building-tiny-ai-tools/" rel="noopener noreferrer"&gt;Building Tiny AI Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke highlights an overlooked area of AI application alongside agentic coding and mass-market AI products: building tiny, personalized tools to automate repetitive workflows. He distinguishes between &amp;ldquo;executive thought&amp;rdquo; (making strategic decisions) and &amp;ldquo;mechanical thought&amp;rdquo; (reading, analyzing, and summarizing information), noting that the latter can now be handed off to AI.&lt;/p&gt;
&lt;p&gt;He gives two examples: &lt;code&gt;gh-standup&lt;/code&gt;, a GitHub CLI extension that pulls commit history and feeds it through an AI prompt to generate a more useful standup report than manual review, and a GitHub Action that aggregates individual engineers&amp;rsquo; updates into a weekly team summary, saving significant time even though it only serves his own company. Tools like these are too niche to sell commercially yet carry high internal value; the clearest sign is that when they break, coworkers immediately speak up. The author believes that as models continue to improve, this kind of automation will become more widespread, and software engineers are best positioned to build them for their own teams.&lt;/p&gt;
&lt;h2 id="modern-git-commands-and-features-you-should-be-using"&gt;&lt;a href="https://martinheinz.dev/blog/109" rel="noopener noreferrer"&gt;Modern Git Commands and Features You Should Be Using&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Most of us use Git every day yet stick to &lt;code&gt;add&lt;/code&gt;, &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; as if it were still 2005. Martin Heinz introduces more modern commands: &lt;code&gt;git switch&lt;/code&gt; (Git 2.23) replaces &lt;code&gt;git checkout&lt;/code&gt; for switching branches, adding safety checks to prevent data loss and conveniences like &lt;code&gt;git switch -&lt;/code&gt; to jump back to the previous branch; &lt;code&gt;git restore&lt;/code&gt; consolidates file-restoration tasks previously scattered across &lt;code&gt;reset&lt;/code&gt; and &lt;code&gt;checkout&lt;/code&gt; with clearer syntax; &lt;code&gt;git sparse-checkout&lt;/code&gt; (Git 2.25) populates only the needed directories in the working tree of a large monorepo, and when combined with partial clone also reduces downloaded data; &lt;code&gt;git worktree&lt;/code&gt; lets you check out multiple branches simultaneously in separate directories without stashing or cloning again; and &lt;code&gt;git bisect&lt;/code&gt; uses binary search to pinpoint the commit that introduced a bug.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch other-branch
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch - &lt;span class="c1"&gt;# Switch back to the previous branch&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch remote-branch &lt;span class="c1"&gt;# Switch to a remote branch with automatic tracking&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;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage and discard working tree changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged --worktree some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Restore a file to a specific commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --source HEAD~2 some-file.py
&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;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git clone --no-checkout https://github.com/example/monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout init --cone
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git checkout main &lt;span class="c1"&gt;# Only checks out files in the root directory&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout &lt;span class="nb"&gt;set&lt;/span&gt; service/common &lt;span class="c1"&gt;# Only pulls the needed directory&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;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree add ../hotfix master &lt;span class="c1"&gt;# Create a new worktree from master&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ../hotfix &lt;span class="c1"&gt;# Work independently&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree list &lt;span class="c1"&gt;# List active worktrees&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-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect start
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect bad HEAD &lt;span class="c1"&gt;# Current commit is broken&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good abc123 &lt;span class="c1"&gt;# Last known good commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Git automatically checks out the midpoint commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good/bad &lt;span class="c1"&gt;# Test and mark the result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect reset &lt;span class="c1"&gt;# Return to the original commit&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;p&gt;The takeaway is that when you run into a Git problem, consult the latest official documentation rather than relying on old StackOverflow answers—Git has evolved considerably, and there is likely already a simpler, safer way to solve your problem.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing, I noticed Kimi K2 consistently responds faster than Qwen 3 Coder whether using Cline or Roo Code, and Roo Code makes more requests than Cline, though my satisfaction with the output is roughly the same. Since OpenRouter&amp;rsquo;s rate limit is based on request count rather than total tokens, I&amp;rsquo;ll probably stick with Cline + Kimi K2 as a fallback whenever Claude Code hits its quota.&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #37</title><link>https://miti99.com/en/post/2025/07/26/</link><pubDate>Sat, 26 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #37.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="i-think-it"&gt;&lt;a href="https://maych.in/blog/its-time-to-give-nix-a-chance/" rel="noopener noreferrer"&gt;I Think It&amp;rsquo;s Time to Give Nix a Chance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chinmay D. Pai makes the case that Nix deserves a closer look from everyday developers. Unlike traditional package managers that install everything into shared global directories, Nix stores each package inside an immutable &lt;code&gt;/nix/store&lt;/code&gt; path prefixed with a cryptographic hash of all its build inputs. That allows multiple versions of the same software to coexist without conflict, each carrying its own complete dependency tree. Nix flakes pin dependencies so environments can be reproduced reliably across machines, even if they don&amp;rsquo;t guarantee bit-for-bit identical builds in every case. You can also try out tools without installing them permanently via &lt;code&gt;nix shell&lt;/code&gt; or &lt;code&gt;nix run&lt;/code&gt;, while the immutable store and non-standard filesystem layout neutralize several common Linux attack vectors.&lt;/p&gt;
&lt;p&gt;Pai is equally candid about the downsides: learning a bespoke functional language, deciphering cryptic error messages, understanding Nix&amp;rsquo;s evaluation model to debug issues, wrestling with software that hardcodes standard Linux paths, high disk usage, and fragmented documentation. To get started without drowning, he recommends installing via the Determinate Systems Installer, experimenting with &lt;code&gt;nix shell&lt;/code&gt;, and then setting up a simple project dev shell. Nix pays off most for teams plagued by &amp;ldquo;works on my machine&amp;rdquo; drift, painful onboarding, cross-platform builds, or strict compliance requirements—while small projects with stable dependencies probably don&amp;rsquo;t need it yet.&lt;/p&gt;
&lt;h2 id="you-can-choose-tools-that-make-you-happy"&gt;&lt;a href="https://borretti.me/article/you-can-choose-tools-that-make-you-happy" rel="noopener noreferrer"&gt;You Can Choose Tools That Make You Happy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fernando Borretti argues that programmers&amp;rsquo; technology choices are driven largely by emotion rather than the pure engineering rationality we claim. People pick tools that match an aesthetic and a desired self-image: using Emacs because it feels intellectually elite, or running NetBSD because it fits a cyberpunk persona. Afterward, we construct technical rationalizations to disguise the real motive—downplaying glaring flaws in niche tools (&amp;ldquo;sure, I had to write my own HTTP server&amp;rdquo;), inventing dubious advantages, or lobbing vague criticisms at mainstream options like &amp;ldquo;Docker is too complex&amp;rdquo; or &amp;ldquo;C++ builds character, whereas Rust makes you soft.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Borretti has no problem with emotional tool choices as long as you don&amp;rsquo;t lie to yourself or others. If you pick something for its aesthetic or identity, lean into it honestly and intentionally; just don&amp;rsquo;t claim SNOBOL has a bright commercial future, or tell your manager the decision came from a sober cost-benefit analysis. The core message: you are allowed to choose tools that make you happy—just be honest about why. He also cautions that passion still needs a reality check, because extreme choices divorced from reason can sink years into dead-end paths.&lt;/p&gt;
&lt;h2 id="the-copilot-delusion"&gt;&lt;del&gt;&lt;a href="https://deplet.ing/the-copilot-delusion/" rel="noopener noreferrer"&gt;The Copilot Delusion&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post delivers a sharp critique of AI coding assistants like GitHub Copilot and their negative impact on software development. The author argues that these tools generate code without any real understanding of system architecture or deep technical trade-offs.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The core concern is that relying on AI erodes developers&amp;rsquo; critical thinking and ability to learn. When we &amp;ldquo;outsource our thinking to AI,&amp;rdquo; we also &amp;ldquo;outsource our learning&amp;rdquo; to it. These tools lack intuition for hardware performance, memory management, and low-level optimization—key ingredients of high-quality software engineering.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author worries about the cultural shift across the industry, warning it could produce a generation of developers who prioritize fast output over quality, threatening the &amp;ldquo;hacker spirit&amp;rdquo; and deep technical curiosity. The risk is a wave of developers who think they are skilled simply because their bot got CI to pass, while lacking foundational understanding.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Main concerns:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- AI generates code without understanding system architecture&lt;/del&gt;
&lt;del&gt;- Erosion of developers&amp;rsquo; critical thinking skills&lt;/del&gt;
&lt;del&gt;- Lack of intuition around performance and optimization&lt;/del&gt;
&lt;del&gt;- Risk of creating a generation of developers who are only &amp;ldquo;good on paper&amp;rdquo;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="why-cline-doesn"&gt;&lt;a href="https://cline.bot/blog/why-cline-doesnt-index-your-codebase-and-why-thats-a-good-thing" rel="noopener noreferrer"&gt;Why Cline Doesn&amp;rsquo;t Index Your Codebase (And Why That&amp;rsquo;s a Good Thing)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this May 2025 post, the Cline team explains why they deliberately avoid vector-indexing your codebase and why direct exploration fits their agent better. First, code doesn&amp;rsquo;t work in isolated fragments: chopping it into small chunks breaks interconnected logic, like trying to understand a symphony from random ten-second clips, especially since source code lacks the clean paragraph boundaries of prose. Second, indexes go stale fast as code is refactored and updated; an outdated snapshot can lead an AI to suggest functions that no longer exist or miss recent architectural shifts. Third, generating vector embeddings creates a secondary copy of your intellectual property, bringing extra storage and security risk.&lt;/p&gt;
&lt;p&gt;Instead, Cline navigates a repository the way an experienced engineer does: systematically following imports and call chains. When modifying a payment handler, for instance, Cline traces imports to locate custom error utilities, inspects sibling functions to pick up local conventions, and checks call sites—building contextual understanding rather than doing fuzzy pattern matching. That workflow is now practical thanks to the huge context windows of modern frontier models, shifting the bottleneck from raw retrieval volume to context quality: prioritizing comprehension over retrieval.&lt;/p&gt;
&lt;h2 id="the-perfect-commit"&gt;&lt;a href="https://simonwillison.net/2022/Oct/29/the-perfect-commit/" rel="noopener noreferrer"&gt;The Perfect Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he organizes his work around the idea of the &amp;ldquo;perfect commit,&amp;rdquo; treating each commit as a carefully packaged unit of work rather than a rough save point. A perfect commit bundles four things: an implementation focused on a single change, tests proving it works, updated documentation, and a link to an issue thread with the surrounding context. In his view, tests boost long-term velocity by letting you change code confidently without regressions, so every project should start with at least one passing test. Documentation—whether for a Python module, a web service, or a CLI tool—belongs right inside the repository so it stays in sync with the code, is versioned alongside it, and gets reviewed in the same diff.&lt;/p&gt;
&lt;p&gt;Rather than writing long commit messages, Willison puts rich context into GitHub issues, which are easier to search, support pasted screenshots, and can be updated later. He acknowledges this goes against traditional Git orthodoxy, but finds it much more effective in practice. Not every commit needs all four elements: tiny bug fixes or doc typo corrections can skip the ceremony. For messy exploratory work, use a separate branch with rough commits and squash-merge a single clean commit into &lt;code&gt;main&lt;/code&gt;. To make the habit effortless, he uses cookiecutter templates that pre-configure test harnesses and GitHub Actions from day one, as seen across open-source projects like Datasette and &lt;code&gt;sqlite-utils&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-software-engineering-kanagawa-moment"&gt;&lt;a href="https://pashabitz.substack.com/p/the-software-engineering-kawagara" rel="noopener noreferrer"&gt;The Software Engineering Kanagawa Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pasha uses Hokusai&amp;rsquo;s woodblock print &amp;ldquo;The Great Wave off Kanagawa&amp;rdquo; as a metaphor for the wave of AI automation reshaping software engineering. In his view, programming is uniquely exposed to automation because abundant training data exists, outputs can be verified objectively, and the field faces none of the regulatory barriers that protect professions like medicine or law. Coding agents have already moved well past autocomplete, turning ticket descriptions into complete pull requests, while junior developer hiring has noticeably cooled. Well-bounded, self-contained tasks like refactoring and test writing are being automated first.&lt;/p&gt;
&lt;p&gt;What remains for humans is understanding business needs, shaping product design, setting up technical scaffolding, and defining coding conventions—though the author admits even that boundary is fragile as language models keep improving. His advice for engineers at every level is to adopt coding agents actively, audit workflows for automation opportunities, and sharpen product and business judgment; junior developers in particular should practice shipping end-to-end products, learn deployment infrastructure, and study how real production systems are built rather than just following tutorials. His conclusion is blunt: the wave cannot be stopped, and much like agricultural mechanization shifted labor out of farming, it could displace millions of coding jobs.&lt;/p&gt;
&lt;h2 id="websockets-guarantee-order---so-why-are-my-messages-scrambled"&gt;&lt;a href="https://www.sitongpeng.com/writing/websockets-guarantee-order-so-why-are-my-messages-scrambled" rel="noopener noreferrer"&gt;WebSockets guarantee order - so why are my messages scrambled?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sitong Peng recounts an interesting debugging mystery: WebSocket messages were showing up out of order in her logs, even though WebSockets run over TCP, which guarantees in-order delivery. The culprit wasn&amp;rsquo;t the network protocol, but the application layer. The message event handler called &lt;code&gt;await blob.arrayBuffer()&lt;/code&gt;, suspending execution while each message payload was processed; because processing took anywhere from 1 to 5 seconds per message, a smaller message that arrived later could finish before an earlier, slower one. TCP delivered the frames in exact order—the async handler scrambled them afterward.&lt;/p&gt;
&lt;p&gt;Peng walks through two fixes. The first buffers incoming messages in a queue and processes them in batches of five with &lt;code&gt;Promise.all&lt;/code&gt;, preserving order across results while still allowing parallelism within each batch. The second uses an async generator to process messages strictly one at a time—slower since there is no concurrency, but guaranteeing total ordering when application logic requires it. The broader lesson is how tricky it is to debug across multiple abstraction layers: even when the transport layer guarantees reliability and ordering, careless concurrency in application code can undo it, so you have to separate what each layer actually promises.&lt;/p&gt;
&lt;h2 id="why-agents-are-bad-pair-programmers"&gt;&lt;a href="https://justin.searls.co/posts/why-agents-are-bad-pair-programmers/" rel="noopener noreferrer"&gt;Why agents are bad pair programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Searls argues that AI coding agents make terrible pair programmers because they &amp;ldquo;write code faster than humans can think.&amp;rdquo; That speed breaks the collaborative loop: the human partner can&amp;rsquo;t keep up, tunes out, and loses track of how the system works. It feels like pairing with someone who grabs the keyboard and types in silence at superhuman speed. When the agent inevitably hits a wall, the human lacks the mental context from earlier decisions needed to bail it out; worse, the agent may have solved the wrong problem entirely, leaving behind a pile of accidental complexity to clean up.&lt;/p&gt;
&lt;p&gt;Searls suggests two paths forward. First, move agents into an asynchronous workflow: hand them self-contained tasks and review the output via pull requests, like GitHub&amp;rsquo;s Coding Agent. Second, slow things down when working synchronously by using &amp;ldquo;Edit&amp;rdquo; or &amp;ldquo;Ask&amp;rdquo; modes instead of fully autonomous &amp;ldquo;Agent&amp;rdquo; mode; ping-pong pairing in Edit mode, where you review and approve each step, strikes the best balance. He also urges toolmakers to add adjustable generation speed, pause-and-ask checkpoints, UIs that reflect workflow state like GitHub integration and to-do lists, less overconfident agent personas that check in more often, and voice chat. Those changes would turn agents into genuine collaborators rather than lone sprinters.&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 #26</title><link>https://miti99.com/en/post/2025/05/13/</link><pubDate>Tue, 13 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #26.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-philosophy-of-software-design--with-john-ousterhout"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-philosophy-of-software-design" rel="noopener noreferrer"&gt;The Philosophy of Software Design – with John Ousterhout&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt; podcast, Stanford professor John Ousterhout (author of &lt;em&gt;A Philosophy of Software Design&lt;/em&gt;) explains why software design matters even more in the age of AI. He compares today&amp;rsquo;s AI code-generation tools to a &amp;ldquo;tactical tornado&amp;rdquo;: they crank out working code at breakneck speed while easily leaving behind a trail of technical debt, meaning high-level architectural thinking remains firmly a human responsibility. At its core, Ousterhout says, software design is the art of decomposition—breaking a complex system into relatively independent modules. He also advocates the principle of &amp;ldquo;design it twice&amp;rdquo;: always force yourself to consider at least two genuinely different approaches before committing, because your second design is almost always better than your first.&lt;/p&gt;
&lt;p&gt;Ousterhout famously disagrees with several tenets of Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; school. He argues that strict TDD encourages developers to fixate on narrow tactical details rather than overall system architecture (though he likes writing tests first when fixing bugs), that splitting code into tiny methods proliferates shallow interfaces instead of the &amp;ldquo;deep modules&amp;rdquo; (simple interfaces hiding rich functionality) we should aim for, and that code comments are essential for capturing abstractions and field invariants that code alone cannot express. At Stanford, he teaches software design through intensive code reviews and comparing student solutions side by side, much like a creative writing workshop. He is currently contributing an implementation of the Homa transport protocol to the Linux kernel. It&amp;rsquo;s a must-listen episode for junior developers.&lt;/p&gt;
&lt;h2 id="20-years-of-git-still-weird-still-wonderful"&gt;&lt;a href="https://blog.gitbutler.com/20-years-of-git" rel="noopener noreferrer"&gt;20 years of Git. Still weird, still wonderful&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marking Git&amp;rsquo;s 20th anniversary, Scott Chacon (co-founder of GitHub and GitButler) looks back on the history of the tool. In April 2005, Linus Torvalds created Git as &amp;ldquo;the stupid content tracker&amp;rdquo; to replace BitKeeper and improve how the Linux kernel community collaborated via patches and tarballs. The very first commit contained just seven low-level C programs like &lt;code&gt;write-tree&lt;/code&gt; and &lt;code&gt;commit-tree&lt;/code&gt;, with zero concern for user-friendliness. Early on, Git was almost entirely low-level &amp;ldquo;plumbing,&amp;rdquo; while usable &amp;ldquo;porcelain&amp;rdquo; interfaces came from community shell-script wrappers like Cogito. Many familiar commands emerged organically: the original &lt;code&gt;git log&lt;/code&gt; was literally a three-line shell script piping &lt;code&gt;git-rev-list&lt;/code&gt; into &lt;code&gt;LESS&lt;/code&gt;, and &lt;code&gt;git rebase&lt;/code&gt; grew out of mailing-list discussions between Junio Hamano and Linus about patch workflows in 2005.&lt;/p&gt;
&lt;p&gt;Chacon also shares his personal journey: he originally used Git as a content distribution system for digital signage displays—matching Linus&amp;rsquo;s original &amp;ldquo;content tracker&amp;rdquo; philosophy—before writing the &lt;em&gt;Pro Git&lt;/em&gt; book and co-founding GitHub. In a fun bit of trivia, Git&amp;rsquo;s &amp;ldquo;octopus merge&amp;rdquo; strategy directly inspired GitHub&amp;rsquo;s Octocat mascot. Twenty years later, Git dominates software development while remaining as &amp;ldquo;weird and wonderful&amp;rdquo; as ever: an eccentric command-line UI sitting on top of a remarkably elegant data model.&lt;/p&gt;
&lt;h2 id="a-modest-critique-of-optional-handling"&gt;&lt;a href="https://mccue.dev/pages//4-5-25-optional-critique" rel="noopener noreferrer"&gt;A Modest Critique of Optional Handling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan McCue critiques how many Java developers misuse &lt;code&gt;java.util.Optional&lt;/code&gt; when refactoring methods that previously returned &lt;code&gt;null&lt;/code&gt;. In his view, &lt;code&gt;Optional&lt;/code&gt; shines in Stream pipelines and API return types, not as a wholesale replacement for &lt;code&gt;null&lt;/code&gt; inside method bodies. The conventional wisdom to avoid &lt;code&gt;.isPresent()&lt;/code&gt;/&lt;code&gt;.get()&lt;/code&gt; in favor of &lt;code&gt;.map()&lt;/code&gt; or &lt;code&gt;.ifPresent()&lt;/code&gt; quickly falls apart when you need to throw checked exceptions, combine multiple &lt;code&gt;Optional&lt;/code&gt; values, or mutate local variables inside a lambda; nesting &lt;code&gt;.ifPresent()&lt;/code&gt; calls also pushes code into deeply indented arrow anti-patterns.&lt;/p&gt;
&lt;p&gt;McCue&amp;rsquo;s proposed alternative is refreshingly simple: unwrap the &lt;code&gt;Optional&lt;/code&gt; immediately into a nullable local variable using &lt;code&gt;.orElse(null)&lt;/code&gt; and handle it with standard &lt;code&gt;if (x != null)&lt;/code&gt; control flow. Static analysis tools and IDEs already excel at tracking nullability on local variables, checked exceptions work naturally inside regular &lt;code&gt;if&lt;/code&gt; blocks, and the method signature still explicitly forces callers to confront the possibility of a missing value. Backed by concrete before-and-after refactorings, the post is a great reminder for junior developers to favor clear, maintainable code over dogmatically following &amp;ldquo;never call &lt;code&gt;.get()&lt;/code&gt;&amp;rdquo; lint rules.&lt;/p&gt;
&lt;h2 id="project-loom-structured-concurrency-in-java"&gt;&lt;a href="https://rockthejvm.com/articles/structured-concurrency-in-java" rel="noopener noreferrer"&gt;Project Loom: Structured Concurrency in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Riccardo Cardin at Rock the JVM provides a deep-dive tutorial on structured concurrency—part of Project Loom—running on Java 23 with &lt;code&gt;--enable-preview&lt;/code&gt;. He starts by showing the flaw in traditional unstructured concurrency with &lt;code&gt;ExecutorService&lt;/code&gt;: when a parent task fails or times out, child tasks can keep running in the background, leaking threads and wasting resources. Structured concurrency fixes this by enforcing the principle that the syntactic block structure of your code mirrors the runtime lifetime of its concurrent subtasks—meaning every child thread is guaranteed to finish before execution exits the enclosing lexical scope.&lt;/p&gt;
&lt;p&gt;At the center of the API is &lt;code&gt;StructuredTaskScope&lt;/code&gt;, which implements &lt;code&gt;AutoCloseable&lt;/code&gt; for &lt;code&gt;try-with-resources&lt;/code&gt; blocks and provides &lt;code&gt;fork()&lt;/code&gt; to spawn subtasks on virtual threads, &lt;code&gt;join()&lt;/code&gt; to await completion according to the scope&amp;rsquo;s policy, and &lt;code&gt;shutdown()&lt;/code&gt; to request cancellation of remaining subtasks. Cancellation is cooperative, and closing the scope still waits for all forked threads to terminate cleanly. Cardin illustrates this with a GitHub API client that fetches user profiles and repositories in parallel using the built-in &lt;code&gt;ShutdownOnFailure&lt;/code&gt; and &lt;code&gt;ShutdownOnSuccess&lt;/code&gt; policies. From there, he shows how to build custom policies by subclassing &lt;code&gt;StructuredTaskScope&lt;/code&gt; and overriding &lt;code&gt;handleComplete()&lt;/code&gt;, implementing functional helpers like &lt;code&gt;par()&lt;/code&gt;, &lt;code&gt;race()&lt;/code&gt;, &lt;code&gt;timeout()&lt;/code&gt;, and nested parent-child task trees. It is an excellent hands-on guide to writing safer, easier-to-reason-about concurrent code in modern Java.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://mccue.dev/pages/4-5-25-go-http-server" rel="noopener noreferrer"&gt;Go&amp;rsquo;s HTTP Server Patterns in Java 25&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan McCue demonstrates that modern Java can build HTTP servers in a lightweight, Go-like style by walking through a simple file-backed wiki web app written in Java 25. The application supports creating, viewing, and editing wiki pages stored as plain text files on disk. Its foundation is the JDK&amp;rsquo;s built-in &lt;code&gt;jdk.httpserver&lt;/code&gt; module, paired with McCue&amp;rsquo;s small &lt;code&gt;dev.mccue.jdk.httpserver&lt;/code&gt; helper library (which adds a clean &lt;code&gt;Body&lt;/code&gt; abstraction for writing responses), JMustache for HTML templating, and &lt;code&gt;dev.mccue.urlparameters&lt;/code&gt; for parsing form submissions.&lt;/p&gt;
&lt;p&gt;He models wiki entries with a &lt;code&gt;Page&lt;/code&gt; record exposing &lt;code&gt;save()&lt;/code&gt; and &lt;code&gt;load()&lt;/code&gt; methods, wires up dedicated request handlers for viewing, editing, and saving pages, and returns HTTP 302 redirects when users visit a nonexistent page. The walkthrough proves that with just the standard library and a few tiny, composable dependencies, you can build a clean web application in Java without reaching for a heavyweight framework. For high-traffic production workloads, he still suggests considering battle-tested servers like Jetty—while noting an important distinction in the JDK docs: the &amp;ldquo;testing, development, and debugging only&amp;rdquo; caveat applies specifically to &lt;code&gt;SimpleFileServer&lt;/code&gt; and the &lt;code&gt;jwebserver&lt;/code&gt; CLI tool, not to the underlying &lt;code&gt;jdk.httpserver&lt;/code&gt; HTTP/HTTPS API itself.&lt;/p&gt;
&lt;h2 id="java-is-dying-and-it-paid-off-my-mortgage"&gt;&lt;a href="https://alyosha.net/posts/java-is-dying-and-it-paid-off-my-mortgage/" rel="noopener noreferrer"&gt;Java is dying and it paid off my mortgage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alyosha looks back on the career anxiety they felt as a junior developer specializing in Java. On Hacker News and YouTube, Java was practically invisible compared to JavaScript and the latest hyped frameworks, making the author worry they were betting their career on a dying language. Once they actually entered the job market, however, they found the exact opposite: Java roles consistently led in pay, benefits, and stability, driven by profitable enterprises quietly running their core systems on the JVM.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, Java is in the sweet spot of a mature technology: nobody talks about it on social media, yet it powers massive economic value—and precisely because it is viewed as &amp;ldquo;uncool,&amp;rdquo; fewer new developers flock to it, keeping compensation high for those who know it well. Java skills bought the author&amp;rsquo;s house and paid off the mortgage. The lesson for junior developers: online hype does not reflect real-world hiring demand, and mastering a boring, rock-solid foundation often builds a far more lucrative and stable career than chasing the trend of the week.&lt;/p&gt;
&lt;h2 id="localhost-domains"&gt;&lt;a href="https://inclouds.space/localhost-domains" rel="noopener noreferrer"&gt;.localhost domains&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Chamberlain shares how he escaped having to memorize arbitrary port numbers like &lt;code&gt;localhost:4333&lt;/code&gt; or &lt;code&gt;localhost:5050&lt;/code&gt; when running multiple web apps locally. Instead, he gives each local project a memorable &lt;code&gt;.localhost&lt;/code&gt; domain such as &lt;code&gt;inclouds.localhost&lt;/code&gt;. His macOS setup has three moving parts: running each web app as a background service via &lt;code&gt;launchd&lt;/code&gt; listening on its own port; adding an entry in &lt;code&gt;/etc/hosts&lt;/code&gt; pointing the &lt;code&gt;.localhost&lt;/code&gt; domain to &lt;code&gt;127.0.0.1&lt;/code&gt;; and running Caddy as a local reverse proxy that routes each domain to its port while automatically handling internal TLS certificates and &lt;code&gt;gzip&lt;/code&gt;/&lt;code&gt;zstd&lt;/code&gt; compression. Here is the minimal config for an app running on port 5050:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;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;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&lt;/span&gt;&lt;span class="lnt"&gt;9
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# /etc/hosts&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;127.0.0.1 inclouds.localhost
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Caddyfile&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;inclouds.localhost &lt;span class="o"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; reverse_proxy localhost:5050
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; tls internal
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; encode gzip zstd
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="o"&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;p&gt;Chamberlain admits that manually editing multiple system files is still a bit clunky and hopes to wrap the whole workflow into a single install/uninstall CLI command; a reader also pointed out that &lt;code&gt;dnsmasq&lt;/code&gt; can eliminate the manual &lt;code&gt;/etc/hosts&lt;/code&gt; edits. It&amp;rsquo;s a neat quality-of-life trick for keeping your local development environment organized when juggling several projects at once.&lt;/p&gt;
&lt;h2 id="ai-50-ai-agents-move-beyond-chat"&gt;&lt;a href="https://sequoiacap.com/article/ai-50-2025/" rel="noopener noreferrer"&gt;AI 50: AI Agents Move Beyond Chat&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://sequoiacap.com/wp-content/uploads/sites/6/2025/04/ai-50-2025.png" alt=""&gt;&lt;/p&gt;
&lt;p&gt;Konstantine Buhler at Sequoia Capital analyzes the firm&amp;rsquo;s 2025 AI 50 list and highlights a major shift: AI is moving from answering questions in a chat box to autonomously completing end-to-end work. Powered by agentic workflows and reasoning models, the companies on this year&amp;rsquo;s list don&amp;rsquo;t just handle isolated prompts—they own entire business workflows, turning AI into an &amp;ldquo;engine of action&amp;rdquo; inside the enterprise. Standout examples include Harvey handling end-to-end legal workflows from document review and drafting to case analysis, Sierra automating customer service resolution, and Cursor generating complete software features from natural-language specs.&lt;/p&gt;
&lt;p&gt;The piece also spotlights the rise of physical robotics, where transformer models meet hardware: Figure AI is building humanoid robots powered by its new Helix model, while Skild AI is developing a shared foundation model for general-purpose robotics—a market Nvidia estimates at $50 trillion. Buhler views 2025 as the inflection point where AI agents began taking on high-value enterprise work, and predicts that by 2026 consumer AI agents will take off in earnest, automatically managing calendars, booking travel, and organizing files as enterprise breakthroughs trickle into everyday life.&lt;/p&gt;
&lt;h2 id="interesting-images-from-bytebytego"&gt;Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/65279cf0-3266-445d-852b-a45d6ac9afa4_2250x2862.png" alt="A Cheatsheet On OOP Design Patterns"&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 #20</title><link>https://miti99.com/en/post/2025/05/07/</link><pubDate>Wed, 07 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #20.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="performance-improvements-in-jdk-24"&gt;&lt;a href="https://inside.java/2025/03/19/performance-improvements-in-jdk24/" rel="noopener noreferrer"&gt;Performance Improvements in JDK 24&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Inside.java article rounds up the most notable performance improvements in JDK 24 over JDK 23, organized by JDK bug tracker issue. In the core libraries, bulk operations in the Foreign Function &amp;amp; Memory API such as &lt;code&gt;MemorySegment::fill&lt;/code&gt;, &lt;code&gt;copy&lt;/code&gt;, and &lt;code&gt;mismatch&lt;/code&gt; are now handled in pure Java when memory segments are small enough, avoiding the overhead of transitioning to native code via &lt;code&gt;Unsafe&lt;/code&gt;. String concatenation now uses cacheable, reusable hidden classes instead of constructing chains of intermediate &lt;code&gt;MethodHandle&lt;/code&gt; combinators; SHA3 digests are up to 27% faster by reducing conversions between &lt;code&gt;byte&lt;/code&gt; and &lt;code&gt;long&lt;/code&gt; arrays; and internal migrations to the new Class-File API have been tuned to minimize startup overhead.&lt;/p&gt;
&lt;p&gt;At the runtime layer, JEP 491 allows virtual threads blocked inside a &lt;code&gt;synchronized&lt;/code&gt; block to unmount from their carrier thread rather than pinning it, significantly improving scalability for code that uses &lt;code&gt;synchronized&lt;/code&gt;. &lt;code&gt;String::indexOf&lt;/code&gt; is roughly 1.3x faster on x64 platforms with AVX2. JEP 483 (Ahead-of-Time Class Loading &amp;amp; Linking), the first deliverable from Project Leyden, uses an AOT cache to cut startup time by around 42% in the article&amp;rsquo;s benchmark. JEP 450 introduces experimental 8-byte compact object headers, reducing memory footprint by 10–20% on typical workloads. Finally, the RISC-V port gained several new intrinsics including CRC32, Adler32, string comparison optimizations, and byte-reversal operations.&lt;/p&gt;
&lt;h2 id="clean-your-memory-from-finalize-to-cleaner"&gt;&lt;a href="https://blog.frankel.ch/java-cleaner/" rel="noopener noreferrer"&gt;Clean your Memory: From Finalize to Cleaner&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago explains that Java&amp;rsquo;s garbage collector (GC) only manages heap memory and does not automatically release external resources like sockets or file handles; mismanaging them can lead to resource leaks, gradual slowdowns, or crashes. The old approach was overriding &lt;code&gt;finalize()&lt;/code&gt;, which has been deprecated because its execution timing is unpredictable, objects require at least one extra GC cycle to be reclaimed, accidental object resurrection can cause leaks, and the dedicated Finalizer thread is prone to contention. Its replacement is the &lt;code&gt;Cleaner&lt;/code&gt; API, introduced in Java 9: under the hood, it uses &lt;code&gt;PhantomReference&lt;/code&gt; and a background daemon thread while hiding the complexity of raw reference queues. You register an object alongside a cleanup action, and once the object becomes phantom-reachable, that action is enqueued to run on the background thread.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Cleaner&lt;/code&gt; pairs well with &lt;code&gt;AutoCloseable&lt;/code&gt;: the &lt;code&gt;close()&lt;/code&gt; method invokes &lt;code&gt;clean()&lt;/code&gt; for immediate deterministic cleanup, while the &lt;code&gt;Cleaner&lt;/code&gt; acts as a safety net. Even so, Fago stresses that &lt;code&gt;Cleaner&lt;/code&gt; should only be a fallback when resources cannot be released via &lt;code&gt;try-with-resources&lt;/code&gt; or an explicit &lt;code&gt;close()&lt;/code&gt; call, since cleanup is asynchronous and carries background-thread overhead. When writing a cleanup action, avoid lambdas that capture fields through &lt;code&gt;this&lt;/code&gt;, as doing so accidentally keeps a strong reference to the very object you want collected; cleanup logic should also be short and non-blocking, since multiple actions may share the same &lt;code&gt;Cleaner&lt;/code&gt; thread pool.&lt;/p&gt;
&lt;h2 id="5-hidden-git-tips-for-java-developers"&gt;&lt;a href="https://www.azul.com/blog/5-hidden-git-tips-for-java-developers/" rel="noopener noreferrer"&gt;5 Hidden Git Tips for Java Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On the Azul blog, Luqman Saeed walks through five underappreciated Git features beyond the everyday &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; trio, with examples tailored to Java projects. First is &lt;code&gt;git bisect&lt;/code&gt;: when you don&amp;rsquo;t know which commit introduced a bug, you mark the current commit as bad (&lt;code&gt;git bisect bad&lt;/code&gt;) and an older working commit as good (&lt;code&gt;git bisect good &amp;lt;commit-hash&amp;gt;&lt;/code&gt;), and Git performs a binary search by checking out midpoint commits for you to test until the culprit is found, finishing with &lt;code&gt;git bisect reset&lt;/code&gt;. Next, &lt;code&gt;git blame &amp;lt;file&amp;gt;&lt;/code&gt; shows who last modified each line and when (pass &lt;code&gt;-L 50,60&lt;/code&gt; to inspect a specific line range), giving you helpful context before debugging or refactoring. When you need to switch tasks mid-flight, &lt;code&gt;git stash&lt;/code&gt; shelves uncommitted changes and &lt;code&gt;git stash pop&lt;/code&gt; restores them; &lt;code&gt;git stash list&lt;/code&gt; and &lt;code&gt;git stash apply &amp;lt;stash-id&amp;gt;&lt;/code&gt; let you manage multiple stashes.&lt;/p&gt;
&lt;p&gt;For temporary build artifacts generated by Maven or Gradle like &lt;code&gt;.class&lt;/code&gt; files or the &lt;code&gt;target/&lt;/code&gt; directory, &lt;code&gt;git clean -n&lt;/code&gt; previews what would be deleted, &lt;code&gt;-f&lt;/code&gt; removes untracked files, &lt;code&gt;-fd&lt;/code&gt; removes untracked directories as well, and &lt;code&gt;-x&lt;/code&gt; also deletes ignored files such as &lt;code&gt;.idea/&lt;/code&gt;. Finally, Git hooks are scripts that run automatically before or after events like commits, pushes, or merges—for example, a &lt;code&gt;pre-commit&lt;/code&gt; hook in &lt;code&gt;.git/hooks&lt;/code&gt; can run &lt;code&gt;mvn test&lt;/code&gt; and abort the commit if tests fail. As a bonus tip, &lt;code&gt;git checkout -&lt;/code&gt; jumps straight back to the previous branch you were working on without retyping its name, saving time and avoiding typos.&lt;/p&gt;
&lt;h2 id="simplify-your-system-by-challenging-the-status-quo-and-learning-from-other-ecosystems"&gt;&lt;a href="https://www.infoq.com/podcasts/simplify-system-learning-ecosystems/" rel="noopener noreferrer"&gt;Simplify Your System by Challenging the Status-Quo and Learning from Other Ecosystems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this InfoQ podcast, Max Rydahl Andersen—Distinguished Engineer at Red Hat and creator of JBang—recounts how taking a year away from Java helped him see upon returning that the ecosystem had accumulated too much accidental complexity, like &amp;ldquo;a thousand paper cuts&amp;rdquo;: each small feature is useful on its own, but together they become a burden. Quarkus, which he works on, flips traditional Java conventions by shifting most framework processing from runtime to build time, enabling near-instant startup. That speed unlocks a much better developer experience: live reload, continuous testing, Dev Services that automatically spin up containers like PostgreSQL or Kafka, and an interactive chat UI for testing AI services via LangChain4j right inside the Dev UI.&lt;/p&gt;
&lt;p&gt;With JBang, he drew inspiration from Python and Node.js to let developers run Java from a single source file—even downloading a JDK automatically if none is installed; he jokes that if you find any development environment easier to set up, that&amp;rsquo;s a bug in JBang. Andersen also argues that AI cannot replace core software engineering fundamentals and systems thinking, and warns that AI will accelerate CVE exploitation, meaning legacy systems will need much more frequent patching. The overarching takeaway: challenge the status quo and borrow good ideas from other ecosystems to keep systems simple.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/03/24/about-vibe-coding/" rel="noopener noreferrer"&gt;About &amp;ldquo;vibe coding&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea writes a brief reflection on &amp;ldquo;vibe coding&amp;rdquo;—the trend of letting AI write code in place of the developer. After reading &amp;ldquo;Vibe Coding vs Reality,&amp;rdquo; he was relieved to see he wasn&amp;rsquo;t the only skeptic, recounting his own attempt to use Cursor on a Java Maven project where the tool couldn&amp;rsquo;t even rename a class properly: first it renamed the class declaration without renaming the file, and when asked to fix it, it created an empty file with the new name—twice in a row.&lt;/p&gt;
&lt;p&gt;When he shared the experience on Hacker News, the replies were mostly along the lines of &amp;ldquo;haha Java,&amp;rdquo; leaving him wondering whether Cursor was only trained on trendy frontend frameworks or whether its vocal fans simply don&amp;rsquo;t care about real-world enterprise codebases. He ended up uninstalling Cursor and feeling even more skeptical of &amp;ldquo;magical&amp;rdquo; AI coding tools, though he leaves the door open: &amp;ldquo;Next year though? Next year we&amp;rsquo;ll see.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="visual-focused-algorithms-cheat-sheet"&gt;&lt;a href="https://photonlines.substack.com/p/visual-focused-algorithms-cheat-sheet" rel="noopener noreferrer"&gt;Visual-Focused Algorithms Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nick M compiles a visual-first cheat sheet of essential algorithms used in practice, following up on his earlier data structures cheat sheet; each algorithm is explained through everyday analogies and diagrams. The sorting section progresses from Selection Sort and Insertion Sort—simple but O(n²)—to Heap Sort and Merge Sort at O(n log n), Quick Sort with an O(n log n) average case and O(n²) worst case, and Tim Sort, the hybrid of Insertion Sort and Merge Sort used in Python and Java. Searching covers Binary Search at O(log n) alongside DFS and BFS for depth-first and breadth-first graph traversal. The graph section walks through Prim&amp;rsquo;s and Kruskal&amp;rsquo;s algorithms for minimum spanning trees, Dijkstra&amp;rsquo;s and Bellman-Ford for shortest paths (with Bellman-Ford handling negative edge weights), A* using heuristics, plus Union-Find and Ford-Fulkerson.&lt;/p&gt;
&lt;p&gt;Later sections cover string search, data compression and encoding (Huffman coding, LZ compression, Fourier transforms, JPEG compression), optimization (Simplex, Simulated Annealing), machine learning and data science, and security and cryptography algorithms. The post wraps up with coding interview resources like &amp;ldquo;14 Patterns to Ace Any Coding Interview&amp;rdquo; and &amp;ldquo;5 Simple Steps for Solving Dynamic Programming Problems,&amp;rdquo; making it a handy reference for junior developers preparing for interviews.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/81074d22-5821-4aec-bb2d-0a099d06b6ac_1600x840.png" alt="3 Steps to Master Your Software"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/67c39b9a-9a91-4e57-9e24-7714b4f806dd_1280x1349.gif" alt="The Ultimate Software Architect Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fb1b1cd1-eac3-4b66-a391-9ec73f6c37f3_1280x1502.gif" alt="How Two-factor Authentication (2FA) Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3efae3ad-8c45-4fb2-a79f-6b3387b0751e_1280x1601.gif" alt="How Amazon S3 Works?"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #18</title><link>https://miti99.com/en/post/2025/05/05/</link><pubDate>Mon, 05 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #18.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="no-longer-my-favorite-git-commit"&gt;&lt;a href="https://mtlynch.io/no-longer-my-favorite-git-commit/" rel="noopener noreferrer"&gt;No Longer My Favorite Git Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch revisits the commit famously praised by David Thompson in &amp;ldquo;My favourite Git commit&amp;rdquo;: a six-paragraph commit message with five code snippets that painstakingly narrates a debugging journey just to explain replacing a single whitespace character. Lynch acknowledges that the message is valuable for searchability and for showing how the author investigated the bug, but points out three flaws: the most important takeaway is buried at the very end, the root cause is never clearly explained, and references to external source code lack links or commit hashes so readers cannot reproduce the trail. Digging into it himself, Lynch discovered the culprit was a UTF-8 non-breaking space that had accidentally slipped into a &lt;code&gt;routes.conf.erb&lt;/code&gt; template while Ruby 1.9.3 defaulted to reading files as US-ASCII, causing the test suite to fail.&lt;/p&gt;
&lt;p&gt;From there, he rewrites the commit message using journalism&amp;rsquo;s &amp;ldquo;inverted pyramid&amp;rdquo; style: opening with a concise summary of the change, followed by the root cause and fix, and only then a &amp;ldquo;How I discovered this&amp;rdquo; section containing most of the original narrative, complete with a link to the commit that introduced the stray character. The lesson for junior developers: technical context is worth keeping, but structure your commit messages so anyone scanning the commit log immediately understands what changed and why.&lt;/p&gt;
&lt;h2 id="our-interfaces-have-lost-their-senses"&gt;&lt;a href="https://wattenberger.com/thoughts/our-interfaces-have-lost-their-senses" rel="noopener noreferrer"&gt;Our interfaces have lost their senses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amelia Wattenberger argues that digital interfaces have grown increasingly flat and sensory-deprived. Early computing was a full-body experience of punch cards, patch cables, and switches; then came command lines, graphical interfaces with skeuomorphic buttons, and finally touchscreens where everything sits behind a sheet of glass. With the wave of AI chatbots, we have lost even texture, color, and shape: whether editing a photo, tweaking settings, or learning a subject, everything is reduced to a single text input box. She notes that removing all friction also strips away meaning: doomscrolling social media is effortless, but kneading dough, playing an instrument, or sketching is what brings real satisfaction. In her words, we have turned painting into typing, when we should have made typing feel more like painting.&lt;/p&gt;
&lt;p&gt;Her proposed direction is designing interfaces that fit the human body: computers can respond through text, rich visuals, sound, and haptics, while humans can provide input via keyboards, drag-and-drop, touch gestures, body movement, and voice. The real power lies in combining multiple modalities at once, such as speaking while pointing and clicking. She envisions future interfaces where we collaborate on tangible artifacts rather than just chat histories, use multiple modalities simultaneously, and have tools respond to ambient context—illustrated by an experimental prototype that automatically organizes a user&amp;rsquo;s thoughts into visual cards as they speak or type.&lt;/p&gt;
&lt;h2 id="labeled-breaks-in-java-useful-tool-or-code-smell"&gt;&lt;a href="https://www.baeldung.com/java-labeled-break" rel="noopener noreferrer"&gt;Labeled Breaks in Java: Useful Tool or Code Smell?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Leo Helfferich&amp;rsquo;s article on Baeldung examines labeled &lt;code&gt;break&lt;/code&gt; and &lt;code&gt;continue&lt;/code&gt; statements in Java, a feature present since Java 1.0 and largely unchanged since. Unlike an unlabeled &lt;code&gt;break&lt;/code&gt;, which only exits the innermost loop, a labeled break jumps straight out of a named outer loop—for instance, &lt;code&gt;break outer;&lt;/code&gt; in the snippet below terminates both nested loops at once. The advantage is efficiency: when searching through nested collections, you can stop immediately upon finding a match without extra flag variables or auxiliary conditions, while explicitly controlling which loop terminates in deeply nested structures.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;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;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&lt;/span&gt;&lt;span class="lnt"&gt;9
&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="nl"&gt;outer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="c1"&gt;// &amp;lt;-- label&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="k"&gt;for&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&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;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="k"&gt;for&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&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;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;i&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="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;j&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="k"&gt;if&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;j&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;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&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;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="k"&gt;break&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;outer&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="c1"&gt;// exit the outer loop&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;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;span class="line"&gt;&lt;span class="cl"&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;p&gt;On the flip side, labels can easily make code read like &lt;code&gt;GOTO&lt;/code&gt; statements and confuse maintainers, especially with arbitrary label names like &lt;code&gt;x:&lt;/code&gt;; modifying a labeled loop in a large codebase can also subtly break dependent logic. The author suggests clearer alternatives such as extracting loop logic into a separate method or using the Stream API with &lt;code&gt;flatMap&lt;/code&gt; and &lt;code&gt;anyMatch&lt;/code&gt;. The post also compares Java&amp;rsquo;s syntax with Kotlin (&lt;code&gt;outer@&lt;/code&gt; and &lt;code&gt;break@outer&lt;/code&gt;) and JavaScript (nearly identical to Java), concluding that labeled breaks should remain a niche tool for rare, complex scenarios where they don&amp;rsquo;t hurt readability.&lt;/p&gt;
&lt;h2 id="distributed-locking-a-practical-guide"&gt;&lt;a href="https://www.architecture-weekly.com/p/distributed-locking-a-practical-guide" rel="noopener noreferrer"&gt;Distributed Locking: A Practical Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Oskar Dudycz explains distributed locking—the mechanism ensuring only one process operates on a shared resource at a time when an application runs across multiple machines or microservices. It is needed when multiple processes update the same record, when messages may be delivered more than once, or when scheduled jobs run across multiple nodes. The basic flow is simple: a node requests a lock from a lock manager, acquires it if free, performs its critical work, and releases it; if the node crashes, a TTL or ephemeral node automatically clears the lock to prevent &amp;ldquo;zombie&amp;rdquo; locks. Dudycz compares four common options: Redis with &lt;code&gt;SET ... NX EX&lt;/code&gt;, which is simple and fast but risky during network partitions; ZooKeeper/etcd, which offer strong consistency via quorum consensus at the cost of heavier operations; database locks like &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; or PostgreSQL advisory locks, which are convenient when you already have a single database but harder to scale; and running a single replica on Kubernetes, which avoids locking altogether but sacrifices scalability, high availability, and can still briefly run two pods during rollouts.&lt;/p&gt;
&lt;p&gt;The article also covers pitfalls like deadlocks, lock contention, single points of failure, clock skew, and network partitions. Crucially, a TTL only prevents a lock from staying stuck forever: an expired lock does not stop the original process from continuing its work, so you still have to account for long pauses or lost connections. His closing advice: avoid distributed locks if you can, use them sparingly since excessive locking kills parallelism, pick a tool that fits your existing infrastructure, and always plan for failures with time-bounded locks.&lt;/p&gt;
&lt;h2 id="if-it-is-worth-keeping-save-it-in-markdown"&gt;&lt;a href="https://p.migdal.pl/blog/2025/02/markdown-saves" rel="noopener noreferrer"&gt;If it is worth keeping, save it in Markdown&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Piotr Migdał opens with an uncomfortable truth: content posted online eventually disappears. Links rot when websites restructure, platforms shut down or lock posts behind logins and paywalls, and even self-hosted sites vanish due to forgotten domain renewals or botched database upgrades. The most durable solution, he argues, is UTF-8 plain text in Markdown format: any computer can read it without proprietary software, and Markdown&amp;rsquo;s deliberate lack of fine-grained styling control is actually a strength under the &amp;ldquo;rule of least power.&amp;rdquo; He uses Obsidian for personal notes and a static site generator for his blog—both store plain Markdown files, making sharing and platform migrations effortless.&lt;/p&gt;
&lt;p&gt;His workflow is pragmatic: whenever he comes across something worth keeping, he copies it into a Markdown file with YAML frontmatter recording the publication date, source, and tags; whenever he catches himself searching for something a second time, he saves it immediately, because anything worth looking up twice is worth keeping forever. His toolkit includes &lt;code&gt;pandoc&lt;/code&gt; for format conversion, specialized exporters for Medium or Reddit, AI for extracting text from PDFs, and Git for versioning and backups. He also periodically exports data archives from services he uses, even before converting them into Markdown.&lt;/p&gt;
&lt;h2 id="the-software-engineering-identity-crisis"&gt;&lt;a href="https://annievella.com/posts/the-software-engineering-identity-crisis/" rel="noopener noreferrer"&gt;The Software Engineering Identity Crisis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Vella examines the identity crisis facing software engineers in the age of AI. Many developers entered the field for the joy of building things with their own hands—tracking down an elusive bug or optimizing a slow algorithm—but AI coding assistants are turning them from creators into orchestrators, from builders into supervisors. The shift is already underway: Google reports that AI generates more than a quarter of its new code, and Y Combinator&amp;rsquo;s CEO noted that roughly a quarter of a recent batch had 95% of their code written by AI. Andrej Karpathy&amp;rsquo;s concept of &amp;ldquo;vibe coding,&amp;rdquo; which focuses on the &amp;ldquo;what&amp;rdquo; rather than the &amp;ldquo;how,&amp;rdquo; raises an existential question: are we still engineers if we forget the code exists? Vella relates this to her own reluctant transition into engineering management, while citing GitClear research showing sharp rises in copy-pasted and churned code, alongside studies showing that trust in AI often starts high before dropping sharply with experience.&lt;/p&gt;
&lt;p&gt;Still, the piece is not pessimistic. Like artisans during the Industrial Revolution, engineers can adapt, and durable skills such as communication, systems thinking, and navigating ambiguity are becoming even more valuable. Vella proposes a pendulum metaphor: swinging intentionally between writing code directly, orchestrating AI, and blending both. In her view, AI isn&amp;rsquo;t taking the job away so much as giving engineers a chance to reclaim parts of the role that were gradually carved off to other specialists—from understanding user needs and business impact to system design and operations.&lt;/p&gt;
&lt;h2 id="revenge-of-the-junior-developer"&gt;&lt;a href="https://sourcegraph.com/blog/revenge-of-the-junior-developer" rel="noopener noreferrer"&gt;Revenge of the junior developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sourcegraph&amp;rsquo;s Steve Yegge argues that software development is passing through six overlapping waves: traditional programming (2022), completions-based coding (2023), chat-based coding (2024), coding agents (first half of 2025), agent clusters (second half of 2025), and agent fleets (2026). In his view, &amp;ldquo;vibe coding&amp;rdquo; means letting an LLM write code, feeding the results back in, and iterating in a continuous loop—a workflow that will persist across all these waves. Coding agents like Claude Code or Aider can already read tickets, track down bugs, propose fixes, and write tests, though they still need tasks broken down into small pieces and close supervision. He estimates a single agent costs roughly $10–$12 per hour, meaning companies should budget significantly more LLM spend per developer as engineers start running multiple agents in parallel.&lt;/p&gt;
&lt;p&gt;The &amp;ldquo;revenge&amp;rdquo; comes at the end: contrary to his earlier essay &amp;ldquo;The Death of the Junior Developer,&amp;rdquo; junior developers are adopting AI far faster than many senior developers, who often resist because they are heavily invested in the status quo and view learning from scratch as a loss of status. His message is blunt: it&amp;rsquo;s not that AI has to prove it&amp;rsquo;s better than you—you have to become better with AI. By the end of the year, he predicts software engineering will involve much less manual coding and much more supervising agents, so adapt as early as possible; and if you don&amp;rsquo;t know where to start, ask a junior developer.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/111cec1b-a195-4ff5-963c-714ceecd01ab_1280x1664.gif" alt="How does SSO Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b415d54d-0dbd-428d-a09c-3de0332c0f71_1280x1502.gif" alt="How Java Virtual Threads Work?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/8ef255cc-ebbb-4710-9faf-f366274a2bef_1280x1373.gif" alt="Memcached vs Redis"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2370fff4-b515-484e-a081-4ce73b2c62c2_1280x1566.gif" alt="The Shopify Tech Stack"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=eHEHE2fpnWQ" rel="noopener noreferrer"&gt;What Are AI Agents Really About?&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 #14</title><link>https://miti99.com/en/post/2025/04/30/</link><pubDate>Wed, 30 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/30/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #14.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="bloom-filter-a-deep-dive"&gt;&lt;a href="https://www.kirupa.com/data_structures_algorithms/bloom_filter.htm" rel="noopener noreferrer"&gt;Bloom Filter: A Deep Dive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kirupa Chinnathambi explains Bloom filters through a classic real-world problem: checking whether a username is already taken during sign-up on a social network with tens of millions of users. Scanning the database on every keystroke is too slow, while keeping every username string in an in-memory hash table eats up too much RAM. A Bloom filter sits in front of the database as a compact probabilistic gatekeeper: instead of storing the strings themselves, it stores bit &amp;ldquo;fingerprints&amp;rdquo; inside a fixed-size bit array. Each inserted item is run through $k$ independent hash functions, each mapping to an index in the array whose bit is flipped to &lt;code&gt;1&lt;/code&gt;. On lookup, if even a single one of those $k$ bits is &lt;code&gt;0&lt;/code&gt;, the item is guaranteed &lt;em&gt;not&lt;/em&gt; to exist; if all $k$ bits are &lt;code&gt;1&lt;/code&gt;, the item &lt;em&gt;might&lt;/em&gt; exist and you fall back to a database query, because other items may have happened to set those same bits (a false positive).&lt;/p&gt;
&lt;p&gt;The second half walks through the formulas for picking the optimal bit-array size $m$ and number of hash functions $k$ given an expected item count $n$ and target false-positive rate $p$. For 10 million usernames at a 1% false-positive rate ($p = 0.01$), a Bloom filter needs only about 95.85 million bits (~12 MB) and 7 hash functions—whereas an equivalent in-memory hash table would consume 160 MB to 240 MB, or 13x to 20x more memory. Trading a tiny, tunable chance of an extra database lookup for massive memory savings makes the Bloom filter one of the most practical probabilistic data structures in systems engineering.&lt;/p&gt;
&lt;h2 id="rethinking-llm-inference-why-developer-ai-needs-a-different-approach"&gt;&lt;a href="https://www.augmentcode.com/blog/rethinking-llm-inference-why-developer-ai-needs-a-different-approach" rel="noopener noreferrer"&gt;Rethinking LLM inference: Why developer AI needs a different approach&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Augment Code explains why AI coding assistants demand a fundamentally different LLM inference architecture than consumer chatbots: repository-aware coding requires feeding tens of thousands of tokens of codebase context into the model, and suggestion quality keeps climbing well past 10,000 input tokens. Unlike chat workloads (roughly ~100 input tokens to generate hundreds of output tokens), developer AI workloads are heavily &lt;strong&gt;prefill-dominated&lt;/strong&gt;—thousands of context tokens in, only a few dozen completion tokens out—whereas off-the-shelf engines like vLLM and TensorRT-LLM are tuned primarily for decode-heavy workloads. Because of this, Augment optimizes ruthlessly for prefill throughput and time-to-first-token (TTFT). After showing why single-token autoregressive decoding leaves GPUs below 1% compute utilization (memory-bandwidth bound), the post explains &lt;strong&gt;token-level batching&lt;/strong&gt; (known in academia as &lt;em&gt;chunked prefill&lt;/em&gt;), where lightweight decode steps &amp;ldquo;piggyback&amp;rdquo; onto another request&amp;rsquo;s compute-bound prefill batch, sized right at the ridge point between memory-bandwidth bound and FLOPS bound.&lt;/p&gt;
&lt;p&gt;The article also details production systems requirements like reliable request cancellation as a developer types rapidly, alongside low-level GPU optimizations: CUDA Graphs to eliminate CPU launch overhead, FP8 quantization, FlashAttention-3, and custom fused CUDA kernels. Together, these optimizations deliver a time-to-first-token under 300ms for a 10,000-token prompt on Llama 3 70B—a 3x speedup—while sustaining nearly 10 requests per second across an 8x H100 node. It&amp;rsquo;s a great case study in why LLM inference tuning has to match the exact input/output shape of your application.&lt;/p&gt;
&lt;h2 id="floyds-cycle-algorithm-fraud-detection-in-java-systems"&gt;&lt;a href="https://dzone.com/articles/floyds-cycle-algorithm-fraud-detection-java-systems" rel="noopener noreferrer"&gt;Floyd’s Cycle Algorithm: Fraud Detection in Java Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DZone article illustrates how Floyd&amp;rsquo;s Cycle-Finding Algorithm (the &amp;ldquo;tortoise and the hare&amp;rdquo;) can be applied to spot circular money transfers in banking systems. Bank accounts are modeled as vertices and wire transfers as directed edges in a graph; a loop like &lt;code&gt;A → B → C → D → B&lt;/code&gt; forms a cycle, a classic pattern in money laundering (&amp;ldquo;round-tripping&amp;rdquo;) used to obscure the origin of funds. Floyd&amp;rsquo;s algorithm advances two pointers through the sequence—a slow pointer moving one step at a time and a fast pointer moving two steps at a time; if a cycle exists, the two pointers are guaranteed to meet inside the loop. The Java walkthrough provides a &lt;code&gt;TransactionGraph&lt;/code&gt; backed by a &lt;code&gt;HashMap&lt;/code&gt; adjacency list, a &lt;code&gt;FraudDetection&lt;/code&gt; cycle checker, and a test harness with sample transfer data.&lt;/p&gt;
&lt;p&gt;The appeal of Floyd&amp;rsquo;s algorithm is its simplicity, $O(N)$ time complexity, and $O(1)$ auxiliary memory footprint, making it attractive for lightweight real-time checks. However, an important caveat applies: Floyd&amp;rsquo;s tortoise-and-hare algorithm assumes each node has at most &lt;em&gt;one&lt;/em&gt; outgoing edge (a functional graph or linked list). In a general transaction graph where an account sends money to multiple recipients, following only a single outgoing edge per node can miss cycles on other branches—meaning full Depth-First Search (DFS) or Johnson&amp;rsquo;s/Tarjan&amp;rsquo;s strongly connected components algorithms are needed for general multi-branch graphs, and any detected cycle is merely a heuristic flag for deeper investigation rather than proof of fraud on its own. The post also notes applications in network routing loop detection, DNA motif analysis, ML pipelines, and blockchain transaction graphs.&lt;/p&gt;
&lt;h2 id="succinct-data-structures"&gt;&lt;a href="https://blog.startifact.com/posts/succinct/" rel="noopener noreferrer"&gt;Succinct data structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martijn Faassen introduces &lt;strong&gt;succinct data structures&lt;/strong&gt;—a family of data structures he was delighted to discover. Like compression algorithms, they store data in space close to the information-theoretic minimum; unlike standard compression, however, you don&amp;rsquo;t need to decompress them before use—you can run fast queries directly on the compact representation. The foundational building block is a bitvector supporting two constant-time ($O(1)$) operations with tiny memory overhead: &lt;code&gt;rank&lt;/code&gt; (count how many &lt;code&gt;1&lt;/code&gt; bits appear up to index $i$) and &lt;code&gt;select&lt;/code&gt; (find the index of the $n$-th &lt;code&gt;1&lt;/code&gt; bit). From that primitive, a &lt;strong&gt;Wavelet Matrix&lt;/strong&gt; generalizes &lt;code&gt;rank&lt;/code&gt; and &lt;code&gt;select&lt;/code&gt; to larger alphabets like DNA bases or 256-byte text; an &lt;strong&gt;FM-index&lt;/strong&gt; enables compact full-text search that counts and locates substrings rapidly (widely used in bioinformatics); and &lt;strong&gt;balanced parentheses&lt;/strong&gt; bitvectors encode arbitrary trees using just &lt;em&gt;2 bits per node&lt;/em&gt; instead of bulky 64-bit pointers while still supporting fast navigation to parent, child, and sibling nodes.&lt;/p&gt;
&lt;p&gt;Faassen walks through an XML querying prototype he built by combining a balanced-parentheses tree with sparse bitvectors to jump straight to elements matching a specific tag name, and sketches how the same trick could shrink compiler ASTs in memory. He closes with pointers to Rust crates in this space, including &lt;code&gt;vers&lt;/code&gt; (blazing fast with minimal overhead), &lt;code&gt;sucds&lt;/code&gt; (offering sparse bitvectors like &lt;code&gt;SArray&lt;/code&gt;), and &lt;code&gt;fm-index&lt;/code&gt;. Though still relatively niche outside bioinformatics, succinct data structures hold huge promise anywhere fitting a working set into CPU cache or RAM is the key to speed.&lt;/p&gt;
&lt;h2 id="the-art-of-engineering-team-focus-less-is-more"&gt;&lt;a href="https://github.com/resources/insights/engineering-team-focus" rel="noopener noreferrer"&gt;The art of engineering team focus: less is more&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub Resources piece makes a counterintuitive case: if you want your engineering team to ship &lt;em&gt;more&lt;/em&gt;, they need to work on &lt;em&gt;fewer&lt;/em&gt; things at the same time. Unshipped work delivers zero value to users, yet leaders often struggle to say &amp;ldquo;no&amp;rdquo; to stakeholders, slicing the team across half a dozen parallel initiatives under the illusion that everything is moving forward. The antidote starts with making all work visible so leadership confronts the team&amp;rsquo;s true capacity and actively kills or pauses lower-priority tracks; breaking projects into 1–2 week milestones to keep momentum high, shrink pull requests, de-risk deployments, and create natural pivot points; and strictly limiting Work in Progress (WIP), since every context switch can cost up to 23 minutes to regain deep focus while driving up bug rates and burnout.&lt;/p&gt;
&lt;p&gt;The author goes further and recommends &amp;ldquo;stacking&amp;rdquo; engineers onto the single highest-priority initiative until adding another person would literally cause them to trip over one another, and only then staffing the #2 priority. Finally, never plan a team to 100% utilization—leave roughly a 20% capacity buffer to absorb unexpected bugs and production interrupts, because a highway at 100% capacity is a parking lot. Teams with slack in the system consistently ship faster, innovate more, and burn out less.&lt;/p&gt;
&lt;h2 id="performance-optimization-and-how-to-do-it-wrong"&gt;&lt;a href="https://genna.win/blog/convolution-simd/" rel="noopener noreferrer"&gt;Performance optimization, and how to do it wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author, a contributor to the Rust &lt;code&gt;burn&lt;/code&gt; machine learning framework, shares a humbling war story about optimizing direct 2D CPU convolution using SIMD intrinsics. Even after implementing an academic paper&amp;rsquo;s optimal loop ordering and register blocking scheme, the new SIMD kernel ran more than &lt;em&gt;twice as slow&lt;/em&gt; as the naive baseline. Standard profilers like &lt;code&gt;cargo-flamegraph&lt;/code&gt;, &lt;code&gt;samply&lt;/code&gt;, and AMD μProf couldn&amp;rsquo;t pinpoint why, forcing the author to strip the kernel down piece by piece to isolate the regression. The culprits turned out to be a combination of &lt;strong&gt;SIMD register spilling&lt;/strong&gt; (x86 AVX2 provides only 16 YMM registers) and &lt;strong&gt;excessive branching inside the hot inner loop&lt;/strong&gt; to handle boundary padding. Splitting the loop into a branchless fast path for interior pixels and a separate edge path—plus using compile-time monomorphization (const generics) to specialize common cases like zero padding or stride 1—brought massive speedups.&lt;/p&gt;
&lt;p&gt;The biggest plot twist came from the Rust compiler itself: adding one more specialized branch pushed the outer function past LLVM&amp;rsquo;s inlining size threshold, causing the compiler to stop inlining the inner SIMD routines and tanking performance all over again. Adding &lt;code&gt;#[inline(always)]&lt;/code&gt; to the top-level functions immediately restored the speedup. It&amp;rsquo;s a classic lesson in low-level optimization: measure everything, understand your hardware&amp;rsquo;s register file, and never assume the compiler is doing what you think it&amp;rsquo;s doing.&lt;/p&gt;
&lt;h2 id="supercharging-discord-mobile-our-journey-to-a-faster-app"&gt;&lt;a href="https://discord.com/blog/supercharging-discord-mobile-our-journey-to-a-faster-app" rel="noopener noreferrer"&gt;Supercharging Discord Mobile: Our Journey to a Faster App&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord shares a sweeping set of mobile performance improvements for their React Native app, aimed especially at power users in hundreds of servers. First, they virtualized the server list so only on-screen server icons stay mounted in memory, cutting startup memory usage by 14% and cold-start time by 10% for users in 100+ servers. For the chat message list (already a native component), they overhauled view recycling, lazily initialized rarely used message attachments, and pre-populated the recycle pool at startup with common row types—reducing slow frames by up to 60% and trimming memory by ~12%. On Android, they rewrote the emoji picker completely in native Kotlin views to eliminate blank white flashes during fast fling scrolls on budget devices, and switched animated emojis from GIF to WebP to hit a smooth 60 FPS.&lt;/p&gt;
&lt;p&gt;For the channel list, the team actually migrated &lt;em&gt;back&lt;/em&gt; from Shopify&amp;rsquo;s &lt;code&gt;FlashList&lt;/code&gt; to their own in-house &lt;code&gt;FastList&lt;/code&gt; after finding that &lt;code&gt;FlashList&lt;/code&gt; frequently rendered blank cells on low-end Android phones, and went on to build &lt;code&gt;FastestList&lt;/code&gt; backed by Android&amp;rsquo;s native &lt;code&gt;RecyclerView&lt;/code&gt;. On iOS, the media picker now displays a fast low-resolution thumbnail first while streaming in the high-res asset and requests 256×256 previews to hit Apple PhotoKit&amp;rsquo;s fast system cache, eliminating a 4.5-second freeze when opening large camera rolls. Looking ahead to 2025, Discord plans to enable React Native&amp;rsquo;s New Architecture, experiment with Static Hermes, and move core client state logic to Rust.&lt;/p&gt;
&lt;h2 id="git-without-a-forge"&gt;&lt;a href="https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/git-no-forge/" rel="noopener noreferrer"&gt;Git without a forge&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Tatham, creator of PuTTY, explains why he still hosts his open-source projects on plain bare Git repositories on his own server rather than moving to a web forge like GitHub or GitLab. He trusts machines administered by friends more than corporate platforms whose ownership and policies can shift overnight; he has no desire to sysadmin a heavy self-hosted forge instance himself; he dislikes how forges bake in rigid opinions about issue tracking and pull-request workflows; he doesn&amp;rsquo;t want to force drive-by contributors to register yet another web account just to send a patch; and he worries about platform lock-in trapping years of issue and PR discussions outside the Git repository itself. He also candidly admits that sheer inertia plays a part.&lt;/p&gt;
&lt;p&gt;In the second half, Tatham ranks ways contributors can send him patches without a forge, from best to worst: sending a public Git repo URL and branch name he can &lt;code&gt;git fetch&lt;/code&gt; directly (giving all the benefits of a pull request with zero forge lock-in), emailing a &lt;code&gt;git bundle&lt;/code&gt; binary file containing the exact commits, attaching files generated by &lt;code&gt;git format-patch&lt;/code&gt;, sending a raw &lt;code&gt;git diff&lt;/code&gt; (which loses commit messages and base-commit metadata), and dead last, &lt;code&gt;git send-email&lt;/code&gt;, which turns a patch series into a burst of separate emails he has to reassemble by hand. While he acknowledges that public forges help newcomers gauge how welcoming a project is from past PR threads, he remains holding out for a lightweight, decentralized code-review protocol that keeps discussion portable.&lt;/p&gt;
&lt;h2 id="40-thoughts-on-turning-40"&gt;&lt;a href="https://newsletter.pathlesspath.com/p/40-thoughts-on-turning-40-287" rel="noopener noreferrer"&gt;40 Thoughts On Turning 40&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Millerd, author of &lt;em&gt;The Pathless Path&lt;/em&gt;, shares 40 reflections on turning 40, spanning reinvention, work, money, relationships, fatherhood, and happiness. Looking back, he considers walking away from a conventional high-status consulting career into uncertainty the defining decision of his 30s, noting that real personal transformation is slow, messy, and gradual rather than a single cinematic epiphany. On work, he argues that the FIRE movement&amp;rsquo;s dream of &amp;ldquo;escaping work&amp;rdquo; through early retirement misses the point: you don&amp;rsquo;t transcend work by avoiding it, you transcend it by finding &lt;strong&gt;good work&lt;/strong&gt;—work that feels meaningful both in the moment and in hindsight. Everyone should try freelancing or self-employment for at least a year, he suggests, adding that taking a steep pay cut after quitting his corporate job was the fastest way to discover what he actually valued.&lt;/p&gt;
&lt;p&gt;On life outside work, he reflects on how lucky he feels to have met his wife and encourages anyone still looking for a partner not to give up, while calling fatherhood the most humbling experience of his life. His closing thoughts are pithy reminders: following breaking news has never made anyone happier, deep rest is a skill that takes practice, &amp;ldquo;doing less&amp;rdquo; is the most underrated way to get unstuck, and writing in public remains one of the most powerful forces for personal clarity—even if it forces you to confront what you truly want.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/f7fc4f19-ebd8-45a0-9398-469805bb4a26_1280x1532.gif" alt="A Cheatsheet on Comparing Key-Value Stores"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/16fe4308-ed47-451f-a852-c476ecfb4167_1280x1977.jpeg" alt="A Handy Cheatsheet for the Most Popular Cloud Services"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/89a09e07-6548-4c12-87c6-0486c6177ea7_1308x1536.jpeg" alt="Which Database Should I Use on AWS?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=hFURlsMwU7c" rel="noopener noreferrer"&gt;What Is the Most Popular Open-Source AI Stack?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #10</title><link>https://miti99.com/en/post/2025/04/05/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #10.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="gaining-years-of-experience-in-a-few-months"&gt;&lt;a href="https://marcgg.com/blog/2025/02/11/high-growth/" rel="noopener noreferrer"&gt;Gaining Years of Experience in a Few Months&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G. Gauthier, former VP of Engineering at Drivy, reflects on uneven learning curves in a career: those rare, intense stretches where you absorb so much so quickly that a few months feel like years of experience. For him, that moment came when Drivy was acquired by Getaround in 2019, forcing him to juggle technical, architectural, communication, management, business, and product challenges simultaneously under high stakes and tight deadlines. He distinguishes this from merely &amp;ldquo;stepping outside your comfort zone&amp;rdquo;: it pushes well past your current capabilities, carries a real risk of failure, and is impossible to sustain indefinitely.&lt;/p&gt;
&lt;p&gt;To frame this, he divides work into four zones: the &lt;strong&gt;Comfort Zone&lt;/strong&gt; (safe, but staying too long leads to stagnation), the &lt;strong&gt;Learning Zone&lt;/strong&gt; (healthy stretch challenges where you should spend most of your career), the &lt;strong&gt;High Growth Zone&lt;/strong&gt; (compressing years of growth into months, unsustainable and not always available on demand), and the &lt;strong&gt;Burnout Zone&lt;/strong&gt; if you stay in high growth too long. He sketches healthy career trajectories that alternate between the Learning and High Growth zones, or use the Comfort Zone briefly to recover after an intense sprint before returning to the Learning Zone. His closing advice: when a rare High Growth opportunity comes along, lean in and make the most of it—but watch your health closely, because none of the career gains matter if you burn out.&lt;/p&gt;
&lt;h2 id="writing-better-commit-messages"&gt;&lt;a href="https://refactoringenglish.com/chapters/commit-messages/" rel="noopener noreferrer"&gt;Writing Better Commit Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this chapter from &lt;em&gt;Refactoring English&lt;/em&gt;, Michael Lynch argues that commit messages are routinely treated as an afterthought, resulting in useless one-liners like &lt;code&gt;&amp;quot;Fix bug&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;Update UI&amp;quot;&lt;/code&gt;. The most important reader of a commit message, he notes, is your code reviewer—followed by teammates, library consumers, future bug investigators, and automated release-note generators. Because of that, you should structure commit messages like a journalist&amp;rsquo;s &amp;ldquo;inverted pyramid,&amp;rdquo; putting the most essential context right at the top and using section headings to break up longer messages.&lt;/p&gt;
&lt;p&gt;The subject line is the most critical piece because it&amp;rsquo;s what shows up in &lt;code&gt;git log --oneline&lt;/code&gt; and GitHub&amp;rsquo;s commit history view; it should describe the &lt;em&gt;impact&lt;/em&gt; of the change (e.g., &lt;code&gt;&amp;quot;Prevent database corruption when users register concurrently&amp;quot;&lt;/code&gt;) rather than the mechanics of the code edit. The body should explain how the change affects end users and, above all, the &lt;em&gt;motivation&lt;/em&gt;: why the change was needed and what constraints shaped the chosen solution. Depending on the situation, you can include breaking-change notices, non-obvious reference links, reasons for adding a new dependency, issue tracker links, testing instructions and limitations, and alternatives considered. Conversely, leave out anything already obvious from the diff, ephemeral review chatter, and temporary preview URLs—and remember that anything essential for ongoing code maintenance belongs in code comments, not buried in commit history.&lt;/p&gt;
&lt;h2 id="the-rotation-program-that-keeps-this-startup"&gt;&lt;a href="https://review.firstround.com/the-rotation-program-that-keeps-this-startups-engineers-learning-and-not-leaving/" rel="noopener noreferrer"&gt;The Rotation Program That Keeps This Startup&amp;rsquo;s Engineers Learning — and Not Leaving&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This First Round Review interview with Krista Moroder, VP of Engineering at Checkr, tells the story of an internal rotation program that drove voluntary attrition in her org down to nearly zero. A former high school teacher, Moroder borrowed an exercise from the faculty lounge: putting stickers next to the names of students who had a strong adult connection at school to spot which kids were falling through the cracks. She adapted that idea into a spreadsheet tracking every engineer, observing that when engineers leave after two or three years, it&amp;rsquo;s usually not just about equity vesting—it&amp;rsquo;s because they stopped learning and got bored, a restlessness only amplified by anxiety over falling behind in the AI wave.&lt;/p&gt;
&lt;p&gt;The program runs in three steps: maintaining a &amp;ldquo;sticker chart&amp;rdquo; spreadsheet with three columns (joined a rotation or cross-functional tiger team, worked on multiple teams, or received training for a new role) with the goal that every engineer has at least one box checked before their third anniversary; matching that list against quarterly company priorities to rotate engineers where they&amp;rsquo;re needed; and holding deliberate check-ins before making any transfer permanent. Roughly half of all rotations end with the engineer staying on the new team permanently, and one temporary AI tiger team evolved into a permanent core team. To persuade managers to let their top performers rotate out, she argues that having an &amp;ldquo;indispensable&amp;rdquo; single point of failure is actually a succession-planning bug, and that the whole engineering org needs to get an A together. The result: roughly 60% of Checkr&amp;rsquo;s Staff+ engineers have been with the company for six years or more.&lt;/p&gt;
&lt;h2 id="judge-your-coworkers"&gt;&lt;a href="https://blog.staysaasy.com/p/judge-your-coworkers" rel="noopener noreferrer"&gt;Judge Your Coworkers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Stay SaaSy post warns against a cultural failure mode the author calls &lt;strong&gt;Mutually Assured Mediocrity&lt;/strong&gt;: when everyone is performing at a mediocre level, they form an unspoken pact never to criticize one another out of fear that their own weaknesses will be exposed in return. The post traces how this creeps in as a company grows: new departments form, &amp;ldquo;you don&amp;rsquo;t understand our job, stay in your lane&amp;rdquo; becomes a defensive shield, leaders avoid holding peers accountable to avoid being judged themselves, and eventually the few people who dare to point out real problems get punished as troublemakers.&lt;/p&gt;
&lt;p&gt;To counter this, the author advocates encouraging employees to form healthy judgments about their coworkers&amp;rsquo; work, governed by three ground rules: never criticize peers publicly—share feedback only privately with your direct manager or in formal peer reviews; keep performance management strictly confidential; and remind everyone that nobody is promised flawless coworkers. Managers should explicitly tell reports early on that they are expected to have opinions on their collaborators&amp;rsquo; effectiveness, and check in on those opinions every 6–12 months. When a report praises someone, it&amp;rsquo;s a coaching moment to calibrate what great work looks like across seniority levels; when they complain, it surfaces hidden performance issues or role misunderstandings early (for example, mistaking a product manager for a project manager). The closing message: failing to hold people accountable is one of the worst disservices a company can do to its employees, and tech has pushed &amp;ldquo;blameless&amp;rdquo; culture way too far.&lt;/p&gt;
&lt;h2 id="my-llm-codegen-workflow-atm"&gt;&lt;a href="https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/" rel="noopener noreferrer"&gt;My LLM Codegen Workflow ATM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Harper Reed shares his current workflow for building software with LLMs, distilled into three stages: hone an idea into a spec, generate an execution plan, and execute in tight loops. For greenfield projects, he has a conversational model interview him one question at a time to turn a rough idea into a detailed &lt;code&gt;spec.md&lt;/code&gt;; next, he feeds that spec to a reasoning model to break it down into incremental steps—each written as a self-contained prompt for a coding agent—saved as &lt;code&gt;prompt_plan.md&lt;/code&gt; alongside a &lt;code&gt;todo.md&lt;/code&gt; checklist to preserve state across sessions. The entire planning phase takes about 15 minutes. For execution, he prefers Claude directly or Aider: paste a prompt, run the test suite, commit if green, or pack the codebase with &lt;code&gt;repomix&lt;/code&gt; and hand it back to the model to debug if red.&lt;/p&gt;
&lt;p&gt;For existing codebases, he pairs &lt;code&gt;repomix&lt;/code&gt; with &lt;code&gt;mise&lt;/code&gt; tasks to bundle repository context, then uses targeted prompts to review code, file GitHub issues, or identify missing test coverage. He admits it&amp;rsquo;s easy to get &amp;ldquo;out over your skis&amp;rdquo; when code is flying by that fast, which is why upfront planning and automated tests are non-negotiable guardrails. He also notes that these workflows are still largely single-player rather than team-friendly, and shares how he uses the idle minutes while waiting on model inference—often by kicking off the spec for the &lt;em&gt;next&lt;/em&gt; project.&lt;/p&gt;
&lt;h2 id="structured-logging-in-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/structured-logging-in-spring-boot.html" rel="noopener noreferrer"&gt;Structured Logging in Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yatin Batra&amp;rsquo;s tutorial on Java Code Geeks walks through setting up structured logging in Spring Boot. Unlike the plain-text log lines Logback emits by default, structured logging formats entries as machine-parseable JSON, making it far easier for log aggregation platforms like the ELK stack or Grafana Loki to parse, search, and filter events. The author shows how to add the &lt;code&gt;logstash-logback-encoder&lt;/code&gt; dependency to &lt;code&gt;pom.xml&lt;/code&gt;, configure &lt;code&gt;logback-spring.xml&lt;/code&gt; under &lt;code&gt;src/main/resources&lt;/code&gt;, and inspect the resulting JSON output from a sample application.&lt;/p&gt;
&lt;p&gt;Moving to advanced topics, the post covers injecting custom contextual fields via MDC (Mapped Diagnostic Context)—such as attaching a &lt;code&gt;userId&lt;/code&gt; to every log event—shipping logs to Logstash, and configuring Promtail to scrape and forward logs into Loki. Finally, the author introduces two standardized schemas: Elastic Common Schema (ECS) for unifying field names across the Elastic ecosystem, and Graylog Extended Log Format (GELF) for shipping structured logs to Graylog, comparing their core fields and trade-offs. This setup is essential for cloud-native deployments where centralized observability is a must.&lt;/p&gt;
&lt;h2 id="secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency"&gt;&lt;a href="https://gainjavaknowledge.medium.com/secret-java-stream-hacks-that-will-instantly-improve-your-coding-efficiency-8253d57d692b" rel="noopener noreferrer"&gt;Secret Java Stream Hacks That Will Instantly Improve Your Coding Efficiency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Medium post by Gain Java Knowledge highlights several lesser-known Java Stream API tricks for writing cleaner, more expressive pipelines. A standout is &lt;code&gt;Collectors.teeing()&lt;/code&gt;, which lets you pipe a single stream through two separate collectors simultaneously and merge their results—for example, computing both the sum and the average in a single pass instead of iterating twice. The post also covers &lt;code&gt;takeWhile()&lt;/code&gt; (taking elements until a predicate turns false) and &lt;code&gt;dropWhile()&lt;/code&gt; (skipping elements while a predicate remains true) for concise short-circuiting stream slicing.&lt;/p&gt;
&lt;p&gt;Beyond those operators, the author touches on parallel streams, memory efficiency, handling checked exceptions cleanly inside lambdas, and composing multi-stage collectors. Practical tips include picking the most specific collector for the job, avoiding side effects inside stream operations, preferring method references over verbose lambdas where readable, and keeping pipelines short enough to scan easily. Understanding lazy evaluation is also key when weighing stream performance on large datasets.&lt;/p&gt;
&lt;h2 id="death-of-a-thousand-nits-code-review-best-practices"&gt;&lt;a href="https://bitfieldconsulting.com/posts/code-review" rel="noopener noreferrer"&gt;Death of a Thousand Nits: Code Review Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an excerpt from his book &lt;em&gt;Code For Your Life&lt;/em&gt;, John Arundel explores how to make code reviews less adversarial and genuinely useful. His number-one recommendation is &lt;strong&gt;pair reviewing&lt;/strong&gt;: instead of trading walls of text in pull request comments, hop on a quick call or screen-share. Voice tone and facial expressions convey far more nuance than text, a 15-second question can replace days of back-and-forth comment threads, and people are naturally kinder face-to-face.&lt;/p&gt;
&lt;p&gt;When asynchronous written review is unavoidable, every comment should genuinely add value to the code. Leave purely stylistic preferences to automated formatters; if you don&amp;rsquo;t recognize a language construct, look it up yourself first; if you don&amp;rsquo;t understand why the author took a particular approach, ask a genuine question; and even when suggesting an improvement or pointing out a likely bug, frame it as a question rather than a command. Start reviews by calling out what you liked, close with an encouraging note, and drop any trace of condescension. On the receiving end, when hit with a blunt or abrasive review comment, resist getting defensive and look for the kernel of truth inside it—and for pure style nitpicks, either ignore them politely or ask privately what the deeper concern is. Ultimately, the best way to build a kinder code review culture is to model it yourself.&lt;/p&gt;
&lt;h2 id="hash-functions-deep-dive"&gt;&lt;a href="https://www.kirupa.com/data_structures_algorithms/hash_functions_deep_dive.htm" rel="noopener noreferrer"&gt;Hash Functions Deep Dive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kirupa explains hash functions from first principles: a function that takes an arbitrary input—text, a file, or raw binary data—and maps it to a fixed-size output, powering everything from hash tables and password verification to file integrity checks, digital signatures, and deduplication. A good hash function needs eight properties: determinism (the same input always yields the same output), uniform distribution, fast computation (ideally O(1) for table lookups), the avalanche effect (a tiny change in input flips roughly half the output bits), fixed output length, low collision rate, pre-image resistance (one-way), and no correlation between similar inputs.&lt;/p&gt;
&lt;p&gt;To make these properties concrete, the author builds a toy hash function in JavaScript from scratch: summing the character codes of a string modulo a prime table size like 37. That naive version immediately fails on anagrams like &lt;code&gt;&amp;quot;hello&amp;quot;&lt;/code&gt; and &lt;code&gt;&amp;quot;olleh&amp;quot;&lt;/code&gt;, which produce identical sums; multiplying each character code by its positional weight fixes the anagram collision, yet the toy function still flunks nearly every other criterion on the list. The lesson is never to roll your own hash function in production; the author walks through how MD5 satisfies the structural criteria with its 128-bit (32-hex-character) output (noting that MD5 is no longer safe against deliberate collisions and that password storage requires dedicated slow hashes like bcrypt or Argon2). Hash functions sit quietly underneath almost everything we build, from fast in-memory lookups to verifying downloaded ISOs.&lt;/p&gt;
&lt;h2 id="xor-a-deep-dive-into-the-exclusive-or-operation"&gt;&lt;a href="https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/xor/" rel="noopener noreferrer"&gt;XOR: A Deep Dive into the Exclusive OR Operation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Tatham takes a deep dive into the XOR (exclusive OR) operation and its surprisingly rich applications across computer science. At the bit level, XOR outputs &lt;code&gt;1&lt;/code&gt; when its two input bits differ and &lt;code&gt;0&lt;/code&gt; when they match, and is both commutative and associative. Tatham shows that you can view the exact same operation through four equivalent mental models: a &amp;ldquo;not equal&amp;rdquo; bit comparison, a conditional bit-flipper controlled by a mask bit, addition modulo 2 (carryless bit addition), and parity calculation (counting whether the number of &lt;code&gt;1&lt;/code&gt; bits is odd or even).&lt;/p&gt;
&lt;p&gt;Each mental model unlocks classic applications. In cryptography, XORing plaintext with a keystream encrypts and decrypts symmetrically—where the entire security challenge lies in generating an unpredictable keystream, and raw XOR alone provides no message integrity protection against bit-flipping attacks. In retro computer graphics, XORing a sprite onto a framebuffer twice cleanly erases it and restores the original background pixels. Tatham also walks through the classic XOR swap trick, overflow-safe integer averaging, and carryless polynomial arithmetic (used in CRCs and Galois fields), showing how one humble bitwise operator looks completely different depending on the lens you bring to it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/6b437484-1fd8-4b59-ba05-46bb3352b053_2904x2559.jpeg" alt="SOAP vs REST vs GraphQL vs RPC"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3ecf2600-10d8-4180-8328-8d790fbba0cc_1280x1557.gif" alt="SQS vs SNS vs EventBridge vs Kinesis"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/217bf342-bfd4-4088-bba3-b2734f065a20_1280x1280.gif" alt="Top 5 common ways to improve API performance"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-inside-java"&gt;Bonus 2: Interesting videos from &lt;a href="https://inside.java/" rel="noopener noreferrer"&gt;Inside Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://inside.java/2025/02/22/devoxxbelgium-loom-next/" rel="noopener noreferrer"&gt;Project Loom and Virtual Threads: Next Phases&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Git LFS: Use Cases, Limitations, How to Remove It, and Alternatives</title><link>https://miti99.com/en/post/2025/02/26/</link><pubDate>Tue, 25 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/26/</guid><description>&lt;p&gt;Beyond source code, we sometimes store assets like images, audio, videos, data files, or large build outputs in our repositories. These files can be very heavy, and storing them directly in a Git repository bloats the repo size and slows down cloning, pushing, pulling, and fetching. To solve this problem, Git Large File Storage (Git LFS) was created. In this post, I&amp;rsquo;ll introduce Git LFS, its use cases, its limitations, how to remove it, and alternative solutions.&lt;/p&gt;
&lt;h2 id="1-what-is-git-lfs"&gt;1. What Is Git LFS?&lt;/h2&gt;&lt;p&gt;Git LFS is a Git extension that helps manage large files in a repository. Instead of storing the full contents of large files inside the Git repository itself, Git LFS stores the actual files on a remote server (typically a dedicated Git LFS server) and keeps only lightweight pointer metadata in the repository. When you need the files, Git LFS downloads them from the remote server to your local machine.&lt;/p&gt;
&lt;h2 id="2-use-cases-for-git-lfs"&gt;2. Use Cases for Git LFS&lt;/h2&gt;&lt;p&gt;Git LFS is well-suited for the following scenarios:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Managing media files and large datasets:&lt;/strong&gt; When a project needs to store large images, audio, video, datasets, or analysis files, Git LFS manages them efficiently without significantly inflating the repository size.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Storing binaries and build artifacts:&lt;/strong&gt; Binary files, libraries, executables, or build outputs can be stored in Git LFS to take the load off the main repository.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Projects with large files that rarely change:&lt;/strong&gt; For large files that are infrequently modified, Git LFS is an ideal way to keep them accessible while keeping everyday Git operations fast.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Previously, when building a website for &lt;a href="https://ngamtheprojec.github.io" rel="noopener noreferrer"&gt;Ngăm&lt;/a&gt;, I used Git LFS to store the group&amp;rsquo;s videos. Since GitHub limits individual file sizes to 100MB, I turned to Git LFS to host larger video files. That turned out to be a mistake on my part.&lt;/p&gt;
&lt;h2 id="3-limitations-of-git-lfs"&gt;3. Limitations of Git LFS&lt;/h2&gt;&lt;p&gt;Although Git LFS reduces repository bloat, it comes with several drawbacks:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Bandwidth and storage limits on GitHub:&lt;/strong&gt; GitHub Free only provides 1GB of storage and 1GB of bandwidth per month for Git LFS. Exceeding these limits incurs extra charges.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Issues with GitHub Pages:&lt;/strong&gt; When deploying GitHub Pages from a repository that uses LFS, LFS files are not served properly, resulting in broken links and missing content.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Complicated removal process:&lt;/strong&gt; Once you&amp;rsquo;ve adopted Git LFS, removing it from a repository is a tricky and potentially risky process.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Because of the bandwidth cap, I remember running out of bandwidth after cloning the repository just a few times. That forced me to figure out how to strip Git LFS out of the repository.&lt;/p&gt;
&lt;h2 id="4-how-to-remove-git-lfs"&gt;4. How to Remove Git LFS&lt;/h2&gt;&lt;p&gt;To remove Git LFS from a repository, follow these steps:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt; 1
&lt;/span&gt;&lt;span class="lnt"&gt; 2
&lt;/span&gt;&lt;span class="lnt"&gt; 3
&lt;/span&gt;&lt;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;span class="lnt"&gt; 7
&lt;/span&gt;&lt;span class="lnt"&gt; 8
&lt;/span&gt;&lt;span class="lnt"&gt; 9
&lt;/span&gt;&lt;span class="lnt"&gt;10
&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-shell" data-lang="shell"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git lfs uninstall
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git rm --cached &lt;span class="s2"&gt;&amp;#34;*.mp4&amp;#34;&lt;/span&gt; &lt;span class="c1"&gt;# Replace with the file patterns you tracked with LFS&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Edit the .gitattributes file to remove any LFS-related entries&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git add .gitattributes
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git commit -m &lt;span class="s2"&gt;&amp;#34;remove: Git LFS&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git push
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;&lt;strong&gt;Note:&lt;/strong&gt; This process can be much more complicated if your repository already has commit history containing Git LFS objects. In that case, you may need to rewrite history or create a fresh repository and migrate your non-LFS history over to it.&lt;/p&gt;
&lt;p&gt;In some cases, you may also need to open a ticket with GitHub Support to delete the LFS objects stored on GitHub&amp;rsquo;s LFS servers for your repository.&lt;/p&gt;
&lt;h2 id="5-alternatives"&gt;5. Alternatives&lt;/h2&gt;&lt;p&gt;Instead of using Git or Git LFS for large files, my advice is to separate your source code from large assets altogether. For example: upload videos to YouTube, upload images to Imgur, etc., and reference their links in your repository.&lt;/p&gt;
&lt;p&gt;When building the website for Ngăm, I ended up running an optimization tool to compress the videos under the 100MB threshold so they could be stored directly on GitHub. That allowed me to avoid Git LFS entirely and stop worrying about bandwidth limits.&lt;/p&gt;</description></item></channel></rss>