<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Career on miti99</title><link>https://miti99.com/en/tags/career/</link><description>Recent content in Career 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/career/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #103</title><link>https://miti99.com/en/post/2026/05/23/</link><pubDate>Sat, 23 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #103.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="drunk-post-things-i"&gt;&lt;a href="https://luminousmen.substack.com/p/drunk-post-things-ive-learned-as" rel="noopener noreferrer"&gt;Drunk Post: Things I&amp;rsquo;ve Learned as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post preserves a famous r/ExperiencedDevs thread where a data engineer with 10 years of experience got &amp;ldquo;a little tipsy&amp;rdquo; and wrote down every career lesson he had learned. The original account has since been deleted, but its rare candor keeps the post widely shared. On career growth, the author argues that switching companies is the most effective way to get promoted, job titles matter less than what you actually accomplish, and the closer you are to the product and revenue, the more valued you are — regardless of how technically complex your work is.&lt;/p&gt;
&lt;p&gt;On the technical side, every domain has only about 10–20 core principles, and the fundamentals change very slowly even as tools churn constantly. Good code is code a junior engineer can read and understand, and the best code is code you never had to write at all. Writing documentation is the most underrated skill, right alongside writing proposals for change. For newcomers, SQL is the highest-ROI language; testing is essential, but TDD is overly worshiped. Good engineers know best practices, while senior engineers know when to break them. What the author is proudest of is not any grand system he built, but helping others do better work. The archivist agrees with nearly all of it, except for the author&amp;rsquo;s preference for dynamic languages.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-to-code"&gt;&lt;a href="https://www.chrismdp.com/coding-with-ai-april-2026/" rel="noopener noreferrer"&gt;How I Use AI to Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Parsons argues that if you are still tethered to an IDE like Cursor or Copilot, you are a year behind: the best tools have left the editor for the command line, and he recommends Claude Code or Codex CLI. Programming is AI&amp;rsquo;s &amp;ldquo;home turf&amp;rdquo; because code can be executed and verified immediately. He distinguishes &amp;ldquo;vibe coding&amp;rdquo; (never checking the output) from &amp;ldquo;agentic engineering&amp;rdquo; (deliberately deciding which changes require human inspection and which can be entrusted to tests and automated checks). His core message: senior engineers should train AI to write better code rather than manually reviewing every single diff, because the harness surrounding the model matters more than the prompt.&lt;/p&gt;
&lt;p&gt;A good harness consists of persistent instructions in CLAUDE.md or AGENTS.md, skill files that both enforce rules and load extra context on demand, a verification loop so the agent can check its own work, and a feedback loop that feeds lessons back into those three components — with all knowledge stored in a dedicated markdown repository. The author also walks back his earlier advice to specify the entire solution up front, calling that waterfall in disguise: specify the problem, not the solution. Output quality hinges on context volume — too little yields generic results, while too much drowns the model in noise. Once code generation is no longer the bottleneck, verification becomes the new bottleneck, giving teams with strong automated testing and CI/CD foundations a massive advantage.&lt;/p&gt;
&lt;h2 id="email-is-crazy"&gt;&lt;a href="https://samkhawase.com/blog/email-is-crazy/" rel="noopener noreferrer"&gt;Email is crazy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Email is one of the most successful communication technologies in history, yet underneath it lies a patchwork system governed by more than 100 RFCs. Sam Khawase traces the journey of a single message from Alice to Bob: the mail client merely &amp;ldquo;submits&amp;rdquo; the message to a server, the relay server looks up DNS MX records to find the recipient&amp;rsquo;s mail server, and email is fundamentally a store-and-forward queueing system that retries for days rather than a real-time channel. SMTP was born in an era of trust-based academic networks, so the envelope address (&lt;code&gt;MAIL FROM&lt;/code&gt;) and the user-visible &lt;code&gt;From&lt;/code&gt; header are allowed to differ — the root vulnerability that makes phishing and spam possible.&lt;/p&gt;
&lt;p&gt;Instead of replacing SMTP, the industry bolted on three authentication layers: SPF (a list of authorized sending IPs, which breaks when mail is forwarded), DKIM (a cryptographic signature whose public key lives in DNS), and DMARC (requiring the domain in the &lt;code&gt;From&lt;/code&gt; header to align with the domain validated by SPF or DKIM, paired with a policy of none, quarantine, or reject). Messages then pass through each provider&amp;rsquo;s proprietary filtering stack: IP reputation, domain reputation, content analysis, virus scanning, and link checking. Encryption is usually just &amp;ldquo;Opportunistic TLS&amp;rdquo;: if the receiving server doesn&amp;rsquo;t support &lt;code&gt;STARTTLS&lt;/code&gt;, the connection falls back to plaintext (though policies like MTA-STS can enforce TLS), and TLS only encrypts the transport hop rather than end-to-end. Worst of all, an email can be silently dropped into a spam folder without notifying anyone — completely legal under RFC 5321. Even so, email reliably delivers billions of messages every single day.&lt;/p&gt;
&lt;h2 id="high-performance-git"&gt;&lt;a href="https://gitperf.com/" rel="noopener noreferrer"&gt;High Performance Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;High Performance Git&lt;/em&gt; is a book by Ted Nyman about Git&amp;rsquo;s internal architecture and how to operate massive repositories. Rather than teaching a handful of everyday commands, the book views Git as a stack of layers — a content-addressable database, a filesystem cache, a graph walker, and a wire transfer protocol — and analyzes the performance cost of each layer.&lt;/p&gt;
&lt;p&gt;The chapters progress from objects, refs, the index, and history traversal to packfiles, repository maintenance, sparse checkout, partial clone, transfer protocols, operating at scale, troubleshooting, configuration, and data recovery. The book is aimed at anyone who needs Git to stay fast as codebases, histories, and teams grow: build and CI engineers, monorepo maintainers, and developer productivity teams. The entire book is released for free as a PDF under a Creative Commons Attribution-ShareAlike 4.0 license.&lt;/p&gt;
&lt;h2 id="you-can-beat-the-binary-search"&gt;&lt;a href="https://lemire.me/blog/2026/04/27/you-can-beat-the-binary-search/" rel="noopener noreferrer"&gt;You can beat the binary search&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire looks for ways to speed up checking whether a value exists in a sorted array of 16-bit integers — a common operation in Roaring Bitmaps, which currently use binary search. He builds on two observations: modern CPUs (both 64-bit ARM and x64) have SIMD instructions that compare eight 16-bit integers at once, and they have substantial memory-level parallelism, so splitting the array into four parts instead of two can be more effective. This leads to the SIMD Quad algorithm: divide the array into blocks of 16 elements, use a quaternary search on the last element of each block to narrow down the candidate block, and then use SIMD to check all 16 elements in that block simultaneously.&lt;/p&gt;
&lt;p&gt;Benchmarks on Apple M4 and Intel Emerald Rapids show SIMD Quad beating binary search across the article&amp;rsquo;s tests: on Intel it is more than 2x faster when the cache is &amp;ldquo;hot,&amp;rdquo; while on Apple it is more than 2x faster when the cache is &amp;ldquo;cold.&amp;rdquo; The &amp;ldquo;quad&amp;rdquo; step makes almost no difference on Apple, but helps significantly on Intel with large arrays and cold caches. The takeaway: classic algorithms weren&amp;rsquo;t designed for hardware with as much parallelism as today&amp;rsquo;s CPUs, leaving plenty of room for performance gains.&lt;/p&gt;
&lt;h2 id="how-might-a-browser-be-developed"&gt;&lt;a href="https://aifoc.us/how-might-a-browser-be-developed/" rel="noopener noreferrer"&gt;How might a browser be developed?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Kinlan asks: how will browsers be developed in the age of AI? Drawing from experiments building browsers with AI and ultra-fast inference chips, he observes that a comprehensive specification paired with an extensive unit test suite acts as an effective guardrail to keep models on track. In the near term, standards bodies could build a &amp;ldquo;reference browser&amp;rdquo; to uncover gaps in specifications and test suites, while browser vendors use AI to implement features from those battle-tested specs. The focus would then shift to writing great specifications, and browsers would differentiate themselves by their vision for the web rather than raw engineering headcount or budget.&lt;/p&gt;
&lt;p&gt;His longer-term vision ventures into sci-fi territory: a browser that synthesizes feature implementations on the fly at runtime from markup, or even purely from expressed intent. For instance, instead of waiting on WebBluetooth support, the browser could generate the code to talk to a heart-rate monitor directly from available hardware documentation. That could eliminate polyfills and make accessibility and localization happen by default, but it also threatens the web&amp;rsquo;s core promise: that the same URL delivers roughly the same experience to everyone, since the experience would now depend on each user&amp;rsquo;s device and local model. Kinlan urges the industry to start thinking seriously about this trajectory now.&lt;/p&gt;
&lt;h2 id="agentic-coding-is-a-trap"&gt;&lt;a href="https://larsfaye.com/articles/agentic-coding-is-a-trap" rel="noopener noreferrer"&gt;Agentic Coding is a Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lars Faye warns against the trend of &amp;ldquo;agentic coding,&amp;rdquo; where AI writes all the code while humans merely plan and orchestrate. The core issue is the &amp;ldquo;supervision paradox,&amp;rdquo; which Anthropic itself has acknowledged: using AI effectively requires supervising it, yet supervision demands the exact programming skills that atrophy when you overuse AI. Another Anthropic study recorded a 47% drop in debugging proficiency. Unlike past transitions such as moving from assembly to FORTRAN, the skill erosion this time is already visible even among veteran engineers, while junior engineers lose the struggle with code that serves as their most important learning mechanism.&lt;/p&gt;
&lt;p&gt;The author argues that AI is accelerating the wrong part of the job: we don&amp;rsquo;t actually need to write code faster, especially code we don&amp;rsquo;t understand, and for many developers, writing code &lt;em&gt;is&lt;/em&gt; how they think and plan. There is also vendor lock-in risk — when Claude goes down, many teams grind to a halt — and unpredictable token costs, whereas human salaries are fixed. His prescription is to demote AI back to an assistant role: use AI for specs and planning, but write 20% to 100% of the code yourself depending on the task, never generate more code than you can review in a single sitting, and never ask AI to do something you haven&amp;rsquo;t done or couldn&amp;rsquo;t do yourself.&lt;/p&gt;
&lt;h2 id="be-the-idiot"&gt;&lt;a href="https://luminousmen.substack.com/p/be-the-idiot" rel="noopener noreferrer"&gt;Be the Idiot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;luminousmen argues that most engineering failures happen because someone was afraid of looking stupid, making clarifying questions not a weakness but a core professional skill. Drawing inspiration from military radio protocols — where the receiver always reads back an order to confirm, not out of incompetence, but because being understood matters more than sounding smart — the author applies two principles to software engineering: repeat critical information across multiple channels such as types, docstrings, and explicit parameter names; and choose unambiguous wording, like &lt;code&gt;timeout_seconds: 30&lt;/code&gt; instead of &lt;code&gt;timeout: short&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author shares four &amp;ldquo;dumb&amp;rdquo; questions that have saved him time and again: what happens when this fails, how do we know it&amp;rsquo;s working properly, what does &amp;ldquo;done&amp;rdquo; look like, and can you show me an example? Phrasing matters too: instead of asking &amp;ldquo;Why are we doing this stupid thing?&amp;rdquo;, ask &amp;ldquo;Is there a specific reason we&amp;rsquo;re using X here?&amp;rdquo; — assuming you&amp;rsquo;re missing context rather than assuming the other person is wrong. About 80% of the time he really was missing context, and the other 20% of the time the question sparked a valuable discussion. After all, the only thing more expensive than looking dumb in a meeting is building the wrong thing because nobody dared to ask.&lt;/p&gt;
&lt;h2 id="3-constraints-before-i-build-anything"&gt;&lt;a href="https://jordanlord.co.uk/blog/3-constraints/" rel="noopener noreferrer"&gt;3 constraints before I build anything&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jordan Lord shares three constraints he applies before building any product, distilled from 10 years of product work and multiple failures caused by overcomplication or lack of identity. To him, constraints are a catalyst for creativity because they narrow the option space. The first constraint is &amp;ldquo;one page or nothing&amp;rdquo;: every idea must fit onto a single-page brief that serves as a north star when talking to investors, teammates, or family. If you can&amp;rsquo;t fill one page, the idea isn&amp;rsquo;t ready; if you need more than one page, it&amp;rsquo;s too complicated.&lt;/p&gt;
&lt;p&gt;The second constraint: the core technology must be separable from the product. That could be a method, tool, or library that powers the current product but survives if the product pivots — much like Git was created to support Linux kernel development, or Kubernetes at Google. Products pivot, while core technology compounds in value over time. The third constraint: a defining constraint must shape the product and remain immediately visible to the user, like Minecraft being built entirely out of blocks or IKEA&amp;rsquo;s flat-pack self-assembly furniture. It wards off feature creep and creates unmistakable identity. Any idea that fails to pass all three constraints doesn&amp;rsquo;t get built.&lt;/p&gt;
&lt;h2 id="swissing-a-table"&gt;&lt;a href="https://philpearl.github.io/post/swissing_a_table/" rel="noopener noreferrer"&gt;Swissing a Table&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Pearl explores the Swiss table — the hash table design behind Go&amp;rsquo;s new map implementation — by evolving a simple open-addressed hash table step by step. First, he replaces linear probing with a quadratic-style probing sequence like Go&amp;rsquo;s; next, he groups 8 key–value pairs into a bucket; then he adds 8 control bytes per group (the highest bit marks an empty slot, while the lower 7 bits store a hash fragment); and finally he uses bitwise SWAR tricks on a 64-bit integer to match all 8 control bytes simultaneously instead of checking slots one by one.&lt;/p&gt;
&lt;p&gt;Insertion benchmarks show that a Swiss table doesn&amp;rsquo;t always win: when the table is sparse (around 10–4,000 elements), it is 19–36% slower than the simple table, only pulling ahead as the table fills up and cutting insertion time by up to 71.65% when completely full (32,768 elements). According to the author, the biggest win is that the table can run at high load factors with very little performance degradation — making it primarily a memory-saving optimization rather than a raw speed boost. Go&amp;rsquo;s map currently uses SIMD on amd64 (Intel) but not yet on ARM, so the author saves the SIMD exploration for a follow-up post.&lt;/p&gt;
&lt;h2 id="the-ai-engineering-stack-we-built-internally--on-the-platform-we-ship"&gt;&lt;a href="https://blog.cloudflare.com/internal-ai-engineering-stack/" rel="noopener noreferrer"&gt;The AI engineering stack we built internally — on the platform we ship&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares the internal AI infrastructure they built over 11 months, running entirely on the same products they sell to customers. Over a 30-day window, 3,683 internal users (93% of R&amp;amp;D) used AI coding tools, driving over 20 million requests through AI Gateway and 241 billion tokens; in some weeks, merge request volume nearly doubled the previous quarter&amp;rsquo;s baseline. The architecture spans three layers. The foundation layer uses Cloudflare Access for zero-trust authentication, AI Gateway for routing, cost tracking, and data retention controls, and Workers AI to serve open-weight models at a fraction of proprietary model costs. A single login command configures everything, and routing traffic through an intermediate Worker from day one let them roll out new features later without touching user-side configs.&lt;/p&gt;
&lt;p&gt;The knowledge layer uses Backstage as a service catalog and automatically generates &lt;code&gt;AGENTS.md&lt;/code&gt; files across roughly 3,900 repositories, describing structure, conventions, and boundaries so agents don&amp;rsquo;t have to guess. The execution layer runs an AI Code Reviewer on every merge request: it classifies risk level, dispatches specialized agents, organizes findings by category and severity, and cites specific rules from the Engineering Codex — Cloudflare&amp;rsquo;s internal engineering standards packaged as agent skills. According to Cloudflare, none of the individual pieces are novel; the differentiator is how they are wired together.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7jIm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5632abfa-88b9-4f40-8feb-13b4a7c6e1ce_2484x3002.png" alt="MCP vs Skills, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gUOK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F32f62036-5c89-4686-941e-57d84297de42_2484x3002.png" alt="5 Way to Defend Prompt Injection"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #97</title><link>https://miti99.com/en/post/2026/04/17/</link><pubDate>Fri, 17 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/17/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #97.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-we"&gt;&lt;a href="https://blog.cloudflare.com/rethinking-cache-ai-humans/" rel="noopener noreferrer"&gt;Why we&amp;rsquo;re rethinking cache for the AI era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare reports that 32% of traffic across its network is automated, with AI bots alone surpassing 10 billion requests per week. Unlike human visitors, AI crawlers—especially agentic RAG loops that iteratively refine queries—exhibit 70–100% unique URL ratios, constantly fetching fresh deep links across documentation, source code, and media rather than revisiting popular pages, and they maintain no session state so every worker instance looks like a separate client. The result is soaring cache-miss rates, ineffective traditional prefetching, and degraded performance for real humans: Wikimedia saw multimedia bandwidth jump 50%, while Read the Docs, Fedora, and Diaspora all suffered slowdowns from crawlers repeatedly pulling large assets.&lt;/p&gt;
&lt;p&gt;In the short term, Cloudflare is experimenting with replacing classic LRU cache eviction with SIEVE and S3-FIFO—early tests show human cache-hit ratios stay protected even under heavy AI crawler load—while developing ML-driven, workload-aware caching policies. Longer term, they envision dedicated caching tiers for AI traffic: human users stay on fast latency-optimized edge caches, latency-sensitive AI workloads like live RAG or summarization use an intermediate tier, and latency-tolerant model-training crawlers get routed to deeper storage tiers or queued during origin overload.&lt;/p&gt;
&lt;h2 id="a-behind-the-scenes-look-at-how-we-release-the-spotify-app-part-1"&gt;&lt;a href="https://engineering.atspotify.com/2025/04/how-we-release-the-spotify-app-part-1" rel="noopener noreferrer"&gt;A Behind-the-Scenes Look at How We Release the Spotify App (Part 1)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spotify pulls back the curtain on how its Release team ships the iOS and Android apps to more than 675 million users, bundling hundreds of changes into every weekly release. Release Managers both coordinate across feature squads and build the internal release tooling, constantly balancing velocity against stability. Following version 8.9.2 as a case study, each release cycle spans roughly two weeks: week one is active development with nightly builds shipped to internal alpha testers; in week two, a release branch is cut that accepts only critical cherry-pick fixes while moving through beta testing and manual regression QA; the weekend and Monday cover final stabilization and app-store submission, followed by a staged rollout from 1% to 100% of users on Tuesday and Wednesday.&lt;/p&gt;
&lt;p&gt;Before submission, every release must clear strict quality gates: all commits pass automated test suites, zero release-blocking bugs remain open, stakeholder teams sign off, crash-free rates stay above threshold, and content-consumption telemetry looks healthy. To de-risk big launches like Audiobooks in 8.9.2, major features get dedicated rollout schedules and extra crash scrutiny; feature flags let engineers merge unfinished code safely while keeping it dark in production; and the initial 1% rollout catches severe regressions before they hit the wider user base. Thanks to this discipline, roughly 95% of scheduled releases ship to 100% of users on time every week.&lt;/p&gt;
&lt;h2 id="components-of-a-coding-agent"&gt;&lt;a href="https://magazine.sebastianraschka.com/p/components-of-a-coding-agent" rel="noopener noreferrer"&gt;Components of A Coding Agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sebastian Raschka explains that coding agents like Claude Code or Codex CLI are fundamentally software harnesses wrapped around an LLM that turn a raw text model into a capable engineering tool. An agent&amp;rsquo;s real-world effectiveness, he argues, comes not just from the underlying model weights, but largely from the harness—its control loop, runtime environment, and context-management discipline. A well-engineered harness makes both reasoning and non-reasoning models perform dramatically better than they ever could inside a plain chat window.&lt;/p&gt;
&lt;p&gt;The article breaks a coding agent down into six core components. First is &lt;em&gt;live repo context&lt;/em&gt;: gathering directory structure, Git status, and project instructions before acting on a prompt. Second is &lt;em&gt;prompt prefix caching&lt;/em&gt;: splitting the prompt into a stable prefix (tools, system instructions) and a dynamic suffix so KV caches can be reused across turns, slashing latency and cost. Third is &lt;em&gt;structured tool access&lt;/em&gt;: an explicit catalog of typed tools gated by permission checks, far safer and more reliable than parsing free-form shell commands from prose. Fourth is &lt;em&gt;context compaction&lt;/em&gt;: truncating giant tool outputs, deduplicating repeated file reads, and summarizing old turns to prevent context bloat. Fifth is &lt;em&gt;structured session memory&lt;/em&gt;: maintaining both a full on-disk transcript and a compact working memory so long sessions stay sharp and resumable. Sixth is &lt;em&gt;bounded subagents&lt;/em&gt;: letting the primary agent delegate subtasks to scoped worker agents with isolated context windows, enabling parallel execution without losing control.&lt;/p&gt;
&lt;h2 id="say-the-thing-you-want"&gt;&lt;a href="https://terriblesoftware.org/2026/04/01/say-the-thing-you-want/" rel="noopener noreferrer"&gt;Say the Thing You Want&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of &lt;em&gt;Terrible Software&lt;/em&gt; offers a simple piece of career advice that engineers routinely ignore: tell your manager explicitly what you want. At the end of a 1:1, when asked &amp;ldquo;anything else?&amp;rdquo;, countless engineers say &amp;ldquo;nope, all good&amp;rdquo; even when they badly want to lead the next project, get promoted, or switch teams—afraid of sounding entitled, being told they aren&amp;rsquo;t ready, or admitting out loud that they want something they might not get. Yet as the post puts it, a goal you keep in your head has &amp;ldquo;zero surface area&amp;rdquo;—nobody can react to it, build on it, or help you reach it.&lt;/p&gt;
&lt;p&gt;Even the most caring manager cannot read your mind and is juggling a dozen other priorities. When a tech-lead opportunity opens up between two equally capable engineers, the one who previously said &amp;ldquo;I want to lead a project&amp;rdquo; gets the nod almost every time. Saying it out loud also unlocks actionable feedback: your manager can tell you the exact skill gaps between where you are and where you want to go—a roadmap self-assessment can never provide because we all have blind spots. Speaking the goal also makes it real and forces you to act on it. Starting doesn&amp;rsquo;t require a grand speech: just ask what the path to Senior looks like or what it would take to lead an upcoming initiative. And if merely stating a career goal gets held against you, that tells you something vital about your workplace too.&lt;/p&gt;
&lt;h2 id="agentic-coding-and-microservices"&gt;&lt;a href="https://www.natemeyvis.com/agentic-coding-and-microservices/" rel="noopener noreferrer"&gt;Agentic Coding and Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nate Meyvis responds to Ben Borgers&amp;rsquo;s argument that AI coding agents will push the industry toward microservices because LLMs work better inside small, strictly encapsulated contexts. Meyvis agrees with the premise—strict encapsulation helps LLMs—but points out that encapsulation has &lt;em&gt;always&lt;/em&gt; helped humans, teams, and agents alike, and isn&amp;rsquo;t unique to AI. In fact, coding with AI has pushed his own projects &lt;em&gt;more&lt;/em&gt; toward monoliths: microservices still suffer from all the classic distributed-data headaches whenever features span service boundaries, and moving faster with AI means you hit those cross-service walls even sooner; meanwhile, deploying a monolith is faster and simpler, matching the tight iteration loop of AI-assisted development.&lt;/p&gt;
&lt;p&gt;His core point is that network boundaries between microservices are neither necessary nor sufficient for good encapsulation: microservices regularly degenerate into distributed monoliths with hidden coupling, while a single-repo monolith can enforce clean module boundaries with discipline. Left to their own devices, LLMs naturally prefer adding code to an existing service over standing up a new one, and a clear &lt;code&gt;AGENTS.md&lt;/code&gt; file paired with regular refactoring prompts is usually enough to keep subsystem boundaries clean inside a monolith without paying the operational tax of distributed systems. In an AI-first workflow, a well-structured, well-documented monolith is often the most pragmatic choice.&lt;/p&gt;
&lt;h2 id="garbage-collection-from-first-principles-to-modern-collectors-in-java-go-and-python"&gt;&lt;a href="https://shbhmrzd.github.io/systems/garbage-collection/memory-management/2026/04/01/garbage-collectors-deep-dive.html" rel="noopener noreferrer"&gt;Garbage Collection: From First Principles to Modern Collectors in Java, Go and Python&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This comprehensive guide traces garbage collection from its theoretical roots—starting with John McCarthy&amp;rsquo;s 1960 Lisp paper introducing mark-and-sweep—up through modern collectors in Java, Go, and Python. Following Paul Wilson&amp;rsquo;s classic 1992 survey taxonomy, automatic memory management rests on three foundational families: &lt;em&gt;mark-and-sweep&lt;/em&gt; (simple, but fragments the heap), &lt;em&gt;semi-space copying&lt;/em&gt; (copies live objects into a fresh half-heap, enabling fast bump-pointer allocation at the cost of reserving half of memory), and &lt;em&gt;reference counting&lt;/em&gt; (frees memory deterministically as soon as the count hits zero, but struggles with cyclic references). The weak generational hypothesis—&amp;ldquo;most objects die young&amp;rdquo;—underpins modern collectors that focus collection effort on a small young generation to dramatically cut pause times.&lt;/p&gt;
&lt;p&gt;Comparing production runtimes: Go uses a non-moving, concurrent tri-color mark-and-sweep collector with a hybrid write barrier targeting sub-millisecond pauses without heap compaction. Java&amp;rsquo;s G1GC divides the heap into 1–32MB regions and uses Snapshot-At-The-Beginning (SATB) concurrent marking, while ZGC encodes metadata into unused pointer bits (&lt;em&gt;colored pointers&lt;/em&gt;) and uses load barriers to remap pointers lazily, achieving sub-millisecond pauses even on multi-hundred-gigabyte heaps. CPython relies primarily on GIL-protected reference counting backed by a three-generation (0, 1, 2) cycle detector. Looking at the trade-offs: tracing collectors dominate server runtimes because reference counting&amp;rsquo;s per-write overhead compounds quickly; compacting collectors unlock fast bump allocation at the cost of moving objects and rewriting pointers, while non-compacting collectors like Go&amp;rsquo;s avoid pointer updates and accept more complex free-list/span allocation instead.&lt;/p&gt;
&lt;h2 id="i-told-claude-code-to-build-me-an-executive-assistant"&gt;&lt;a href="https://x.com/obie/status/2013955736292704342" rel="noopener noreferrer"&gt;I told Claude Code to build me an executive assistant&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Obie Fernandez, CTO at ZAR, recounts turning Claude Code into a personal executive assistant with a single prompt: asking Claude to design a markdown-based system from scratch to help him operate as a world-class CTO. He didn&amp;rsquo;t create a single folder or template himself—he let Claude design and evolve the structure. Three weeks later, the system had processed 82 meeting transcripts (47 meetings that month alone), tracked 23 team members across 264 lines of rich interpersonal context, and accumulated 11,579 lines of structured organizational knowledge—all while he managed 10 engineers, shipped code, and handled executive duties.&lt;/p&gt;
&lt;p&gt;The secret is that he &amp;ldquo;never thinks about the system&amp;rdquo;: he just talks to Claude naturally, usually dictating via Wispr Flow, with at least one Claude Code terminal session open all day (and multiple parallel sessions when prepping for back-to-back meetings). Everyday prompts include &lt;code&gt;&amp;quot;morning sync&amp;quot;&lt;/code&gt; to synthesize his calendar and top priorities, &lt;code&gt;&amp;quot;prep for 1:1 with Daniel&amp;quot;&lt;/code&gt; to review past notes and surface talking points, and &lt;code&gt;&amp;quot;log decision about X&amp;quot;&lt;/code&gt; to record architectural or org decisions; after every meeting, he simply pastes the raw transcript and lets Claude extract notes and action items. Connecting Calendar, Slack, Twitter, and Linear through Rube/MCP is the linchpin that lets Claude take action directly without context-switching. Fernandez&amp;rsquo;s conclusion: every knowledge worker will eventually run a personal agent harness like this, and those who wait will fall behind.&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_!OXGA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6025205d-78d1-4aa9-b2ba-281d1b9fc57e_2484x3002.png" alt="Monolithic vs Microservices vs Serverless"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!70vn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F71e475fe-34fa-44f8-a564-02f946456588_2508x3042.png" alt="CLI vs MCP"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!INti!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F29e4bde9-65ea-4d95-bc99-1802e4f74448_2484x3002.png" alt="Comparing 5 Major Coding Agents"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ujMG!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1fd50345-af15-4236-ab47-73225d1aa660_800x803.jpeg" alt="JWT Visualized"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #76</title><link>https://miti99.com/en/post/2026/01/05/</link><pubDate>Mon, 05 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #76.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="tcp-vs-udp-vs-grpc-choosing-the-right-protocol-for-your-architecture"&gt;&lt;a href="https://designgurus.substack.com/p/an-engineers-guide-to-basic-networking" rel="noopener noreferrer"&gt;TCP vs. UDP vs. gRPC: Choosing the Right Protocol for Your Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you call a local function, data moves entirely within a single machine&amp;rsquo;s memory; modern software, however, constantly communicates with databases, APIs, and browsers halfway around the world. Network protocols are the rules governing data formats, how conversations are opened and closed, and how errors are handled. This article starts at the transport layer with its two pillars: TCP and UDP. TCP prioritizes reliability: before sending data, both sides perform a three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;); the protocol then guarantees that every byte arrives intact and in order, automatically retransmits lost packets, and uses flow control and congestion control to avoid overwhelming the receiver. That makes TCP ideal when accuracy matters more than raw speed, such as database queries, email, and web pages. UDP is the opposite: connectionless, no handshake, no packet numbering, and any packet dropped in transit is gone for good; in exchange, latency is minimal, making it a great fit for live video streaming or online gaming, where dropping a frame is far better than pausing to wait for an old one.&lt;/p&gt;
&lt;p&gt;At the application layer, HTTP follows a request–response model using methods like &lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, and &lt;code&gt;DELETE&lt;/code&gt;, headers carrying metadata, and status codes like &lt;code&gt;200 OK&lt;/code&gt; or &lt;code&gt;404 Not Found&lt;/code&gt;. The HTTP version matters too: HTTP/1.1 processes requests one at a time per connection and suffers from head-of-line blocking when a slow resource holds up the entire page; HTTP/2 adds multiplexing so multiple requests and responses can run concurrently over a single TCP connection; and HTTP/3 drops TCP entirely in favor of QUIC (built on top of UDP) for better performance on lossy networks. Finally, WebSockets overcome HTTP&amp;rsquo;s unidirectional limitation: a connection begins as an HTTP request asking for an &amp;ldquo;upgrade&amp;rdquo; and then stays open so both client and server can push messages at any time without per-message header overhead—ideal for chat apps or live stock tickers that need low-latency bidirectional communication.&lt;/p&gt;
&lt;h2 id="software-engineering-in-2026"&gt;&lt;a href="https://benjamincongdon.me/blog/2025/12/29/Software-Engineering-in-2026/" rel="noopener noreferrer"&gt;Software Engineering in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Congdon observes that the biggest impact of LLM tooling so far is a dramatic drop in the marginal cost—both in time and money—of producing high-quality code. Because writing code is only one part of software engineering, the bottleneck is shifting elsewhere. He breaks an engineer&amp;rsquo;s job down into building, evolving, and operating distributed systems: the first two have become much cheaper and easier thanks to LLMs, while operations remains largely untouched. The market will expect engineers to harness LLM productivity, making the profession feel more &amp;ldquo;industrialized&amp;rdquo; yet also higher-leverage. As a result, investments in solid infrastructure pay off faster than ever: metrics, logging, feature flags, deployments, autoscaling, and configuration should be self-service for both humans and LLMs via ergonomic CLIs or MCP-ready APIs. CI infrastructure also becomes more critical as AI agents write more code, potentially justifying investments in property-based testing and formal verification—and since LLMs don&amp;rsquo;t mind writing tests, there is no longer any excuse for poor test coverage.&lt;/p&gt;
&lt;p&gt;He emphasizes human-guided abstractions: without clear guardrails, LLMs fill in the blanks with greedy solutions just to get CI green, steadily degrading the codebase. Module boundaries, library interfaces, and contracts between infrastructure and product layers become the primary levers for maintaining long-term quality. Human code review also becomes a new bottleneck: style issues should be offloaded to automated linters so reviewers can focus on hard-to-reverse decisions like interface changes, data persistence, and performance-critical paths. This creates a paradox for junior engineers, who need to develop &amp;ldquo;review taste&amp;rdquo; earlier while writing less code by hand to build that intuition. Project estimation variance will also widen, since cost now depends heavily on how amenable a task is to LLM automation. On build-versus-buy, thin CRUD-style SaaS tools will increasingly tilt toward &amp;ldquo;build&amp;rdquo; at mid-to-large companies, whereas infrastructure and compliance SaaS will change much less because operational costs haven&amp;rsquo;t fallen like development costs have.&lt;/p&gt;
&lt;h2 id="reflections-on-2025"&gt;&lt;a href="https://samuelalbanie.substack.com/p/reflections-on-2025" rel="noopener noreferrer"&gt;Reflections on 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Samuel Albanie looks back on 2025 across three themes in his trademark witty style. First is &amp;ldquo;The Compute Theory of Everything&amp;rdquo;: in 2021, the handcrafted architectural inductive biases he painstakingly designed for computer vision at VGG (Oxford) were swept aside by a simpler system backed by massive pre-training compute. He revisits Hans Moravec&amp;rsquo;s 1976 argument that intelligence is not about magical symbolic manipulation, but raw processing power—&amp;ldquo;with enough thrust, anything flies.&amp;rdquo; Moravec noted that AI capability scales in lockstep with researchers&amp;rsquo; access to faster hardware; since upcoming hardware clusters will make 2025&amp;rsquo;s supercomputers look like pocket calculators, Albanie believes we are nowhere near hitting a ceiling. His second theme is model evaluation: AI systems are becoming increasingly general, while our benchmarks remain narrow. METR&amp;rsquo;s approach measures the duration of tasks models can complete compared to a skilled human, which jumped from roughly 5 minutes in early 2024 to 4 hours and 49 minutes with Claude Opus 4.5 in late 2025, even as the surface area needing evaluation has exploded from MNIST digit recognition to nearly the entire economy.&lt;/p&gt;
&lt;p&gt;His final theme, &amp;ldquo;Floreat Britannia,&amp;rdquo; examines the UK: real wages grew 33% per decade from 1970 to 2007 before stalling out, industrial electricity prices are the highest in Europe, the Hinkley Point C nuclear plant cost £46 billion, and an acoustic fish deterrent system alone cost roughly £700 million while projected to save just 0.083 salmon per year. In his view, the bottleneck is coordination and decision-making, and he is optimistic that AI will make high-quality probabilistic forecasting cheap and ubiquitous. Still, good forecasts are useless if the culture is paralyzed by risk aversion; invoking Benjamin Franklin flying a kite in a thunderstorm and inventing the lightning rod, he concludes that Britain needs both boldness and prudence—both the &amp;ldquo;kite&amp;rdquo; and the &amp;ldquo;lightning rod.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="8-predictions-for-2026-what-comes-next-in-ai"&gt;&lt;a href="https://www.philschmid.de/2026-predictions" rel="noopener noreferrer"&gt;8 Predictions for 2026. What comes next in AI?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philipp Schmid rarely writes prediction posts, but after a watershed 2025, he outlines eight AI trends for 2026. Generative UI will take off once code-generation latency and quality are good enough for apps to synthesize bespoke interfaces in real time tailored to each user&amp;rsquo;s task and preferences. Personal agents will move to the edge, powered by Small Language Models (SLMs) running locally on dedicated hardware. The smart home will finally deliver on its promise as assistants understand context and intent rather than rigid voice commands, blending into general assistants like the Gemini or ChatGPT apps. As traditional benchmarks saturate, AI labs will compete on &amp;ldquo;harnesses&amp;rdquo;—complex environments that prove agents can reliably execute multi-day workflows. Vibe coding will mature into real engineering: engineers will spend 99% of their time reviewing, evaluating, shaping ideas, and thinking, with the core skill being connecting implementation details, code quality, velocity, and business goals; knowing how to code becomes a distinct competitive advantage.&lt;/p&gt;
&lt;p&gt;His remaining three predictions revolve around social media: &amp;ldquo;AI slop&amp;rdquo; will turn human-created content into a premium market; every post on X, Instagram, or LinkedIn will be assumed AI-generated by default unless it carries a cryptographic signature under a &amp;ldquo;Human-Signed&amp;rdquo; metadata standard (like C2PA for cameras), with unsigned content downranked by algorithms as &amp;ldquo;synthetic noise&amp;rdquo;; and to fight agent spam, platforms will carve out a &amp;ldquo;verified human web&amp;rdquo; requiring biometric proof of personhood. In closing, he isn&amp;rsquo;t worried about the future of software engineers and believes learning to code is still well worth it, as deep technical understanding is more important than ever for steering these systems. His advice: build and learn—closely observe what others are building, dissect the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; and build your own version. Agents will remain center stage as successful patterns from coding agents spread to general-purpose agents that proactively anticipate needs rather than waiting for prompts.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #64</title><link>https://miti99.com/en/post/2025/12/06/</link><pubDate>Sat, 06 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #64. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; Qwen3-Coder-Plus&lt;sup id="fnref:1"&gt;&lt;a href="#fn:1" class="footnote-ref" role="doc-noteref"&gt;1&lt;/a&gt;&lt;/sup&gt;&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="caching"&gt;&lt;a href="https://planetscale.com/blog/caching" rel="noopener noreferrer"&gt;Caching&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains caching from first principles: pairing a small amount of fast, expensive storage with a large amount of slow, cheap storage so that frequently accessed data lives in the fast tier. The key metric is the hit rate (the percentage of requests served from the cache rather than the backing store); the higher the hit rate, the less often you pay the latency penalty of slow storage. Familiar examples include CPU L1, L2, and L3 caches, RAM acting as a cache for disk, or a social network keeping recent posts in fast memory while pushing older posts to colder storage.&lt;/p&gt;
&lt;p&gt;The author breaks down two forms of locality: temporal locality (data accessed recently is likely to be accessed again soon, such as caching posts from the last 48 hours) and spatial locality (accessing one item makes nearby items likely to be needed next, such as a photo app prefetching adjacent images). CDNs tackle geographic distance by placing cached copies close to end users. When a cache fills up, it needs an eviction policy: FIFO is simple but naive, LRU evicts the least recently used item to better match real-world access patterns, and time-aware LRU expires stale entries automatically. Finally, databases layer caches of their own—PostgreSQL combines &lt;code&gt;shared_buffers&lt;/code&gt; with the OS page cache, while MySQL uses its buffer pool—delivering multi-tier caching while preserving ACID guarantees.&lt;/p&gt;
&lt;h2 id="consistent-hashing"&gt;&lt;a href="https://eli.thegreenplace.net/2025/consistent-hashing/" rel="noopener noreferrer"&gt;Consistent Hashing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Distributing keys across N nodes with a simple &lt;code&gt;hash % N&lt;/code&gt; formula works fine until the node count changes: adding or removing even a single node remaps nearly every key to a different server, triggering a thundering herd of cache misses right when the system is already under load. Consistent hashing solves this by using the same hash function to map both nodes and keys onto a ring, assigning each key to the next node clockwise on the ring. When a node joins or leaves, only about M/N keys (where M is the total number of keys and N is the number of nodes, assuming an even distribution) need to move instead of nearly all of them.&lt;/p&gt;
&lt;p&gt;For the implementation, the author stores node positions in a sorted array representing a discrete ring, turning key lookup into a fast, cache-friendly binary search. The remaining catch is that random placement leaves uneven gaps between nodes on the ring: with 20 nodes, one node can end up owning roughly 40x as many keys as another. The fix is virtual nodes—mapping each physical node to multiple points around the ring; testing with 10 virtual nodes per physical node smooths out the distribution dramatically. Originally invented at MIT for distributed web caching, consistent hashing became the foundation of Akamai and influenced AWS&amp;rsquo;s Dynamo storage system.&lt;/p&gt;
&lt;h2 id="how-to-stop-linux-threads-cleanly"&gt;&lt;a href="https://mazzo.li/posts/stopping-linux-threads.html" rel="noopener noreferrer"&gt;How to stop Linux threads cleanly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post tackles a problem far trickier than spawning threads: stopping a Linux thread cleanly while still giving it a chance to run cleanup code. The simplest approach is a quasi-busy loop where the thread checks an atomic flag after each unit of work, assuming each iteration finishes quickly enough. It&amp;rsquo;s easy to reason about, but forces you to structure your code around short work slices. &lt;code&gt;pthread_cancel()&lt;/code&gt; looks tempting at first glance but has serious pitfalls: on &lt;code&gt;glibc&lt;/code&gt;/&lt;code&gt;libstdc++&lt;/code&gt;, cancellation is implemented via forced stack unwinding; if unwinding crosses a &lt;code&gt;noexcept&lt;/code&gt; boundary—such as cancelling inside a destructor—the program terminates immediately, and cancelling mid-operation can corrupt shared application state.&lt;/p&gt;
&lt;p&gt;A signal-based approach using &lt;code&gt;SIGUSR1&lt;/code&gt; and careful signal-mask manipulation can interrupt blocking system calls, but still suffers from a race condition because checking the stop flag and entering the syscall isn&amp;rsquo;t atomic. For syscalls that have signal-mask-aware variants—such as &lt;code&gt;ppoll&lt;/code&gt;, &lt;code&gt;pselect&lt;/code&gt;, and &lt;code&gt;epoll_pwait&lt;/code&gt;—this race is solved cleanly. For all other blocking syscalls, the author demonstrates a clever trick using &lt;code&gt;rseq&lt;/code&gt; (restartable sequences, available since Linux 4.18) to wrap the flag check and the syscall instruction in a single atomic critical section that the kernel aborts and restarts if interrupted mid-way. The takeaway is that no single solution is perfect: polling a flag works for most applications, signals suit I/O-heavy threads, and &lt;code&gt;rseq&lt;/code&gt; requires inline assembly and is best reserved for specialized low-level code.&lt;/p&gt;
&lt;h2 id="advice-for-new-principal-tech-ics-ie-notes-to-myself"&gt;&lt;a href="https://eugeneyan.com/writing/principal/" rel="noopener noreferrer"&gt;Advice for New Principal Tech ICs (i.e., Notes to Myself)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eugene Yan compiles 31 pieces of advice for newly minted Principal Engineers and Applied Scientists, distilled from observing experienced peers. The starting premise is that what got you promoted to senior levels becomes secondary at Principal: writing code yourself isn&amp;rsquo;t always the highest-leverage use of your time, even though you must stay close enough to the tech to maintain credibility and context. Principals come in different archetypes—some go deep technically, others drive broad cross-org alignment—and the role frequently blends parts of product management, design, and culture-building. Being right isn&amp;rsquo;t enough; you have to persuade others to care and act—one mentor shared that out of every 10 proposal docs they write, only about 3 actually get built.&lt;/p&gt;
&lt;p&gt;Yan advises picking work that wouldn&amp;rsquo;t happen without you, sitting at the intersection of your unique strengths and the organization&amp;rsquo;s gaps, and splitting your portfolio across three modes: leading (roughly 50%), sponsoring (20%), and advising (30%). Scaling your impact means helping others make decisions the way you would and setting aside dedicated weekly time for mentoring, including interns. In meetings, ask questions to create space for others, and explicitly label whether you are stating a known fact or just wondering aloud so a casual remark isn&amp;rsquo;t mistaken for a mandate. Greater autonomy comes with greater accountability: protect time for deep thinking and ultimately aim to make the organization succeed without depending on you.&lt;/p&gt;
&lt;h2 id="how-fast-is-java-teaching-an-old-dog-new-tricks"&gt;&lt;a href="https://dgerrells.com/blog/how-fast-is-java-teaching-an-old-dog-new-tricks" rel="noopener noreferrer"&gt;How fast is java? Teaching an old dog new tricks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author tests whether modern Java can keep up with Rust by building a particle simulation using Java&amp;rsquo;s new Vector API for SIMD math. The Vector API abstracts CPU-specific vector instructions behind the concept of a &amp;ldquo;species,&amp;rdquo; letting you write SIMD code once that runs across hardware architectures. To squeeze out maximum performance, the author decouples the physics simulation from the UI event thread, manages worker threads manually instead of using parallel streams, and gives each worker thread its own pixel buffer before merging them at the end to avoid cache contention from concurrent writes.&lt;/p&gt;
&lt;p&gt;On an M1 MacBook Air, Rust still runs roughly 2x faster across most particle counts—for instance, simulating 100 million particles takes ~69 ms per frame in Rust versus ~119 ms in Java. Java also carries higher baseline overhead from heap allocations, whereas Rust&amp;rsquo;s memory allocation is much leaner. While the author acknowledges Java has come a long way with lambdas and the Vector API, the surrounding ecosystem remains a pain point: just pulling in a couple of small libraries required frustrating build-system ceremony. His verdict: the old dog can indeed learn new tricks, but it&amp;rsquo;s still weighed down by legacy tooling.&lt;/p&gt;
&lt;h2 id="50-things-i-know"&gt;&lt;a href="https://usefulfictions.substack.com/p/50-things-i-know" rel="noopener noreferrer"&gt;50 things I know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cate Hall shares 50 lessons she has learned about relationships, decision-making, and personal growth. On people, she notes that you can care deeply for someone who doesn&amp;rsquo;t reciprocate, and that loving without needing anything back is the essence of selflessness; she separates admiration, obsession, and infatuation from real love, and observes that revenge is rarely worth it because difficult people are already their own punishment. Many social dynamics are paradoxical: actions that feel weak from the inside, when done without apology, are perceived by others as strength.&lt;/p&gt;
&lt;p&gt;On decision-making, she pushes back against the idea that effort times time equals results, highlights the importance of spotting asymmetric payoffs where being wrong in one direction is far costlier than the other, and advises doubling both time and budget estimates because you can never fully correct for the planning fallacy. If you want better opinions, start by having fewer of them. Knowing when to quit is an underrated skill, and she avoids totalizing ideologies because no moral framework survives every edge case intact. She closes with reminders that being of service to others is the only reliable way to feel better yourself, and that ten years from now you&amp;rsquo;ll look back and marvel at how great you had it today—so why not see it that way right now?&lt;/p&gt;
&lt;h2 id="programming-languages-that-blew-my-mind"&gt;&lt;a href="https://yoric.github.io/post/programming-languages-that-blew-my-mind/" rel="noopener noreferrer"&gt;Programming Languages That Blew My Mind&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Teller looks back at the programming languages that reshaped how he thinks about software. BASIC introduced arrays and &lt;code&gt;GOTO&lt;/code&gt;/&lt;code&gt;GOSUB&lt;/code&gt; control flow; Turbo Pascal brought IDEs, debuggers, structured programming, and modules; x86 assembly taught him memory addressing, registers, and talking directly to hardware. HyperCard introduced visual programming, natural-language-like scripting, and garbage collection. OCaml—with parametric polymorphism, type inference, pattern matching, and higher-order functions—humbled him, while Prolog taught declarative programming, where instead of writing an algorithm you teach the computer how to reason.&lt;/p&gt;
&lt;p&gt;In industry, Java stood out for its batteries-included standard library, thorough documentation, and the JVM; Erlang impressed him with its &amp;ldquo;let it fail&amp;rdquo; philosophy and actor model for distributed systems; Coq turned specifications into types and programs into formally verified proofs. Opalang experimented with multi-tier compilation that automatically split code across client, server, and database, while Rust combined functional-language safety guarantees with systems-programming performance. Teller notes that many ideas from academic languages eventually filter into mainstream software, and says he is still waiting for the next truly mind-expanding programming paradigm.&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/9cfa2d94-1602-47c2-8942-b585c1d8d285_2252x2752.jpeg" alt="Docker vs Kubernetes"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!P-gB!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c9090b5-77c7-4f04-88bc-481df27de32d.tif" alt="Batch vs Stream Processing"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!f0s-!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb6d1ef48-faea-4d57-b2ea-f8411efc8334_2360x2770.png" alt="What are Modular Monoliths?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MDHC!,w_1456,c_limit,f_webp,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7cf3f3a0-726f-47a3-94e4-755fa9aa8036_2196x2319.jpeg" alt="What is the difference between Process and Thread?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-jEP!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa7885eb0-3b6d-4be3-bbb7-332b3f9fc0e0_2360x2920.jpeg" alt="How to Debug a Slow API?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!uW-M!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd7494e44-82ec-43fc-bd7f-eabea7776dd1_2250x2624.png" alt="Top Service-to-Service Communication Patterns"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict: Overall this is still a fairly solid post. However, the summaries are a bit on the long side and will need further refinement.&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;
&lt;div class="footnotes" role="doc-endnotes"&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;&lt;del&gt;Qwen3-Coder-480B-A35B-Instruct&lt;/del&gt;&amp;#160;&lt;a href="#fnref:1" class="footnote-backref" role="doc-backlink"&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&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 #45</title><link>https://miti99.com/en/post/2025/08/04/</link><pubDate>Mon, 04 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/04/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was put together using Cline + Kimi K2.&lt;/del&gt; Enjoy Newsletter #45.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-best"&gt;&lt;a href="https://www.paulgraham.com/best.html" rel="noopener noreferrer"&gt;The Best&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his essay &amp;ldquo;The Best Essay,&amp;rdquo; Paul Graham asks: what would the best possible essay look like? His first answer is that it must tackle the most important topic about which one can still say something surprising—but that line of thought leads toward major scientific discoveries, which are tied to the moment of their discovery rather than being timeless. So he reframes it into a more practical question: how do you write a truly great essay? According to Graham, everything starts with a compelling initial question where the writer has a fresh perspective or a distinct approach.&lt;/p&gt;
&lt;p&gt;The writing process turns vague ideas into concrete prose, followed by ruthless rereading and revision until the gap between the current answer and the truth becomes visible—sometimes opening up an entirely new direction. An essay works like a recursive exploration: each answer spawns new questions, and the writer should follow whichever branch offers the best combination of generality and novelty, ready to discard whole passages already written if they no longer serve the main thread. Although the initial question caps the maximum quality of the essay, Graham advises against being overly cautious when choosing topics; instead, write a lot, because most questions can yield a good essay. The ability to ask great questions comes from broad knowledge and deep experience across multiple fields.&lt;/p&gt;
&lt;h2 id="ai-tools-make-developers-19-slower-not-faster"&gt;&lt;a href="https://threadreaderapp.com/thread/1943360399220388093.html" rel="noopener noreferrer"&gt;AI Tools Make Developers 19% Slower, Not Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The research organization METR conducted a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories, which averaged over 22,000 stars and more than one million lines of code. Each task was randomly assigned to either allow or disallow AI tools (primarily Cursor Pro with Claude 3.5/3.7). The results were surprising: before the experiment, developers predicted AI would make them 24% faster; after finishing, they still felt they had been 20% faster; yet the actual measurements showed they were 19% slower when assisted by AI.&lt;/p&gt;
&lt;p&gt;The researchers emphasize that these findings apply specifically to this setting and do not represent the entire software industry; future models or more effective usage patterns could yield different outcomes. The slowdown appeared consistently across multiple metrics and stemmed from several factors at once: when allowed to use AI, developers spent time prompting the AI, waiting for responses, reviewing AI output, and idling, rather than directly writing code or looking up documentation. The takeaway is that the gap between subjective perception and actual productivity can be huge, so measure rather than relying on gut feeling when evaluating new tools.&lt;/p&gt;
&lt;h2 id="evolution-of-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/evolution-of-ubers-search-platform/" rel="noopener noreferrer"&gt;Evolution of Uber&amp;rsquo;s Search Platform&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article recounts the three-stage evolution of Uber&amp;rsquo;s search platform. Initially, Uber treated Elasticsearch (built on Apache Lucene) almost as a &amp;ldquo;black box,&amp;rdquo; with engineers focused mainly on keeping operations stable. A major limitation was Lucene&amp;rsquo;s near-real-time mechanism: new data became searchable only after being flushed to the index, introducing latency in time-sensitive scenarios like matching riders with drivers. Starting in 2019, Uber built Sia in-house, extending Lucene with an in-memory live index for real-time search, switching to lighter-weight gRPC/Protobuf communication, pull-based ingestion via Kafka, and active-active multi-region deployment. However, the complex custom architecture made it very difficult to adopt new Lucene features such as vector search, while most use cases didn&amp;rsquo;t actually need real-time freshness.&lt;/p&gt;
&lt;p&gt;In 2024, with Project Sunrise, Uber recognized that maintaining a custom fork was no longer sustainable and migrated to OpenSearch, becoming a founding member of the OpenSearch Software Foundation. The current architecture separates the write path from the read path: data from Kafka is compacted into optimized segments and uploaded to remote storage, while search nodes simply download them to serve queries, keeping all ingestion overhead off the query path. Uber also contributed features back to OpenSearch 3.0, including pull-based ingestion and gRPC APIs. The lesson: custom-built solutions are expensive to maintain when the ecosystem moves fast, and complexity should only be accepted where it is genuinely needed.&lt;/p&gt;
&lt;h2 id="vercel"&gt;&lt;a href="https://leerob.com/vercel" rel="noopener noreferrer"&gt;Vercel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson reflects on his five years at Vercel, where he grew from an individual engineer to VP, watching the company scale from 30 people and $1 million in ARR to 650 people and over $200 million. His first lesson is work-life balance: he once answered work messages even during his honeymoon, and only broke free by building processes and hiring people capable enough to run things themselves. Second, speed is a competitive advantage: asking &amp;ldquo;what would it take to ship this next week?&amp;rdquo; forces teams to find creative solutions, and even if you miss the deadline, you still finish faster than if you had set none at all.&lt;/p&gt;
&lt;p&gt;Third, scaling requires hiring rather than doing everything yourself—always be recruiting, keep the bar high, and only hire candidates who genuinely excite you. Fourth, avoid unilateral decisions: he once parachuted into a product launch at the last minute and demanded changes without full context, something he regrets; leaders should get involved early and build consensus before making calls. Finally, stay adaptable and admit mistakes: personally reviewing every company social media post created a bottleneck, and delegating ownership alongside clear quality guidelines produced better results. These are valuable lessons for any developer moving toward a leadership role.&lt;/p&gt;
&lt;h2 id="tools"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/3/tools/" rel="noopener noreferrer"&gt;Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that when working with AI agents, &amp;ldquo;code is all you need.&amp;rdquo; He critiques the MCP protocol, which lets language models invoke external tools and services: this approach is hard to compose because every step depends on model inference, consumes substantial context on each tool call, and scales poorly when automating repetitive tasks. In his view, without AI, a software engineer solves problems by writing code—so AI should do the same.&lt;/p&gt;
&lt;p&gt;Model-generated code has explicit logic that humans can inspect, runs repeatedly at low cost once written, and is easier to debug. As an illustration, Armin describes migrating his entire blog from reStructuredText to Markdown: the model wrote AST-based conversion scripts, wrote additional scripts comparing the old and new HTML to verify the output, and iterated on that feedback loop with almost no human intervention. Here, the model acted as a code quality evaluator rather than manually executing each step. He concludes that MCP looks like a dead end for large-scale automation, and a more promising path is combining code generation with having the model evaluate the results after execution.&lt;/p&gt;
&lt;h2 id="how-i-build-software-quickly"&gt;&lt;a href="https://evanhahn.com/how-i-build-software-quickly/" rel="noopener noreferrer"&gt;How I Build Software Quickly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn shares how he builds software quickly while maintaining acceptable quality. The core principle is balancing speed and quality: aim for &amp;ldquo;8 out of 10, delivered on time&amp;rdquo; rather than chasing perfection. What counts as &amp;ldquo;good enough&amp;rdquo; depends on context—a 24-hour game jam tolerates messy code, whereas a pacemaker demands excellence—so you need to understand what your team considers good enough. He recommends building a rough draft first, full of TODOs, hardcoded data, and unhandled errors, to uncover unforeseen problems early, avoid wasting effort on code that will be thrown away, and prevent premature abstraction.&lt;/p&gt;
&lt;p&gt;Doing less is also a way to move faster: question the scope, combine screens, skip unnecessary edge cases, or trim API parameters. To stay focused, he sets timers for tasks and pair-programs. Small changes are easier to write, review, revert, and debug—for instance, fixing a bug, upgrading a library, and adding a feature in separate changes. The skills that speed him up most include reading code (the most important one), data modeling, writing automation scripts, using a debugger, taking breaks, writing pure functions, and leveraging LLM tools.&lt;/p&gt;
&lt;h2 id="the-most-mysterious-bug-i-solved-at-work"&gt;&lt;a href="https://cadence.moe/blog/2025-07-02-the-most-mysterious-bug-i-solved-at-work/" rel="noopener noreferrer"&gt;The Most Mysterious Bug I Solved at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cadence recounts the most mysterious bug she ever solved on an electronic patient referral application in Australia, a system that converts referral data into HL7, CDA, or PDF formats to send to healthcare providers. Occasionally, the system threw the error &lt;code&gt;Illegal Character entity: expansion character (code 0x2) not a valid XML character&lt;/code&gt;. Character &lt;code&gt;0x2&lt;/code&gt; (Start of Text) is an obsolete control character from the early days of computing with virtually no modern use—yet it was showing up inside referral letters typed by doctors.&lt;/p&gt;
&lt;p&gt;Investigation gradually uncovered the clues: the affected letters all had unusual hard line breaks, and the same doctor was submitting identical letters multiple times. It turned out the doctor was copying text from PDFs of previous referrals stored in their practice management software, and character &lt;code&gt;0x2&lt;/code&gt; appeared right where hyphens sat at the ends of lines in the PDF. The culprit was Microsoft Edge&amp;rsquo;s built-in PDF viewer—the default on Windows—which mistakenly converted end-of-line hyphens into &lt;code&gt;0x2&lt;/code&gt; when copying text. The team fixed the issue by automatically replacing &lt;code&gt;0x2&lt;/code&gt; with a hyphen rather than stripping it, preserving the intended text. The story reminds developers that the root cause of a bug sometimes lies outside the codebase, in users&amp;rsquo; habits and the tools they rely on.&lt;/p&gt;
&lt;h2 id="how-to-think-about-time-in-programming"&gt;&lt;a href="https://shanrauf.com/archive/how-to-think-about-time-in-programming" rel="noopener noreferrer"&gt;How to Think About Time in Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shan Rauf lays out a clear mental model for handling time in programming. The foundation is absolute time, consisting of &amp;ldquo;instants&amp;rdquo; and &amp;ldquo;durations&amp;rdquo;: an instant is represented as seconds elapsed since a reference point called an epoch (Unix uses January 1, 1970), while a duration is the length of time between two instants, so comparisons and calculations require only basic arithmetic. Humans, however, use civil time based on the Gregorian calendar, with months of varying lengths. UTC defines the second using atomic clocks and occasionally inserts leap seconds to stay aligned with Earth&amp;rsquo;s rotation, meaning a day can be 86,401 or 86,399 seconds long; JavaScript&amp;rsquo;s &lt;code&gt;Date&lt;/code&gt; ignores leap seconds. Time zones are not fixed offsets but evolving sets of rules: during daylight saving transitions, certain civil times are skipped or repeated twice, and the IANA time zone database (such as &lt;code&gt;America/New_York&lt;/code&gt;) records known rules and historical transitions, though it does not guarantee accuracy for every location prior to 1970.&lt;/p&gt;
&lt;p&gt;In practice, chat messages should be stored in UTC and displayed in the viewer&amp;rsquo;s local time zone. For events, intent matters: a class held at a physical location should be stored as local time plus a time zone identifier, whereas an absolute event like a solar eclipse should be stored in UTC. The author recommends bundling the IANA database and updating it regularly, using Unicode CLDR data to display friendly time zone names, and never assuming a UTC offset is immutable. The advice &amp;ldquo;just use UTC&amp;rdquo; isn&amp;rsquo;t enough, because converting to UTC too early discards information about the user&amp;rsquo;s original intent.&lt;/p&gt;
&lt;h2 id="phrase-origin-why-do-we"&gt;&lt;a href="https://quuxplusone.github.io/blog/2025/04/04/etymology-of-call/" rel="noopener noreferrer"&gt;Phrase origin: Why do we &amp;ldquo;call&amp;rdquo; functions?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arthur O&amp;rsquo;Dwyer investigates why we say we &amp;ldquo;call&amp;rdquo; a function. There are three intuitive hypotheses: calling as in visiting a friend (dropping by, staying a while, then leaving), calling as in summoning a servant to do a task, or calling on the telephone to ask a question and get an answer. The real answer is closest to the second hypothesis, but via a detour through library science: in closed-stack libraries, patrons &amp;ldquo;called for&amp;rdquo; books by their shelf mark—the term &amp;ldquo;call number&amp;rdquo; coined by Melvil Dewey in 1876. Early computer scientists borrowed this metaphor for subroutine libraries, where programmers &amp;ldquo;called&amp;rdquo; prewritten routines off the shelf much like a librarian retrieving a book by its call number.&lt;/p&gt;
&lt;p&gt;The timeline shows the evolution clearly: in 1947, John Mauchly wrote about subroutines being &amp;ldquo;called in&amp;rdquo; from a library on magnetic tape; in 1956, MANIAC II assembly used a &amp;ldquo;call number&amp;rdquo; to identify subroutines; in 1958, Fortran II introduced the &lt;code&gt;CALL&lt;/code&gt; statement, turning &amp;ldquo;call&amp;rdquo; into a runtime action; around 1959–1960, Algol and other languages adopted the term; in 1961, the verb phrase &amp;ldquo;call a subroutine&amp;rdquo; was first recorded in Burroughs documentation; and by 1963, modern usage had settled into MIT&amp;rsquo;s curriculum. The author concludes that Fortran II&amp;rsquo;s &lt;code&gt;CALL&lt;/code&gt; keyword is what cemented &amp;ldquo;call&amp;rdquo; as the standard verb for invoking a function.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing again with many URLs, it seems Cline + Kimi K2 overflowed its context window; after compacting, it forgot parts of the context and easily got confused, needing repeated reminders that this environment is Windows and requires PowerShell-compatible commands instead of Linux ones. On top of that, it made a few silly mistakes like summarizing&amp;hellip; the wrong URL :&amp;gt;&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 #42</title><link>https://miti99.com/en/post/2025/08/01/</link><pubDate>Fri, 01 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #42.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="challenging-algorithms-and-data-structures-every-programmer-should-try"&gt;&lt;a href="https://austinhenley.com/blog/challengingalgorithms.html" rel="noopener noreferrer"&gt;Challenging algorithms and data structures every programmer should try&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Austin Z. Henley highlights six algorithms and data structures that are genuinely fun to build, have shown up in interviews, and reshaped how he thinks about software. Topological sort comes up whenever you need to order items with dependencies, such as task execution in a build system or cell evaluation in a spreadsheet. Recursive descent parsing maps each grammar rule directly to a function, letting you put together a working compiler for a small language in a few hours. The Myers diff algorithm is the default algorithm Git uses to compute clean differences between two versions of a file.&lt;/p&gt;
&lt;p&gt;Bloom filters are a gateway into probabilistic data structures: using very little memory, a Bloom filter can tell you with certainty that an element is &lt;em&gt;not&lt;/em&gt; in a set, or that it &lt;em&gt;might&lt;/em&gt; be present—though Henley admits he has never needed one outside an interview. Piece tables represent editable text as a sequence of spans pointing into an immutable original buffer and an append-only add buffer, avoiding repeated full-string copies on every keystroke and making undo and incremental saves straightforward; VS Code uses a battle-tested variant of this design. Finally, Splay trees are self-adjusting binary search trees that move recently accessed nodes to the root without storing extra balance metadata, acting like a tree with a built-in cache that is far simpler to implement than a red-black tree. The post closes with honorable mentions like tries, segment trees, and union-find.&lt;/p&gt;
&lt;h2 id="everything-i-know-about-good-system-design"&gt;&lt;a href="https://www.seangoedecke.com/good-system-design/" rel="noopener noreferrer"&gt;Everything I know about good system design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke defines system design as how you assemble services like application servers, databases, caches, queues, and event buses—and argues that good system design usually looks boring: it runs quietly for years without anyone having to think about it. The hardest part of any system is state, because stateful components can get into corrupted states, so minimize the number of stateful pieces and make sure only a single service writes to any given database table. On the database side, align indexes with your hot queries, do &lt;code&gt;JOIN&lt;/code&gt;s in the database rather than stitching rows together in application memory, and offload read-heavy traffic to read replicas.&lt;/p&gt;
&lt;p&gt;Slow operations should be split into the minimum synchronous work needed to respond to the user immediately, with the rest handed off to background workers via a queue. Caches are another source of state, so reach for them only after you have tried speeding up the underlying query; event hubs like Kafka are useful when multiple consumers genuinely need the same stream, but shouldn&amp;rsquo;t replace simple direct API calls that are much easier to trace. Goedecke also advises designing around your highest-load hot paths, logging richly on error branches, tracking p95 and p99 latencies, pairing retries with circuit breakers and idempotency keys, and deciding upfront whether a component should fail open or fail closed: rate limiters should usually fail open, while authentication must always fail closed. His takeaway: good design isn&amp;rsquo;t about clever tricks—it&amp;rsquo;s about putting boring, proven components in the right places.&lt;/p&gt;
&lt;h2 id="ai-coding-agents-are-already-commoditized"&gt;&lt;a href="https://www.seangoedecke.com/ai-agents-are-commoditized/" rel="noopener noreferrer"&gt;AI Coding Agents are Already Commoditized&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues there is no &amp;ldquo;secret sauce&amp;rdquo; in AI coding agents. Back in 2023, he built an internal agent on GPT-3.5 and GPT-4 that required elaborate scaffolding just to keep the model on track; at the time, many assumed winning agents would need complex multi-agent swarms cross-checking each other or deep AST-level code indexing. In reality, all it took was a slightly smarter base model. Claude Sonnet 3.7 pulled ahead thanks to its ability to stay on task and make sound decisions over long horizons, while the surrounding agent harness is little more than a loop giving the model tools to read and write files.&lt;/p&gt;
&lt;p&gt;That simplicity makes the agent market brutally hard to defend: open-source tools like OpenAI&amp;rsquo;s Codex CLI raise the baseline for everyone, while inference is interchangeable and switching model providers is trivial. Goedecke even wired up a working coding agent on GitHub Actions backed by GitHub Models—both free—in about 50 lines of YAML. In his view, the only durable ways to win are owning distribution, like GitHub&amp;rsquo;s built-in platform advantage, or training a frontier model and locking its best capabilities inside your own first-party agent.&lt;/p&gt;
&lt;h2 id="java-what"&gt;&lt;a href="https://foojay.io/today/java-whats-old-part-i-collections/" rel="noopener noreferrer"&gt;Java, What&amp;rsquo;s Old? Part I: Collections&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthony Goubard highlights hidden gems inside the JDK Collections framework—all available since Java 8 or earlier, so you can use them anywhere. Instead of boxing primitives with &lt;code&gt;Optional&amp;lt;Integer&amp;gt;&lt;/code&gt;, Java provides &lt;code&gt;OptionalInt&lt;/code&gt;, &lt;code&gt;OptionalLong&lt;/code&gt;, and &lt;code&gt;OptionalDouble&lt;/code&gt;. &lt;code&gt;IntSummaryStatistics&lt;/code&gt; and &lt;code&gt;DoubleSummaryStatistics&lt;/code&gt; track min, max, sum, count, and average in a single pass and can merge statistics across streams; Goubard discovered them during the One Billion Row Challenge. &lt;code&gt;LinkedHashMap&lt;/code&gt; has a constructor flag that orders entries by access order rather than insertion order; combine that with overriding &lt;code&gt;removeEldestEntry&lt;/code&gt; and you get a compact LRU cache that can be wrapped in &lt;code&gt;Collections.synchronizedMap&lt;/code&gt; for multi-threaded access (though iteration and compound operations still require explicit synchronization).&lt;/p&gt;
&lt;p&gt;&lt;code&gt;WeakHashMap&lt;/code&gt; holds weak references to its keys so the garbage collector can evict entries once no strong references to a key remain; values are still strongly referenced, and because entries can vanish at any moment it isn&amp;rsquo;t suited for iteration or check-then-act patterns. Goubard uses it in his file manager Ant Commander Pro to cache formatted timestamp strings, cutting CPU usage while scrolling large tables. Finally, &lt;code&gt;BitSet&lt;/code&gt; packs boolean flags at roughly one bit per value, grows dynamically, and exposes fast bitwise operations—using a fraction of the memory of &lt;code&gt;boolean[]&lt;/code&gt; or &lt;code&gt;List&amp;lt;Boolean&amp;gt;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="challenging-projects-every-programmer-should-try"&gt;&lt;a href="https://austinhenley.com/blog/challengingprojects.html" rel="noopener noreferrer"&gt;Challenging projects every programmer should try&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Austin Z. Henley shares six challenging projects that taught him the most and that he revisits whenever he wants to learn a new language or framework. Building a text editor forces you to pick a text buffer data structure like a rope, gap buffer, or piece table, figure out how the cursor &amp;ldquo;remembers&amp;rdquo; its column across lines of different lengths, and implement undo/redo with the Command pattern alongside line wrapping. A 2D game like &lt;em&gt;Space Invaders&lt;/em&gt; teaches rendering, the game loop, input handling, and managing entities with the Factory pattern. A compiler for a tiny language like Tiny BASIC—targeting whatever output language you already know—walks you through lexing, recursive descent parsing, abstract syntax trees, semantic analysis, and code generation. A mini operating system demystifies bootloading, memory management, paging, scheduling, and filesystems.&lt;/p&gt;
&lt;p&gt;For an even steeper challenge, Henley suggests a spreadsheet—which combines the tricky parts of a text editor and a compiler with directed acyclic graphs (DAGs) and reactive evaluation—and a video game console emulator, starting with CHIP-8 before tackling the NES or Game Boy. Each project includes a checklist of concepts to learn and recommended reading, rounded out by community suggestions like building a relational database, a ray tracer, or a &lt;code&gt;grep&lt;/code&gt;-style CLI tool.&lt;/p&gt;
&lt;h2 id="autonomous-coding-agents-a-codex-example"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/autonomous-agents-codex-example.html" rel="noopener noreferrer"&gt;Autonomous coding agents: A Codex example&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler distinguishes between two flavors of AI coding agents: supervised agents steered interactively inside an IDE (like GitHub Copilot, Cursor, or Claude Code) and autonomous background agents (like OpenAI Codex, Google Jules, or Devin) that work through a task in an isolated cloud environment and open a pull request. She gave OpenAI Codex a small ticket in the Haiven app—formatting the filter label &lt;code&gt;&amp;quot;client-research&amp;quot;&lt;/code&gt; as &lt;code&gt;&amp;quot;Client Research&amp;quot;&lt;/code&gt;—and published the full execution log. The agent read &lt;code&gt;AGENTS.md&lt;/code&gt; and &lt;code&gt;README.md&lt;/code&gt;, then ran repeated &lt;code&gt;grep&lt;/code&gt; searches across keywords, wandering into &lt;code&gt;node_modules&lt;/code&gt; three separate times without learning from the mistake before finally finding an existing &lt;code&gt;toReadableText&lt;/code&gt; helper to extend. However, it failed to run the test suite, and its pull request broke two existing regression tests despite the fix itself being trivial.&lt;/p&gt;
&lt;p&gt;From that experiment, Böckeler draws several observations. Agents increasingly rely on brute-force text search rather than structured code navigation. Pre-configuring the remote execution environment is critical, yet setting up all required runtimes and linters (Node, Python, Semgrep, Gitleaks) for cloud agents remains clunky. Across six runs of the same task on Codex, Jules, and Claude Code, every attempt produced working behavior, but only two reused the existing helper while the other four duplicated code. She closes by asking when a team is better off discarding a flawed agent PR outright rather than falling into the sunk-cost trap of fixing it up.&lt;/p&gt;
&lt;h2 id="implementing-an-undoredo-system-in-a-complex-visual-application"&gt;&lt;a href="https://mlacast.com/projects/undo-redo" rel="noopener noreferrer"&gt;Implementing an Undo/Redo System in a Complex Visual Application&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;mlacast, lead developer of Alkemion Studio—a visual brainstorming and writing tool for tabletop RPGs—breaks down how he built a context-aware undo/redo system. Because users work across multiple distinct views such as the Board, the Editor, and Node panels, the core UX rule is that pressing undo should never silently revert something off-screen that the user cannot currently see. Every mutation is modeled as an &lt;code&gt;Action&lt;/code&gt; class with &lt;code&gt;undo&lt;/code&gt; and &lt;code&gt;redo&lt;/code&gt; methods, while &lt;code&gt;ActionGroup&lt;/code&gt; bundles related steps into a single undoable unit (such as deleting a Node and automatically removing its attached Tokens). A singleton &lt;code&gt;ActionStore&lt;/code&gt; holds actions across two &lt;code&gt;Action Volume&lt;/code&gt;s for performed and undone work, while a configuration file defines which action types are valid in the active view so the system can dynamically filter and sort the local undo/redo stacks by a global index.&lt;/p&gt;
&lt;p&gt;Inspired by Docker, a container abstraction creates an isolated sandbox whenever the user opens a modal dialog: actions performed inside the modal can either be discarded on cancel or committed back into the main store like a database transaction. The trickiest part was preserving chronological order as users switch contexts, requiring the global index to increment and decrement carefully across creation, undo, and redo so the most recently redone action always sits at the top of the stack. The remaining limitation is cross-action dependencies, which the author plans to solve next with a declarative dependency graph.&lt;/p&gt;
&lt;h2 id="the-software-engineering"&gt;&lt;a href="https://newsletter.manager.dev/p/the-software-engineering-squeeze" rel="noopener noreferrer"&gt;The software engineering &amp;lsquo;squeeze&amp;rsquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides argues that for the past 10–15 years, software engineering offered the highest return on investment of any career for anyone willing to study hard for a year, with companies hiring almost anyone who could clear an interview bar. In his view, much of the day-to-day work wasn&amp;rsquo;t actually that hard, which produced a massive middle tier of average engineers now getting &amp;ldquo;squeezed&amp;rdquo; between a tighter market and AI automation. He candidly notes that many developers grew used to comfortable workloads and constant complaining, whereas newcomers in most other professions have always had to grind through tough, lower-paid early years to advance.&lt;/p&gt;
&lt;p&gt;Even so, Zaides is optimistic about the long term: many startups launched by &amp;ldquo;vibe-coding&amp;rdquo; founders will find traction and need strong engineers to scale. To thrive, engineers need to add product-management instincts and design taste rather than waiting for detailed tickets to implement—because while the market has an oversupply of average developers, it still has a shortage of great ones. He advises unemployed engineers to experiment with modern AI tools and build solutions to real problems around them, while adding that there is no shame in changing careers: software engineering is once again a field for people who genuinely want to be in it.&lt;/p&gt;
&lt;h2 id="go-is-8020-language"&gt;&lt;a href="https://blog.kowalczyk.info/article/d-2025-06-26/go-is-8020-language.html" rel="noopener noreferrer"&gt;Go is 80/20 language&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Krzysztof Kowalczyk describes Go as an 80/20 language: it delivers 80% of the utility for 20% of the complexity, and most of the hate directed at Go comes from programmers who want 85% or 97%. Paraphrasing Rob Pike, he writes: &amp;ldquo;Nobody denies that 87% is more utility than 80%. The point is that those extra 7% of utility cost 36% more effort.&amp;rdquo; His examples include struct tags that are far simpler than annotations or macros, a standard testing package that fits in a few hundred lines of code while covering the essentials that take tens of thousands of lines in JUnit, goroutines that handle concurrency with a fraction of the complexity of &lt;code&gt;async/await&lt;/code&gt; in C# or Rust, and built-in generic types like slices, maps, and channels that solved most day-to-day needs long before Go added user-defined generics.&lt;/p&gt;
&lt;p&gt;Meanwhile, languages like C#, Swift, Rust, and even JavaScript keep accumulating features endlessly. There is a lower bound, of course: skipping enums is survivable, whereas skipping structs would make a language unusable. Every added feature imposes a tax on users—who must learn not just how a feature works, but when to use it and how to read teammates&amp;rsquo; code that uses it, which is why Google needed a strict C++ style guide—and on compiler writers too: more than a decade in, the Swift compiler can still feel slow and fragile, whereas Go&amp;rsquo;s toolchain has been fast, cross-platform, and rock-solid since version 1.0.&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 #34</title><link>https://miti99.com/en/post/2025/07/23/</link><pubDate>Wed, 23 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #34.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-tdd-doesn"&gt;&lt;a href="https://tidyfirst.substack.com/p/why-tdd-doesnt-lead-to-dumb-code" rel="noopener noreferrer"&gt;Why TDD Doesn&amp;rsquo;t Lead to Dumb Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck pushes back against a common critique: that test-driven development (TDD) leads to &amp;ldquo;dumb&amp;rdquo; code because programmers write only the bare minimum to pass each test and never generalize. In his view, the design quality of TDD code is only as good as the design decisions its author makes—no different from code written without TDD. He illustrates this with a factorial function: start with &lt;code&gt;assert factorial(1) == 1&lt;/code&gt; and return &lt;code&gt;1&lt;/code&gt;, then add &lt;code&gt;assert factorial(2) == 2&lt;/code&gt; and temporarily return &lt;code&gt;2&lt;/code&gt;. Rather than piling on &lt;code&gt;if&lt;/code&gt; statements forever, the programmer notices the underlying structure: &lt;code&gt;2&lt;/code&gt; is really &lt;code&gt;2 * 1&lt;/code&gt;, where &lt;code&gt;2&lt;/code&gt; is the parameter &lt;code&gt;n&lt;/code&gt; and &lt;code&gt;1&lt;/code&gt; is the result of a recursive call, arriving at the general &lt;code&gt;n * factorial(n - 1)&lt;/code&gt; in tiny steps.&lt;/p&gt;
&lt;p&gt;The real difficulties lie elsewhere: sometimes you don&amp;rsquo;t yet have enough tests to constrain the code to only the right behavior, and sometimes you don&amp;rsquo;t yet see how to generalize and leave a few special cases in place for years—which is still fine as long as the code handles the cases that matter. What never happens is endless copy-pasting. Finally, Beck points out that a naive implementation is tightly coupled to the test suite, requiring code edits every time an assertion is added, whereas generalizing decouples them so you can add tests without changing code and vice versa.&lt;/p&gt;
&lt;h2 id="how-discord-indexes-trillions-of-messages"&gt;&lt;a href="https://discord.com/blog/how-discord-indexes-trillions-of-messages" rel="noopener noreferrer"&gt;How Discord Indexes Trillions of Messages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord recounts how it re-architected its message search system—originally built on Elasticsearch in 2017—to keep up with trillions of messages. The old setup was showing serious cracks: Redis-backed indexing queues dropped messages when backlogged, bulk indexing wasn&amp;rsquo;t fault-tolerant when an Elasticsearch index or node had trouble, large clusters were expensive to operate and painful to upgrade or rolling-restart, and indexes for massive servers (guilds) grew unwieldy. Their new architecture runs Elasticsearch on Kubernetes via the Elastic Operator, splits storage into many smaller clusters grouped into &amp;ldquo;cells,&amp;rdquo; replaces Redis queues with Google PubSub for durability and replayability, and introduces a Rust router built on Tokio to batch messages by target cluster and index before bulk indexing.&lt;/p&gt;
&lt;p&gt;The cell architecture also unlocked new product capabilities: direct messages (DMs) are sharded by &lt;code&gt;user_id&lt;/code&gt; inside a dedicated cell, enabling cross-DM search for a user. For &amp;ldquo;Big Freaking Guilds&amp;rdquo; that hit Lucene&amp;rsquo;s ~2-billion-document limit, Discord reindexes their messages into indexes with more primary shards inside a dedicated cell. The results: indexing throughput doubled, median query latency dropped from 500 ms to under 100 ms (p99 from 1 second to under 500 ms), the team now runs 40 clusters hosting thousands of indexes, and cluster upgrades happen automatically without user-visible impact.&lt;/p&gt;
&lt;h2 id="data-oriented-programming-dop-in-java"&gt;&lt;a href="https://nejckorasa.github.io/posts/data-oriented-programming-in-java/" rel="noopener noreferrer"&gt;Data Oriented Programming (DOP) in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Data-Oriented Programming (DOP) flips traditional object-oriented habits on their head: instead of bundling state and behavior together inside a class, you model data with simple passive structures and put logic in standalone functions that operate on that data. The post outlines four principles: model data immutably and transparently, model only the exact data needed, make illegal states unrepresentable, and separate operations from data. Modern Java supports this style cleanly through three features: &lt;code&gt;record&lt;/code&gt;s provide compact data carriers with &lt;code&gt;final&lt;/code&gt; fields (though they don&amp;rsquo;t automatically make referenced objects deeply immutable), &lt;code&gt;sealed&lt;/code&gt; classes restrict subtypes so the compiler knows every case, and pattern-matching &lt;code&gt;switch&lt;/code&gt; expressions enforce exhaustiveness, shifting bugs from runtime to compile time.&lt;/p&gt;
&lt;p&gt;In a &lt;code&gt;Shape&lt;/code&gt; example with &lt;code&gt;Circle&lt;/code&gt;, &lt;code&gt;Rectangle&lt;/code&gt;, and &lt;code&gt;Triangle&lt;/code&gt;, a &lt;code&gt;getCenter&lt;/code&gt; function written as a single &lt;code&gt;switch&lt;/code&gt; expression replaces adding methods across every subclass, removing the need for the Visitor pattern in this case. When a new subtype like &lt;code&gt;Pentagon&lt;/code&gt; is added, the compiler flags every &lt;code&gt;switch&lt;/code&gt; missing that branch—which is why the author advises avoiding &lt;code&gt;default&lt;/code&gt; branches that silence exhaustiveness checks. DOP also fits explicit result handling, such as a &lt;code&gt;Result&lt;/code&gt; type with &lt;code&gt;Ok&lt;/code&gt; and &lt;code&gt;Error&lt;/code&gt; variants that forces callers to handle both outcomes. Overall benefits include code that is easier to read, maintain, test, and refactor safely with lower coupling.&lt;/p&gt;
&lt;h2 id="why-performance-optimization-is-hard-work"&gt;&lt;a href="https://purplesyringa.moe/blog/why-performance-optimization-is-hard-work/" rel="noopener noreferrer"&gt;Why performance optimization is hard work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that performance optimization is hard not because engineers lack skill or knowledge, but because it is inherently exhaustive work that requires testing a huge number of possibilities. First is combinatorics: some optimizations only pay off when combined, others slow each other down, and ruling out &amp;ldquo;obviously bad&amp;rdquo; ideas upfront is mostly guesswork because a simple algorithm can win via vectorization while clever code loses to branch mispredictions. Second is continuity: algorithms with crossover thresholds, like hybrid sorts or FFTs, require tuning parameters empirically and re-measuring after every change, making an automated benchmark harness invaluable. Third is incompatibility: hardware constraints like two lookup tables that cannot fit in cache together or register pressure force hard trade-offs.&lt;/p&gt;
&lt;p&gt;The post also pushes back on the myth that &amp;ldquo;the compiler is smarter than you&amp;rdquo;: compilers don&amp;rsquo;t reason at the level of your domain abstractions and often allocate registers poorly, so you still have to inspect assembly and profile with tools like &lt;code&gt;perf&lt;/code&gt;. Documentation is another hurdle: x86 has detailed optimization manuals, whereas Apple Silicon has almost none, turning optimization into reverse engineering. In short, optimization means exploring dozens of variants, working around imperfect tooling, and reconciling conflicting wins—yet small improvements compound and are still worth the effort because they save real users&amp;rsquo; time.&lt;/p&gt;
&lt;h2 id="good-vs-great-animations"&gt;&lt;a href="https://emilkowal.ski/ui/good-vs-great-animations" rel="noopener noreferrer"&gt;Good vs Great Animations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski shares practical tips for taking UI animations from good to great. First, give animations a clear origin: a dropdown menu should expand from the button that triggered it by setting &lt;code&gt;transform-origin&lt;/code&gt;, and libraries like Radix expose CSS variables you can plug right in. Easing is the single most impactful lever; for an element already on screen that moves to a new position, &lt;code&gt;ease-in-out&lt;/code&gt; mimics natural acceleration and deceleration like a car, while &lt;code&gt;ease-out&lt;/code&gt; should be the default almost everywhere else. Built-in CSS easing curves are often too mild, so Kowalski nearly always reaches for custom curves and recommends easing.dev and easings.co.&lt;/p&gt;
&lt;p&gt;For cursor-driven interactions, tying values directly to mouse coordinates feels robotic; Motion&amp;rsquo;s &lt;code&gt;useSpring&lt;/code&gt; hook interpolates changes with spring physics so movement feels natural, though he advises saving it for decorative motion rather than functional charts like those in a banking app. Knowing your tools matters too: &lt;code&gt;clip-path&lt;/code&gt; makes tab-bar label colors transition cleanly in sync with the active indicator, while 3D transforms open up expressive effects. In Kowalski&amp;rsquo;s view, when baseline software quality is high everywhere, thoughtful motion is one of the clearest ways for a product to stand out.&lt;/p&gt;
&lt;h2 id="senior-engineers-should-make-side-bets"&gt;&lt;a href="https://www.seangoedecke.com/side-bets/" rel="noopener noreferrer"&gt;Senior engineers should make side bets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that junior engineers should stick closely to assigned work, because their tasks need experienced oversight and the fastest path to promotion is executing their core assignments well. Senior engineers, by contrast, shouldn&amp;rsquo;t just work down a ticket queue—they should spend 10–20% of their time on &amp;ldquo;side bets&amp;rdquo;: projects they believe are valuable to the company that nobody has asked for yet, such as a new feature, a performance optimization, or a developer-velocity improvement, provided the payoff is concrete. Side bets carry real risk: at worst you waste time and look to management like you&amp;rsquo;re working on the wrong things, and most bets will fail—in which case you quietly drop them and move on.&lt;/p&gt;
&lt;p&gt;The reason to make them anyway is that one winning bet pays for all the rest: anyone could have completed your routine ticket work, whereas the value of a successful side bet happened entirely because of you. When a bet pays off, share it proactively via an internal write-up or a chat with your manager; if you feel awkward showing it off, the benefit probably wasn&amp;rsquo;t concrete enough. Goedecke shares examples from GitHub: an &amp;ldquo;open in prompt editor&amp;rdquo; button saw zero adoption, whereas wiring AI inference permissions into GitHub Actions saw real usage. He lands two or three winning bets a year—and notes that if your bets never pan out, it&amp;rsquo;s a sign to stop making them.&lt;/p&gt;
&lt;h2 id="avoiding-skill-atrophy-in-the-age-of-ai"&gt;&lt;a href="https://addyo.substack.com/p/avoiding-skill-atrophy-in-the-age" rel="noopener noreferrer"&gt;Avoiding Skill Atrophy in the Age of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani warns of the paradox of AI coding assistants: productivity goes up, but core skills can atrophy if you aren&amp;rsquo;t careful. A 2025 study by Microsoft and Carnegie Mellon found a correlation between higher trust in AI and lower self-reported critical thinking, though the findings don&amp;rsquo;t prove long-term skill loss. The warning signs creep in gradually: stopping reading documentation, pasting error messages straight into AI instead of debugging, copying code without understanding why it works, shying away from architectural design, and forgetting basic syntax. Osmani worries this erodes both individual learning and team mentorship. While letting go of obsolete skills is normal, the key is distinguishing which tasks can be safely offloaded to machines and which fundamentals must stay sharp.&lt;/p&gt;
&lt;p&gt;His prescription is to treat AI as a collaborator rather than a crutch: always verify and understand its output, actively hunt for bugs and edge cases, and ask AI to explain code line by line; schedule &amp;ldquo;no-AI days&amp;rdquo; to code from scratch and read docs directly; spend 15–30 minutes tackling a problem yourself before prompting; review AI-generated code as rigorously as a teammate&amp;rsquo;s PR; log topics you repeatedly ask AI about so you can fill those knowledge gaps; and use AI in a pair-programming style where you stay in the driver&amp;rsquo;s seat. The core message: use AI to amplify your capability rather than replace it, preserving both the craft and the joy of problem-solving.&lt;/p&gt;
&lt;h2 id="cursor-best-practices"&gt;&lt;a href="https://x.com/paraschopra/status/1917466537637859544" rel="noopener noreferrer"&gt;Cursor best practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://pbs.twimg.com/media/Gpw1p1waYAAeAyY?format=jpg" alt="Cursor best practices"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #17</title><link>https://miti99.com/en/post/2025/05/04/</link><pubDate>Sun, 04 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #17.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="to-fork-or-not-to-fork"&gt;&lt;a href="https://www.augmentcode.com/blog/to-fork-or-not-to-fork" rel="noopener noreferrer"&gt;To fork or not to fork?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Dietzen, CEO of Augment Code (and former CEO of Pure Storage), discusses a key architectural decision facing AI coding assistants: running as a plugin inside standard IDEs versus forking VS Code outright. GitHub Copilot and Augment chose the former, operating as plugins in VS Code, JetBrains, or Vim. Cursor and Windsurf (by Codeium) chose the latter, modifying the VS Code source directly for deeper AI integration.&lt;/p&gt;
&lt;p&gt;According to Dietzen, forking yields short-term advantages, but users pay the price: they are forced out of their familiar IDEs (especially painful for JetBrains users), lose official Microsoft support, run into issues with official plugins like Python, C++, Docker, or Jupyter, lose access to the official VS Code extension marketplace, and have to wait for the fork maintainers to port upstream features. For the long-term benefit of customers, Augment chose the plugin route and focused on its core strength of supporting large, complex codebases. Dietzen also notes that Cursor is the third most popular IDE among users trialing Augment, showing that the two products can complement each other.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://blog.container-solutions.com/why-im-no-longer-talking-to-architects-about-microservices" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m No Longer Talking to Architects About Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ian Miell explains why he no longer wants to debate microservices with software architects. The first problem is that nobody agrees on what &amp;ldquo;microservices&amp;rdquo; actually means: some measure it by lines of code, others tie it to team structure, and others equate it with container deployments. Like DevOps or Agile, the term has lost much of its original meaning through overuse.&lt;/p&gt;
&lt;p&gt;The second problem is that discussions are typically abstract and disconnected from business goals: promises of scalability, agility, or reduced cognitive load rarely go tested. The third problem is that microservices only pay off when the organization changes alongside them—requiring cross-functional teams, decentralized decision-making, and a mature DevOps culture—and changing organizational structure is far harder than changing software architecture. Even Sam Newman advises that most organizations shouldn&amp;rsquo;t adopt microservices without a compelling reason. Miell suggests starting from concrete problems like shortening release cycles, improving reliability, or removing bottlenecks, and only then asking whether microservices are the right solution.&lt;/p&gt;
&lt;h2 id="not-all-ai-assisted-programming-is-vibe-coding-but-vibe-coding-rocks"&gt;&lt;a href="https://simonwillison.net/2025/Mar/19/vibe-coding/" rel="noopener noreferrer"&gt;Not all AI-assisted programming is vibe coding (but vibe coding rocks)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison argues that the term &amp;ldquo;vibe coding,&amp;rdquo; coined by Andrej Karpathy in February 2025, is being misused as a catch-all for any AI-assisted programming. By Karpathy&amp;rsquo;s original definition, vibe coding means &amp;ldquo;forgetting that the code even exists&amp;rdquo;: accepting every change generated by an LLM without reading it. Responsible AI-assisted programming, by contrast, still involves reviewing, testing, and understanding every implementation detail. Willison&amp;rsquo;s golden rule: never commit code to a repository if you couldn&amp;rsquo;t explain exactly what it does to someone else.&lt;/p&gt;
&lt;p&gt;Even so, Willison is a fan of vibe coding. It lowers the barrier for beginners, helps them build useful tools on their own, and is a great way for experienced developers to build intuition for what LLMs can and cannot do. The key is restricting it to low-stakes, disposable projects—ideally inside a sandbox like Claude Artifacts—and avoiding anything involving security, privacy, or financial risk. He also hopes to see safer tools emerge so newcomers can experiment without causing harm.&lt;/p&gt;
&lt;h2 id="career-advice-in-2025"&gt;&lt;a href="https://lethain.com/career-advice-2025" rel="noopener noreferrer"&gt;Career advice in 2025.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson surveys the 2025 tech job market and identifies four major shifts. First, managers who advanced between 2010 and 2020 through strong hiring and team morale now face new expectations: getting into the details, driving faster execution, and leading the transition to AI. Second, the wave of foundation models has invalidated many old playbooks; products now need to be designed around progressive validation with human-in-the-loop verification for critical data, while staying prepared for models either making massive leaps forward or plateauing right where they are.&lt;/p&gt;
&lt;p&gt;Third, non-AI companies are struggling to raise funding, leading to fewer promotions and raises, while equity at AI startups is far from a guaranteed payout. Fourth, companies are pushing existing teams harder to find growth, turning once-comfortable roles into high-pressure ones. Today it is rare to find great colleagues, prestige, and learning opportunities all in the same job. Larson&amp;rsquo;s advice: don&amp;rsquo;t sit on the sidelines waiting for the market to recover—make your current work count, and remember that these headwinds are industry-wide, not a reflection of your personal ability.&lt;/p&gt;
&lt;h2 id="tips-for-better-interactions"&gt;&lt;a href="https://staysaasy.com/saas/2025/03/17/interactions.html" rel="noopener noreferrer"&gt;Tips For Better Interactions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy shares six practical tips for more effective workplace meetings and interactions. When someone says you seem &amp;ldquo;frustrated,&amp;rdquo; don&amp;rsquo;t accept that framing—restate calmly that you are escalating an issue or need more information so you aren&amp;rsquo;t dismissed as acting out of emotion. Volunteer to take notes in meetings: it signals humility, lets you help steer the discussion, gives you a natural pause to stay composed, and shows people their points are being heard. Avoid pushing back with extreme slippery-slope hypotheticals like &amp;ldquo;if we let everyone choose their own project, it&amp;rsquo;ll be chaos,&amp;rdquo; which implicitly insults the proposer&amp;rsquo;s judgment and wastes time.&lt;/p&gt;
&lt;p&gt;Don&amp;rsquo;t interrupt someone mid-thought just to correct an immaterial detail; follow up privately afterward if needed. Schedule important meetings thoughtfully—avoid Mondays, Fridays, lunch hours, and the end of the day—and keep a consistent weekly slot for 1:1s. Finally, order meeting agendas by priority: thoroughly resolving two important topics is far better than rushing through five without reaching a conclusion.&lt;/p&gt;
&lt;h2 id="code-is-the-new-no-code"&gt;&lt;a href="https://lumberjack.so/code-is-the-new-no-code/" rel="noopener noreferrer"&gt;Code is the new no-code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Szabo-Stuban and Evan Boyle (CEO of GenSX) argue that the promise of the no-code movement is finally being realized in an unexpected way: through code itself. Visual programming tools are easy at first, but complexity balloons rapidly—a marketing automation workflow in n8n can easily sprawl into a spiderweb of 47 interconnected nodes. Abstractions inevitably leak, forcing users to learn technical concepts anyway, and power users usually end up migrating back to code.&lt;/p&gt;
&lt;p&gt;According to the authors, AI coding assistants like Claude, ChatGPT, and GitHub Copilot have flipped the script: users describe their goal in plain language, the AI generates working code and explains each piece, and learning happens gradually instead of hitting a wall. Combined with familiar component models like React, code becomes even more intuitive than node-based visual editors. The post illustrates this with GenSX, where a workflow that fetches CRM data, filters it, and generates a report is written as readable JavaScript components, arguing that because most workflows are sequential, the tree structure of code is naturally easier to follow than a graph.&lt;/p&gt;
&lt;h2 id="how-to-improve-jvm-based-application-startup-time"&gt;&lt;a href="https://softwaremill.com/how-to-improve-jvm-based-application-startup-time/" rel="noopener noreferrer"&gt;How to Improve JVM-Based Application Startup Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michał Zyga (SoftwareMill) compares five approaches to shortening JVM application startup time, a critical metric for serverless and microservices. The JVM starts slowly because it has to load, verify, and initialize a large number of classes. Class Data Sharing (CDS) pre-packages core JDK classes and has been enabled by default since JDK 12; Application Class Data Sharing (AppCDS) extends this to application classes and became easier to use in JDK 19. GraalVM compiles ahead-of-time (AOT) into a native binary, CRaC snapshots a running JVM process using CRIU (Linux-only) for fast restore, and Project Leyden is a newer JDK effort that caches additional optimization data.&lt;/p&gt;
&lt;p&gt;Benchmarks on a sample Netty application across two machines (a personal Intel i5 laptop and a Google Cloud Xeon instance, 50 runs per configuration) show that AppCDS more than doubles startup speed over the default, CRaC and GraalVM are the fastest overall, and Project Leyden sits in the middle while still under active development. Zyga recommends choosing based on context: AppCDS is an easy win with moderate gains, CRaC suits long-running services since it retains full runtime JIT optimizations, and GraalVM fits short-lived workloads that need near-instant startup.&lt;/p&gt;
&lt;h2 id="domain-driven-design"&gt;&lt;a href="https://dev.to/lovestaco/domain-driven-design-3i2j" rel="noopener noreferrer"&gt;Domain Driven Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Athreya (Maneshwar) introduces Domain-Driven Design (DDD), an approach to software design that puts the business domain at the center rather than focusing purely on technical concerns. The article walks through core DDD building blocks: domains and subdomains; Bounded Contexts that draw clear boundaries so models stay independent; Entities with distinct identities versus immutable Value Objects defined by their attributes; Aggregates that group related objects under an Aggregate Root; Domain Events that decouple system components; Repositories, Services, and Factories for persistence, domain operations, and object creation; and Ubiquitous Language, a shared vocabulary between developers and domain experts.&lt;/p&gt;
&lt;p&gt;These concepts are illustrated through an e-commerce platform where order management is separated from the product catalog, accompanied by TypeScript examples of an &lt;code&gt;Order&lt;/code&gt; class managing state and an &lt;code&gt;OrderRepository&lt;/code&gt; handling persistence. The author notes that DDD shines in complex, long-lived projects requiring close collaboration between engineering and business teams, but can easily lead to over-engineering for simple CRUD apps; applying it well requires a solid grasp of design patterns and object-oriented principles.&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/66d12ddc-2abe-4a98-82d5-ee177e80487c_1470x1600.png" alt="Monolith vs Microservices vs Modular Monoliths"&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 #3</title><link>https://miti99.com/en/post/2025/02/23/</link><pubDate>Sun, 23 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/23/</guid><description>&lt;i&gt;
Hello everyone, another weekend has rolled around—sit back, relax, and enjoy MiTi's Newsletter #3.
&lt;/i&gt;
&lt;h2 id="java"&gt;&lt;a href="https://www.youtube.com/watch?v=y26XGt8d_kI" rel="noopener noreferrer"&gt;Java&amp;rsquo;s Plans for 2025 - Inside Java Newscast #83&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #83 of the Inside Java Newscast from the official Java channel surveys Java&amp;rsquo;s roadmap for 2025 across the major OpenJDK projects: Babylon, Loom, Leyden, Lilliput, Panama, and Valhalla. For each project, the video recaps what has been accomplished so far and what is planned next, saving Project Amber for a dedicated follow-up episode. It is a quick way to get the big picture of where the Java language and platform are headed.&lt;/p&gt;
&lt;h2 id="why-you-should-learn-kotlin-in-2025"&gt;&lt;del&gt;&lt;a href="https://dev.to/empiree/why-you-should-learn-kotlin-in-2025-47g0" rel="noopener noreferrer"&gt;Why You Should Learn Kotlin in 2025&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This article on Dev.to encourages developers to learn Kotlin in 2025, highlighting its modern features, Java interoperability, and versatile applications. The post also discusses the job market and salary potential for Kotlin developers.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="mastering-java-logging-best-practices-for-effective-application-monitoring"&gt;&lt;a href="https://dev.to/nithinbharathwaj/mastering-java-logging-best-practices-for-effective-application-monitoring-20h7" rel="noopener noreferrer"&gt;Mastering Java Logging: Best Practices for Effective Application Monitoring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Dev.to article rounds up best practices for logging in Java applications. The author recommends pairing SLF4J as the logging facade with Logback as the underlying implementation so you can swap logging frameworks without touching application code, and explains how to choose appropriate log levels from TRACE to FATAL to avoid both missing critical errors and flooding alerting systems (the post mentions FATAL, though SLF4J and Logback only define TRACE, DEBUG, INFO, WARN, and ERROR). It also walks through structured JSON logging with &lt;code&gt;logstash-logback-encoder&lt;/code&gt; and using MDC (Mapped Diagnostic Context) to automatically attach contextual metadata like request IDs or user IDs to every log line.&lt;/p&gt;
&lt;p&gt;The second half focuses on performance and operations: using asynchronous appenders, avoiding expensive computations inside logging calls, and deferring message construction (in SLF4J 2, you can pass a &lt;code&gt;Supplier&lt;/code&gt; via the fluent logging API). On the security front, the author stresses masking sensitive data such as credit card numbers and passwords. Finally, the post covers centralized log aggregation with the ELK stack or Graylog, along with log rotation and retention policies to keep disks from filling up.&lt;/p&gt;
&lt;h2 id="fixed-window-counter-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/fixed-window-counter-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Fixed Window Counter Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io tutorial walks through building a Fixed Window Counter rate limiter using Redis and Java. The algorithm divides time into fixed intervals, counts requests within each interval, and rejects requests once the threshold is exceeded; its main advantage is simplicity, though bursts of traffic near the boundary between two windows can let twice the allowed rate through. The implementation uses Jedis with a dedicated key per client: it reads the current counter with &lt;code&gt;GET&lt;/code&gt;, and then inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction increments the counter with &lt;code&gt;INCR&lt;/code&gt; and sets the TTL using &lt;code&gt;EXPIRE&lt;/code&gt; with the &lt;code&gt;NX&lt;/code&gt; flag so the expiration is only set when the key is first created rather than extending the window on every request.&lt;/p&gt;
&lt;p&gt;The post also demonstrates how to test the rate limiter using Redis TestContainers, JUnit 5, and AssertJ, covering key scenarios: requests within the limit are allowed, requests exceeding the limit are rejected, the counter resets once the window expires, separate clients maintain independent counters, and rejected requests do not increment the counter. Note that because the initial &lt;code&gt;GET&lt;/code&gt; and threshold check happen outside the &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction, concurrent requests can still race past the limit; stricter enforcement requires a Lua script or &lt;code&gt;WATCH&lt;/code&gt; with retries.&lt;/p&gt;
&lt;h2 id="how-jvm-handles-exceptions"&gt;&lt;a href="https://foojay.io/today/how-jvm-handles-exceptions/" rel="noopener noreferrer"&gt;How JVM handles exceptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io article explains how the Java Virtual Machine (JVM) handles exceptions at the bytecode level. Each method can carry an exception table where every entry specifies a protected bytecode range (&lt;code&gt;from&lt;/code&gt;, &lt;code&gt;to&lt;/code&gt;), a handler jump target (&lt;code&gt;target&lt;/code&gt;), and the exception type to catch—or &lt;code&gt;any&lt;/code&gt; for handlers that catch all throwables. When an &lt;code&gt;athrow&lt;/code&gt; instruction executes, the JVM pops the exception object from the operand stack and searches the current method&amp;rsquo;s exception table for a matching handler; if none is found, it unwinds the call stack frame by frame. If the exception remains uncaught all the way up the call chain, the active thread terminates after running its uncaught exception handler.&lt;/p&gt;
&lt;p&gt;The author also dissects how the compiler translates &lt;code&gt;try-catch-finally&lt;/code&gt; blocks into bytecode. In the example, the &lt;code&gt;finally&lt;/code&gt; block&amp;rsquo;s bytecode is duplicated along the normal execution path, while &lt;code&gt;any&lt;/code&gt; entries in the exception table route control flow through the &lt;code&gt;finally&lt;/code&gt; block whenever an exception is thrown inside &lt;code&gt;try&lt;/code&gt; or &lt;code&gt;catch&lt;/code&gt;. It is a great read if you want to see what actually happens under the hood when an exception is thrown.&lt;/p&gt;
&lt;h2 id="database-sharding-explained"&gt;&lt;a href="https://architecturenotes.co/p/database-sharding-explained" rel="noopener noreferrer"&gt;Database Sharding Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Architecture Notes piece explains database sharding—the technique of partitioning data across multiple machines when a single database server can no longer handle the load. Before reaching for sharding, the author advises exhausting simpler alternatives: doing nothing if there isn&amp;rsquo;t a clear bottleneck yet, scaling vertically with bigger hardware, adding read replicas to offload read traffic, or moving specific workloads to specialized stores like Elasticsearch for search or S3 for large blobs.&lt;/p&gt;
&lt;p&gt;The article then covers three primary sharding strategies: hash-based sharding (distributes data evenly but makes resharding painful), range-based sharding (requires a lookup table and a well-distributed shard key to avoid hot spots), and relationship-based sharding (keeps related entities together on the same shard). The author clarifies the role of the shard key, distinguishes logical shards from physical shards, and introduces two-phase commit (2PC) as a way to coordinate atomic transactions across multiple shards—at the cost of extra write latency and significant complexity. The overarching message: sharding unlocks horizontal scale, but comes with a heavy operational burden.&lt;/p&gt;
&lt;h2 id="protecting-your-time-from-predators-in-large-tech-companies"&gt;&lt;a href="https://www.seangoedecke.com/predators/" rel="noopener noreferrer"&gt;Protecting your time from predators in large tech companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this post, Sean Goedecke warns high-performing engineers at large tech companies about people who constantly try to hijack their time—whom he calls &amp;ldquo;predators.&amp;rdquo; Two archetypes stand out: product managers from other teams who slide into DMs asking for a &amp;ldquo;quick fix&amp;rdquo; to bypass official prioritization channels, and underperforming engineers who lean on others as a substitute for learning on their own, claiming credit for the resulting work without acknowledging the help.&lt;/p&gt;
&lt;p&gt;To protect yourself, the author advises spotting asymmetric requests—where the requester puts in minimal effort while expecting hours of work from you—and matching their level of effort in your response. Move private requests into public channels so your contributions are visible and your manager stays in the loop. He also makes sure to distinguish legitimate demands on your time: helping your own manager, your reports, or junior teammates who are genuinely ramping up is part of the job. Above all, remember that shipping your own assigned projects is your primary responsibility.&lt;/p&gt;
&lt;h2 id="how-to-improve-your-wfh-lighting-to-reduce-eye-strain"&gt;&lt;a href="https://rustle.ca/posts/articles/work-from-home-lighting" rel="noopener noreferrer"&gt;How to improve your WFH lighting to reduce eye strain&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on rustle.ca shares practical ways to set up your work-from-home lighting to reduce eye strain. The author identifies three main culprits: imperceptible monitor flicker (PWM), especially when screen brightness is turned down and the monitor is the sole light source in the room; high-contrast environments such as harsh window glare or unevenly lit rooms; and focusing at a fixed distance for hours on end. For the last issue, the author recommends the 20/20/20 rule: every 20 minutes, look at something at least 20 feet (about 6 meters) away for at least 20 seconds.&lt;/p&gt;
&lt;p&gt;Concrete recommendations include making the most of natural daylight, using sheer curtains to diffuse direct sunlight rather than blocking it completely, placing multiple indirect light sources around the room to eliminate dark corners, choosing dimmable, flicker-free bulbs with a high Color Rendering Index (CRI) and a warm color temperature around 2700K, and adding a desk lamp or monitor bias lighting matched roughly to your screen&amp;rsquo;s brightness.&lt;/p&gt;
&lt;h2 id="working-fast-and-slow"&gt;&lt;a href="https://www.seangoedecke.com/working-fast-and-slow/" rel="noopener noreferrer"&gt;Working fast and slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that uneven productivity isn&amp;rsquo;t a flaw to be fixed; instead, he deliberately alternates between two working modes. During high-focus states, complex problems feel effortless, so he channels that energy into high-impact tasks, blocks out distractions, and works for hours at a stretch. However, this state burns through a finite internal reservoir of energy that takes time to recharge.&lt;/p&gt;
&lt;p&gt;When focus is low, he switches to lighter work such as knocking out easy tickets, reviewing pull requests, or unblocking other projects. Trying to force hard engineering work while unfocused, he notes, only introduces bugs that take longer to fix than simply waiting for focus to return—and usually gives you a headache to boot. This two-speed rhythm also aligns naturally with the cadence of large tech companies, where quiet maintenance periods alternate with high-stakes crunches that demand everything you&amp;rsquo;ve got.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="bonus-1-interesting-images-from-bytebytego"&gt;Bonus #1: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fe9062b4-fd0e-4530-8e20-eea854b8490e_2250x2814.png" alt="Top Strategies to Reduce Latency"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9c309ad3-78a8-4511-a6f2-e69c06d5c500_1280x1566.gif" alt="The Ultimate API Learning Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a44f9f4b-193d-484e-bbf1-169751104380_1280x1568.gif" alt="10 Essential Components of a Production Web Application"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d5155be3-163d-479c-a75e-632e0f98dd36_3006x3453.jpeg" alt="How do we design effective and safe APIs?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/aad520f5-00d9-4606-af4b-fdb5d1ac63c4_1600x1483.png" alt="Code First v.s. API First"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/bb375f63-bf06-4956-b3a3-914fd6aa2d91_1280x1664.jpeg" alt="Oauth 2.0 Explained With Simple Terms"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c1155e03-c3dc-4192-8e05-e6b87dc6a574_1280x1664.gif" alt="Session, Cookie, JWT, Token, SSO, and OAuth 2.0 Explained in One Diagram"&gt;&lt;/p&gt;
&lt;h3 id="bonus-2-other-interesting-links"&gt;Bonus #2: Other interesting links&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://openalternative.co/self-hosted" rel="noopener noreferrer"&gt;Self-hosted Alternatives to Popular Software&lt;/a&gt;&lt;/li&gt;
&lt;/ul&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>