<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Code Quality on miti99</title><link>https://miti99.com/en/tags/code-quality/</link><description>Recent content in Code Quality 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/code-quality/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #119</title><link>https://miti99.com/en/post/2026/07/07/</link><pubDate>Tue, 07 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #119.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="special-cases-in-go"&gt;&lt;a href="https://www.dolthub.com/blog/2026-05-22-special-cases-in-go/" rel="noopener noreferrer"&gt;Special Cases in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go is frequently marketed as a &amp;ldquo;simple&amp;rdquo; language that deliberately avoids special cases. Nick Tobey points out that Go actually has plenty of exceptions hiding in unexpected places. The &lt;code&gt;init&lt;/code&gt; function is the clearest example: it runs automatically when a package is imported, takes no arguments, returns no values, can be declared multiple times within the same package, yet cannot be called manually. If you try to call it, the compiler reports &lt;code&gt;undefined: init&lt;/code&gt; without further explanation. Similarly, the &lt;code&gt;internal&lt;/code&gt; directory creates a visibility scope narrower than public/private, yet that rule doesn&amp;rsquo;t exist in the Go language specification at all—it is enforced by the &lt;code&gt;go&lt;/code&gt; toolchain.&lt;/p&gt;
&lt;p&gt;The reason is that the language spec intentionally leaves import path interpretation implementation-defined. That flexibility lets build systems like Bazel apply their own rules while allowing the standard &lt;code&gt;go&lt;/code&gt; toolchain to evolve without amending the language spec—adding special cases like &lt;code&gt;internal&lt;/code&gt; directories or &lt;code&gt;_test&lt;/code&gt; package suffixes that live in the same directory as the package under test. Tobey also notes that a package&amp;rsquo;s declared name doesn&amp;rsquo;t have to match its directory name, forcing IDEs to parse every imported package just to resolve where an identifier comes from; for new code, explicit import aliases avoid the ambiguity. The broader takeaway: while most of these quirks rarely get in the way of day-to-day work, they show that a language&amp;rsquo;s simplicity often just means the complexity was pushed somewhere else.&lt;/p&gt;
&lt;h2 id="writing-code-vs-shipping-code-productivity-effects-across-generations-of-ai-coding-tools"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/writing-code-vs-shipping-code.html" rel="noopener noreferrer"&gt;Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Murat Demirbas analyzes an MIT and Wharton study that combines internal Microsoft telemetry with public GitHub traces from over 100,000 developers to measure the real-world productivity impact of AI coding tools. The study divides tools into three generations: autocomplete, synchronous agents like Claude Code or Cursor, and asynchronous agents. Output gains at the lines-of-code level are striking, but attenuate sharply at each downstream stage—from files to commits, pull requests, repositories, and finally shipped releases: with autocomplete, lines of code jump by over 228% while shipped releases rise by only ~10%; with synchronous agents, the corresponding numbers are 741% and 20%.&lt;/p&gt;
&lt;p&gt;While Demirbas is skeptical of applying a linear manufacturing production function to software development, he finds the framing useful because it exposes human coordination and review costs. Translating the findings into Amdahl&amp;rsquo;s Law, he calculates that the parallelizable, acceleratable fraction of software work sits right around 35% across all three tool generations—matching the share of time developers actually spend writing code. Agents produce more shipped releases not because they expand that 35% slice, but because they accelerate it more aggressively and intervene closer to the finish line. The remaining 65%—understanding the problem, planning, team alignment, and code review—remains a serial bottleneck. To genuinely ship faster, organizations have to improve those non-coding stages rather than just generating code faster.&lt;/p&gt;
&lt;h2 id="when-was-the-last-time-you-did-just-one-thing"&gt;&lt;a href="https://alifeengineered.substack.com/p/when-was-the-last-time-you-did-just" rel="noopener noreferrer"&gt;When Was the Last Time You Did Just One Thing?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Huynh recounts packing for a long trip: downloading dozens of YouTube videos, queueing up a backlog of podcasts, packing a handheld game console, two physical books, a Kindle, and his laptop just in case he wanted to get some work done. Then it hit him that this entire &amp;ldquo;arsenal&amp;rdquo; against a single moment of boredom would cause him to miss the trip itself—and that paradoxically, the harder we try not to waste a single second, the emptier every second feels. While the public preview ends there, the message from the title and setup is unmistakable: doing just one thing at a time is no longer our default state, but a skill we have to actively practice.&lt;/p&gt;
&lt;p&gt;For people in tech, it is a timely reminder about attention management. Not every quiet gap in the day needs to be filled with upskilling, podcasts, or side work. When every spare moment is stuffed with fresh stimulation, we gradually lose the ability to observe, rest properly, think deeply, and be fully present with whatever is in front of us. Looking busy and optimized isn&amp;rsquo;t the same as living intentionally; leaving blank space in your day is part of sustainable productivity, especially in engineering roles already fragmented by constant context switching.&lt;/p&gt;
&lt;h2 id="predicting-ai-job-exposure"&gt;&lt;a href="https://www.ben-evans.com/benedictevans/2026/5/24/ai-job-exposure" rel="noopener noreferrer"&gt;Predicting AI job exposure&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benedict Evans critiques efforts to score which professions, companies, or industries are most &amp;ldquo;exposed&amp;rdquo; to AI disruption. In his view, this amounts to predicting the unpredictable, and the simplest sanity check is running the same methodology backward against previous technology waves. Over the past century, we automated accounting with mainframes, databases, spreadsheets, and ERPs—yet the total number of accountants kept growing. When analysis becomes cheap and fast, organizations do far more of it and ask different questions, while new regulations create entire categories of compliance work.&lt;/p&gt;
&lt;p&gt;A second blind spot is that a job&amp;rsquo;s core tasks can stay unchanged while the business model underneath it collapses: the internet didn&amp;rsquo;t automate away the craft of journalism, it destroyed the classified-ad monopoly that funded newsrooms. Third are second-order shocks nobody extrapolates from task lists, like smartphone GPS enabling Uber and reshaping the taxi industry. Deeper still, occupational databases like O*NET cannot capture what a real job actually entails, much like early expert systems failed to capture tacit human expertise. Evans concludes that while high-level frameworks are useful for thinking, granular job-by-job forecasts at this early stage will only be right by accident, because we have no way of knowing whether the exceptions will dwarf the rule.&lt;/p&gt;
&lt;h2 id="choosing-values-for-robust-tests"&gt;&lt;a href="https://testing.googleblog.com/2026/06/choosing-values-for-robust-tests.html" rel="noopener noreferrer"&gt;Choosing Values for Robust Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Radion Khait highlights a subtle testing bug that is remarkably easy to miss: a test passes not because the implementation is correct, but because the test input happens to match the type&amp;rsquo;s default value. In the post&amp;rsquo;s example, a custom map&amp;rsquo;s &lt;code&gt;insert&lt;/code&gt; method forgets to assign the &lt;code&gt;value&lt;/code&gt; parameter and simply default-initializes the entry. A test that inserts &lt;code&gt;0&lt;/code&gt; and asserts that lookup returns &lt;code&gt;0&lt;/code&gt; passes with flying colors, because &lt;code&gt;0&lt;/code&gt; is already the default value for an integer. The result is a false sense of security: the method was called, but nothing proved the input was actually stored.&lt;/p&gt;
&lt;p&gt;From that example, Khait distills three practical rules for choosing test inputs. First, always use non-default values: non-zero numbers, non-empty strings, and enum variants other than the first declared value—changing &lt;code&gt;0&lt;/code&gt; to &lt;code&gt;5&lt;/code&gt; exposes the map bug immediately. Second, where appropriate, test representative inputs across equivalence classes such as empty, missing, &lt;code&gt;null&lt;/code&gt;, boundary values, and inputs that trigger complex branches, optionally pairing with fuzzing for broader coverage. Third, use distinct values for every parameter so tests immediately catch implementations that accidentally reuse an argument or swap parameter order; parameterized tests make it easy to cover multiple input combinations without duplicating test code.&lt;/p&gt;
&lt;h2 id="ai-demands-more-engineering-discipline-not-less"&gt;&lt;a href="https://charity.wtf/p/ai-demands-more-engineering-discipline" rel="noopener noreferrer"&gt;AI demands more engineering discipline. Not less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charity Majors pushes back against a growing temptation: if AI generates code quickly and reasonably well, can we relax code reviews, verification, and engineering rigor? Her answer is the exact opposite. As the cost of generating code plummets, lines of code stop being a precious asset and become a disposable artifact of our current understanding. A software team&amp;rsquo;s true output is shared understanding, and what retains lasting value is everything that tells us whether the system is actually working: requirements, invariants, failure modes, tests, observability, and reproducibility.&lt;/p&gt;
&lt;p&gt;She compares the AI wave to the shift from hand-tended &amp;ldquo;pet&amp;rdquo; servers to immutable infrastructure. Once servers could be torn down and rebuilt at will, engineering discipline didn&amp;rsquo;t vanish—it moved up a level into configuration management, provisioning pipelines, verification, and repeatable operations. Software is undergoing the same shift: when code can be regenerated cheaply, individual lines of code stop being the highest-leverage place to spend review energy, and focus moves to artifacts that specify behavior, architecture, trade-offs, and production outcomes. Human brains were never great at statically verifying code anyway, and non-deterministic AI systems make tracing, testing in production, record-and-replay, and tight feedback loops even more critical. Far from making software less rigorous, AI demands more engineering discipline than ever.&lt;/p&gt;
&lt;h2 id="nine-questions-i-now-ask-in-interviews-that-i-wish-i"&gt;&lt;a href="https://louisedeason.substack.com/p/nine-questions-i-now-ask-in-interviews" rel="noopener noreferrer"&gt;Nine Questions I Now Ask in Interviews That I Wish I&amp;rsquo;d Asked Five Years Ago&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Louise Deason reminds candidates that an interview is a two-way evaluation, even though most people still treat it like a school exam—which conveniently benefits the employer. The &amp;ldquo;do you have any questions for us?&amp;rdquo; segment at the end is the most underutilized part of the process, precisely because interviewers let their guard down and inadvertently reveal how the org actually runs. She shares nine questions designed to force specific, revealing answers: how the most recent promotion on the team happened, what the longest-tenured person in this role is doing now, what the team is genuinely bad at, how the team handled a recent disagreement with leadership, headcount plans for the next year, whether you can meet the people you&amp;rsquo;ll actually work with day to day, what six-month success and failure look like, when the last reorg happened, and why this role is open.&lt;/p&gt;
&lt;p&gt;The real signal lies in how the interviewer responds: whether the answer is concrete, evasive, or hesitant. A clear story about promotion criteria or an honest admission of a team&amp;rsquo;s weak spots signals transparency; conversely, claims that &amp;ldquo;we always agree,&amp;rdquo; reluctance to let you speak with future peers, or an awkward pause when asked why the seat is open are major red flags. Her closing reminder: you are always choosing between differently imperfect options, and any company that gets defensive when asked thoughtful questions doesn&amp;rsquo;t deserve your time.&lt;/p&gt;
&lt;h2 id="agentic-testing-where-agents-fit-in-the-e2e-testing-stack"&gt;&lt;a href="https://slack.engineering/agentic-testing-where-agents-fit-in-the-e2e-testing-stack/" rel="noopener noreferrer"&gt;Agentic Testing: Where Agents Fit in the E2E Testing Stack&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergii Gorbachov at Slack shares findings from over 200 end-to-end test runs powered by AI agents, exploring where agentic testing belongs in the testing stack. Traditional E2E tests enforce a rigid, scripted path through the UI, whereas agentic tests start from a high-level goal: the agent observes the current UI state, decides the next action on the fly, and verifies the outcome. The team benchmarked three approaches—an agent driving Playwright MCP, an agent driving Playwright CLI, and AI-generated deterministic Playwright test scripts—against a staging workspace with synthetic data across two user flows: replying to a thread and search discovery.&lt;/p&gt;
&lt;p&gt;The AI-generated Playwright scripts ran fastest at around 3 minutes, but their failure rate spiked to ~48% on the more complex flow. Using Sonnet 4.5 to run the agent and Opus 4.6 to generate tests, Playwright MCP achieved the lowest failure rate at 0–12%, compared to 12–20% for Playwright CLI, where most failures stemmed from login and navigation hiccups at the execution layer. MCP also required fewer interaction turns because it batches actions and returns updated state in a single round-trip. However, each agentic test run cost $15–$30 and took over 5 minutes, with most of the cost driven by repeatedly re-sending conversation history. Slack&amp;rsquo;s conclusion: deterministic E2E tests remain the backbone for fast CI regression checks, while agentic testing sits as a complementary layer at the top of the testing pyramid—ideal for exploratory testing of complex flows, diagnosing flaky journeys, and reproducing production bugs.&lt;/p&gt;
&lt;h2 id="making-agents-easy-13-lessons-from-forter"&gt;&lt;a href="https://blog.forter.dev/making-agents-easy-13-lessons-from-forters-agentic-ai-sprint/" rel="noopener noreferrer"&gt;Making Agents Easy: 13 Lessons from Forter&amp;rsquo;s Agentic AI Sprint&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Maraney recounts how Forter ran a two-week company-wide sprint to get their entire R&amp;amp;D organization building AI agents. The core thesis isn&amp;rsquo;t that building agents is inherently effortless, but that an organization can systematically remove friction across three layers: tooling, agent runtime infrastructure, and organizational guardrails. On the tooling side, Forter built an internal MCP server called Toolchain: engineers open a web UI, pick and configure the tools they need, and immediately get an API key; adding a new internal tool takes just a declarative YAML file and a thin wrapper. By the end of the two-week sprint, Toolchain had grown to over 90 internal tools. And rather than standing up a complex custom RAG pipeline, they exposed their existing enterprise search engine as an MCP tool.&lt;/p&gt;
&lt;p&gt;The post shares several pragmatic operational lessons as well. Agent builders need full visibility into every raw tool request and response—one Forter incident-response agent appeared to &amp;ldquo;solve&amp;rdquo; an outage brilliantly until traces revealed it had simply read the already-written postmortem doc. For internal human-in-the-loop tools, teams don&amp;rsquo;t need formal eval suites on day one; prioritize tracing and observability first. Bring legal and security in early, enforce permissions in deterministic code rather than prompts, and put token costs on a visible dashboard. Finally, when training teams, tell them to treat an LLM like a bright new-grad intern: broad textbook knowledge, zero institutional context—meaning the responsibility for giving clear instructions rests squarely on the builder.&lt;/p&gt;
&lt;h2 id="agentic-code-review"&gt;&lt;a href="https://addyosmani.com/blog/agentic-code-review/" rel="noopener noreferrer"&gt;Agentic Code Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that as coding agents write code faster and faster, the primary bottleneck in software engineering shifts from writing code to verifying and trusting it. AI can produce mountains of syntactically valid, test-accompanied, plausible-looking code, but human reading comprehension hasn&amp;rsquo;t sped up to match. That makes code review the highest-leverage skill in modern engineering: not merely hunting for typos, but reconstructing intent, assessing blast radius, spreading system knowledge across the team, and deciding whether a change should exist at all. Industry data from 2026 cited in the post shows that while code output has surged, code churn, defects, production incidents, and review wait times have climbed right alongside it.&lt;/p&gt;
&lt;p&gt;There is no single review policy that fits every context. Solo side projects with no users can lean heavily on automated tests and AI review; long-lived production systems handling real users, money, or sensitive data require risk-tiered human review. Osmani recommends keeping pull requests small, stating intent explicitly, requiring concrete proof of verification (such as real test outputs) before human review begins, reading test diffs more closely than implementation diffs, treating deterministic CI as a non-negotiable guardrail, and using AI reviewers as sensors rather than final judges. Humans may no longer read every single generated line, but they still own the merge button, carry accountability for production, and must focus their deepest scrutiny on high-blast-radius changes like auth, billing, security, and privacy.&lt;/p&gt;
&lt;h2 id="i-thought-redis-was-just-a-hashmap"&gt;&lt;a href="https://mukul0x9.pages.dev/blog/memdb/" rel="noopener noreferrer"&gt;I Thought Redis Was Just a HashMap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mukul Makwana starts from a deceptively simple question: how different is Redis or Memcached from a global hash map supporting &lt;code&gt;set&lt;/code&gt;, &lt;code&gt;get&lt;/code&gt;, and &lt;code&gt;del&lt;/code&gt;? To find out, he built a minimal in-memory database from scratch in Go. Version one wrapped Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt;, accepted commands over TCP, and spawned one goroutine per client connection. The bottleneck appeared immediately as soon as multiple goroutines read and wrote concurrently: the map needed synchronization, and a single global mutex forced every operation to wait in line.&lt;/p&gt;
&lt;p&gt;To fix that, Makwana replaced the built-in map with a two-array arena design: &lt;code&gt;bucket_array&lt;/code&gt; stores offsets while &lt;code&gt;data_array&lt;/code&gt; packs metadata, keys, values, and next-entry offsets for collision chaining in contiguous byte slices. To reduce lock contention, the keyspace is partitioned into shards, each with its own arrays and &lt;code&gt;RWMutex&lt;/code&gt;, while a background goroutine handles shard resizing when load factors climb. Because &lt;code&gt;data_array&lt;/code&gt; is append-only, deletes simply mark a tombstone bit, and a compaction pass rebuilds the shard once dead bytes cross a threshold—at the cost of locking that shard during compaction. Benchmarking &lt;code&gt;SET&lt;/code&gt; workloads showed Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt; still winning on raw throughput and stop-the-world pause times, but the custom pointer-free arena slashed concurrent GC mark time from ~113 ms down to 7.8 ms. Even then, this toy engine still lacks persistence, eviction policies, crash recovery, and replication—the exact things that make real Redis a serious piece of engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #108</title><link>https://miti99.com/en/post/2026/06/04/</link><pubDate>Thu, 04 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #108.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-is-solved-software-is-not"&gt;&lt;a href="https://arcplane.ai/journal/software-is-not-solved" rel="noopener noreferrer"&gt;Coding is solved? Software is not.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Opening with Boris Cherny&amp;rsquo;s (creator of Claude Code) remark that coding is &amp;ldquo;basically solved,&amp;rdquo; Arcplane&amp;rsquo;s Gao argues that the statement is true but incomplete. Coding is merely translating instructions into source code, whereas software development is turning ambiguous intent into a reliable system — a process of progressively reducing entropy. The paradox is that fast AI code generation can actually increase entropy: massive test suites that only validate whatever implementation the agent happened to pick, and plausible-sounding plans that leave core product decisions unresolved. Code arrives sooner, but the team doesn&amp;rsquo;t reach confidence any sooner — the bottleneck simply shifts to review, reconstructing the agent&amp;rsquo;s intent, and interpreting noisy verification evidence.&lt;/p&gt;
&lt;p&gt;Drawing on experience running an authentication product managing millions of identities, the author points to four things that need to change. First, context must be curated deliberately, and review feedback must be captured for future runs. Second, specifications must live alongside the work and be updated as new edge cases surface, because an agent will happily build a complete implementation of an ambiguous requirement. Third, verification evidence must be clear enough for a reviewer to see what the agent ran, what failed, and how it fixed it. Fourth, humans need well-placed checkpoints — especially before deployment — because &amp;ldquo;clean code cannot save a bad spec,&amp;rdquo; and review depth should scale with risk.&lt;/p&gt;
&lt;h2 id="ideas"&gt;&lt;a href="https://www.noahzender.com/ideas" rel="noopener noreferrer"&gt;Ideas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rather than a single essay, this is Noah Zender&amp;rsquo;s index page collecting nearly 500 mental models, patterns, and frameworks distilled from hundreds of books, podcasts, and videos. The ideas are organized into 11 categories: mental models and decision-making, knowledge and learning, creativity and writing, product and startups, brand and marketing, tech innovation and AI, investing and economics, psychology and self-improvement, work and leadership, philosophy and worldview, plus an uncategorized bucket. Each entry links to a short standalone page, reading more like a personal knowledge base than a linear article.&lt;/p&gt;
&lt;p&gt;A representative example is the &amp;ldquo;Leveraged Expert&amp;rdquo; concept, which argues that &lt;em&gt;when&lt;/em&gt; you specialize matters just as much as &lt;em&gt;what&lt;/em&gt; you specialize in. Every technology adoption curve has an inflection point where growth either crosses into the mainstream or rapidly fizzles out. If you are already an expert in a field right as it hits that inflection point, your leverage compounds automatically as adoption takes off without requiring extra effort on your part. Specializing too early in a field that is still too nascent yields much lower leverage; the sweet spot is the early-adopter phase, where the surface area for luck is highest. For younger developers, it&amp;rsquo;s a useful lens when deciding which technologies to invest in deeply.&lt;/p&gt;
&lt;h2 id="ai-productivity-debate"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-productivity-debate" rel="noopener noreferrer"&gt;AI productivity debate&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from DX&amp;rsquo;s Engineering Enablement newsletter recaps the closing panel of the DX Annual conference, featuring engineering leaders and researchers from Etsy, Twilio, GitHub, Google, and DX. Asked whether AI will mean needing fewer engineers, most panelists disagreed: demand for software rises as the cost of building it falls, so total builder headcount won&amp;rsquo;t shrink even if the definition of an engineer evolves. On technical debt, opinions split: Twilio&amp;rsquo;s representative viewed AI as an amplifier (garbage in, garbage out), while Brian Houck warned that organizations are optimizing for PR velocity over simplicity, accumulating &amp;ldquo;comprehension debt&amp;rdquo; as humans understand less and less of a codebase largely written by AI.&lt;/p&gt;
&lt;p&gt;The panelists opposed top-down AI mandates: Twilio simply pre-installed tools and offered basic guidance yet still saw adoption surge, whereas mandates tend to breed superficial compliance. Using AI utilization as an individual performance metric was roundly rejected by engineers. As for bottlenecks, developers spend only about 14% of their time writing code, so the real constraints remain decision-making, prioritization, and product design; code review mostly feels slower because code is being generated faster. Finally, most adoption hurdles are human and cultural: leaders need to give engineers dedicated time to learn, and two-week group learning sprints proved far more effective than isolated solo tinkering.&lt;/p&gt;
&lt;h2 id="maintainability-sensors-for-coding-agents"&gt;&lt;a href="https://martinfowler.com/articles/sensors-for-coding-agents.html" rel="noopener noreferrer"&gt;Maintainability sensors for coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) shares hands-on experiments with maintainability &amp;ldquo;sensors&amp;rdquo; that help both humans and AI coding agents gauge code quality, building on the concept of &amp;ldquo;harness engineering.&amp;rdquo; Her testbed was a TypeScript, Next.js, and React dashboard rebuilt entirely with AI and given almost no up-front code-quality instructions, designed to see how far an agent could get relying solely on feedback from sensors like the type checker, ESLint, Semgrep, &lt;code&gt;dependency-cruiser&lt;/code&gt;, the test suite, and mutation testing. With ESLint, she enabled rules capping parameter counts, file length, function length, and cyclomatic complexity, rewriting error messages into actionable remediation instructions and allowing the agent to suppress warnings only if it attached an explicit justification for reviewers.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;dependency-cruiser&lt;/code&gt; helped the agent respect layered module boundaries and self-correct violations. Raw coupling metrics, by contrast, proved noisy and poorly interpreted by AI because &amp;ldquo;good&amp;rdquo; versus &amp;ldquo;bad&amp;rdquo; coupling depends heavily on context — whereas an AI modularity review guided by a strong prompt caught valuable issues like duplicated route logic and misplaced responsibilities. For AI-generated tests, high line coverage did not guarantee quality: some files hit 100% statement coverage without a single true unit test, and only mutation testing exposed the missing assertions. Böckeler concludes that computational sensors work best at the file and function level, while cross-module design issues require AI to supply semantic interpretation. Sensors boost confidence in agent output, but they still cannot replace human judgment.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #88</title><link>https://miti99.com/en/post/2026/03/13/</link><pubDate>Fri, 13 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #88.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-broken-heart"&gt;&lt;a href="https://allenpike.com/2026/a-broken-heart/" rel="noopener noreferrer"&gt;A Broken Heart&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allen Pike recounts a memorable debugging war story: the dashboard of a web app his team was building suddenly started taking ten seconds to load instead of one. He immediately suspected React and asked Claude to audit the components, but fixing redundant renders and missing memoization barely moved the needle. Digging deeper, he noticed the slowdown only happened in Safari, where the profiler showed the browser spending 94% of CPU time in Layout—over 1,600ms per pass, roughly 100 times slower than normal. Pairing binary search with a coding agent, he systematically stripped out pieces of the UI to narrow down the culprit. Within about ten minutes, the offender emerged: a single heart emoji ❤️ inside a &amp;ldquo;Send Feedback&amp;rdquo; button. Removing the emoji dropped Layout time to 2ms.&lt;/p&gt;
&lt;p&gt;With the coding agent&amp;rsquo;s help, he quickly put together a minimal reproduction for a bug report and uncovered the root cause: Google&amp;rsquo;s Noto Color Emoji webfont, which had been added so emojis would render consistently on Linux. The font uses the COLRv1 format and falls back to embedded SVGs on browsers that don&amp;rsquo;t support it, including Safari; the WebKit team confirmed the bottleneck was inside Apple&amp;rsquo;s CoreSVG. The bug was even glyph-specific: ❤️ and 🤯 took 1,600ms, while 🧺 and 🫠 took just 0.2ms. The workaround was placing &lt;code&gt;&amp;quot;Apple Color Emoji&amp;quot;&lt;/code&gt; ahead of &lt;code&gt;&amp;quot;Noto Color Emoji&amp;quot;&lt;/code&gt; in the &lt;code&gt;font-family&lt;/code&gt; stack. The punchline: Claude was the one that had suggested adding Noto Color Emoji in the first place, prompting the author to compare coding agents to a chainsaw—wildly productive, and proportionally dangerous.&lt;/p&gt;
&lt;h2 id="wrapping-code-comments"&gt;&lt;a href="https://matklad.github.io/2026/02/21/wrapping-code-comments.html" rel="noopener noreferrer"&gt;Wrapping Code Comments&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this short note, matklad makes two observations about line wrapping: code and comments should be wrapped at different widths, and comment width should be measured relative to where the comment starts. A hard limit around 100 columns makes sense for code because it still fits two editor panes side by side, whereas prose reads best at around 60–70 columns. The apparent contradiction disappears once you account for indentation eating into the line and code being much sparser horizontally than prose. Accordingly, the author wants code lines wrapped at 100 columns and comment text wrapped at roughly 70 columns; deeply indented comments shift to the right while keeping the same measure of text, as long as the total line length stays under 100.&lt;/p&gt;
&lt;p&gt;Simple as that sounds, popular editors don&amp;rsquo;t support it well: VS Code&amp;rsquo;s Rewrap extension lets you configure a separate width for comments, but measures it from column zero, making deeply indented comments narrower and narrower, while Emacs&amp;rsquo;s &lt;code&gt;M-q&lt;/code&gt; doesn&amp;rsquo;t wrap comments to a relative width by default either. The author also explains why soft wrapping in the editor isn&amp;rsquo;t a substitute: proper wrapping requires understanding the structure of the text—for example, a wrapped line inside a Markdown list item needs to align with the item&amp;rsquo;s indentation, which only works when the comment is parsed as Markdown.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!h2M_!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1d6d88ea-4355-4f29-96fa-9770907beebb_2360x2960.png" alt="RabbitMQ vs Kafka vs Pulsar"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!8P-v!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6039d506-e02f-4313-ab97-2c04f8c94d90_2360x2960.png" alt="REST vs GraphQL"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yela!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5ac3310f-e380-48c2-93ff-051f7606b533_2250x2624.png" alt="Eventual Consistency in Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!vB9v!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fbc02c74f-e91f-438a-8ad8-d5ba6831e7f0_2250x2624.png" alt="Strong Consistency In Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!h8d0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc5f67fe5-0efa-4fc6-98da-d176b60b1a92_2508x3000.jpeg" alt="PostgreSQL versus MySQL"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_roW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fdbdb9cae-3bda-4a62-9077-3f9d1e13fede_2360x2960.jpeg" alt="Network Protocols Explained"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=z_NbVtbgBJw" rel="noopener noreferrer"&gt;Video: What Is Redis Really About? - ByteByteGo&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #81</title><link>https://miti99.com/en/post/2026/02/18/</link><pubDate>Wed, 18 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/18/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #81.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="java-interview-question---why-you-should-not-use-static-initializers"&gt;&lt;a href="https://javabulletin.substack.com/p/java-interview-question-why-you-should" rel="noopener noreferrer"&gt;Java Interview Question - Why you should not use static initializers?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains why you should avoid static initializer blocks (&lt;code&gt;static { ... }&lt;/code&gt;) in Java, even though they look convenient for setting up complex static state. The biggest hazard is that a static block runs when the JVM initializes the class (the first time an instance is created, a static method is called, or a non-constant static field is accessed): if it throws an uncaught exception, the JVM wraps it in an &lt;code&gt;ExceptionInInitializerError&lt;/code&gt; and marks the class as permanently unusable, causing subsequent accesses and dependent classes to fail in a cascade that is notoriously painful to debug. Static blocks also execute implicitly at times developers rarely control, hiding side effects. Worse, when multiple classes have interdependent static blocks, initialization order depends on whichever class happens to be touched first at runtime rather than clear application logic, breeding subtle order-dependent bugs.&lt;/p&gt;
&lt;p&gt;Instead, the author recommends lazy initialization or constructor-based dependency injection so initialization happens explicitly when needed. That allows exceptions to be handled gracefully, prevents the application from crashing at startup over an unused class, makes unit testing much easier, and keeps code clear and maintainable.&lt;/p&gt;
&lt;h2 id="how-to-write-high-performance-code"&gt;&lt;a href="https://blog.bytebytego.com/p/how-to-write-high-performance-code" rel="noopener noreferrer"&gt;How to Write High-Performance Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteGo article distills foundational principles for writing high-performance code without requiring deep systems expertise, starting with building intuition for where performance actually matters—typically just ~3% of a codebase. The first skill is back-of-the-envelope cost estimation before writing code: CPU cache accesses take nanoseconds, RAM is roughly 100x slower, SSD reads are 40,000x slower, and network calls are slower still. For example, processing one million records with a separate 50 ms database round-trip per record would take nearly 14 hours, whereas batching 1,000 records per query brings total time down to about 50 seconds. The golden rule is to measure first and optimize second, since human intuition about bottlenecks is frequently wrong; always profile against realistic workloads.&lt;/p&gt;
&lt;p&gt;Algorithmic improvements yield the largest speedups—often 10x to 100x: finding common elements between two 1,000-item lists with nested loops takes a million comparisons (&lt;code&gt;O(N²)&lt;/code&gt;), while loading one list into a hash set takes just ~1,000 lookups (&lt;code&gt;O(N)&lt;/code&gt;). Memory layout matters just as much: data accessed together should sit contiguously in memory, which is why arrays usually outperform linked lists by making full use of CPU cache lines. Finally, the post recommends minimizing memory allocations, pre-allocating container capacity, pooling and reusing objects, adding fast paths for common cases, and eliminating unnecessary work altogether.&lt;/p&gt;
&lt;h2 id="introducing-moltworker-a-self-hosted-personal-ai-agent-minus-the-minis"&gt;&lt;a href="https://blog.cloudflare.com/moltworker-self-hosted-ai-agent/" rel="noopener noreferrer"&gt;Introducing Moltworker: a self-hosted personal AI agent, minus the minis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare introduces Moltworker, a way to run Moltbot (the open-source personal AI assistant, renamed OpenClaw in January 2026) entirely on Cloudflare&amp;rsquo;s platform instead of buying a dedicated Mac mini. The architecture consists of an entrypoint Worker acting as an API router and proxy alongside adapted scripts, all protected behind Cloudflare Access. Under the hood, the Sandbox SDK provides isolated containers to run Moltbot&amp;rsquo;s native runtime with a clean API for command execution and lifecycle management; Browser Rendering provides a headless Chromium instance accessed via a thin Chrome DevTools Protocol proxy so the agent can browse the web, fill out forms, and take screenshots; and R2 stores session state and conversation history, mounted as a filesystem volume so data persists across ephemeral container restarts.&lt;/p&gt;
&lt;p&gt;AI Gateway sits between the agent and model providers, supporting Bring Your Own Key (BYOK) or Unified Billing while centralizing cost tracking and logs. Zero Trust Access protects the API and admin UI with custom authentication policies, automatically issuing JWTs validated on every request. Because Cloudflare Workers now offer deep Node.js compatibility (Cloudflare tested the top 1,000 npm packages and found only 15 incompatible after excluding build tools, CLIs, and browser-only packages), most logic can run directly on Workers. The source code is open-sourced on GitHub, and Cloudflare notes that Moltworker is a proof-of-concept demonstrating that their developer platform can host complex, stateful AI agents without dedicated hardware.&lt;/p&gt;
&lt;h2 id="building-a-high-performance-rotating-bloom-filter-in-java"&gt;&lt;a href="https://medium.com/@udaysagar.2177/building-a-high-performance-rotating-bloom-filter-in-java-a9e75de993bf" rel="noopener noreferrer"&gt;Building a High-Performance Rotating Bloom Filter in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uday Sagar walks through building a rotating Bloom filter in his open-source Java library to answer &amp;ldquo;have I seen this element recently?&amp;rdquo; over an unbounded data stream while keeping memory usage strictly bounded. Instead of a single fixed-capacity filter whose false-positive rate climbs toward 100% as it fills up, a rotating Bloom filter partitions stream data into time windows and automatically expires old windows (based on first-insertion time rather than LRU), making it ideal for stream deduplication. For lock-free concurrent writes, threads set bits using Compare-And-Swap (&lt;code&gt;CAS&lt;/code&gt;) loops on an &lt;code&gt;AtomicLongArray&lt;/code&gt; and retry on contention; because bits are spread across millions of positions, collisions are rare, yielding 3–4x higher throughput than lock-based synchronization. When a time window expires, the active filter is copied into an immutable &lt;code&gt;long[]&lt;/code&gt; array for faster reads, forming a chain &lt;code&gt;[ReadOnly-1, ReadOnly-2, ReadOnly-3, Active]&lt;/code&gt;: writes go exclusively to &lt;code&gt;Active&lt;/code&gt;, while reads check from newest to oldest.&lt;/p&gt;
&lt;p&gt;To prevent lost writes when a thread is mid-write as a window rotates, the write path acquires the read lock of a &lt;code&gt;ReentrantReadWriteLock&lt;/code&gt; while the rare rotation step acquires the write lock, leaving queries completely lock-free. Across &lt;em&gt;N&lt;/em&gt; independent windows, the cumulative false-positive rate compounds as &lt;code&gt;1 - (1 - p)^N&lt;/code&gt;, so five windows configured at 1% each produce nearly a 5% overall false-positive rate; configuring per-window rates lower balances retention duration against accuracy. Combined with double hashing and &lt;code&gt;xxHash&lt;/code&gt;, the library achieves millions of operations per second.&lt;/p&gt;
&lt;h2 id="what-every-java-developer-should-know-about-thread-pools"&gt;&lt;a href="https://dev.to/realnamehidden1_61/what-every-java-developer-should-know-about-thread-pools-4jam" rel="noopener noreferrer"&gt;What Every Java Developer Should Know About Thread Pools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article covers the essentials of thread pools in Java. The author compares spawning a brand-new OS thread for every incoming task to hiring, training, and firing a delivery driver for every single pizza order: it wastes memory and CPU and can crash your server under a traffic spike. A thread pool managed via &lt;code&gt;ExecutorService&lt;/code&gt; maintains a steady pool of worker threads for reuse, bounding the maximum thread count, cutting latency because threads are already warm, and providing a clean API for delayed or periodic scheduling. The post reviews four main flavors: &lt;code&gt;FixedThreadPool&lt;/code&gt; for predictable workloads, &lt;code&gt;CachedThreadPool&lt;/code&gt; which spawns threads on demand and reuses them for short-lived tasks, &lt;code&gt;ScheduledThreadPool&lt;/code&gt; for delayed or recurring jobs, and Java 21&amp;rsquo;s Virtual Threads (&lt;code&gt;newVirtualThreadPerTaskExecutor()&lt;/code&gt;), which run millions of concurrent blocking tasks with minimal overhead.&lt;/p&gt;
&lt;p&gt;On best practices, always shut pools down cleanly (using &lt;code&gt;try-with-resources&lt;/code&gt; in Java 19+), as forgetting to shut down an &lt;code&gt;ExecutorService&lt;/code&gt; is a classic source of memory and thread leaks. For CPU-bound workloads, size the pool to the number of CPU cores; for I/O-bound workloads like database or API calls, use virtual threads. Always give threads meaningful names via a custom &lt;code&gt;ThreadFactory&lt;/code&gt; to make stack traces and thread dumps readable, and avoid &lt;code&gt;newCachedThreadPool()&lt;/code&gt; behind public APIs where a sudden traffic burst can spawn unbounded OS threads.&lt;/p&gt;
&lt;h2 id="goodbye-java-hello-go"&gt;&lt;a href="https://wso2.com/library/blogs/goodbye-java-hello-go" rel="noopener noreferrer"&gt;Goodbye Java, Hello Go!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WSO2, the 20-year-old enterprise middleware company whose server-side codebase was roughly 95% Java, announced it is moving to Go for its next generation of products. The primary driver is how cloud infrastructure has changed: in the container era, servers no longer run continuously for months—they spin up, handle traffic, and scale down, while middleware is increasingly embedded as a library inside a single process. Java&amp;rsquo;s post-startup JIT warmup model is a poor fit for ephemeral containers, startup times are measured in seconds rather than milliseconds, and its heavy ecosystem bloats memory and CPU footprints, driving up cloud bills. In WSO2&amp;rsquo;s view, GraalVM native images and Project Loom are band-aids on a language and runtime designed for a different era.&lt;/p&gt;
&lt;p&gt;WSO2 also evaluated Rust but concluded they didn&amp;rsquo;t need it: Rust shines for OS kernels, browsers, and low-level systems software, whereas WSO2 builds API gateways and identity platforms much higher up the stack. Go hits the sweet spot with efficient memory management, pragmatic concurrency primitives, and straightforward cross-compilation to native binaries, backed by a proven track record in cloud-native infrastructure (Kubernetes, Docker), rich libraries, and a large talent pool. The company has already used Go for nearly a decade across projects like OpenChoreo, the Ballerina compiler rewrite, and its Thunder identity platform. Existing Java products will continue to be supported indefinitely.&lt;/p&gt;
&lt;h2 id="tbm-399-10-prioritization-traps"&gt;&lt;a href="https://cutlefish.substack.com/p/tbm-399-10-prioritization-traps" rel="noopener noreferrer"&gt;TBM 399: 10 Prioritization Traps&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;John Cutler shares 10 product prioritization traps, each named after a classic song; the goal isn&amp;rsquo;t making perfect decisions, but making &amp;ldquo;good enough&amp;rdquo; decisions while avoiding catastrophic ones. &amp;ldquo;Burning Down the House&amp;rdquo; is constantly chasing urgent, low-value fires; combat it by ring-fencing 10–20% of capacity for preventative work. &amp;ldquo;Too Much Time on My Hands&amp;rdquo; is over-polishing medium-value work instead of finding the 80/20 cut; force yourself to define the smallest version shippable in 2–4 weeks. &amp;ldquo;Everybody Wants to Rule the World&amp;rdquo; is when everything is labeled &amp;ldquo;top priority&amp;rdquo; and nothing gets dropped; explicitly name one effort that is allowed to slip. &amp;ldquo;Just Enough Is Never Enough&amp;rdquo; is shipping fast MVPs that only capture 20% of the value before moving on; pre-approve a follow-on investment tranche up front. &amp;ldquo;Running on Empty&amp;rdquo; is letting long projects drift without kill signals; set explicit re-commitment checkpoints.&lt;/p&gt;
&lt;p&gt;&amp;ldquo;Dreamer&amp;rdquo; is open-ended innovation work with no forcing function; add a hard constraint like a live customer demo or integration deadline. &amp;ldquo;Slow Ride&amp;rdquo; is ignoring internal developer friction; measure wasted time as cost of delay. &amp;ldquo;Someday Never Comes&amp;rdquo; is deferring high-upside bets forever due to low confidence; run cheap, failure-tolerant experiments to buy information. &amp;ldquo;The Logical Song&amp;rdquo; is ignoring the cost of increasing confidence; always ask, &amp;ldquo;What is the cheapest way to raise our confidence?&amp;rdquo; Finally, &amp;ldquo;Takin&amp;rsquo; Care of Business&amp;rdquo; is when blocked teams invent busywork to stay utilized; maintain a small, well-vetted queue of high-value fallback tasks instead.&lt;/p&gt;
&lt;h2 id="assessing-internal-quality-while-coding-with-an-agent"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/ccmenu-quality.html" rel="noopener noreferrer"&gt;Assessing internal quality while coding with an agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on Martin Fowler&amp;rsquo;s site, Erik Doernenburg recounts using AI coding agents to add GitLab support to CCMenu, a macOS Swift menu-bar app that displays CI/CD build status. He tested Windsurf with Claude Sonnet 3.5 and later Claude Code with Sonnet 4.5, focusing on an under-discussed dimension: the internal code quality of AI-generated code. The most telling issue occurred when the agent declared the API token parameter on wrapper functions as a non-optional &lt;code&gt;String&lt;/code&gt;, even though the underlying &lt;code&gt;makeRequest&lt;/code&gt; helper accepted an optional &lt;code&gt;String?&lt;/code&gt;; when a caller needed to pass an optional token, the agent patched the call site with &lt;code&gt;apiToken ?? &amp;quot;&amp;quot;&lt;/code&gt; instead of fixing the wrapper&amp;rsquo;s signature—unidiomatic Swift that erased the type system&amp;rsquo;s distinction between &amp;ldquo;no token&amp;rdquo; and an empty string. Beyond that, the agent proposed unnecessary caching, failed to notice fundamental API differences between GitHub and GitLab and wrote convoluted logic for a non-existent problem, duplicated URL-building logic instead of reusing an existing helper, and spun its wheels trying to fetch avatar URLs that lived on a separate endpoint.&lt;/p&gt;
&lt;p&gt;Doernenburg concludes that AI agents naturally gravitate toward accumulating technical debt, making future changes harder for both humans and agents alike. With Windsurf and Sonnet 3.5, the constant supervision required made it not worth the trouble; Claude Code with Sonnet 4.5 was a marked improvement, needing far less hand-holding and proving good enough for regular use. Even so, actively guarding internal code quality remains essential for sustainable software development.&lt;/p&gt;
&lt;h2 id="a"&gt;&lt;a href="https://www.jtolio.com/2026/01/tinyemu-go/" rel="noopener noreferrer"&gt;A &amp;ldquo;Pure Go&amp;rdquo; Linux environment, ported by Claude, inspired by Fabrice Bellard&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;JT Olio recounts using Claude to port Fabrice Bellard&amp;rsquo;s TinyEMU RISC-V emulator from C to pure Go. The result is a pure-Go Linux environment complete with VirtIO devices, filesystem mounting, and networking: a simple &lt;code&gt;go run&lt;/code&gt; boots a Linux environment with root access inside the emulator, requiring no host privileges or containers and running anywhere Go compiles. The first 80% was exhilarating as Claude rapidly translated the foundational subsystems, but the final 20% was grueling: Linux booted the kernel yet failed to mount the &lt;code&gt;initrd&lt;/code&gt;, the project stalled for weeks, and the author lacked mental context because he hadn&amp;rsquo;t written the code himself. Claude repeatedly drifted from instructions, inventing &amp;ldquo;better&amp;rdquo; error handling or ignoring directives to preserve exact C behavior, forcing the author to switch to batch-by-batch function audits cross-referenced against the original C source. He also found the popular agent task tracker Beads overly bloated (294k lines of Go, 128 MB repo) and recommends the lightweight &lt;code&gt;ticket&lt;/code&gt; CLI instead.&lt;/p&gt;
&lt;p&gt;His hard-won lessons for agentic coding: break work into the smallest, most concrete tickets possible; enforce strict commit and test-coverage gates; clear the agent&amp;rsquo;s context window frequently; require the agent to file tickets for any follow-up work or behavioral deviations it encounters; and never expect a cohesive architecture or clean internal API to emerge organically across sessions. The project left him simultaneously impressed and more cautious about LLM coding: writing code by hand is less frustrating and yields higher quality, but at lower throughput; succeeding with Claude means treating it like an eager junior developer who needs tight supervision.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F36412c2b-8782-476e-9db4-aaf794629b74_2250x2624.png" alt="How to Scale An API"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4V7B!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc9589feb-6f59-4971-9da4-26712d1a2ca1_2360x2960.png" alt="HTTP/2 over TCP vs HTTP/3 over QUIC"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ihnd!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ffe954900-e8d8-40d0-a4b1-2f8e14068882_2360x2960.png" alt="How Git Really Stores Your Data"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5SHy!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fcbddfb5f-a652-4749-b0b9-210102774f4f_2360x2960.png" alt="How NAT 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 #70</title><link>https://miti99.com/en/post/2025/12/13/</link><pubDate>Sat, 13 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #70.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-developer-productivity-paradox-why-faster-coding-doesn"&gt;&lt;a href="https://gradle.com/blog/developer-productivity-paradox-faster-coding-slower-delivery/" rel="noopener noreferrer"&gt;The developer productivity paradox: Why faster coding doesn&amp;rsquo;t mean faster software delivery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Trisha Gee (Gradle) distills a central theme from DPE Summit 2025: the developer productivity paradox. Nearly every developer now uses AI (~90%) and over 80% believe it makes them more productive, yet organizational delivery metrics have barely budged. The 2025 DORA report shows that AI is neither the problem nor the cure—it is a mirror and an amplifier of whatever strengths and weaknesses an engineering organization already has. Because AI models carry an inherent error rate, generating more code faster actually makes systems &lt;em&gt;less&lt;/em&gt; stable unless the surrounding delivery pipeline is solid enough to catch defects. Context-switching costs also eat up the time saved: every interruption takes 15–20 minutes to recover from, and AI introduces new interruptions of its own as developers verify outputs, tweak prompts, or jump between tools to debug subtle mistakes.&lt;/p&gt;
&lt;p&gt;To overcome the paradox, Gee argues for treating AI adoption as an organization-wide transformation grounded in Developer Productivity Engineering (DPE): invest in platform engineering and shared standards, strengthen rollback mechanisms, and tighten CI/CD feedback loops; shrink batch sizes, eliminate toil, and apply value-stream management; measure end-to-end flow and business outcomes rather than lines of code or pull request counts; and train engineers to critically evaluate AI-generated code instead of blindly clicking &amp;ldquo;Accept.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="what-actually-makes-you-senior"&gt;&lt;a href="https://terriblesoftware.org/2025/11/25/what-actually-makes-you-senior/" rel="noopener noreferrer"&gt;What Actually Makes You Senior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, the core skill that separates senior engineers from everyone else isn&amp;rsquo;t technical trivia, but the ability to &lt;strong&gt;reduce ambiguity&lt;/strong&gt;. A mid-level engineer can execute a well-defined spec cleanly, but when handed a vague problem like &amp;ldquo;we need to improve performance&amp;rdquo; or &amp;ldquo;users are complaining about the signup flow,&amp;rdquo; a senior engineer digs in: asking questions nobody else thought to ask, separating signal from noise, and deciding what to tackle now versus what to defer. They ask what the real problem is, who the users are and what frustrates them, which assumptions the plan depends on that might be wrong, and what the blast radius looks like if they ship and those assumptions fail. In doing so, they &lt;strong&gt;de-risk the project&lt;/strong&gt;, turning &amp;ldquo;I have no idea what this even is&amp;rdquo; into &amp;ldquo;two small well-scoped projects and one thing we shouldn&amp;rsquo;t build at all.&amp;rdquo; Done well, this work is nearly invisible—projects simply run smoothly with fewer surprises and fewer outages.&lt;/p&gt;
&lt;p&gt;The author criticizes tech hiring for fixating on keyword checklists, years of experience, and LeetCode puzzles, producing &amp;ldquo;senior&amp;rdquo; engineers who can invert a binary tree on a whiteboard but freeze in front of a half-baked spec. The good news is that reducing ambiguity isn&amp;rsquo;t an innate gift, but a skill built through practice: start with the next vague ticket in your queue and spend time clarifying it upfront instead of waiting to be spoon-fed requirements or jumping straight into code.&lt;/p&gt;
&lt;h2 id="becoming-unblockable"&gt;&lt;a href="https://www.seangoedecke.com/unblockable/" rel="noopener noreferrer"&gt;Becoming unblockable&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares practical tactics for becoming &amp;ldquo;unblockable&amp;rdquo;—always finding a way to keep moving forward when obstacles arise. First, keep more than one task in flight at a time, just like a CPU core switching threads while waiting on I/O; avoid juggling two urgent deadlines at once, and pick low-urgency background work like refactoring, performance tuning, or mandatory training rather than grabbing another feature ticket. Second, front-load the parts of a project most likely to get blocked (such as database migrations that require another team&amp;rsquo;s sign-off) or spark design debates. Be ruthless about your tooling: stick to mainstream development setups, treat a broken local environment with the same urgency as a production outage, and when you&amp;rsquo;re truly stuck locally, find workarounds like running tests in CI or deploying to a staging environment.&lt;/p&gt;
&lt;p&gt;When you hit an error coming from another team&amp;rsquo;s service, don&amp;rsquo;t immediately declare yourself blocked—go read their source code and logs yourself; today you can even point AI agents like Codex or Claude Code at their repo, which Goedecke estimates gives the right answer about a third of the time. Beyond code, build goodwill with engineers on other teams by being helpful so you have fast informal backchannels when you need a favor, and secure &amp;ldquo;air cover&amp;rdquo; from directors or VPs by aligning your projects with top company priorities.&lt;/p&gt;
&lt;h2 id="treat-test-code-like-production-code"&gt;&lt;a href="https://blog.ploeh.dk/2025/12/01/treat-test-code-like-production-code/" rel="noopener noreferrer"&gt;Treat test code like production code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mark Seemann argues that test code deserves the same care as production code: the same coding standards, readability, structure, and code-review rigor. In practice, test suites are often treated as second-class citizens—properly indented, yet full of copy-pasted duplication, commented-out &amp;ldquo;zombie&amp;rdquo; tests, and arbitrary &lt;code&gt;sleep&lt;/code&gt; calls in place of proper thread synchronization. Coding standards and design principles don&amp;rsquo;t exist to appease the compiler; they exist so humans—usually your future self—can understand and maintain the system. When a project has strong test coverage, the test suite is huge, making the DRY principle even more important: without it, a minor production API change triggers &amp;ldquo;Shotgun Surgery&amp;rdquo; across dozens of broken tests.&lt;/p&gt;
&lt;p&gt;For test-specific design questions like structure, organization, naming, and determinism, Seemann recommends &lt;em&gt;xUnit Test Patterns&lt;/em&gt; as the definitive reference. He also pushes back against the slogan that tests should be &amp;ldquo;DAMP, not DRY,&amp;rdquo; noting that descriptive, meaningful phrasing is a virtue whether code is duplicated or factored into helpers. There are still sensible exceptions, mostly around security when test code is never deployed: hardcoding dummy test passwords or skipping input validation in test helpers is fine. Platform-specific exceptions make sense too, such as relaxing &lt;code&gt;.NET&lt;/code&gt;&amp;rsquo;s &lt;code&gt;ConfigureAwait&lt;/code&gt; rule in tests or allowing orphan instances in Haskell test suites.&lt;/p&gt;
&lt;h2 id="how-good-engineers-write-bad-code-at-big-companies"&gt;&lt;a href="https://www.seangoedecke.com/bad-code-at-big-companies/" rel="noopener noreferrer"&gt;How good engineers write bad code at big companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke explains why big tech companies can hire armies of talented engineers and still produce terrible code. The core reason is that large companies are &lt;strong&gt;full of engineers working outside their area of expertise&lt;/strong&gt;. With average tenure hovering around one to two years and frequent reorgs shuffling teams, many services are a decade old while most code changes are made by relative newcomers—engineers within their first six months at the company, in that codebase, or in that programming language. The few long-tenured veterans who deeply understand the system can catch issues in code review, but that stewardship role is informal and they are perpetually stretched thin by their own deliverables.&lt;/p&gt;
&lt;p&gt;The typical big-company engineer is therefore a capable developer racing to hit a deadline inside an unfamiliar codebase—doing their best in an environment that isn&amp;rsquo;t set up to produce high-craft code. In Goedecke&amp;rsquo;s view, this is a deliberate executive trade-off: leadership prioritizes organizational flexibility and fungible headcount over deep codebase mastery and code quality, and individual engineers have very little power to change it. He contrasts &amp;ldquo;pure engineering&amp;rdquo; (self-contained domains like compilers, where bad code usually reflects low skill) with &amp;ldquo;impure engineering&amp;rdquo; (more like contract electrical or plumbing work under deadline pressure, where messy code is an inevitable byproduct of the environment). At big companies, bad code happens because almost everyone is perpetually working in unfamiliar territory.&lt;/p&gt;
&lt;h2 id="the-success-trap"&gt;&lt;a href="https://mikefisher.substack.com/p/the-success-trap" rel="noopener noreferrer"&gt;The Success Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mike Fisher explores how success can quietly narrow your freedom and options. He contrasts a waiter at a neighborhood diner—whose skills are portable enough to switch jobs or careers at any time—with a waiter at a Michelin-starred restaurant, whose mastery is far higher but whose exit options are much narrower without taking a step down. In organizational theory, the &amp;ldquo;success trap&amp;rdquo; describes becoming so good at exploiting your current strengths that you stop exploring new opportunities; it is closely related to Clayton Christensen&amp;rsquo;s &lt;em&gt;Innovator&amp;rsquo;s Dilemma&lt;/em&gt;, except the innovator&amp;rsquo;s dilemma is disruption from the outside, whereas the success trap is rot from within.&lt;/p&gt;
&lt;p&gt;Fisher illustrates this with three examples: an engineer promoted up the management ladder until he no longer built anything himself, who eventually took a pay cut at a startup just to write code again; Kodak inventing the digital camera in 1975 and shelving it to protect its film cash cow; and Radiohead deliberately reinventing their sound with &lt;em&gt;Kid A&lt;/em&gt; right after the massive success of &lt;em&gt;OK Computer&lt;/em&gt;. To escape the trap, organizations need to institutionalize curiosity through dedicated experimentation time, while individuals should regularly put themselves back in the beginner&amp;rsquo;s seat and value learning velocity over comfort. For leaders, it requires a mindset of stewardship—holding success lightly and optimizing for renewal rather than coasting on past wins—because freedom, not achievement, is the true measure of success.&lt;/p&gt;
&lt;h2 id="writing-a-good-claudemd"&gt;&lt;a href="https://www.humanlayer.dev/blog/writing-a-good-claude-md" rel="noopener noreferrer"&gt;Writing a good CLAUDE.md&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide from HumanLayer starts from a simple fact: LLMs are stateless. At the beginning of every session, a coding agent knows nothing about your repository, and &lt;code&gt;CLAUDE.md&lt;/code&gt; (or &lt;code&gt;AGENTS.md&lt;/code&gt;) is the one file injected into every conversation by default. Its job is to onboard Claude into the codebase by answering three questions: &lt;strong&gt;WHAT&lt;/strong&gt; (the tech stack and directory structure, especially in monorepos), &lt;strong&gt;WHY&lt;/strong&gt; (the purpose of each component), and &lt;strong&gt;HOW&lt;/strong&gt; (how to work in the repo—running tests, typechecks, and builds). The author notes that Claude frequently ignores &lt;code&gt;CLAUDE.md&lt;/code&gt; because Claude Code wraps it in a system reminder telling the model to ignore instructions that aren&amp;rsquo;t &amp;ldquo;highly relevant to the current task&amp;rdquo;—so the more task-specific clutter you stuff into the file, the more likely Claude is to tune the whole thing out.&lt;/p&gt;
&lt;p&gt;Key recommendations: fewer instructions are better, since frontier reasoning models reliably follow only about 150–200 instructions in total and Claude Code&amp;rsquo;s system prompt already uses ~50 of them; keep &lt;code&gt;CLAUDE.md&lt;/code&gt; under 300 lines and as short as possible (HumanLayer&amp;rsquo;s own root file is under 60 lines), containing only rules that apply to every single task. Use progressive disclosure: put workflow-specific docs in separate Markdown files and link to them from &lt;code&gt;CLAUDE.md&lt;/code&gt;, and reference &lt;code&gt;file:line&lt;/code&gt; pointers instead of pasting code snippets that quickly go stale. Never use an LLM as an expensive linter—use deterministic linters and formatters wired into hooks or slash commands instead. Finally, don&amp;rsquo;t just run &lt;code&gt;/init&lt;/code&gt; and call it a day: &lt;code&gt;CLAUDE.md&lt;/code&gt; is the highest-leverage point of the entire agent harness, so craft every line deliberately.&lt;/p&gt;
&lt;h2 id="we-should-all-be-using-dependency-cooldowns"&gt;&lt;a href="https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependency-cooldowns" rel="noopener noreferrer"&gt;We should all be using dependency cooldowns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;William Woodruff argues that dependency cooldowns are a free, low-effort, and remarkably effective defense against the vast majority of open-source supply-chain attacks. Most supply-chain attacks follow the same playbook: an attacker compromises a popular project (usually via phished credentials or a CI/CD vulnerability), publishes a malicious release to PyPI, npm, or GitHub, downstream users automatically pull the update, security researchers spot the anomaly, and the registry yanks the malicious package. While the attacker&amp;rsquo;s preparation may take weeks, the window between publishing the malicious version and the registry taking it down is almost always just a few hours to a few days. Out of ten high-profile incidents analyzed, eight had an active compromise window of under a week—the notable outlier being &lt;code&gt;xz-utils&lt;/code&gt; at roughly five weeks.&lt;/p&gt;
&lt;p&gt;A dependency cooldown simply puts a minimum waiting period between when a package version is published and when your tooling considers it eligible for installation, giving the security community time to catch compromises first. Configuring one takes just a couple of lines—such as &lt;code&gt;cooldown: default-days: 7&lt;/code&gt; in Dependabot, or equivalent settings in Renovate and modern package managers. A 7-day cooldown would have blocked almost every attack on the list, and a 14-day cooldown would have stopped all of them except &lt;code&gt;xz-utils&lt;/code&gt;. While it isn&amp;rsquo;t a silver bullet—since supply-chain security is fundamentally a social-trust problem—eliminating 80–90% of the risk at near-zero cost is a no-brainer.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #57</title><link>https://miti99.com/en/post/2025/09/30/</link><pubDate>Tue, 30 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/30/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was created using &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; with the &lt;code&gt;qwen3-coder&lt;/code&gt; model running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #57.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="agentic-ai-has-changed-my-career"&gt;&lt;a href="https://medium.com/@elliotgraebert/agentic-ai-has-changed-my-career-2c6e3dd29708" rel="noopener noreferrer"&gt;Agentic AI has changed my career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elliot Graebert, a director of engineering at Skydio, confesses that for most of his career he barely wrote code because he moved into management too early. About four months ago, he started &amp;ldquo;vibe coding&amp;rdquo; directly in the multi-million-line monorepo that powers the company&amp;rsquo;s drone fleet, and he is now among its top five contributors, sometimes submitting up to ten pull requests per hour. He distinguishes between two approaches: vibe coding is like pair programming with AI (using tools like Windsurf or Cursor), where the loop is measured in seconds and requires constant attention; agentic AI is like delegating to an eager intern, where the loop is measured in minutes and you only check back once the task is done. His journey went from 0.5x speed (fixing small UI bugs in a single editor), to 1.5x by running three environments in parallel with Gemini, Claude, and GPT to &amp;ldquo;swarm&amp;rdquo; a tough bug, and then to 3x thanks to context files (Windsurf Rules) documenting code conventions and test commands, refined iteratively whenever the AI got stuck.&lt;/p&gt;
&lt;p&gt;The jump to 10x came from Coder Tasks—automated environments that go from prompt to pull request—combined with two MCPs: GitHub to read issues and open pull requests (triggering CI and Vercel previews), and Playwright so the AI can launch a browser, reproduce a bug, fix it, and verify the fix itself. The core lesson is that agentic AI succeeds when it has a feedback loop that does not require a human in the middle; at that point, he can run dozens of tasks at once, such as completing an entire data-filter component migration in a single day. He also stresses that AI does not magically solve everything—you have to invest in tooling—and the most exciting result is that designers, product managers, and even the flight test team can now contribute directly to the product.&lt;/p&gt;
&lt;h2 id="the-evolution-of-garbage-collectors-from-javas-cms-to-zgc-and-a-jvm-vs-go-vs-rust-latency-shootout"&gt;&lt;del&gt;&lt;a href="https://codemia.io/blog/path/The-Evolution-of-Garbage-Collectors-From-Javas-CMS-to-ZGC-and-a-JVM-vs-Go-vs-Rust-Latency-Shootout" rel="noopener noreferrer"&gt;The Evolution Of Garbage Collectors From Javas CMS To ZGC And A JVM Vs Go Vs Rust Latency Shootout&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Memory management is a critical topic in programming, especially in languages like Java, Go, and Rust. This article explores the evolution of garbage collectors (GCs) from Java&amp;rsquo;s traditional Concurrent Mark-Sweep (CMS) to the modern Z Garbage Collector (ZGC).&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;ZGC is a major leap forward in minimizing application pause times, aiming to keep pauses under 10ms regardless of heap size. This makes a dramatic performance difference compared to earlier-generation GCs like CMS.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The article also compares latency performance across platforms:&lt;/del&gt;
&lt;del&gt;- JVM (with ZGC): Significantly reduced pause times thanks to improvements in GC design&lt;/del&gt;
&lt;del&gt;- Go: Efficient low-latency GC powered by a concurrent algorithm and tri-color marking&lt;/del&gt;
&lt;del&gt;- Rust: Avoids GC entirely through its ownership model, delivering predictable performance without GC overhead&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- ZGC keeps application pause times under 10ms&lt;/del&gt;
&lt;del&gt;- Go uses an efficient marking algorithm to keep latency low&lt;/del&gt;
&lt;del&gt;- Rust eliminates the need for GC altogether through its ownership model&lt;/del&gt;
&lt;del&gt;- Language choice significantly impacts performance and user experience&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="new-in-java25-generational-shenandoah-gc-is-no-longer-experimental"&gt;&lt;del&gt;&lt;a href="https://theperfparlor.com/2025/09/14/new-in-java25-generational-shenandoah-gc-is-no-longer-experimental/" rel="noopener noreferrer"&gt;New in Java25: Generational Shenandoah GC is no longer experimental&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Java 25 officially graduates Generational Shenandoah from experimental status, making it ready for production use. Shenandoah is a low-pause-time garbage collector introduced in Java 12 that runs mostly concurrently with the application. Its generational mode, introduced experimentally in Java 24, separates heap memory into young and old generations. Because most objects die young, this separation spares the collector from repeatedly scanning long-lived objects unnecessarily, improving performance and reducing memory footprint.&lt;/p&gt;
&lt;p&gt;In Java 25, the feature has been stabilized with numerous bug fixes, lower garbage collection overhead, more efficient memory region management, and improved tooling and logging. According to the article, these improvements make Generational Shenandoah mature enough for real-world applications, and you no longer need the &lt;code&gt;-XX:+UnlockExperimentalVMOptions&lt;/code&gt; flag to enable it. It marks an important milestone in Java&amp;rsquo;s ongoing garbage collection optimization journey.&lt;/p&gt;
&lt;h2 id="if-all-the-world-were-a-monorepo"&gt;&lt;a href="https://jtibs.substack.com/p/if-all-the-world-were-a-monorepo?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;If all the world were a monorepo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julie Tibshirani shares her experience with CRAN, the central package repository for R. Before accepting an update, CRAN not only checks the submitted package itself, but also runs checks across every package that depends on it. When she released &lt;code&gt;grf&lt;/code&gt; 2.0 with a breaking API change, CRAN blocked publication until the downstream package &lt;code&gt;policytree&lt;/code&gt; was updated. At first she found this unreasonable: why should she be responsible for someone else&amp;rsquo;s code? Over time, however, she realized this isn&amp;rsquo;t merely a different point on the speed-versus-stability trade-off spectrum, but a form of &amp;ldquo;radical empathy&amp;rdquo; in software maintenance: users&amp;rsquo; code is the library author&amp;rsquo;s responsibility too, much like the mindset inside a monorepo.&lt;/p&gt;
&lt;p&gt;She contrasts this with her time working on Elasticsearch, where leaving individual projects to upgrade on their own left thousands of projects stuck on old versions years later. Watching large-scale migrations at Databricks, she saw that when engineering teams took end-to-end ownership—including fixing downstream dependent code—completion rates rose dramatically. Although R packages tolerate less consistent APIs than ecosystems like npm or PyPI, users enjoy nearly painless dependency upgrades, offering a lesson worth pondering for other ecosystems.&lt;/p&gt;
&lt;h2 id="9-software-architecture-patterns-for-distributed-systems"&gt;&lt;a href="https://dev.to/somadevtoo/9-software-architecture-patterns-for-distributed-systems-2o86?=&amp;amp;aid=recZm2jVus1yqUHWw" rel="noopener noreferrer"&gt;9 Software Architecture Patterns for Distributed Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article introduces nine common architectural patterns in distributed systems that are useful both in real-world design and in system design interviews. The communication patterns include: Peer-to-Peer, where nodes exchange data directly without a central coordinator, used in file sharing and blockchains; API Gateway, a unified entry point for backend services that handles security and load balancing in microservices architectures; Pub-Sub, which decouples message senders and receivers through a broker, well suited for real-time messaging, event-driven systems, and IoT; and Request-Response, where a client sends a request and receives a corresponding response from a server, ubiquitous in REST APIs and web applications (though the pattern does not strictly require synchronous execution).&lt;/p&gt;
&lt;p&gt;The data management and processing patterns include: Event Sourcing, which stores state as an immutable sequence of events for easy auditing and replay, commonly seen in financial systems; ETL (extract, transform, load) to consolidate data from multiple sources into a data warehouse for analytics and data migration; Batching, which groups data into batches to process all at once for higher efficiency; Streaming Processing, which processes continuous data streams in real time for finance, IoT, or cybersecurity; and Orchestration, which uses a central coordinator to manage workflows across services. Understanding the strengths and trade-offs of each pattern helps you build reliable, scalable, and maintainable systems as requirements evolve.&lt;/p&gt;
&lt;h2 id="sort-lines-in-source-code"&gt;&lt;a href="https://testing.googleblog.com/2025/09/sort-lines-in-source-code.html?=&amp;amp;aid=recV8wgDMqTb7Hwko" rel="noopener noreferrer"&gt;Sort Lines in Source Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kyle Freeman&amp;rsquo;s post on the Google Testing Blog, adapted from a &amp;ldquo;Tech on the Toilet&amp;rdquo; episode, opens with a familiar scenario: you enable two-player mode on the last line of a config file, but when you run the game, the feature doesn&amp;rsquo;t show up. The culprit is that the &lt;code&gt;enable_two_players&lt;/code&gt; flag was declared twice with different values—easy to miss when lines are in random order. Simply sorting the lines places the duplicates right next to each other, exposing the bug immediately. The main takeaway is that sorted lists and source lines are easier to read, easier to maintain, and help prevent bugs.&lt;/p&gt;
&lt;p&gt;To automate this, the author introduces &lt;code&gt;keep-sorted&lt;/code&gt; (&lt;a href="http://github.com/google/keep-sorted" rel="noopener noreferrer"&gt;github.com/google/keep-sorted&lt;/a&gt;): you wrap the lines to sort with &lt;code&gt;keep-sorted start&lt;/code&gt; and &lt;code&gt;keep-sorted end&lt;/code&gt; comments, run &lt;code&gt;keep-sorted [file1] [file2] ...&lt;/code&gt;, and optionally hook it into pre-commit so it runs automatically on every commit. The tool also supports case-insensitive sorting, numeric sorting, prefix order, and regular expressions (for example, using &lt;code&gt;by_regex&lt;/code&gt; to sort a Go slice by its end-of-line comments). One important caveat: before sorting, make sure the original order doesn&amp;rsquo;t carry semantic meaning, such as dependency load order.&lt;/p&gt;
&lt;h2 id="rating-26-years-of-java-changes"&gt;&lt;a href="https://neilmadden.blog/2025/09/12/rating-26-years-of-java-changes/" rel="noopener noreferrer"&gt;Rating 26 years of Java changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neil Madden looks back on 26 years of working with Java, from Java 1.1.8 in 1999 to Java 25, and gives subjective ratings to language and core library changes (skipping UI, graphics, the JVM, and GC). Top marks go to &lt;code&gt;java.util.concurrent&lt;/code&gt; (10/10), so well designed that people use it in place of the original collection classes; try-with-resources (10/10), which made exception handling far safer; Records (10/10), which he says Java &amp;ldquo;should have had all along&amp;rdquo;; UTF-8 by default (10/10), fixing thousands of character-encoding bugs at a stroke; along with Generics (8/10) and &lt;code&gt;var&lt;/code&gt; type inference (9/10). The Collections Framework gets just 4/10, lambdas 4/10 because of ugly stack traces, and switch expressions 6/10 as a pleasant minor improvement.&lt;/p&gt;
&lt;p&gt;On the flip side, NIO gets 0/10 for its convoluted API, Streams get 1/10 and are called one of modern Java&amp;rsquo;s biggest mistakes due to complexity, overpromised parallelism, and easy resource leaks, while the cryptography APIs get 1/10 for being easy to misuse. Worst of all is Modules at -10/10: massive disruption for very little practical benefit. Virtual threads are deemed promising but not yet battle-tested enough to score. The post also touches on time-based release cadences, pattern matching, and post-quantum cryptography, closing with an invitation for readers to debate his ratings.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals 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/aa5ea98b-c832-429d-8e48-63f25b7feb5a_3000x3900.jpeg" alt="Python vs Java"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4863d93c-ca2a-4b5a-b0b4-fe3621a6c184_2250x2920.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d6d04f12-2adc-4d8e-a9ca-2de16399066f_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a370bb6a-82d3-45ad-b6f4-a2a9a4317402_800x1099.jpeg" alt="CI/CD Simplified Visual Guide"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5d9faeeb-3428-44c8-94fd-4b52fc287da3_3000x3900.png" alt="How Apache Kafka Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/45136e24-79ee-4c6d-a53a-89df6afebef6_3000x3900.png" alt="Load Balancers vs API Gateways vs Reverse Proxy"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4Uyj!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1a1213e2-86cb-4fa8-bf72-e37ffe0da44d_2250x2624.heic" alt="Understanding Load Balancers: Traffic Management at Scale"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, the output is concise and I&amp;rsquo;m fairly satisfied—probably around 80% compared to Claude Code with Claude models, and since it&amp;rsquo;s free I&amp;rsquo;m very happy with it :)))&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 #48</title><link>https://miti99.com/en/post/2025/08/07/</link><pubDate>Thu, 07 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #48.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="todos-aren"&gt;&lt;a href="https://sophiebits.com/2025/07/21/todos-arent-for-doing" rel="noopener noreferrer"&gt;TODOs aren&amp;rsquo;t for doing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sophie Alpert pushes back against two common policies for handling &lt;code&gt;TODO&lt;/code&gt; comments in codebases: requiring every &lt;code&gt;TODO&lt;/code&gt; to have a corresponding ticket in an issue tracker, or automatically deleting &lt;code&gt;TODO&lt;/code&gt;s that have sat around too long. In her view, only urgent &lt;code&gt;TODO&lt;/code&gt;s like &amp;ldquo;Finish writing the second half of this file so next week&amp;rsquo;s launch doesn&amp;rsquo;t crash&amp;rdquo; actually need to be tracked as tasks. The most valuable &lt;code&gt;TODO&lt;/code&gt;s aren&amp;rsquo;t meant to be done at all: they document edge cases and design hints, such as &amp;ldquo;if the user clicks this button three times in a row, the event handler will break&amp;rdquo;—a rare scenario the author noticed but didn&amp;rsquo;t need to fix yet.&lt;/p&gt;
&lt;p&gt;The real value of these comments is preserving the original author&amp;rsquo;s train of thought and context. When another developer reads the code later and wonders whether a structure could be written differently, a well-placed &lt;code&gt;TODO&lt;/code&gt; answers that question immediately, giving them the confidence to refactor instead of hesitating out of fear that the original author knew something they didn&amp;rsquo;t. For junior developers, this is a helpful perspective: treat &lt;code&gt;TODO&lt;/code&gt;s as small notes left for future readers rather than a backlog of chores that must be swept clean.&lt;/p&gt;
&lt;h2 id="automating-away-claude"&gt;&lt;a href="https://writeaheadblogg.ing/posts/claude-hooks-auto-fix-trailing-whitespace/" rel="noopener noreferrer"&gt;Automating Away Claude&amp;rsquo;s Bad Habits with Hooks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code frequently leaves trailing whitespace at the end of lines because language models generate text token by token without &amp;ldquo;seeing&amp;rdquo; the rendered formatting, and telling it not to in instructions is unreliable. Brian Cosgrove solves this cleanly using hooks—user-defined shell commands that run automatically at specific points in Claude&amp;rsquo;s workflow loop. Specifically, he configures a &lt;code&gt;PostToolUse&lt;/code&gt; hook that runs RuboCop with the &lt;code&gt;Layout/TrailingWhitespace&lt;/code&gt; rule every time Claude edits a Ruby file. He deliberately chooses a language-aware linter over a generic &lt;code&gt;sed&lt;/code&gt; or regex replacement, which could corrupt binary files or break trailing-space line breaks in Markdown and other whitespace-sensitive formats.&lt;/p&gt;
&lt;p&gt;Beyond &lt;code&gt;PostToolUse&lt;/code&gt;, hooks also support &lt;code&gt;PreToolUse&lt;/code&gt;, &lt;code&gt;Notification&lt;/code&gt;, &lt;code&gt;Stop&lt;/code&gt;, and &lt;code&gt;SubagentStop&lt;/code&gt; events, allowing you to inspect, transform, or block actions at various stages: running linters, executing tests, verifying that code compiles, or preventing risky operations like committing untested code. The author also warns that hooks run with the user&amp;rsquo;s full permissions, so you should read every command carefully before adding it, as a malicious hook could compromise your system during routine Claude operations. This is a practical example of turning AI&amp;rsquo;s &amp;ldquo;bad habits&amp;rdquo; into automatically corrected steps rather than repeating yourself in prompts.&lt;/p&gt;
&lt;h2 id="docs-for-ai-agents"&gt;&lt;del&gt;&lt;a href="https://technicalwriting.dev/ai/agents/" rel="noopener noreferrer"&gt;Docs for AI Agents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Kayce Basques shares thoughts on documentation written for AI agents and how it relates to internal technical documentation that engineering teams write for themselves, such as RFCs or build guides. Agent docs make agent outputs more consistent, aligned with project conventions, and accurate: when first using Claude Code, the author noticed the tool correctly guessed the site used Sphinx built with Bazel, but ran the wrong command; adding the right command to the agent doc fixed it permanently. Each tool looks for its own root file (&lt;code&gt;CLAUDE.md&lt;/code&gt; for Claude Code, &lt;code&gt;GEMINI.md&lt;/code&gt; for Gemini CLI, &lt;code&gt;AGENTS.md&lt;/code&gt; for Codex CLI), and the file&amp;rsquo;s contents are injected verbatim into the system prompt on every model call, so it needs to stay concise. Subdirectory and user-level agent docs are also supported.&lt;/p&gt;
&lt;p&gt;The big question is whether to maintain two separate sets of documentation. Reasons to keep them separate include different writing styles, agents&amp;rsquo; need for brevity versus humans&amp;rsquo; need for comprehensive context, and the fact that models already know many general concepts; the reason to merge them is avoiding duplication and drift over time. The author suggests several approaches: using AI itself to keep the two sets in sync, merging them into one, embedding agent instructions as comments inside human docs and extracting them via a script, using &lt;code&gt;@&lt;/code&gt; imports to pull in files like &lt;code&gt;CONTRIBUTING.md&lt;/code&gt;, or using pre-merge checks to enforce that related files are updated together.&lt;/p&gt;
&lt;h2 id="developers-are-using-these-ai-agents-to-build-software-10x-faster"&gt;&lt;a href="https://dev.to/therealmrmumba/developers-are-using-these-ai-agents-to-build-software-10x-faster-efn" rel="noopener noreferrer"&gt;Developers Are Using These AI Agents to Build Software 10x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article rounds up AI coding agents that are helping developers move significantly faster in 2025, with brief descriptions of how each tool automates parts of the workflow. The list includes Cursor (an AI-first editor with real-time suggestions), Emergent (multi-agent orchestration for generating features and preparing deployments), DeepDocs (automatically syncing GitHub documentation with code changes via GitHub Actions), Continue.dev (an open-source platform for building custom AI-integrated IDEs), ByteDance&amp;rsquo;s Trae (end-to-end web app development with multimodal input support), Cline (a VS Code extension built for large codebases), Google&amp;rsquo;s Gemini CLI and Sourcegraph&amp;rsquo;s Cody CLI (in-terminal assistants), OpenHands (an autonomous open-source agent framework), Replit AI (a cloud environment with built-in database support), Augment Code (an IDE-integrated agent that can run code and spot performance issues), and CodeRabbit (automated GitHub pull request reviews).&lt;/p&gt;
&lt;p&gt;The central message is that these agents take over repetitive tasks, enabling faster delivery and cleaner code for solo developers, startups, and large enterprises alike. The author concludes that adopting a few such tools in your 2025 workflow is shifting from a productivity boost to a necessity. For newer developers, it serves as a handy survey for picking tools to try out.&lt;/p&gt;
&lt;h2 id="what-kind-of-work-i-want-in-2025"&gt;&lt;a href="https://www.seangoedecke.com/my-engineering-values-2025/" rel="noopener noreferrer"&gt;What kind of work I want (in 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke candidly lists the kind of engineering work he wants in 2025—a great template for any engineer thinking deliberately about their career path. On work environment, he prioritizes fully remote roles with occasional in-person gatherings over mandatory hybrid policies; he prefers low-process management that trusts engineers without heavy scrum ceremonies, and wants to stay based in Australia. On projects, he looks for work at the core of the business that leadership cares about, including unglamorous systems like billing; he excels at getting things done inside large monolithic codebases and prefers iteratively improving an imperfect solution over polishing indefinitely.&lt;/p&gt;
&lt;p&gt;He targets large US tech companies or comparable Australian firms, avoids startups, wants to work on large-scale systems people have heard of, and is currently very interested in AI both as a tool and as a transformative technology. His ethical boundaries are explicit: no proof-of-work blockchain, online gambling, autonomous weapons, or predatory financial services, alongside a strong preference for diverse teams. The biggest shift since 2021 is abandoning the idea of building a safe career maintaining legacy systems—since those roles are prime targets during layoffs—in favor of high-priority initiatives; his expectations of managers have also simplified down to competence and honesty.&lt;/p&gt;
&lt;h2 id="welcoming-the-next-generation-of-programmers"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/20/the-next-generation/" rel="noopener noreferrer"&gt;Welcoming The Next Generation of Programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that AI coding tools will expand rather than shrink the programming profession: AI will not reduce the number of programmers—in fact, the opposite seems much more likely. His definition is deliberately inclusive: &amp;ldquo;If you create a program, whether by hand or with the help of an agent, you are a programmer.&amp;rdquo; He sees growing consensus that newcomers will and should write AI-generated code, and points to the Python community&amp;rsquo;s tradition of openness—through initiatives like PyLadies—as a model for welcoming this new wave of learners.&lt;/p&gt;
&lt;p&gt;The challenge he highlights is that whereas new programmers used to learn alongside human mentors, those learning through ChatGPT may lack human connection altogether. Rather than looking down on &amp;ldquo;vibe coders,&amp;rdquo; the community should actively mentor them and build pathways into the broader ecosystem, so tooling companies don&amp;rsquo;t turn them into dependent users with no incentive to learn deeper fundamentals. The goal is to turn isolated human-AI interactions into a shared learning journey that helps the next generation develop sound software engineering practices.&lt;/p&gt;
&lt;h2 id="pattern-matching-across-different-languages"&gt;&lt;a href="https://blog.frankel.ch/pattern-matching-different-languages/" rel="noopener noreferrer"&gt;Pattern-matching across different languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel compares how pattern matching is supported across Java, Scala, Kotlin, Python, and Rust, starting from the traditional C-style &lt;code&gt;switch&lt;/code&gt; statement. Every example uses the same geometric hierarchy of &lt;code&gt;Rectangle&lt;/code&gt; and &lt;code&gt;Circle&lt;/code&gt; with a perimeter function, combining type matching and pattern guards to detect when a rectangle is a square. Java 23 uses &lt;code&gt;switch&lt;/code&gt; expressions with arrow syntax, supporting type patterns and &lt;code&gt;when&lt;/code&gt; guards, selecting the first matching branch. Kotlin uses &lt;code&gt;when&lt;/code&gt; expressions and &lt;code&gt;is&lt;/code&gt; checks, with the article&amp;rsquo;s example enabling an experimental flag for guards. Python added the &lt;code&gt;match&lt;/code&gt; statement in 3.10, which destructures attributes by name very cleanly. The Rust translation uses trait objects and downcasting, making it more verbose; the author explicitly notes that this setup is not idiomatic and does not reflect Rust&amp;rsquo;s true pattern-matching strengths.&lt;/p&gt;
&lt;p&gt;Among the languages compared, Scala pioneered pattern matching early on and still stands out for destructuring and extracting class fields directly inside a match arm without extra variable bindings; it inspired the other languages, though the author notes Java and Kotlin have largely closed the gap in this example. He concludes that pattern matching combined with destructuring makes code significantly more readable and maintainable—a technique well worth learning in any modern language.&lt;/p&gt;
&lt;h2 id="a-real-world-ai-coding-case-sample"&gt;&lt;a href="https://blog.korny.info/2025/07/18/a-real-world-ai-coding-case-sample" rel="noopener noreferrer"&gt;A real-world AI coding case sample&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny shares a real-world walkthrough of using Claude to add a feature to an ASP.NET Core application: publishing a &lt;code&gt;PersonBusinessLink&lt;/code&gt; event to Kafka with a &amp;ldquo;linked&amp;rdquo; or &amp;ldquo;unlinked&amp;rdquo; type whenever a contact person is associated with or removed from a business. The project uses monadic &lt;code&gt;Result&lt;/code&gt; and &lt;code&gt;Option&lt;/code&gt; return types, domain-driven design with repositories and services, and Kafka running in Docker with Testcontainers for integration tests. Rather than letting Claude run on autopilot, he guided it step by step: first asking it to identify existing patterns in the codebase, then requesting the feature with a detailed spec, reviewing every change before committing, and stepping in when Claude picked the wrong Kafka topic or partition key. When Claude struggled with the monadic control flow, he debugged it himself rather than letting it spin its wheels.&lt;/p&gt;
&lt;p&gt;Claude did well at learning test conventions from existing files and handling straightforward boilerplate, but needed course correction on architectural decisions and couldn&amp;rsquo;t resolve deeper bugs on its own. The author&amp;rsquo;s advice is to treat AI like a very fast, enthusiastic, but naive junior developer: useful when carefully guided, but not reliably autonomous on complex tasks. He also raises serious concerns about the environmental cost, unsustainable venture funding, and the motives of the companies behind these tools.&lt;/p&gt;
&lt;h2 id="clowns-to-the-left-of-me"&gt;&lt;a href="https://blog.korny.info/2025/07/19/clowns-to-the-left-of-me" rel="noopener noreferrer"&gt;Clowns to the Left of Me&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny reflects on the polarized debate around AI coding tools and places himself squarely in the middle, echoing the song &amp;ldquo;Stuck in the Middle With You&amp;rdquo; referenced in the title. On one side are the hype evangelists claiming 50x productivity gains, advocating coding without regard for security, and getting swept up in the thrill of rapid code generation—leading them to overstate capabilities and downplay risks. On the other side are the skeptics, who are right to push back against exaggerated claims, but sometimes treat preliminary studies as definitive proof and dismiss the tools after a few low-context tries.&lt;/p&gt;
&lt;p&gt;The author takes a pragmatic view: the tools genuinely help him in real work—such as writing Python scripts, generating diagrams for documentation, or spotting security vulnerabilities—but require careful prompting, output verification, and choosing the right use cases. What matters is learning when and how to use them effectively; he recommends following balanced practitioners like Simon Willison and Birgitta Böckeler. Still, he stresses that we shouldn&amp;rsquo;t ignore systemic issues: massive energy consumption, environmental harm tied to fossil fuels, unsustainable VC subsidies, and power concentrated in the hands of controversial tech leaders. Bottom line: evaluate the tools through evidence and hands-on experience.&lt;/p&gt;
&lt;h2 id="improving-the-prompt-to-the-ai-to-get-better-code"&gt;&lt;a href="https://blog.vanillajava.blog/2025/07/improving-prompt-to-ai-to-get-better.html" rel="noopener noreferrer"&gt;Improving the prompt to the AI to get better code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of Vanilla Java Blog experiments with optimizing a Java method that formats a time zone offset from milliseconds into ISO 8601 (&lt;code&gt;±hh&lt;/code&gt;, &lt;code&gt;±hhmm&lt;/code&gt;, or &lt;code&gt;±hhmmss&lt;/code&gt;) while allocating as few objects as possible for low-latency applications. Initial &amp;ldquo;one-shot&amp;rdquo; prompts produced wildly uneven results across models. A refined prompt spelled out explicit constraints: use a &lt;code&gt;ThreadLocal&lt;/code&gt; buffer, stick to simple arithmetic, avoid &lt;code&gt;String.format&lt;/code&gt; and object allocations, and return an &lt;code&gt;intern()&lt;/code&gt;ed string. This guidance helped weaker models improve dramatically.&lt;/p&gt;
&lt;p&gt;Seven systems were evaluated: Gemini 2.5 Pro, o3-pro, o4-mini-high, Claude 4, Grok 3 Think, GitHub Copilot with GPT-4.1, and Microsoft Copilot in Think Deeper mode. Response times ranged from a few seconds to 18 minutes without a corresponding jump in quality. Most solutions used a &lt;code&gt;ThreadLocal&lt;/code&gt; &lt;code&gt;char[]&lt;/code&gt; buffer and manipulated digits directly, but not a single model suggested using &lt;code&gt;byte[]&lt;/code&gt;, even though modern Java strings store characters internally as a byte array. The takeaways: detailed prompts narrow the gap between models, longer thinking time does not guarantee better code, and AI can still miss specialized performance tricks; the best approach is testing multiple models and iterating on the prompt rather than asking just once.&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 #24</title><link>https://miti99.com/en/post/2025/05/11/</link><pubDate>Sun, 11 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #24.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="google"&gt;&lt;a href="https://newsletter.getdx.com/p/googles-principles-for-measuring-developer-productivity" rel="noopener noreferrer"&gt;Google&amp;rsquo;s principles for measuring developer productivity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abi Noda summarizes the paper &amp;ldquo;Measuring Productivity: All Models Are Wrong, But Some Are Useful&amp;rdquo; by Google researchers Ciera Jaspan and Collin Green. The core idea is that measuring developer productivity is fundamentally an exercise in modeling: every model omits details, so the goal is building a model that remains useful without creating perverse incentives. Drawing on years of internal research at Google, the authors distill five principles. First, avoid single-metric models, because no single metric captures the inherent trade-offs of engineering work. Second, measure all outcomes you care about and use multiple metrics per outcome; when two metrics measuring velocity move in opposite directions, that divergence is an important signal to investigate. Third, think carefully about the incentives your measurements create—when a measure becomes a target, it ceases to be a good measure. Fourth, cover all three dimensions of speed, ease, and quality rather than fixating on just one. Fifth, combine objective system logs with subjective self-reported survey data from engineers.&lt;/p&gt;
&lt;p&gt;The article closes with practical advice. If your team is small enough to fit into a single conference room, you don&amp;rsquo;t need productivity metrics—just sit down and talk to them. Larger organizations should start with developer surveys, which capture the holistic engineering experience far better than raw telemetry alone. Above all, define why you are measuring before choosing any metric.&lt;/p&gt;
&lt;h2 id="in-defense-of-ruthless-managers"&gt;&lt;a href="https://www.seangoedecke.com/ruthless-managers/" rel="noopener noreferrer"&gt;In defense of ruthless managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke divides engineering managers into two archetypes: empathetic managers, who invest emotionally in their reports and regularly go to bat for them against upper management, and &amp;ldquo;ruthless&amp;rdquo; managers, who view their job simply as transmitting the company&amp;rsquo;s needs to engineers and vice versa. While Goedecke agrees that having an empathetic manager is generally great, he argues that ruthless managers are underrated for five reasons. First, they still want their engineers to be happy, because happy engineers perform better, are easier to manage, and don&amp;rsquo;t quit. Second, they accumulate far more political capital with leadership, whereas empathetic managers who constantly push back on executives often burn through their capital right when you need them to advocate for your promotion. Third, they aren&amp;rsquo;t emotionally weighed down by hard decisions, so they stay focused and unbothered. Fourth, they communicate bluntly without sugarcoating bad news or parroting corporate talking points—though they may occasionally lie or withhold information out of self-interest. Finally, they are predictable because they always align with upper management&amp;rsquo;s priorities.&lt;/p&gt;
&lt;p&gt;Goedecke stresses that this defense only applies to competent managers inside reasonably healthy companies. An incompetent, ruthless manager is a recipe for disaster, and given a free choice, most engineers should still pick an empathetic boss. Since we rarely get to choose our managers, though, understanding the strengths of both styles makes it easier to work effectively with whichever one you have.&lt;/p&gt;
&lt;h2 id="ai-ambivalence"&gt;&lt;a href="https://nolanlawson.com/2025/04/02/ai-ambivalence/" rel="noopener noreferrer"&gt;AI ambivalence&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson holds a master&amp;rsquo;s degree in computational linguistics—having studied alongside the researchers who later coined the term &amp;ldquo;stochastic parrots&amp;rdquo;—but left the field because he grew tired of purely statistical approaches and preferred building software directly. For years he avoided generative AI: he was skeptical of AGI claims and disliked how autocomplete assistants turned programming into endlessly reading code rather than writing it. By 2025, with seemingly the entire industry adopting AI, he tried Claude and Claude Code and admitted they were far more capable than he expected: querying a large codebase, generating unit tests, or refactoring dozens of call sites to a new API pattern worked shockingly fast. The problem is that it drains the joy out of programming. He feels like a babysitter reviewing piles of machine-generated code for subtle bugs, where the strongest temptation is to stop reading altogether and surrender to &amp;ldquo;vibe coding.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Lawson doesn&amp;rsquo;t offer a neat conclusion, instead capturing a mood of deep ambivalence. He still uses AI for low-stakes tasks like throwaway prototypes and unit tests, but resents how generative AI has taken over software engineering and the underlying message—as Ezra Klein put it—that human creativity is merely derivative. Caught between adapting to the new normal and keeping his manual coding skills sharp for the day &amp;ldquo;vibe-coded&amp;rdquo; systems inevitably catch fire in production, he admits nobody truly knows how this plays out.&lt;/p&gt;
&lt;h2 id="use-abstraction-to-improve-function-readability"&gt;&lt;a href="https://testing.googleblog.com/2023/09/use-abstraction-to-improve-function.html" rel="noopener noreferrer"&gt;Use Abstraction to Improve Function Readability&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This installment of the Google Testing Blog&amp;rsquo;s Code Health series, written by Palak Bansal and Mark Manley, compares two versions of a &lt;code&gt;createPizza&lt;/code&gt; function in Go. The first version crams everything into a single function: preparing the dough and toppings, looping until the oven reaches temperature, baking the pizza, and boxing and slicing it. The second version consists of just three calls—&lt;code&gt;prepare&lt;/code&gt;, &lt;code&gt;bake&lt;/code&gt;, and &lt;code&gt;box&lt;/code&gt;—each of which delegates to lower-level helpers like &lt;code&gt;addToppings&lt;/code&gt; or &lt;code&gt;heatOven&lt;/code&gt; until reaching leaf functions that handle concrete implementation details without calling further helpers. The second version is far easier to read because the first mixes multiple levels of abstraction: low-level mechanics like polling the oven thermometer sit right alongside intermediate steps like baking and high-level intent.&lt;/p&gt;
&lt;p&gt;The takeaway is the Single Level of Abstraction principle: avoid mixing abstraction levels inside the same function, and instead compose functions at matching levels so the code reads top-to-bottom like a story with self-descriptive function names. This structure makes code easier to follow, debug, and reuse; the authors point readers to Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; for a deeper dive.&lt;/p&gt;
&lt;h2 id="how-apple-pay-handles-41-million-transactions-a-day-securely"&gt;&lt;a href="https://newsletter.systemdesign.one/p/how-does-apple-pay-work" rel="noopener noreferrer"&gt;How Apple Pay Handles 41 Million Transactions a Day Securely&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neo Kim breaks down Apple Pay&amp;rsquo;s architecture through the story of a traveler tapping an iPhone at a London Underground turnstile, noting that the post is based on public research and may differ from Apple&amp;rsquo;s internal implementation. When a user adds a card to Apple Wallet, the card details and device metadata are encrypted and routed through Apple to the payment network (such as Visa or Mastercard); the actual card number is never stored in full on the iPhone or on Apple&amp;rsquo;s servers. Once the payment network verifies the card with the issuing bank, it generates a Device Account Number (DAN)—an irreversible token bound to that specific card and iPhone pair—which is stored inside the iPhone&amp;rsquo;s Secure Element, a dedicated tamper-resistant hardware chip. At checkout, the point-of-sale terminal sends transaction details to the iPhone over NFC; the user authenticates via Touch ID or Face ID, and biometric data stays strictly inside the isolated Secure Enclave processor, never leaving the device.&lt;/p&gt;
&lt;p&gt;Next, the Secure Element combines the DAN with transaction details to compute a dynamic cryptogram—similar to a time-based one-time password—and sends the authorization request through the merchant&amp;rsquo;s acquirer without the merchant ever seeing the real card number. The payment network recomputes the cryptogram against its copy of the DAN to verify the transaction, then returns an approval code and a response cryptogram for the device to verify in turn. Built on the EMV contactless specification, Apple Pay works even when the iPhone has no cellular or Wi-Fi connection and is significantly safer than a physical card because the underlying card number is never exposed.&lt;/p&gt;
&lt;h2 id="four-kinds-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2023/four_kinds_of_optimisation.html" rel="noopener noreferrer"&gt;Four Kinds of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurence Tratt opens with two observations: programmers are chronically over-optimistic about knowing where their programs spend time, and equally over-optimistic about knowing how to speed up the slow parts. The cure for the first is disciplined profiling; for the second, Tratt outlines four categories of optimization, each with its own trade-offs. First, using a better algorithm requires understanding your data distribution: selection sort is three times faster than bubble sort on random data, but much slower on already-sorted data, and hand-rolled &amp;ldquo;fast&amp;rdquo; algorithms are notorious for subtle bugs. Second, using better data structures—such as a sorted array with binary search for read-heavy static data, or shrinking struct field sizes when allocating millions of instances. Third, moving to a lower-level system: rewriting Python in Rust might yield a 60x speedup, whereas running the exact same code on PyPy instead of CPython can deliver a 4x speedup with almost zero effort. Fourth, accepting a less accurate answer—including heuristic local search that may miss the global optimum, or probabilistic/lossy approaches like Bloom filters, JPEG compression, and machine learning.&lt;/p&gt;
&lt;p&gt;Tratt generally avoids jumping straight to a low-level rewrite because the return on engineering time is often poor, preferring simple wins first. He closes with three guiding rules: always pick the simplest optimization that meets your performance target because it introduces the fewest bugs; remember that human engineering time is expensive; and breadth of optimization knowledge matters more than narrow depth.&lt;/p&gt;
&lt;h2 id="the-fifth-kind-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2025/the_fifth_kind_of_optimisation.html" rel="noopener noreferrer"&gt;The Fifth Kind of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this follow-up post, Laurence Tratt admits he left out a fifth optimization technique that he relies on constantly: parallelization. When he parallelized his Rust-based static site builder across multiple threads, build times in &amp;ldquo;quick&amp;rdquo; mode dropped from roughly 0.6 seconds to under 0.3 seconds, while full &amp;ldquo;deploy&amp;rdquo; builds ran more than 3x faster. Similarly, his &lt;code&gt;lang_tester&lt;/code&gt; test harness runs test suites in parallel, cutting a test run on a 72-core machine from 37 seconds down to 2.5 seconds—a speedup that directly improves day-to-day developer flow.&lt;/p&gt;
&lt;p&gt;He reflects on why he overlooked parallelization the first time around. First is hardware history: consumer multicore CPUs only became mainstream around 2005, and it took years before x86 and Arm memory models were well-specified enough to program against reliably. Second is language support: Java only got a sound memory model with JSR 133 in 2004, C and C++ waited until 2011, and shared-memory multithreading remained fraught with data races such as lost updates or compilers optimizing away unsynchronized writes. Languages built around immutable data or actor models avoided most of these pitfalls but often paid a performance penalty. For Tratt, Rust changed the equation via the &lt;code&gt;Send&lt;/code&gt; and &lt;code&gt;Sync&lt;/code&gt; traits and ownership rules: he has yet to hit a single data race in Rust, even if occasional &lt;code&gt;clone()&lt;/code&gt; calls or subtle mutex deadlocks still crop up. Today, he designs for parallelism right from the start.&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/4036e9a7-f2b6-476c-ad5d-48916db3b610_1309x1536.gif" alt="REST API Design Best Practices"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2a933717-1d59-46a6-ba51-76e24ae048fc_1280x1502.gif" alt="How to Learn Backend Development?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b9397d70-0232-4a8b-8b3e-edd4c15eb9bb_800x939.gif" alt="The Simplified Git Workflow"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1bc9340f-de4f-4767-b2f8-f4c6529e9eea_1309x1536.gif" alt="Virtualization vs Containerization"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e7afaab-de4b-4604-a557-22974fb2e3ea_1280x1532.gif" alt="How Netflix Built a Distributed Counter?"&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=_d0duu3dED4" rel="noopener noreferrer"&gt;Why Everyone&amp;rsquo;s Talking About MCP?&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 #16</title><link>https://miti99.com/en/post/2025/05/03/</link><pubDate>Sat, 03 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #16.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="choosing-languages"&gt;&lt;a href="https://steveklabnik.com/writing/choosing-languages" rel="noopener noreferrer"&gt;Choosing Languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Klabnik wrote this piece after Microsoft announced it was porting the TypeScript compiler to Go, sparking immediate community arguments of &amp;ldquo;why not C#?&amp;rdquo; and &amp;ldquo;why not Rust?&amp;rdquo;. His view is simple: write your programs in whatever language you want. Technical constraints are usually contextual rather than absolute, and outsiders rarely know the real context of a project. Microsoft&amp;rsquo;s primary reason is that they are porting an existing codebase rather than rewriting it from scratch, and the existing code is structurally quite close to Go, making the port much easier. Klabnik also dislikes the cliché &amp;ldquo;choose the right tool for the job,&amp;rdquo; because almost nobody intentionally picks the wrong tool; what looks like a bad choice from the outside usually just reflects requirements we can&amp;rsquo;t see.&lt;/p&gt;
&lt;p&gt;The most personal part of the essay comes from 2013, when he was on the Rails team and publicly mocked someone who wrote a &lt;code&gt;grep&lt;/code&gt; tool in Node, hurting the author. That experience made him realize his words carried weight and that the &amp;ldquo;culture of contempt&amp;rdquo; in the Ruby community at the time had rubbed off on him. When he joined the Rust community, he deliberately worked to build a culture that discussed Rust on its own merits rather than putting down other languages—which is why today&amp;rsquo;s &amp;ldquo;rewrite it in Rust&amp;rdquo; crowd frustrates him so much. His closing message: people choose languages for their own reasons, and even when you disagree, there is no excuse to be a jerk about it.&lt;/p&gt;
&lt;h2 id="how-long-should-functions-be"&gt;&lt;a href="https://tidyfirst.substack.com/p/how-long-should-functions-be" rel="noopener noreferrer"&gt;How Long Should Functions Be?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck argues that asking &amp;ldquo;how many lines long should a function be?&amp;rdquo; is the wrong question from the start, because software is grown rather than built all at once. No matter how short functions start out, they tend to grow over time, and the longer a function already is, the more likely it is to grow even longer. To test this, he measured the lengths of 12,513 functions in JUnit 5: most are just 1–4 lines long (5,491 of them are 2-line functions alone), while the longest is 74 lines. The data fits a power-law distribution remarkably well, with an exponent α ≈ 2.46, an R² of 0.96, and a mean length of about 3.49 lines.&lt;/p&gt;
&lt;p&gt;Because it follows a power law, the central limit theorem does not apply: the larger the project, the higher the average function length, and the longest function will keep growing as the system expands. The right answer is therefore a distribution, not a single number: many short functions and a few long ones. We cannot change the fact that function lengths follow a power law, but we can steepen the slope of the distribution—meaning more short functions and a shorter maximum length. The only empirical result Beck knows of is research by Keith Braithwaite showing that test-driven development (TDD) correlates with a steeper slope.&lt;/p&gt;
&lt;h2 id="what-makes-code-hard-to-read-visual-patterns-of-complexity"&gt;&lt;a href="https://seeinglogic.com/posts/visual-readability-patterns/" rel="noopener noreferrer"&gt;What Makes Code Hard To Read: Visual Patterns of Complexity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;While auditing a codebase for bugs, the author noticed himself getting mentally fatigued very quickly despite the code being high quality, and realized the culprit wasn&amp;rsquo;t cyclomatic complexity as he had expected, but readability. Since there is no universally accepted metric for readability, he draws on the two closest proxies. Halstead metrics from the 1970s count operators and operands: the more there are, the more a reader has to reason about how they interact. SonarSource&amp;rsquo;s Cognitive Complexity adds points whenever control flow breaks linear order and whenever control structures are nested. Beyond those, he examines function shape, naming, and variable lifespans.&lt;/p&gt;
&lt;p&gt;From this analysis, he distills 8 visual patterns that apply across languages: write small functions with few variables and operators; avoid esoteric syntax in favor of idiomatic project patterns; break long &lt;code&gt;map&lt;/code&gt;/&lt;code&gt;filter&lt;/code&gt; chains or complex expressions into logical groups using helper functions or intermediate variables; keep conditionals short and avoid mixing multiple boolean operators; never use &lt;code&gt;goto&lt;/code&gt; outside rare special cases; minimize nesting, extracting helper functions when needed; choose clear, distinct variable names and avoid variable shadowing; and keep variable lifespans as short as possible. Together, they form a practical vocabulary for code review discussions.&lt;/p&gt;
&lt;h2 id="io-devices-and-latency"&gt;&lt;a href="https://planetscale.com/blog/io-devices-and-latency" rel="noopener noreferrer"&gt;IO Devices and Latency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benjamin Dicken (PlanetScale) uses interactive visualizations to trace the history of storage devices and their latency profiles. Magnetic tape stores data sequentially, making random access painfully slow. Hard disk drives (HDDs) use rapidly spinning magnetic platters and a moving read/write head, dramatically improving random access times. SSDs have no moving parts, making them far faster and capable of parallel reads and writes, though performance can dip when the drive must run garbage collection to erase stale pages before writing new data.&lt;/p&gt;
&lt;p&gt;In the cloud, providers typically decouple storage from compute using network-attached block storage like EBS. This improves durability and makes scaling capacity easy, but each read or write takes around 250 microseconds compared to roughly 50 microseconds on a locally attached NVMe drive—while a CPU accessing RAM takes only about 100 nanoseconds. On top of that, IOPS are capped: EBS GP3 defaults to 3,000 IOPS, and going higher costs extra. The article serves as an introduction to PlanetScale Metal, where each database (Vitess or Postgres) runs on locally attached NVMe drives with one primary and two replicas for durability, allowing zero-downtime storage scaling and uncapped IOPS.&lt;/p&gt;
&lt;h2 id="the-good-times-in-tech-are-over"&gt;&lt;a href="https://www.seangoedecke.com/good-times-are-over/" rel="noopener noreferrer"&gt;The good times in tech are over&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke observes that for nearly a decade, being a software engineer was extraordinarily comfortable: generous perks, rare layoffs, and being treated like resident geniuses. Over the past two years, everything has changed—layoffs began in 2023, and companies like Meta now publicly cut employees labeled as low performers. According to Goedecke, the root cause is interest rates. Throughout the 2010s, near-zero interest rates meant investors flooded tech companies with cheap capital, fueling massive hiring sprees and speculative projects regardless of profitability. When interest rates rose to around 5% in 2023, profitability suddenly mattered. COVID only created a temporary boom, and AI is not yet the driver behind layoffs.&lt;/p&gt;
&lt;p&gt;As a result, companies are forced to focus on the handful of priorities leadership actually cares about, while budgets for open-source contributions and developer experience get slashed. Goedecke advises engineers to accept that their personal interests may now conflict with their employer&amp;rsquo;s; you can still pursue what you believe is right, but it comes at a career cost, especially for junior engineers. The silver lining is that the tech industry is now closer to reality and the rules of the game are clearer: generating value for the company is rewarded, failing to do so is penalized, and &amp;ldquo;value&amp;rdquo; means advancing leadership&amp;rsquo;s specific plans.&lt;/p&gt;
&lt;h2 id="once-you"&gt;&lt;del&gt;&lt;a href="https://mertbulan.com/2025/01/26/once-you-are-laid-off-you-will-never-be-the-same-again/" rel="noopener noreferrer"&gt;Once You&amp;rsquo;re Laid Off, You&amp;rsquo;ll Never Be the Same Again&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Mert Bulan recounts the day he was laid off alongside most of his teammates. Looking back, he points out five warning signs: team events abruptly canceled; employees receiving notifications about incoming packages (boxes for returning company equipment); leadership lacking clear direction and constantly reorganizing; mandatory meetings appearing on calendars with no concrete agenda; and quarterly earnings season at public companies. What stung most was realizing that all his extra effort—teaching himself React Native, taking on special projects from the CEO, referring talented engineers—meant nothing in the end. During a layoff, you are just a row in an Excel spreadsheet decided by people who don&amp;rsquo;t even know who you are.&lt;/p&gt;
&lt;p&gt;According to the author, trust between companies and employees has been broken as layoffs happen even while companies post record profits. He also notes that German labor laws do not prevent mass layoffs. Many people who have been through a layoff now simply do the exact job they were hired to do. His advice for those who haven&amp;rsquo;t been laid off yet: work your contracted hours; don&amp;rsquo;t overextend yourself hoping for an internal promotion—switch companies to move up instead; keep interviewing elsewhere; use external offers to grow your compensation; and stop worrying so much about having short stints on your resume.&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/840e868d-2c83-4b1b-a881-df1da6c6e332_1309x1536.gif" alt="What is MCP?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/6ff106a0-de83-48b0-9eb4-3f8bf0d43a57_1280x1566.gif" alt="How to Design a System like Instagram"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/214c0c6c-2426-49d0-9fa8-cdb9ce089dcc_1280x1585.gif" alt="How to load your websites at lightning speed"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #11</title><link>https://miti99.com/en/post/2025/04/12/</link><pubDate>Sat, 12 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #11.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="enabling-near-real-time-data-analytics-on-the-data-lake"&gt;&lt;a href="https://engineering.grab.com/enabling-near-realtime-data-analytics" rel="noopener noreferrer"&gt;Enabling near real-time data analytics on the data lake&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grab shares how they brought data lake ingestion latency down to just a few minutes instead of waiting on hourly or daily batch jobs. Their legacy Hive-and-Parquet pipeline worked well for analytical scans but made record-level updates and upserts prohibitively expensive, since modifying a single record required rewriting entire Parquet files. Grab migrated to &lt;strong&gt;Apache Hudi&lt;/strong&gt;, tailoring table types to each source&amp;rsquo;s workload: for high-throughput Kafka event streams, they use &lt;strong&gt;Merge On Read (MOR)&lt;/strong&gt; tables where Apache Flink appends fast Avro row logs and Spark runs periodic background compaction into columnar Parquet files; for lower-throughput sources, they use simpler &lt;strong&gt;Copy On Write (COW)&lt;/strong&gt; tables, accepting a 10–15 minute ingestion latency.&lt;/p&gt;
&lt;p&gt;The article dives into practical production lessons: partitioning high-volume Kafka event tables by event hour to speed up writes and bound compaction scope, using Flink CDC to stream binlog changes directly from relational databases, and choosing Hudi&amp;rsquo;s Bucket Index for deterministic hashing without external index lookups (despite the trade-off that bucket counts are hard to resize later). As a result, business analysts get much fresher operational dashboards, and the fraud detection team can query near-real-time transaction data on the lake without putting extra load on production OLTP databases.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-software-architecture-documentation"&gt;&lt;a href="https://www.workingsoftware.dev/software-architecture-documentation-the-ultimate-guide/" rel="noopener noreferrer"&gt;The Ultimate Guide To Software Architecture Documentation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This comprehensive guide covers how to write, structure, visualize, and maintain software architecture documentation. The author pushes back against the &amp;ldquo;the code is the documentation&amp;rdquo; myth: source code tells you &lt;em&gt;what&lt;/em&gt; the system does at the lowest level, but cannot tell you &lt;em&gt;why&lt;/em&gt; architectural trade-offs were made, what non-functional quality attributes drove the design, or how the system fits into the broader business context. Good architecture documentation aligns stakeholders around a shared mental model, speeds up onboarding for new engineers, guides teams when building new features, and streamlines communication with external partners and auditors.&lt;/p&gt;
&lt;p&gt;For structure, the author recommends the open-source, process-agnostic &lt;strong&gt;arc42&lt;/strong&gt; template, advising teams not to fill out every section up front on day one, but to grow the document incrementally as decisions are made. For visualization, the &lt;strong&gt;C4 model&lt;/strong&gt; provides a clean hierarchy across four zoom levels: Context, Containers, Components, and Code. Finally, the post champions &amp;ldquo;Documentation as Code&amp;rdquo; and &amp;ldquo;Diagrams as Code&amp;rdquo; using tools like AsciiDoc, PlantUML, and Structurizr so architecture docs live in Git alongside the codebase and evolve in lockstep with pull requests.&lt;/p&gt;
&lt;h2 id="beyond-the-basics-designing-for-a-million-users"&gt;&lt;a href="https://javarevisited.substack.com/p/beyond-the-basics-designing-for-a" rel="noopener noreferrer"&gt;Beyond the Basics: Designing for a Million Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post summarizes the opening chapter of Alex Xu&amp;rsquo;s &lt;em&gt;System Design Interview&lt;/em&gt;, walking through the foundational building blocks for scaling a web application from a handful of users to millions. It starts with a single-server deployment: as traffic grows, latency spikes, a single hardware failure takes the entire site offline, vertical scaling hits cost and physical ceilings, and geographically distant users suffer slow page loads.&lt;/p&gt;
&lt;p&gt;The first step is scaling horizontally rather than vertically, pairing a stateless web tier (moving user session data out into a shared persistent store or cache) with a load balancer to distribute traffic across multiple web servers. Next comes choosing the right database (relational SQL vs. NoSQL), adding read replicas and database sharding, placing a cache tier in front of hot database reads, offloading static assets to a CDN, introducing message queues for asynchronous background processing, using geo-routing for global users, and rounding out the stack with centralized logging, metrics, and automation. It serves as a solid primer for anyone preparing for system design interviews.&lt;/p&gt;
&lt;h2 id="decision-making-pitfalls-for-technical-leaders"&gt;&lt;a href="https://chelseatroy.com/2024/10/16/decision-making-pitfalls-for-technical-leaders/" rel="noopener noreferrer"&gt;Decision-Making Pitfalls for Technical Leaders&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chelsea Troy points out that the software industry routinely promotes strong individual contributors into technical leadership roles with zero training in how decision-making changes at scale, highlighting three habits that are harmless as an IC but destructive once you hold authority. The first is &lt;strong&gt;assuming context&lt;/strong&gt;: applying a &amp;ldquo;best practice&amp;rdquo; without examining what problem it was designed to solve, leading to mismatched architectures that the leader can&amp;rsquo;t justify to their team or executives. The second is &lt;strong&gt;treating every criterion as an optimization target&lt;/strong&gt;, which causes decisions to drag on forever or get reopened repeatedly, whipsawing downstream teams. The third is &lt;strong&gt;manufacturing false urgency&lt;/strong&gt;, subjecting the team to constant fire drills over foreseeable problems that should have been planned for.&lt;/p&gt;
&lt;p&gt;Her remedies are straightforward: understand the concrete trade-offs of every option within your specific project context, explicitly separate criteria you want to &lt;em&gt;maximize&lt;/em&gt; from constraints that only need to meet a &amp;ldquo;good enough&amp;rdquo; threshold (satisficing), and actively absorb pressure rather than amplifying it—because people rarely do their best thinking in a panic. Most &amp;ldquo;emergencies&amp;rdquo; in software engineering, she argues, are actually leadership failures in disguise.&lt;/p&gt;
&lt;h2 id="how-i-know-i"&gt;&lt;a href="https://www.seangoedecke.com/thoughts-about-engineers/" rel="noopener noreferrer"&gt;How I know I&amp;rsquo;m working with a strong engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares a simple gut-check for telling whether you&amp;rsquo;re working with a strong engineer: count how often two specific thoughts cross your mind while collaborating with them. The first thought is, &lt;em&gt;&amp;ldquo;Oh, good catch—I hadn&amp;rsquo;t thought of that!&amp;quot;&lt;/em&gt;—triggered when they spot a subtle bug, improve the user experience, or simplify a design, rather than when they pedantically nitpick edge cases that don&amp;rsquo;t matter. If you find yourself thinking that constantly around someone, you should probably defer to their judgment on big technical calls.&lt;/p&gt;
&lt;p&gt;The second thought is, &lt;em&gt;&amp;ldquo;Nice, that&amp;rsquo;ll work,&amp;rdquo;&lt;/em&gt; when they propose the exact sensible approach you would have come up with yourself. That reaction signals reliability and steady execution—which the author notes is actually high praise. Engineers can be great in many different ways, of course, but this two-question heuristic is a surprisingly reliable intuitive litmus test.&lt;/p&gt;
&lt;h2 id="ugly-code-and-dumb-things"&gt;&lt;a href="https://lucumr.pocoo.org/2025/2/20/ugly-code/" rel="noopener noreferrer"&gt;Ugly Code and Dumb Things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, Jinja, and Werkzeug, reflects on two competing passions in software: crafting clean, reusable library abstractions versus hacking together fast, pragmatic solutions for real users. He points to &lt;strong&gt;Flamework&lt;/strong&gt;—an open-source PHP framework capturing Flickr&amp;rsquo;s early engineering ethos of &amp;ldquo;doing the simplest thing that could possibly work.&amp;rdquo; Its code looks messy to modern eyes, concatenating raw SQL strings and using global state, yet it nailed the problems that actually mattered for scaling Flickr: user-based sharding, database replication, and production observability.&lt;/p&gt;
&lt;p&gt;Clean, aesthetically pleasing code doesn&amp;rsquo;t guarantee product success if it doesn&amp;rsquo;t solve a real problem for real people, while &amp;ldquo;ugly&amp;rdquo; code that ships often embodies the exact right compromises needed to iterate quickly. Both mindsets are valid, though they rarely coexist peacefully in the same codebase. The real art, Ronacher concludes, is knowing when to transition from duct-tape pragmatism to solid architectural foundations—because successful projects eventually grow up and need to be re-engineered.&lt;/p&gt;
&lt;h2 id="development-philosophy"&gt;&lt;a href="https://develop.sentry.dev/getting-started/philosophy/" rel="noopener noreferrer"&gt;Development Philosophy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page from Sentry&amp;rsquo;s engineering handbook distills over a decade of lessons into their core development philosophy. Sentry emphasizes that code is not art—it is a tool for solving customer problems—so engineers must constantly weigh building clean abstractions against shipping pragmatic &amp;ldquo;duct tape,&amp;rdquo; and ask experienced teammates when unsure where on that spectrum a task falls. Even &amp;ldquo;correctness&amp;rdquo; can be a trap: for instance, forcing rigid static typing gymnastics onto Python can slow down iteration without delivering commensurate value. Duct tape is great for validating ideas quickly, but you can&amp;rsquo;t build a lasting business on it alone—Sentry is equally willing to invest in multi-year foundational bets, such as replacing shell-outs to &lt;code&gt;llvm-symbolizer&lt;/code&gt; with their own custom Rust-based &lt;code&gt;symbolicator&lt;/code&gt; service.&lt;/p&gt;
&lt;p&gt;Other guiding principles include: avoiding overly &amp;ldquo;clever&amp;rdquo; code that future readers (including yourself six months later) will struggle to decipher; encouraging anyone to open a pull request against any repository in the company; standardizing primarily on Python, Rust, and TypeScript; avoiding proprietary database lock-in so Sentry remains easy to self-host; weighing the long-term maintenance cost of every third-party dependency; and keeping &lt;code&gt;main&lt;/code&gt; green and deployable at all times.&lt;/p&gt;
&lt;h2 id="ai-is-stifling-tech-adoption"&gt;&lt;a href="https://vale.rocks/posts/ai-is-stifling-tech-adoption" rel="noopener noreferrer"&gt;AI is Stifling Tech Adoption&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that AI coding assistants are quietly stifling the adoption of newer web technologies for two reasons. The first is the &lt;strong&gt;knowledge cutoff trap&lt;/strong&gt;: because foundation models are trained on historical snapshots (at the time of writing, Anthropic&amp;rsquo;s latest models had a cutoff around April 2024), they know little or nothing about newly released frameworks or major version upgrades. That creates a vicious cycle: poor AI support discourages developers from adopting a new tool, fewer users means fewer blog posts and forum answers, and less public writing leaves future model training runs starved of examples. The second culprit is &lt;strong&gt;system prompt bias&lt;/strong&gt;: many AI coding tools explicitly instruct the model behind the scenes to default to React and Tailwind CSS—to the point where Claude once rewrote the author&amp;rsquo;s vanilla HTML/CSS/JS snippet into React despite explicit instructions not to.&lt;/p&gt;
&lt;p&gt;To test this, the author asked four major AI chatbots to &amp;ldquo;build a web app&amp;rdquo; with no stack specified: Claude and ChatGPT defaulted straight to React + Tailwind every time, Gemini used vanilla HTML/CSS/JS but immediately suggested migrating to React, and DeepSeek was more flexible but took several prompts to produce working code. The net effect is that technologies that were dominant right before ChatGPT launched are having their dominance locked in, newcomers are being steered toward a monoculture without realizing it, and AI vendors ought to be far more transparent about the stack biases baked into their system prompts.&lt;/p&gt;
&lt;h2 id="february---the-rest-of-the-story---jvm-weekly-vol-119"&gt;&lt;a href="https://www.jvm-weekly.com/p/february-the-rest-of-the-story-jvm" rel="noopener noreferrer"&gt;February - The Rest of the Story - JVM Weekly vol. 119&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This February 27, 2025 issue of JVM Weekly rounds up notable stories from February that didn&amp;rsquo;t fit into earlier editions. The headline news is that the next LTS release of &lt;strong&gt;Scala 3&lt;/strong&gt;, slated for Q4 2025, will officially drop support for JDK 8; the Scala team is currently debating between JDK 11 and JDK 17 as the new minimum baseline, driven largely by the upcoming removal of memory-access methods in &lt;code&gt;sun.misc.Unsafe&lt;/code&gt;, which forces a redesign of how &lt;code&gt;lazy val&lt;/code&gt; is compiled under the hood. The issue also highlights a set of J.P. Morgan Java Lead interview questions, a series on SOLID principles in Kotlin, a draft JEP under Project Leyden that streamlines creating AOT caches into a single command-line step, and a bytecode-level auto-parallelization prototype that achieved up to a 9x speedup in the author&amp;rsquo;s benchmarks.&lt;/p&gt;
&lt;p&gt;Rounding out the issue is part two of a series on building agentic AI systems with Quarkus—where application control flow is handed over to an LLM—alongside fresh ecosystem releases including KotlinPoet 2.0, Dokka 2.0, the Ktor CLI, Pulumi Java 1.0, and CheerpJ 3.1, a WebAssembly-powered JVM that runs full Java applications directly in the browser.&lt;/p&gt;
&lt;h2 id="manager-antipatterns"&gt;&lt;a href="https://blogs.newardassociates.com/blog/2024/management-antipatterns.html" rel="noopener noreferrer"&gt;Manager Antipatterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ted Neward catalogs twelve common engineering management antipatterns—dysfunctional archetypes that companies repeatedly create through poor hiring, promotion, or org design. The roster includes the &lt;strong&gt;Absentee Manager&lt;/strong&gt; (never around), &lt;strong&gt;The Radical&lt;/strong&gt; (wants to burn everything down and rewrite from scratch), &lt;strong&gt;The Nepotist&lt;/strong&gt; (given the team because they&amp;rsquo;re friends with an executive), &lt;strong&gt;The Mouthpiece&lt;/strong&gt; (merely parrots upper management), &lt;strong&gt;The One-Trick Pony&lt;/strong&gt; (applies the same hammer to every problem), &lt;strong&gt;The Chicken Little&lt;/strong&gt; (panics constantly), &lt;strong&gt;The Pushover&lt;/strong&gt; (avoids all conflict), &lt;strong&gt;The Transplant&lt;/strong&gt; (dropped in from an unrelated domain), &lt;strong&gt;The Perfectionist&lt;/strong&gt; (micromanages every detail), &lt;strong&gt;The Promoted Superstar&lt;/strong&gt; (the best coder forced into management), &lt;strong&gt;The Riddler&lt;/strong&gt; (communicates in cryptic hints instead of clear expectations), and &lt;strong&gt;The Player-Coach&lt;/strong&gt; (stretched thin trying to manage and code simultaneously).&lt;/p&gt;
&lt;p&gt;For each archetype, Neward sketches the behavior and offers practical survival strategies from three vantage points: when you report to that manager, when that manager reports to you, and when you realize &lt;em&gt;you&lt;/em&gt; have become that manager yourself. It&amp;rsquo;s a handy field guide for diagnosing leadership dysfunction wherever you sit on the org chart.&lt;/p&gt;
&lt;h2 id="pause--decision-making-superpower"&gt;&lt;a href="https://read.perspectiveship.com/p/pause" rel="noopener noreferrer"&gt;Pause – Decision-Making Superpower&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that even if you master every mental model and decision-making framework in the book, none of them will save you if you react on impulse. Recalling an early-career mistake—giving a snap feature estimate live on a client call and then pulling all-nighters to hit the impossible deadline—the author adopted a personal rule: never give an immediate commitment in the room; always ask to follow up after the meeting. Taking a deliberate pause creates space to step back from emotional hijacking, check for blind spots, and gather missing context—and people rarely push back when you simply tell them it&amp;rsquo;s a personal rule of yours. Nobel laureate Daniel Kahneman famously used the same tactic to stop himself from saying yes to requests on the spot that he would later regret.&lt;/p&gt;
&lt;p&gt;Pausing is especially powerful when you receive an infuriating Slack message or email—wait a few hours or sleep on it before replying—or when fielding high-stakes questions during a crisis, such as right after a layoff. And when you genuinely don&amp;rsquo;t have all the answers yet, state clearly what is within your control and what isn&amp;rsquo;t, and share the concrete steps currently underway so your team knows you are taking their concerns seriously.&lt;/p&gt;
&lt;h2 id="aposd-vs-clean-code"&gt;&lt;a href="https://github.com/johnousterhout/aposd-vs-clean-code/blob/main/README.md" rel="noopener noreferrer"&gt;APOSD vs Clean Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub repository records a written debate between John Ousterhout, author of &lt;em&gt;A Philosophy of Software Design&lt;/em&gt; (APOSD), and Robert &amp;ldquo;Uncle Bob&amp;rdquo; Martin, author of &lt;em&gt;Clean Code&lt;/em&gt;, hashing out their sharpest disagreements on software design. While both agree that the ultimate goal is making software easier to understand and modify, they clash across three main areas. On &lt;strong&gt;method length&lt;/strong&gt;, &lt;em&gt;Clean Code&lt;/em&gt; famously advocates tiny functions of just a few lines, whereas Ousterhout argues that decomposing functions too aggressively creates &amp;ldquo;shallow&amp;rdquo; interfaces and tangles of tiny coupled methods that force readers to jump back and forth to reconstruct the control flow.&lt;/p&gt;
&lt;p&gt;On &lt;strong&gt;code comments&lt;/strong&gt;, &lt;em&gt;Clean Code&lt;/em&gt; treats most comments as a failure to express intent in code, while APOSD views comments as indispensable for capturing high-level interface contracts and design intent that code alone cannot express. On &lt;strong&gt;Test-Driven Development (TDD)&lt;/strong&gt;, Martin champions strict red-green-refactor micro-cycles before writing implementation code, whereas Ousterhout worries that strict TDD encourages tactical, line-by-line hacking at the expense of upfront design thinking. Reading the two authors challenge each other over concrete code examples is a masterclass in software design trade-offs and well worth reading to form your own view.&lt;/p&gt;
&lt;h2 id="the-software-engineer-spectrum-speed-vs-accuracy"&gt;&lt;a href="https://benhowdle.im/software-engineer-spectrum" rel="noopener noreferrer"&gt;The Software Engineer Spectrum: Speed vs. Accuracy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on 15 years of experience ranging from IC engineer to CTO, Ben Howdle observes that every software engineer sits somewhere along a spectrum between &lt;strong&gt;Speed&lt;/strong&gt; and &lt;strong&gt;Accuracy&lt;/strong&gt;. Speed-leaning engineers live by &amp;ldquo;ship now, refine later&amp;rdquo;—excelling at rapid iteration and getting MVPs in front of users, at the risk of accumulating technical debt and missing edge cases. Accuracy-leaning engineers live by &amp;ldquo;make sure it&amp;rsquo;s right before it goes live&amp;rdquo;—excelling at rock-solid reliability, edge-case coverage, and scalable architecture, at the risk of moving slowly and over-engineering. Neither end of the spectrum is inherently superior; what matters is alignment with the company&amp;rsquo;s current stage.&lt;/p&gt;
&lt;p&gt;Different business stages demand different balances: an early-stage seed startup needs Speed to validate product-market fit before the runway runs out; a scaling Series B company needs a balanced mix as testing and architecture start to matter; and a large enterprise or regulated fintech needs Accuracy where downtime or compliance failures are existential. The post offers self-reflection prompts—such as whether you get more frustrated by slow decisions or by shipping imperfect code—and advises engineering leaders to build balanced teams where both archetypes respect each other and can shift along the spectrum as the product matures.&lt;/p&gt;
&lt;h2 id="llm-ecosystem-predictions"&gt;&lt;a href="https://www.moderndescartes.com/essays/llm_predictions/" rel="noopener noreferrer"&gt;LLM Ecosystem Predictions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Kihoon Lee, an engineer at Databricks, lays out his predictions for the LLM ecosystem over the next 5–10 years. The cost of LLM inference at a fixed quality level is dropping roughly three times faster than Moore&amp;rsquo;s Law—halving every six months—driven by hardware advances, systems optimizations, and algorithmic breakthroughs; because all three favor capital-intensive hyperscalers, only a handful of frontier model providers will survive, competing at razor-thin margins. Just as high-level languages beat C and Java on developer iteration speed, simple agent architectures will beat complex, brittle orchestration frameworks: simply swapping in the latest frontier model every 6–12 months, backed by a solid evaluation suite, will beat months of custom prompt-chain tuning on both quality and cost.&lt;/p&gt;
&lt;p&gt;He also predicts the market will bifurcate between managed enterprise AI platforms and DIY tooling, with an &amp;ldquo;Excel for LLMs&amp;rdquo; emerging to let non-programmers build their own AI workflows. Cost per query will span orders of magnitude—from 100-million-parameter small models to 1-trillion-parameter frontier models—while the economic value unlocked will vary even more wildly: LLMs are poised to replace expensive human coordination overhead inside organizations, personalized tutoring, and customer support with 24/7 availability and consistent quality. By 2030, he argues, the world will look as different from today as the mobile and Internet era looked compared to the 1990s.&lt;/p&gt;
&lt;h2 id="the-right-kind-of-stubborn"&gt;&lt;a href="https://www.paulgraham.com/persistence.html" rel="noopener noreferrer"&gt;The Right Kind of Stubborn&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Graham distinguishes between two very different traits that often get lumped together: &lt;strong&gt;persistence&lt;/strong&gt; and &lt;strong&gt;obstinacy&lt;/strong&gt;. Both make people hard to stop, but in opposite ways: the persistent person is like a boat whose engine can&amp;rsquo;t be throttled back, while the obstinate person is like a boat whose rudder can&amp;rsquo;t be turned. Persistent people are fiercely attached to the &lt;em&gt;goal&lt;/em&gt; and happily change tactics when something isn&amp;rsquo;t working—in fact, they listen intently to criticism because they want to know if their current approach is flawed; obstinate people are attached to their &lt;em&gt;initial plan&lt;/em&gt;—which is almost always the least-informed version of the idea—and reflexively dismiss feedback. Obstinacy only works on simple problems where the first idea happens to be right by luck.&lt;/p&gt;
&lt;p&gt;True persistence, Graham argues, has a much richer internal structure built on five distinct qualities: &lt;strong&gt;energy&lt;/strong&gt; to keep trying, &lt;strong&gt;imagination&lt;/strong&gt; to invent new approaches when blocked, &lt;strong&gt;resilience&lt;/strong&gt; to keep morale intact after setbacks, &lt;strong&gt;good judgment&lt;/strong&gt; to weigh expected value, and a &lt;strong&gt;specific focus&lt;/strong&gt; on a concrete problem. For less experienced founders and makers, his advice is to start with a small, well-defined goal and expand your ambition as you gain traction. Because it requires all five ingredients at once, the right kind of stubbornness is much rarer than mere obstinacy—and vastly more powerful.&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/ae95d38c-41f8-4eb7-885e-f7fafa4ca45d_2250x2624.png" alt="Data Consistency Strategies For Microservices"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>