<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>System Design on miti99</title><link>https://miti99.com/en/tags/system-design/</link><description>Recent content in System Design 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/system-design/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #130</title><link>https://miti99.com/en/post/2026/09/08/</link><pubDate>Tue, 08 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #130.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-anthropic-runs-large-scale-code-migrations-with-claude-code"&gt;&lt;a href="https://claude.com/blog/ai-code-migration" rel="noopener noreferrer"&gt;How Anthropic runs large-scale code migrations with Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Migrating a large codebase to another language used to be a multi-year endeavor undertaken only as a last resort. Anthropic shows how that calculus has changed: Bun migrated one million lines of code from Zig to Rust in under two weeks, consuming roughly 5.9 billion input tokens and 690 million output tokens (around $165,000 at standard API pricing). In return, the entire existing test suite passed before merging (19 regressions surfaced afterward and were all fixed), the binary shrank by 19%, runtime performance improved by 2–5%, and one memory benchmark dropped from 6,745 MB to 609 MB. In another example, 165,000 lines of Python were migrated to TypeScript over a single weekend.&lt;/p&gt;
&lt;p&gt;The workflow follows six steps: author a translation rulebook alongside a dependency graph, pilot the rules on a sample batch of files, translate the codebase in parallel using worker agents, run a compilation loop pairing a fixer agent with an adversarial reviewer agent, run fast tests to catch runtime bugs, and finally verify behavioral parity against the original implementation. The core lesson is to fix the generation loop rather than hand-patching generated code: whenever a mistake repeats, update the rulebook and regenerate. Doing so requires an objective &amp;ldquo;oracle&amp;rdquo;—such as a compiler and test suite—up front, plus a resumable work queue. Compute spend should also be tiered deliberately: smaller models like Sonnet handle bulk translation, while larger models like Fable or Opus write the rulebook and perform adversarial reviews.&lt;/p&gt;
&lt;h2 id="the-vfs"&gt;&lt;a href="https://internals-for-interns.com/posts/linux-kernel-vfs/" rel="noopener noreferrer"&gt;The VFS&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Whether you read a file on ext4, a virtual file in &lt;code&gt;/proc&lt;/code&gt; that exists only in kernel memory, or a remote file over NFS, you use the exact same system calls and file descriptor semantics. The layer that makes this possible is the VFS (Virtual File System), sitting between the syscall interface and concrete filesystems. This article explains the VFS as a textbook application of &amp;ldquo;program to an interface, not an implementation&amp;rdquo;—where, in C, an interface is simply a struct of function pointers. Four core objects do the heavy lifting: a &lt;code&gt;superblock&lt;/code&gt; represents a mounted filesystem, an &lt;code&gt;inode&lt;/code&gt; represents an object within it (a file, directory, or link), a &lt;code&gt;dentry&lt;/code&gt; binds a name to an inode (since inodes themselves don&amp;rsquo;t know their own filenames), and a &lt;code&gt;file&lt;/code&gt; represents a specific open handle held by a process with its own read/write offset. The &lt;code&gt;super_operations&lt;/code&gt;, &lt;code&gt;inode_operations&lt;/code&gt;, and &lt;code&gt;file_operations&lt;/code&gt; tables hold filesystem-specific behaviors, falling back to generic VFS implementations whenever a hook is left unimplemented.&lt;/p&gt;
&lt;p&gt;In practice, most work is handled by shared VFS code before ever touching a filesystem driver. When resolving a path like &lt;code&gt;/etc/hostname&lt;/code&gt;, the kernel walks component by component and calls the filesystem&amp;rsquo;s &lt;code&gt;lookup&lt;/code&gt; hook only when the dentry cache (dcache) misses. That cache even remembers nonexistent paths (negative dentries) and is read locklessly via RCU. Reading file contents works similarly: most reads simply copy bytes out of the page cache without touching the disk, and a user-space file descriptor is nothing more than an index into the process&amp;rsquo;s &lt;code&gt;struct file *&lt;/code&gt; array.&lt;/p&gt;
&lt;h2 id="text-editor-data-structures"&gt;&lt;a href="https://cdacamar.github.io/data%20structures/algorithms/benchmarking/text%20editors/c&amp;#43;&amp;#43;/editor-data-structures/" rel="noopener noreferrer"&gt;Text Editor Data Structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When building a text editor from scratch, the first question is how to represent file contents in memory. Cameron DaCamara starts by laying out his requirements: fast insertions and deletions, fast undo/redo, UTF-8 support, and simultaneous multi-cursor editing. From there, he systematically eliminates candidates. A single contiguous string is simple to render, but bogs down on files over 1 MB, reallocations can turn $O(n)$ edits into $O(n^2)$, and snapshotting for undo/redo burns memory. Emacs-style gap buffers are simple but poorly suited to multiple cursors. Ropes give $O(\log n)$ operations, but copy-on-write overhead bloats memory usage. Traditional piece tables, once used in Microsoft Word, hit contiguous-array bottlenecks during long editing sessions. VS Code&amp;rsquo;s piece tree combines the strengths of ropes and piece tables by backing the piece table with a red-black tree.&lt;/p&gt;
&lt;p&gt;DaCamara takes that approach a step further by building an &lt;em&gt;immutable&lt;/em&gt; piece tree called &lt;code&gt;fredbuf&lt;/code&gt;. A purely functional red-black tree needs no parent pointers and allows cheap $O(1)$ snapshots at any point, turning undo and redo into two simple linked lists of tree roots. CRLF line-ending normalization is handled outside the tree, and a &lt;code&gt;TreeWalker&lt;/code&gt; abstraction simplifies character iteration and correctness testing. Two takeaways stand out: analyzing constraints up front saves wasted effort, and investing in debugging tools—like visual tree dumpers—is what gets a complex project across the finish line, especially when implementing notoriously tricky immutable red-black tree deletions. The library is MIT-licensed and requires only C++20.&lt;/p&gt;
&lt;h2 id="scaling-to-1-million-concurrent-sandboxes-in-seconds"&gt;&lt;a href="https://modal.com/blog/scaling-to-1-million-concurrent-sandboxes-in-seconds" rel="noopener noreferrer"&gt;Scaling to 1 million concurrent sandboxes in seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modal rewrote its entire sandbox control plane from the ground up and demonstrated the result with a striking milestone: spinning up one million concurrent sandboxes in under 60 seconds. Their previous architecture, much like Kubernetes, relied on strong consistency across the backend: every placement decision required global coordination, and database writes scaled linearly with sandbox count, making horizontal scaling impossible once demand reached millions of concurrent sandboxes and tens of thousands of creations per second.&lt;/p&gt;
&lt;p&gt;The new architecture embraces decentralization. Instead of a single serialized central scheduler, multiple scheduler servers run in parallel using load-balancing algorithms over in-memory state. Each worker node becomes the source of truth for its own sandboxes, periodically publishing state to Redis rather than writing synchronously to a central datastore, removing Postgres from the sandbox creation hot path entirely. RPC calls that previously scaled per sandbox are coalesced into batches. As a result, creating a sandbox takes just two network hops and a single CPU operation with zero central coordination, achieving a median startup time under 500 ms and scheduling latency of just a few tens of milliseconds. The multi-month effort began with an intense prototyping sprint by four engineers before reimplementing every feature, monitoring pipeline, and container runtime detail—including tracking down and fixing Linux kernel &lt;code&gt;rtnl&lt;/code&gt; lock contention when spinning up containers en masse.&lt;/p&gt;
&lt;h2 id="making-768-servers-look-like-1"&gt;&lt;a href="https://planetscale.com/blog/making-768-servers-look-like-1" rel="noopener noreferrer"&gt;Making 768 servers look like 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When an application has to serve millions of queries per second over petabytes of data, a single database server is no longer enough. PlanetScale outlines three fundamental walls in single-primary scaling: writes always funnel into one machine because the write-ahead log (WAL) is a serialization bottleneck regardless of how many read replicas you add; replicas duplicate the full dataset rather than dividing it; and backing up or restoring a massive monolithic database can take hours or days. The solution is horizontal sharding—splitting both data and queries across many independent primary servers. In the article&amp;rsquo;s example, one petabyte is split across 256 shards of roughly 4 TB each, with one primary and two replicas per shard, totaling 768 servers.&lt;/p&gt;
&lt;p&gt;To shield application developers from that complexity, a routing proxy layer sits between the app and the shards—Vitess for MySQL and Neki for Postgres. Unlike simple connection poolers such as PgBouncer, this router parses SQL queries, understands how data is distributed, plans and scatters queries to the right shards, and merges the results back together. The sharding topology is declared in JSON (a VSchema)—for instance, sharding the &lt;code&gt;user&lt;/code&gt; table by a hash of its &lt;code&gt;id&lt;/code&gt; column. Ultimately, the application connects to a single hostname like &lt;code&gt;mydb.pscale.com&lt;/code&gt;: DNS resolves to network load balancers that distribute connections across stateless query routers, and the application never knows 768 database servers are working behind the scenes.&lt;/p&gt;
&lt;h2 id="branchavoidant-programming"&gt;&lt;a href="https://easylang.online/blog/branchless" rel="noopener noreferrer"&gt;Branch‑Avoidant Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modern CPUs speculate on which way branches will go to keep their instruction pipelines full; when a prediction is wrong, the pipeline must be flushed and refilled at a steep penalty. This article illustrates the cost by filtering numbers smaller than 500 out of a random array—a workload where the branch predictor is essentially guessing a coin flip. The trick is to eliminate the &lt;code&gt;if&lt;/code&gt; statement: unconditionally write the current number into the output slot, and conditionally advance the output index with &lt;code&gt;smlen += (numbers[i] &amp;lt; 500);&lt;/code&gt;. You perform extra writes, but they are far cheaper than branch mispredictions. Filtering 100,000 numbers 1,000 times on an Apple M1 takes 0.345 seconds with an &lt;code&gt;if&lt;/code&gt; branch versus just 0.036 seconds branchless—nearly 10x faster; on an Intel Xeon, it drops from 0.576 to 0.110 seconds. Inspecting the assembly shows why: conditional jump instructions like &lt;code&gt;b.gt&lt;/code&gt; (ARM) or &lt;code&gt;jg&lt;/code&gt; (x86) are replaced by predication instructions like &lt;code&gt;cinc&lt;/code&gt; or &lt;code&gt;setle&lt;/code&gt;, keeping control flow completely straight.&lt;/p&gt;
&lt;p&gt;Compilers don&amp;rsquo;t apply this transformation automatically because they don&amp;rsquo;t know the statistical distribution of your runtime data, nor can they safely assume that a conditional memory write is valid to execute unconditionally (since the destination buffer might only be sized for matching elements or could trigger a data race). Developers therefore have to write branchless loops deliberately when profiling calls for it. The author notes that quicksort partitioning is a prime candidate, as partitioning is fundamentally conditional data movement around a pivot.&lt;/p&gt;
&lt;h2 id="your-redis-leaderboard-is-probably-breaking-ties-wrong"&gt;&lt;a href="https://dev.to/trungdlp/your-redis-leaderboard-is-probably-breaking-ties-wrong-39k4" rel="noopener noreferrer"&gt;Your Redis Leaderboard Is Probably Breaking Ties Wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Building a leaderboard with a Redis sorted set is a classic pattern, but few developers think about what happens when two players have the exact same score. By default, Redis breaks ties lexicographically by member string, meaning the player ID arbitrarily decides who ranks higher—deterministic, but meaningless to players. Common quick fixes have flaws of their own: millisecond timestamps collide under concurrency and suffer from clock skew across servers, while packing both score and timestamp into a single 64-bit IEEE 754 &lt;code&gt;double&lt;/code&gt; eats into the precision and safe range of both numbers.&lt;/p&gt;
&lt;p&gt;Podium, an open-source leaderboard service, implements a clean rule: whoever reaches a tied score first ranks higher. Each leaderboard maintains a monotonic counter initialized to the maximum signed 64-bit integer; whenever a player posts a new score, a Lua script decrements the counter and prepends that 19-digit number to the player&amp;rsquo;s public ID, ensuring earlier arrivals have a lexicographically larger prefix and sort ahead in descending queries. The script atomically updates four keys: the descending sorted set, an ascending sorted set (where counter digits are inverted so earlier arrivals still win ties), a hash mapping public IDs to internal member strings, and the counter itself. If a submitted score equals the player&amp;rsquo;s current score, their existing internal member name is preserved, making retries idempotent. The trade-off is roughly 11–17% higher write latency and 287 bytes per member instead of 99 bytes in local benchmarks—a reasonable price for fair, intuitive tie-breaking.&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 #125</title><link>https://miti99.com/en/post/2026/07/13/</link><pubDate>Mon, 13 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #125.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="275---khi-big-tech-chuyển-mình-thành-ai-factory"&gt;&lt;a href="https://newsletter.grokking.org/p/275-khi-big-tech-chuyen-minh-thanh" rel="noopener noreferrer"&gt;275 - Khi Big Tech chuyển mình thành AI Factory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This edition shares an inside look at how a major tech company is transforming its engineering organization into an &amp;ldquo;AI factory.&amp;rdquo; The author maps agentic automation across five maturity levels: starting with engineers copy-pasting snippets from a chatbot, moving to interactive coding agents guided turn by turn, then agents going autonomously from a written spec to a tested pull request, then humans acting solely as orchestrators of review and deployment, and finally agents autonomously deploying, monitoring production, and remediating incidents. Because each level grants agents broader autonomy, the company has to invest heavily in sandboxed execution environments, automated verification, fine-grained permissions, and hard guardrails that block destructive actions.&lt;/p&gt;
&lt;p&gt;As a result, the software engineer&amp;rsquo;s day-to-day role shifts from writing every line by hand to &amp;ldquo;packaging&amp;rdquo; work into well-bounded specifications with explicit goals and acceptance criteria—a transition that proves surprisingly tough for junior engineers accustomed to exploratory, trial-and-error coding. Human code review remains indispensable because critical product and system requirements often live in unwritten tribal context; automated AI review bots currently have only about half of their suggestions accepted and burn significant token budgets at scale. While individual programming languages are becoming increasingly interchangeable, deep fundamentals in operating systems, networking, security, infrastructure, data structures, and concurrency remain the bedrock that lets engineers evaluate and take accountability for AI-generated systems.&lt;/p&gt;
&lt;h2 id="the-8020-rule-for-your-whole-life"&gt;&lt;a href="https://yewjin.substack.com/p/always-be-curious" rel="noopener noreferrer"&gt;The 80/20 rule for your whole life&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yew Jin Lim proposes applying the 80/20 rule across your entire life: dedicate the 80% majority of your resources to building a rock-solid, low-drama foundation, and treat the remaining 20% as a &amp;ldquo;laboratory&amp;rdquo; for bounded experiments. The governing mindset is evaluating your life as a portfolio rather than agonizing over every individual position. He illustrates this with personal examples: many of the 20%-time side projects he tried at Google went nowhere individually, yet together they shaped his career trajectory; his retirement portfolio grew roughly tenfold through automated contributions and the discipline not to tinker; and his meditation practice deepened simply by showing up every day.&lt;/p&gt;
&lt;p&gt;From that experience he distills three core habits: follow curiosity to expand your knowledge without demanding an immediate payoff, master decision-making by separating emotional reactions from individual outcomes, and stay consistent long enough for compounding to do its work. He draws a sharp distinction between short-term trading and long-term investing, noting that once your foundation is sound, &amp;ldquo;doing nothing&amp;rdquo; is often the highest-leverage move available. Experiments don&amp;rsquo;t need to succeed every time, so long as each bet is sized small enough that failure is cheap tuition rather than ruin—and the 80% foundation is never put at risk.&lt;/p&gt;
&lt;h2 id="three-bad-managers"&gt;&lt;a href="https://randsinrepose.com/archives/three-bad-managers/" rel="noopener noreferrer"&gt;Three Bad Managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) tells the story of three brilliant, commercially successful bosses who were terrible people managers, using them to draw a crisp line between leadership (charting a compelling direction for the organization) and management (helping individuals understand where they stand and navigating day-to-day execution). &amp;ldquo;The Artist&amp;rdquo; was a gifted introvert who cared only about creative product work and treated human team dynamics as an annoying distraction. &amp;ldquo;The Dictator&amp;rdquo; used forceful authority and intimidation to dominate rooms—for instance, casually reopening design directions the team had already spent weeks evaluating rather than trusting their expertise. &amp;ldquo;The Knife&amp;rdquo; was so volatile and unpredictable that neither spoken nor written communication ever landed cleanly.&lt;/p&gt;
&lt;p&gt;For each boss, Lopp found a different survival strategy: writing his own detailed performance review ahead of 1-on-1s so The Artist just had to react to it, doing exhaustive technical homework before meetings so he could push back on The Dictator as an equal, and simply staying out of The Knife&amp;rsquo;s blast radius to get work done independently. His core takeaway is that you will almost never change your boss—especially when they are senior and successful—but you can change how you prepare, communicate, and operate around them. Every working relationship requires calibration, and learning how to adapt to difficult personalities is a practical survival skill rather than an endorsement of bad management.&lt;/p&gt;
&lt;h2 id="cross-team-pragmatics"&gt;&lt;a href="https://philcalcado.com/2026/06/01/cross_team_pragmatics.html" rel="noopener noreferrer"&gt;Cross-Team Pragmatics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Calçado examines why cross-team collaboration almost always slows down and turns political as an engineering organization grows. The root causes are predictable: individual-focused performance review cultures incentivize local optimization, high-level strategic goals contradict each other once cascaded down different org branches (e.g., an infra team rewarded for cutting cloud spend while a product team is rewarded for shipping compute-heavy features), accountability is assigned without matching ownership, and minor disagreements constantly escalate up the management chain instead of getting resolved laterally. The only durable fix is a unified technical strategy that aligns how the business competes with team boundaries, ownership, incentives, and decision rights.&lt;/p&gt;
&lt;p&gt;While waiting for those slow structural fixes to take hold, Calçado shares four pragmatic tools for treating the immediate symptoms. Team charters turn unspoken assumptions into explicit boundaries, responsibilities, and interaction modes, cutting down repetitive renegotiation. Value-stream mapping traces how a feature actually flows from idea to production rather than looking at the org chart, exposing unnecessary handoffs and queues. The 80% rule states that a team should be able to complete at least 80% of its roadmap without blocking dependencies on other teams along the critical path, while Team Topologies gives organizations a shared vocabulary for intentionally choosing how teams interact. These tools buy breathing room and stability, though long-term health still requires continuously reshaping the org around how value is actually delivered.&lt;/p&gt;
&lt;h2 id="technological-involution"&gt;&lt;a href="https://rohan.ga/blog/technological-involution/" rel="noopener noreferrer"&gt;Technological Involution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rohan argues that the tech industry has entered a state of &amp;ldquo;involution&amp;rdquo;: more talent and capital pouring in than ever, yet producing increasingly homogeneous, incremental ideas. In his view, the obvious low-hanging fruit of consumer and SaaS software has largely been picked, standard application software is rapidly commoditizing, and Silicon Valley startup culture encourages young founders to borrow pre-packaged narratives from influencers and VCs rather than forming independent convictions from scratch. Hype manufactures consensus rather than real value, while society at large grows more cynical about tech&amp;rsquo;s future. Meanwhile, the genuinely hard problems sit in atoms, hardware, semiconductors, and messy real-world enterprise operations—domains where most young founders lack hands-on experience.&lt;/p&gt;
&lt;p&gt;AI excels at generating code and synthesizing conventional wisdom, but by design it gravitates toward the consensus mean rather than contrarian, high-impact insights. Rohan argues that this limitation is precisely what preserves the opening for human agency: people who immerse themselves deeply in a domain, test hypotheses from first principles, and have the courage to pursue non-consensus ideas will only become more valuable. The way out of involution is returning to intrinsic motivation—building something because the problem itself is intellectually gripping rather than optimizing for startup vanity metrics—and the success of independent, taste-driven new media proves that work built with genuine conviction still cuts through the noise.&lt;/p&gt;
&lt;h2 id="fintech-engineering-handbook"&gt;&lt;a href="https://w.pitula.me/fintech-engineering-handbook/" rel="noopener noreferrer"&gt;Fintech Engineering Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wojciech Pitula&amp;rsquo;s handbook distills core principles and architectural patterns for building software where money is the primary domain object, anchored on three commandments: never invent money or data out of thin air, never lose data, and never trust any single component blindly. On representing monetary amounts, he compares floating-point numbers (almost never acceptable), arbitrary-precision decimals, integer minor units (e.g., cents), and rational fractions, while warning that standard JSON parsers silently coerce numeric literals into IEEE 754 floats unless amounts are serialized as strings or integers. Every balance change is recorded in a double-entry ledger where money only ever moves between accounts and balances are derived from immutable journal entries—tracking transaction time, booking time, and settlement time as distinct timestamps.&lt;/p&gt;
&lt;p&gt;On the execution side, the handbook covers funds holds/reservations to prevent double-spending, strict idempotency keys, crash-resumable state machines, and at-least-once event delivery. When integrating with external payment processors and banks, systems must validate schemas at the boundary, persist every raw request and response payload for auditability, verify webhook signatures before querying the provider&amp;rsquo;s canonical API for state, and run independent automated reconciliation jobs to catch ledger drift early. Posted ledger entries are strictly immutable—mistakes are corrected via compensating reversal entries, never &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt;—and sensitive manual operations require four-eyes approval. End-to-end walkthroughs of crypto withdrawals, card top-ups, and currency exchanges show how these patterns interlock across multi-step failure scenarios.&lt;/p&gt;
&lt;h2 id="how-to-write-an-effective-software-design-document"&gt;&lt;a href="https://refactoringenglish.com/excerpts/write-an-effective-design-doc/" rel="noopener noreferrer"&gt;How to Write an Effective Software Design Document&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch shares a practical guide to writing software design documents that surface flawed assumptions before coding begins and align stakeholders on how to solve a problem. A design doc is worth writing when a project spans multiple people, takes longer than three months, will live in production long-term, crosses team boundaries, starts from ambiguous requirements, or carries high operational risk. To decide how much detail a section needs, Lynch suggests asking one simple question: &amp;ldquo;what is the cost of being wrong?&amp;rdquo; Hard-to-reverse choices around system architecture, data storage schemas, security, and privacy deserve deep analysis, whereas easily tweaked UI details don&amp;rsquo;t belong in a design doc.&lt;/p&gt;
&lt;p&gt;An effective design doc typically covers background and goals, explicit scope and non-goals, architecture and data-flow diagrams, measurable SLAs/SLOs, security and privacy considerations, a milestone timeline, and a log of open and resolved questions. The document should focus on the hardest trade-offs and gathering early feedback rather than specifying every line-level implementation detail—if you&amp;rsquo;ve written pseudocode for every class, you&amp;rsquo;ve essentially written the code twice. Lynch also recommends using editable diagramming tools (like Mermaid or Excalidraw with source checked in), defining domain jargon in a glossary, documenting rejected alternatives so reviewers don&amp;rsquo;t re-litigate them in comments, and writing clearly enough that cross-functional partners outside the core engineering team can follow along.&lt;/p&gt;
&lt;h2 id="the-cost-yagni-was-never-about"&gt;&lt;a href="https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-about" rel="noopener noreferrer"&gt;The Cost YAGNI Was Never About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck explains that YAGNI (&amp;ldquo;You Aren&amp;rsquo;t Gonna Need It&amp;rdquo;) was never really about saving typing or coding effort—it is an economic principle about &lt;em&gt;when&lt;/em&gt; to commit to a design decision. Building speculative structure before a feature actually demands it incurs two distinct costs that have nothing to do with how fast you can write code. The first is lost optionality: the team locks in a bet when they have the least information about the problem, and when real requirements inevitably diverge from the guess, they have to pay to work around or rip out that speculative abstraction. Even on the rare occasion when the guess turns out right, committing early still forfeits the option value of waiting until you know more; as Beck puts it, waiting isn&amp;rsquo;t procrastination—it is holding a valuable option.&lt;/p&gt;
&lt;p&gt;The second cost is net present value (NPV) and carrying cost: you pay the complexity, maintenance, and cognitive tax immediately while any hypothetical payoff arrives far in the future, meaning you lose economically whether your prediction was right or wrong. Now that AI makes generating code nearly free, the &amp;ldquo;save typing time&amp;rdquo; argument for YAGNI disappears, yet both the optionality cost and the carrying cost remain completely intact—in fact, AI makes it dangerously easy to hallucinate sprawling, speculative frameworks in seconds. Build structure when concrete demand arrives and gives you the information needed to design it right; YAGNI is economic discipline, not stinginess with keystrokes.&lt;/p&gt;
&lt;h2 id="a-cve-dispute"&gt;&lt;a href="https://daniel.haxx.se/blog/2026/06/24/a-cve-dispute/" rel="noopener noreferrer"&gt;a CVE dispute&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Stenberg recounts curl&amp;rsquo;s first formal CVE dispute since the project became a CVE Numbering Authority (CNA). With roughly 30 billion libcurl installations worldwide, publishing a CVE triggers a massive wave of triage, compliance scanning, patching, and backporting across the entire software industry. Because of that amplification effect, the curl security team evaluates reports based on realistic exploitability and occasionally declines to assign a CVE to bugs whose security impact is &amp;ldquo;lower than low&amp;rdquo;—aiming to be completely transparent about real vulnerabilities without crying wolf over purely theoretical edge cases.&lt;/p&gt;
&lt;p&gt;The disputed report involved curl&amp;rsquo;s wildcard certificate hostname matching function when the URL&amp;rsquo;s hostname began with a leading dot (e.g., &lt;code&gt;.example.com&lt;/code&gt;). For this bug to be exploitable in practice, an absurd chain of preconditions had to hold simultaneously: a user had to request a hostname that is syntactically invalid in standard DNS, that invalid name had to resolve via something like a modified local &lt;code&gt;/etc/hosts&lt;/code&gt; file, an attacker-controlled server at that IP had to present a matching wildcard certificate from a trusted CA, and the attacker already needed local privileges to poison name resolution in the first place. The curl team fixed the bug in December 2025 as a normal defect but declined to issue a CVE. A security researcher appealed the decision to MITRE, and after multiple rounds of review in 2026, MITRE agreed with curl that it was simply a fixed bug rather than a security vulnerability because exploiting it required a privileged local attacker. The episode illustrates why not every bug in a network library deserves a CVE, and how the CNA dispute process provides an independent check when opinions differ.&lt;/p&gt;
&lt;h2 id="how-llms-actually-work"&gt;&lt;a href="https://www.0xkato.xyz/how-llms-actually-work/" rel="noopener noreferrer"&gt;How LLMs Actually Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This visual guide explains how autoregressive transformer language models generate text token by token without getting bogged down in heavy calculus. Incoming text is first split into subword tokens by a tokenizer and mapped to integer IDs; an embedding lookup table then converts each ID into a dense vector capturing learned semantic features, placing tokens with related meanings near one another in high-dimensional space. Because self-attention treats inputs as an unordered set by default, the model injects positional information—most modern LLMs use Rotary Position Embeddings (RoPE), rotating query and key vectors by an angle proportional to each token&amp;rsquo;s position in the sequence. Inside each transformer block, self-attention compares query vectors against key vectors to compute attention weights, deciding how much information to pull from each prior token&amp;rsquo;s value vector, while multiple attention heads run in parallel to track grammatical structure, coreference, and recurring patterns simultaneously.&lt;/p&gt;
&lt;p&gt;After tokens exchange context through attention, a feed-forward network (MLP) processes each token vector independently—this layer holds the majority of the model&amp;rsquo;s parameters and stored factual associations. Residual connections allow information to flow and accumulate across dozens of stacked layers without vanishing gradients, while layer normalization keeps activation magnitudes stable. At the very end of the stack, the final token&amp;rsquo;s hidden state vector is projected across the entire vocabulary and passed through softmax to produce a probability distribution over the next token; the runtime samples a token (shaped by temperature, top-p, or top-k), appends it to the sequence, and repeats the loop. While modern frontier models tweak attention variants, architectures, and training recipes, they all share this foundational autoregressive transformer loop.&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_!LlLN!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe4d255e1-536e-4f66-ab48-e8baa1bdd4a4_2484x3002.png" alt="RAG vs Graph RAG vs Agentic RAG"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!15Bw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9b8f9d64-3eae-4237-b49f-ffde033f851a_2484x3002.png" alt="Redis Data Structures Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-ILW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F19ca7f08-d615-4769-8599-2aa9aaa5d6bd_2508x3000.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ydOn!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe46aad28-2935-4b87-8cf4-72787b48a9d0_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_6cl!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fea738d9d-1ae5-4a26-9a50-79ec7720fd80_2360x2664.jpeg" alt="The Testing Pyramid"&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 #124</title><link>https://miti99.com/en/post/2026/07/12/</link><pubDate>Sun, 12 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #124.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="riding-technology-waves"&gt;&lt;a href="https://staysaasy.com/strategy/2026/06/22/riding-technology-waves.html" rel="noopener noreferrer"&gt;Riding Technology Waves&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Major technology waves—the internet, cloud computing, mobile, and now AI—arrive faster and hit harder with each cycle, minting massive new winners while wiping out incumbents, even as other hyped waves like 3D printing or VR fizzle out. To orient yourself early without getting swept up in empty hype, Stay SaaSy proposes answering four questions in order: does this technology actually matter (i.e., do real users get sustained value from it)?; how does it work under the hood, at a level you could explain clearly to a smart outsider?; what concrete new capabilities does it unlock, stated as plain facts rather than buzzwords?; and how do those capabilities affect your specific product, cost structure, or customers?&lt;/p&gt;
&lt;p&gt;The two classic failure modes sit at opposite extremes. Complacency leads companies to dismiss real signals as a fad, though that mistake usually forces its own correction once the wave becomes undeniable. Far more common in volatile times is FOMO-driven panic: leaders who don&amp;rsquo;t understand the technology chase the herd, betting the company on unvalidated use cases or blowing up a working roadmap to slap an &amp;ldquo;AI&amp;rdquo; label on the product while customers are asking for basic reliability. Blindly pivoting is the default strategic blunder during a hype cycle. Yet the worst mistake of all is missing an obvious wave and then letting ego keep you in denial; when that happens, leadership must admit the miss, take ownership, put their best people and real resources on catching up, and stay hands-on until the course is corrected.&lt;/p&gt;
&lt;h2 id="find-a-new-role"&gt;&lt;a href="https://larahogan.me/blog/identify-new-role/" rel="noopener noreferrer"&gt;Find a new role&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When thinking about changing jobs or transitioning into a new role, Lara Hogan recommends filling out a 2×2 grid of four lists: your non-negotiable &amp;ldquo;Must Haves&amp;rdquo;; your &amp;ldquo;Want to Haves&amp;rdquo; that matter a lot, though you&amp;rsquo;d trade off one or two for the right opportunity; things that &amp;ldquo;Don&amp;rsquo;t Matter&amp;rdquo; to you right now, even if they mattered in the past or matter to peers; and a single crisp &amp;ldquo;Optimizing For&amp;rdquo; sentence stating the one thing you are prioritizing above everything else in this chapter. Putting those four boxes on paper turns a murky career decision into concrete criteria for sourcing roles, asking interview questions, and weighing offers.&lt;/p&gt;
&lt;p&gt;Hogan advises leaving job titles off every list entirely, since the same title can mean wildly different things across companies; evaluate the actual day-to-day scope and responsibilities instead. Keep the &amp;ldquo;Must Haves&amp;rdquo; box ruthlessly short: if you would still accept an offer missing a given item, it belongs in &amp;ldquo;Want to Haves,&amp;rdquo; and you will almost certainly have to compromise on at least one want-to-have. Anchor your criteria in what you need &lt;em&gt;today&lt;/em&gt; rather than what you wanted five years ago or might want in the distant future—sometimes top-of-market compensation gives way to great healthcare, or scope gives way to work-life balance. Your single &amp;ldquo;Optimizing For&amp;rdquo; statement is the sharpest tool of all: tape it next to your monitor, share it with trusted friends who can hold you accountable, and use it to ask which opportunity moves you closest to that specific goal. Re-run the exercise whenever your life circumstances shift.&lt;/p&gt;
&lt;h2 id="i-stored-a-website-in-a-favicon"&gt;&lt;a href="https://www.timwehrle.de/blog/i-stored-a-website-in-a-favicon" rel="noopener noreferrer"&gt;I Stored a Website in a Favicon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After previously hiding two bytes of state inside a custom mouse cursor, Tim Wehrle decided to see if he could pack an entire web page inside a &lt;code&gt;favicon.ico&lt;/code&gt;/PNG image. The encoding is delightfully direct: a favicon is an image, an image is a grid of pixels, and each RGB pixel gives you three color channels—red, green, and blue—worth one byte each. Wehrle encodes an HTML snippet into UTF-8 bytes using &lt;code&gt;TextEncoder&lt;/code&gt;, prepends a 4-byte length header so the decoder knows exactly where the payload ends (ignoring any trailing padding pixels in the grid), and writes three bytes into each pixel&amp;rsquo;s RGB values. A 208-byte HTML payload plus the 4-byte header totals 212 bytes, fitting into 71 pixels inside a tiny 9×9 PNG at 87% capacity—producing an icon that looks like colorful static.&lt;/p&gt;
&lt;p&gt;To reconstruct the page, a tiny bootstrap page loads the favicon onto an HTML &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt;, reads back the pixel array via &lt;code&gt;getImageData()&lt;/code&gt;, extracts the RGB bytes up to the 4-byte length prefix, decodes the UTF-8 string with &lt;code&gt;TextDecoder&lt;/code&gt;, and replaces the current document with the recovered HTML. Crucially, a PNG favicon is inert data and cannot execute itself on its own—you still need that small loader script to unpack and render it. Wehrle readily admits the experiment has zero practical utility given the tiny storage budget and the existence of normal HTTP responses, but it is a fun reminder that every file format is ultimately just bytes that can be repurposed in unexpected ways. He closes by noting alternative steganographic tricks like embedding markup inside an SVG favicon, stuffing text into PNG &lt;code&gt;tEXt&lt;/code&gt; chunks, or packing multiple resolutions into an &lt;code&gt;.ico&lt;/code&gt; container.&lt;/p&gt;
&lt;h2 id="antipatterns-never-left-we-just-stopped-calling-them-by-name"&gt;&lt;a href="https://dev.to/leonpennings/antipatterns-never-left-we-just-stopped-calling-them-by-name-969" rel="noopener noreferrer"&gt;AntiPatterns Never Left, We Just Stopped Calling Them by Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in 1998, the book &lt;em&gt;AntiPatterns&lt;/em&gt; cataloged recurring software failure modes—giving each one a memorable name, symptoms, root causes, and a refactoring path out. Leon Pennings argues that those exact failure modes are still everywhere today; we just rebranded them as modern best practices and stopped recognizing them because the system still compiles and passes tests. Short-term delivery creates survivorship bias where teams assume their architectural choices succeeded, since nobody builds the simpler alternative alongside it for comparison. Industry popularity doesn&amp;rsquo;t prove an approach fits your context, and naming anti-patterns explicitly helps teams see water they&amp;rsquo;ve been swimming in for years.&lt;/p&gt;
&lt;p&gt;Pennings groups modern anti-patterns into four recurring themes. First is organizing code around technical layers (&lt;code&gt;controllers/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;, &lt;code&gt;repositories/&lt;/code&gt;) instead of business capabilities, scattering domain concepts across folders, producing anemic domain models, and coupling business logic tightly to frameworks. Second is cargo-culting Resume-Driven Development—reaching for Kubernetes or Kafka as a golden hammer regardless of scale. Third is when the cure recreates the disease: turning a monolithic Big Ball of Mud into a distributed microservices ball of mud where complexity simply moves across network boundaries, or standing up a platform team that becomes just another ticket-driven silo. Fourth is separating decision-makers from the consequences of their decisions, such as Scrum intermediaries insulating developers from real users. Sometimes writing fifty lines of plain code is far cheaper over five years than pulling in a massive dependency; the goal isn&amp;rsquo;t rejecting frameworks, microservices, or Scrum wholesale, but evaluating every trade-off against your actual problem.&lt;/p&gt;
&lt;h2 id="5-more-advanced-java-tips-that-senior-engineers-actually-use"&gt;&lt;a href="https://dev.to/cyclopt_dimitrisk/5-more-advanced-java-tips-that-senior-engineers-actually-use-bbp" rel="noopener noreferrer"&gt;5 More Advanced Java Tips That Senior Engineers Actually Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through five modern Java capabilities, though it is worth noting upfront that they did not all land as final, stable APIs in Java 21: Record Patterns and Sequenced Collections were finalized in JDK 21, the Foreign Function and Memory (FFM) API was finalized in JDK 22, and Stream Gatherers became final in JDK 24, while Structured Concurrency remains a preview feature in the JDK 24 release referenced by the examples—so check your target JDK version before adopting. Structured Concurrency (&lt;code&gt;StructuredTaskScope&lt;/code&gt;) groups related concurrent subtasks into a single lexical lifetime: using a policy like &lt;code&gt;ShutdownOnFailure&lt;/code&gt;, if one subtask fails the remaining siblings are cancelled automatically (assuming they respect thread interruption), and once the &lt;code&gt;try-with-resources&lt;/code&gt; block exits no orphan threads are left running in the background—a major upgrade over manually juggling independent &lt;code&gt;CompletableFuture&lt;/code&gt; chains. Record Patterns let you destructure nested records directly inside &lt;code&gt;switch&lt;/code&gt; expressions; paired with &lt;code&gt;sealed&lt;/code&gt; interfaces, the compiler enforces exhaustiveness so adding a new subtype immediately flags every unhandled &lt;code&gt;switch&lt;/code&gt; at compile time.&lt;/p&gt;
&lt;p&gt;Sequenced Collections (&lt;code&gt;SequencedCollection&lt;/code&gt;, &lt;code&gt;SequencedSet&lt;/code&gt;, &lt;code&gt;SequencedMap&lt;/code&gt;) unify access to first/last elements and reverse-order iteration across ordered collections; calling &lt;code&gt;.reversed()&lt;/code&gt; returns a lightweight view rather than copying the underlying list, which is handy when scanning chronological event logs backward. The Foreign Function and Memory API (Project Panama) replaces brittle &lt;code&gt;sun.misc.Unsafe&lt;/code&gt; and JNI boilerplate with a pure-Java API for allocating off-heap memory and calling native C libraries, complete with bounds checking and deterministic deallocation via &lt;code&gt;Arena&lt;/code&gt; lifetimes (though the underlying native code itself must still be trusted). Finally, Stream Gatherers (&lt;code&gt;Stream::gather&lt;/code&gt;) fill a long-standing gap in the Stream API: just as &lt;code&gt;Collector&lt;/code&gt; lets you customize terminal operations, &lt;code&gt;Gatherer&lt;/code&gt; lets you write custom stateful intermediate operations—such as fixed batching, sliding windows, deduplicating adjacent elements, or running averages—while keeping pipelines readable.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://dev.to/mihirmohapatra/gos-type-system-structs-interfaces-and-life-without-inheritance-2lb7" rel="noopener noreferrer"&gt;Go&amp;rsquo;s Type System — Structs, Interfaces, and Life Without Inheritance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming to Go after six years of Java and Kotlin, Mihir Mohapatra reflects that the biggest mental shift in Go&amp;rsquo;s type system is the complete absence of class inheritance. A &lt;code&gt;struct&lt;/code&gt; holds only data fields—there are no constructors or &lt;code&gt;implements&lt;/code&gt; keywords; a factory function like &lt;code&gt;NewOrder&lt;/code&gt; is just a naming convention, and callers can still instantiate the zero-valued struct directly unless the type is unexported. Methods are declared separately with explicit value receivers (which operate on a copy) or pointer receivers (which can mutate the caller&amp;rsquo;s struct); reassigning a struct field requires a pointer receiver, though a value copy containing a &lt;code&gt;map&lt;/code&gt;, &lt;code&gt;slice&lt;/code&gt;, or pointer still shares the underlying referenced storage. Instead of inheritance, Go uses struct embedding: fields and methods of an embedded inner struct are promoted to the outer struct, modeling a &amp;ldquo;has-a&amp;rdquo; composition relationship rather than an &amp;ldquo;is-a&amp;rdquo; subtype hierarchy.&lt;/p&gt;
&lt;p&gt;The biggest design departure is that Go interfaces are satisfied implicitly: any type that implements the required method signatures automatically satisfies the interface, even types from third-party packages you don&amp;rsquo;t control. That flips interface design on its head: instead of defining massive upfront contracts in a central package that every implementation must explicitly import and declare, Go interfaces are typically small—often one or two methods like &lt;code&gt;io.Reader&lt;/code&gt; and &lt;code&gt;io.Writer&lt;/code&gt;—and defined by the consumer right where the behavior is needed. Types stay decoupled and brittle base-class hierarchies disappear. Mohapatra also notes the trade-offs newcomers bump into: finding every type that satisfies an interface requires IDE tooling rather than grepping for &lt;code&gt;implements&lt;/code&gt;, struct embedding doesn&amp;rsquo;t give you subclass polymorphism, and Go&amp;rsquo;s zero values mean an uninitialized struct compiles cleanly and can look valid unless you validate required fields explicitly.&lt;/p&gt;
&lt;h2 id="conduit-the-gateway-i-built-to-forget-about"&gt;&lt;a href="https://dev.to/adamthedeveloper/conduit-the-gateway-i-built-to-forget-about-2ann" rel="noopener noreferrer"&gt;Conduit: The Gateway I Built to Forget About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adam built an internal Go API gateway sitting in front of three backend services with two authentication schemes: a custom HMAC-signed session token for end-user and chat routes, and JWTs for admin endpoints. While the Go proxy was fast and rock-solid, every new public-route exception or header tweak meant adding another &lt;code&gt;if&lt;/code&gt; branch in Go, recompiling, and redeploying the binary. Conduit solves this by splitting what rarely changes from what changes constantly: a core Go binary handles HTTP ingress, routing, reverse proxying, CORS, and SSRF protection, while an isolated Deno subprocess executes TypeScript policy modules for auth, logging, and request mutation—letting operators edit a &lt;code&gt;.ts&lt;/code&gt; file and reload policies without recompiling Go.&lt;/p&gt;
&lt;p&gt;The two processes communicate over a Unix domain socket using a strict snapshot-and-patch contract. Go sends a serializable JSON snapshot of the incoming request metadata; the TypeScript policy modules return only a minimal patch describing headers to add/remove or whether to short-circuit the request, rather than owning or mutating the live request object directly, while request bodies larger than 64 KiB stay inside Go and are referenced by handle ID. Failure modes are explicitly separated too: if an individual policy module times out, Conduit logs a warning and moves on, whereas if the entire Deno sidecar crashes, each route follows its configured failure policy—either failing closed with &lt;code&gt;503 Service Unavailable&lt;/code&gt; or failing open by proxying directly to the upstream. Simplicity comes from crisp responsibility boundaries rather than raw line count; Conduit isn&amp;rsquo;t trying to replace Envoy or Kong at massive scale, just stay out of the way in front of a handful of services whose edge policies evolve often.&lt;/p&gt;
&lt;h2 id="the-reflect-package"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-reflect" rel="noopener noreferrer"&gt;The Reflect Package&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go compiles ahead of time to native machine code, yet the standard library&amp;rsquo;s &lt;code&gt;reflect&lt;/code&gt; package can inspect struct field names, types, and struct tags at runtime. This post dives into how the Go compiler embeds static type metadata inside the compiled binary so &lt;code&gt;reflect&lt;/code&gt; can read it (while noting that other &lt;code&gt;reflect&lt;/code&gt; APIs can still allocate or construct types dynamically at runtime). Under the hood, an empty interface value (&lt;code&gt;any&lt;/code&gt; / &lt;code&gt;interface{}&lt;/code&gt;) is a two-word struct holding two pointers: one pointing to the underlying data and one pointing to a runtime type descriptor (&lt;code&gt;abi.Type&lt;/code&gt;), whose address is a compile-time constant known to the linker. Calling &lt;code&gt;reflect.TypeOf&lt;/code&gt; therefore just reads that type pointer—no hash table lookup, no heap allocation.&lt;/p&gt;
&lt;p&gt;During compilation, the compiler&amp;rsquo;s &lt;code&gt;reflectdata&lt;/code&gt; pass serializes a descriptor for every needed type as a linker symbol named &lt;code&gt;type:&amp;lt;typename&amp;gt;&lt;/code&gt;, and the linker packs those symbols into a read-only data section of the binary—which is why running &lt;code&gt;strings&lt;/code&gt; on a Go executable reveals your struct tags in plain text. Every descriptor starts with a fixed 48-byte common header (&lt;code&gt;abi.Type&lt;/code&gt;) recording byte size, alignment, kind (&lt;code&gt;Struct&lt;/code&gt;, &lt;code&gt;Slice&lt;/code&gt;, &lt;code&gt;Int&lt;/code&gt;, etc.), type hash, garbage-collector pointer bitmap, equality function pointer, and name offset; immediately following that header in memory sit kind-specific fields—for a struct (&lt;code&gt;abi.StructType&lt;/code&gt;), a slice of &lt;code&gt;StructField&lt;/code&gt; entries holding each field&amp;rsquo;s name, type pointer, and byte offset within the struct, followed by method table metadata. Field names and tags are deduplicated in a shared read-only string pool to save binary size. When you use &lt;code&gt;reflect.Value&lt;/code&gt;, it pairs the type descriptor with the data pointer and adds the stored byte offset to jump straight to a field&amp;rsquo;s memory address. Reading works fine on a value copy, but mutating via reflection requires passing a pointer into &lt;code&gt;any&lt;/code&gt;—otherwise &lt;code&gt;reflect&lt;/code&gt; is only looking at a copy of your struct.&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 #123</title><link>https://miti99.com/en/post/2026/07/11/</link><pubDate>Sat, 11 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #123.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="our-collective-bike-shed-moment"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/our-collective-bike-shed-moment.html" rel="noopener noreferrer"&gt;Our Collective Bike Shed Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post borrows Parkinson&amp;rsquo;s &amp;ldquo;Law of Triviality&amp;rdquo;: a fictional committee approves a nuclear reactor design in ten minutes because the topic is too complex for anyone to debate, then spends forty-five minutes arguing over what color to paint the bike shed. The author argues that society is re-enacting that exact meeting in the face of AI. LLMs have blown past one supposed ceiling after another—from &amp;ldquo;they can&amp;rsquo;t write real code&amp;rdquo; to hallucinations—while growing steadily stronger at formal methods and multi-step reasoning, yet critics keep moving the goalposts while the broader public carries on as if nothing fundamental has changed.&lt;/p&gt;
&lt;p&gt;Demirbas attributes this collective shrug to normalcy bias—our default assumption that tomorrow will look mostly like yesterday—and Douglas Adams&amp;rsquo;s &amp;ldquo;Somebody Else&amp;rsquo;s Problem&amp;rdquo; field, where something colossal is ignored precisely because it is too big to process. Learning new AI tools to stay employable over the next few years is a sensible personal strategy, but it doesn&amp;rsquo;t answer what happens over the coming decades. What worries the author is that even the people who should be leading the serious conversation—technologists, researchers, economists, policymakers, ethicists, defense planners, and educators—still aren&amp;rsquo;t grappling with the long-term societal transformation at the depth required, while public attention remains fixated on surface-level bike-shedding.&lt;/p&gt;
&lt;h2 id="p99-0ms"&gt;&lt;a href="https://ruurtjan.com/articles/p99-0ms-autocomplete-for-240-million-domain-names" rel="noopener noreferrer"&gt;p99 0 ms* autocomplete for 240 million domain names&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ruurtjan Pul explains how Wirewiki achieves instantaneous-feeling autocomplete across a dataset of 240 million domain names. The trick starts in the browser: on &lt;code&gt;keydown&lt;/code&gt;, the client prefetches autocomplete results not only for the current prefix, but for every valid character the user might type next; by the time the next &lt;code&gt;keyup&lt;/code&gt; fires, the suggestions are already sitting in browser memory ready to render. Because domain names use a tiny character set (38 characters), a single response bundling top suggestions for all possible next keystrokes contains at most 312 domain names—roughly 2.5 kB compressed. According to the author&amp;rsquo;s measurements, 99% of keystrokes have at least a 121 ms budget before release, so &amp;ldquo;p99 0 ms&amp;rdquo; means the result is already local before &lt;code&gt;keyup&lt;/code&gt;, not that network packets travel faster than light.&lt;/p&gt;
&lt;p&gt;On the server side, the dataset is split into two tiers. An in-memory prefix tree (trie) holds the top eight suggestions for every prefix drawn from the Tranco top one million domains. The remaining 240 million domains from ICANN&amp;rsquo;s CZDS are sorted, front-coded (prefix-compressed), and packed into fixed-size blocks on SSD; a 27 MB in-memory index locates the right block in one hop while the OS page cache keeps hot blocks in RAM. The Go API typically responds in ~2 ms, and under 1,600 requests/sec Nginx plus the API still maintain a ~15 ms p99. Once the origin server is that fast, network round-trip time through Cloudflare dominates perceived latency—hence the asterisk in the title: a single European server still can&amp;rsquo;t beat the 121 ms budget for users halfway across the globe. The takeaway is to measure latency from the user&amp;rsquo;s physical interaction rather than just server processing time.&lt;/p&gt;
&lt;h2 id="building-reliable-agentic-ai-systems"&gt;&lt;a href="https://martinfowler.com/articles/reliable-llm-bayer.html" rel="noopener noreferrer"&gt;Building Reliable Agentic AI Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article on Martin Fowler&amp;rsquo;s site chronicles how Bayer built PRINCE, an agentic AI platform that helps pharmaceutical researchers query decades of preclinical toxicology data locked inside thousands of PDF study reports. The architecture evolved through three stages: structured metadata search, basic RAG question-answering, and finally a multi-agent workflow for complex cross-study questions. Orchestrated with LangGraph, the system steps through intent clarification, planning, research execution, evidence sufficiency checks, and report synthesis. Specialized research agents combine OpenSearch-backed RAG over unstructured PDF narratives with Athena Text-to-SQL for filtering, aggregating, and comparing structured study tables, while dedicated reflection nodes audit progress, data completeness, and draft quality.&lt;/p&gt;
&lt;p&gt;Reliability comes from the engineering harness around the models rather than clever prompting or waiting for a smarter foundation model. Each graph node receives only the narrow slice of context it needs; workflow state is checkpointed after every node so failures resume from the last completed step instead of restarting from scratch; and bounded retries operate at both the individual model-call level and the graph-node level, failing over to backup models or cloud regions when needed. In a heavily regulated pharmaceutical environment, user trust also depends on surfacing intermediate reasoning steps, linking every claim directly to source PDF pages and paragraphs, running continuous evaluations against both golden datasets and production traffic, and keeping domain scientists in the loop. Breaking a monolith prompt into an observable, checkpointed graph made the system dramatically easier to test, recover, and improve.&lt;/p&gt;
&lt;h2 id="growing-as-an-engineer-in-a-world-of-ai"&gt;&lt;a href="https://nlopes.dev/writing/growing-as-an-engineer-in-a-world-of-ai" rel="noopener noreferrer"&gt;Growing as an engineer in a world of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Norberto Lopes argues that the biggest risk AI poses to early-career engineers isn&amp;rsquo;t replacing their jobs—it&amp;rsquo;s short-circuiting their growth by removing the very friction that produces deep learning. Reading documentation, experimenting, failing, debugging, and piecing together your own mental model builds durable knowledge through &amp;ldquo;desirable difficulty&amp;rdquo; and the generation effect. Getting an instant answer is not the same as understanding the problem: if an engineer simply accepts generated code and moves on to the next ticket, they can ship working features while remaining unable to explain the design choices, trade-offs, or failure modes. That &amp;ldquo;cognitive debt&amp;rdquo; stays hidden until production breaks in a way the AI can&amp;rsquo;t immediately fix.&lt;/p&gt;
&lt;p&gt;Lopes doesn&amp;rsquo;t advocate shunning AI; instead, he recommends using it deliberately as a learning amplifier: ask &lt;em&gt;why&lt;/em&gt; an approach works, ask for alternative designs and failure scenarios, read the code and sketch your own mental model before asking the LLM to explain it, type out critical sections yourself instead of copy-pasting, and treat code review and technical writing as active thinking exercises. Foundational depth still comes from books, Unix fundamentals, primary specifications, architecture debates, and postmortems—and the time saved by AI should be reinvested into harder engineering thinking. Developing junior engineers is also an organizational responsibility: managers must protect space for learning, evaluate judgment and system understanding rather than raw ticket velocity, and keep hiring and mentoring the next generation.&lt;/p&gt;
&lt;h2 id="note-to-my-younger-self"&gt;&lt;a href="https://yewjin.substack.com/p/note-to-my-younger-self" rel="noopener noreferrer"&gt;Note To My Younger Self&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reflecting on two decades at major tech companies, Yew Jin Lim distills eight career principles that sound simple on paper but take discipline to practice. Fall in love with the actual craft rather than chasing titles, and treat your first job as a laboratory for learning how to solve problems; keep asking &amp;ldquo;why&amp;rdquo; until you reach root causes; build genuine relationships by helping people without keeping score while maintaining healthy boundaries; bring energy and joy to the team around you; listen carefully, tailor explanations to your audience, and know when to stay quiet; write down your impact every single week and proactively ask for specific feedback—then act on it visibly—so you have a concrete record of growth and course-correct early; and whenever you have a choice, optimize for a manager who will invest in your growth over a flashier title, because a great manager shapes how you think for the rest of your career.&lt;/p&gt;
&lt;p&gt;Lim candidly acknowledges survivorship bias and notes that none of these rules are absolute. When good work, a supportive manager, kindness, visibility, and mental health come into conflict, the right trade-off depends on your career stage, the skills you still need to build, personal circumstances, and how long a situation will last. When torn between options, a clarifying question is: what will still matter five years from now? Individual projects are almost always forgotten, whereas skills, mental models, and strong relationships keep compounding for decades.&lt;/p&gt;
&lt;h2 id="google-hits-50-ipv6"&gt;&lt;a href="https://blog.apnic.net/2026/04/28/google-hits-50-ipv6/" rel="noopener noreferrer"&gt;Google hits 50% IPv6&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In April 2026, Google&amp;rsquo;s public telemetry crossed the milestone of 50% of users connecting over IPv6, underscoring that IPv6 is now a mature pillar of the global Internet. At the same time, APNIC Labs measured global IPv6 adoption around 42%, and Geoff Huston explains why that gap isn&amp;rsquo;t a contradiction. APNIC&amp;rsquo;s measurement samples run via online ad placements whose impression volume varies across countries, and those per-economy numbers are then weighted by UN/ITU estimates of each country&amp;rsquo;s total Internet population—meaning the global aggregate depends heavily on sample distribution and weighting methodology. At the individual country level, APNIC&amp;rsquo;s figures track closely with Google&amp;rsquo;s and other measurement sources, making the 42%–50% range a solid band for global deployment.&lt;/p&gt;
&lt;p&gt;IPv6 adoption remains wildly uneven across regions, fixed-line ISPs, and mobile carriers. Slow migration doesn&amp;rsquo;t necessarily mean failure: many established ISPs are still amortizing heavy capital investments in IPv4 and CGNAT gear, whereas rapidly growing mobile networks often adopt IPv6 from day one to lower total cost of ownership—making transition a question of capital cycles and market economics rather than pure protocol superiority. Today&amp;rsquo;s Internet operates as a permanent dual-stack/translation hybrid across direct IPv4, NAT/CGNAT IPv4, and native IPv6, so clinging to IPv4 doesn&amp;rsquo;t avoid complexity either. Increasingly, interoperability is absorbed at the edge by CDNs, cloud load balancers, and dual-stack transit providers rather than requiring every backend system on earth to cut over simultaneously.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://www.manager.dev/newsletter/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post collects seven operational laws that engineers usually only internalize the hard way after living through production outages. First: if production breaks right after a deploy, roll back immediately (if safe to do so) to restore service and investigate afterward, instead of burning precious minutes trying to prove your commit couldn&amp;rsquo;t possibly be the cause. Second: backups don&amp;rsquo;t exist until you regularly test restoring from them, and the team knows the exact RPO, RTO, and who has permissions to run the restore. Third: logs must carry enough context and a cross-service correlation ID to trace a request end to end without drowning operators in noise.&lt;/p&gt;
&lt;p&gt;Fourth: every database migration must have a fast, concrete, pre-tested rollback plan before it touches production. Fifth: every external dependency will eventually be slow, rate-limit you, or go down completely, so understand its rate limits, failure impact, and SLAs up front and build fallbacks like caching, queues, or serving stale data. Sixth: use the four-eyes principle for risky manual operations in production—if you feel hesitant to wake a teammate up at 2 a.m. to double-check a command, that is the clearest sign you shouldn&amp;rsquo;t be running it alone. Finally, nothing is more permanent than a temporary hack, so even an MVP must be simple and solid enough to live with for years rather than a fragile patch you promise to clean up later.&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_!mGbr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8558b1b2-984f-4c42-bb23-e63a2252533c_2650x3068.png" alt="Top Anti-Patterns in Service Architecture"&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 #122</title><link>https://miti99.com/en/post/2026/07/10/</link><pubDate>Fri, 10 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #122.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-worst-take-in-tech-new-grad-hiring"&gt;&lt;a href="https://www.scottkennedy.us/new-grads" rel="noopener noreferrer"&gt;The worst take in tech: new grad hiring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Kennedy pushes back hard against the spreading narrative that companies should stop hiring new grads because AI can automate entry-level work. According to that argument, junior engineers historically learned the craft by doing simple tasks; now that AI handles those tasks, juniors won&amp;rsquo;t develop engineering judgment while budgets get spent on tokens instead. Kennedy calls this dead wrong: over the past year, he has seen the strongest new-grad talent pool in more than a decade of recruiting, and Replit doubled its new-grad hiring target to capitalize on it. Driven, curious, high-slope graduates can outperform many experienced hires within a couple of years when given strong mentorship and hard problems; writing them off because of AI is short-sighted.&lt;/p&gt;
&lt;p&gt;He also points out a distinct advantage of &amp;ldquo;AI-native&amp;rdquo; graduates: having grown up alongside modern AI tools, they have no legacy habits to unlearn and use AI coding workflows with natural fluency—something he sees repeatedly in interviews. Even so, the formula for succeeding as a junior engineer hasn&amp;rsquo;t changed: curiosity to dig beneath the surface and debug deeply, resilience to learn from failed attempts, humility to ask for help when stuck, and seeking out high-challenge environments. AI changes how the work gets done, but it doesn&amp;rsquo;t diminish the value of learning speed, grit, and judgment.&lt;/p&gt;
&lt;h2 id="parsing-gigabytes-of-json-per-second"&gt;&lt;a href="https://arxiv.org/pdf/1902.08318" rel="noopener noreferrer"&gt;Parsing Gigabytes of JSON per Second&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This paper introduces &lt;code&gt;simdjson&lt;/code&gt;, the first standard-compliant JSON parser capable of parsing gigabytes of JSON per second on a single core of a commodity CPU. The motivation is straightforward: JSON is ubiquitous across the web and distributed systems, and when applications ingest massive volumes of JSON documents, parsing easily becomes a primary CPU bottleneck despite decades of parser research.&lt;/p&gt;
&lt;p&gt;What sets &lt;code&gt;simdjson&lt;/code&gt; apart from prior validating parsers is its pervasive use of SIMD vector instructions, allowing the processor to inspect and classify dozens of bytes in parallel within a single instruction. As a result, &lt;code&gt;simdjson&lt;/code&gt; executes roughly one-quarter or fewer CPU instructions than RapidJSON—the fastest traditional parser benchmarked—while still performing full UTF-8 and structural validation. The authors released the library under a permissive open-source license, making the results easy to reproduce and enabling widespread adoption across the industry.&lt;/p&gt;
&lt;h2 id="six-sql-patterns-i-use-to-catch-transaction-fraud"&gt;&lt;a href="https://analytics.fixelsmith.com/posts/sql-fraud-patterns/" rel="noopener noreferrer"&gt;Six SQL patterns I use to catch transaction fraud&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post presents six practical SQL patterns as a first line of defense for catching anomalous transaction behavior across credit cards, e-commerce, and healthcare billing. The velocity pattern groups transactions into rolling time windows to spot rapid bursts of activity from a single cardholder; combining multiple window sizes catches both automated card-testing scripts firing in seconds and slower fraud sprees spread over hours. The impossible-travel pattern uses &lt;code&gt;LAG&lt;/code&gt; window functions paired with geographic distance formulas to flag a card used in two distant cities within an unrealistic timeframe. The suspicious-amount pattern hunts for small round test charges or transactions clustered just below reporting thresholds, while the merchant-anomaly pattern compares each merchant&amp;rsquo;s activity against its own historical baseline to spot compromised terminals.&lt;/p&gt;
&lt;p&gt;The off-hours pattern compares transaction timestamps against a cardholder&amp;rsquo;s normal spending hours, making it reliable only once an account has built up sufficient history. Finally, a feature-engineering pattern pre-computes derived window columns—such as seconds since previous transaction or trailing 24-hour spend—so combining multiple fraud signals becomes a simple &lt;code&gt;WHERE&lt;/code&gt; filter. No single rule is accurate enough in isolation, whereas a transaction tripping three or four patterns at once is almost certainly fraudulent. In production, queries still need careful &lt;code&gt;NULL&lt;/code&gt; handling, human review for false positives, and date-range partitioning before running window functions to keep warehouse costs in check.&lt;/p&gt;
&lt;h2 id="we-replaced-redis-with-mysql-for-inventory-reservationsand-it-scaled-2026"&gt;&lt;a href="https://shopify.engineering/scaling-inventory-reservations" rel="noopener noreferrer"&gt;We replaced Redis with MySQL for inventory reservations—and it scaled (2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shopify migrated its flash-sale inventory reservation system from Redis to MySQL so that temporary checkout reservations and the canonical inventory ledger live inside the exact same ACID transaction. Updating two separate stores without atomicity risks overselling or leaked reservations when failures happen mid-flight. Instead of storing a single quantity counter row per SKU—which would serialize every concurrent buyer behind a single row lock—the new schema represents each individual unit of inventory as its own row, capped at a pool of 1,000 rows per SKU-location pair so tables stay compact while queries remain fast even for massive stock counts. MySQL 8&amp;rsquo;s &lt;code&gt;SELECT ... FOR UPDATE SKIP LOCKED&lt;/code&gt; lets concurrent checkouts skip rows currently locked by other buyers instead of waiting in line, drastically cutting lock contention during flash sales. A composite primary key minimizes per-row lock overhead, &lt;code&gt;READ COMMITTED&lt;/code&gt; isolation prevents gap locks from blocking concurrent inventory restocks, and deterministic lock ordering prevents deadlocks.&lt;/p&gt;
&lt;p&gt;During rollout, however, the real bottleneck turned out to be connection pool exhaustion: database CPU sat low while requests queued up waiting for connections. Tagging queries with business workflow metadata and measuring at the proxy layer revealed unrelated checkout operations holding database connections open far too long. After cleaning up connection lifetimes and tuning configs, primary database reads dropped by 50%, total transactions fell by 33%, and writer CPU stayed below 50% even during peak flash sales. To migrate safely, Shopify dual-wrote to both Redis and MySQL while Redis remained primary, shadowed and compared results against live traffic, and shifted primary reads incrementally by cohort with instant rollback ready at every step.&lt;/p&gt;
&lt;h2 id="cell-based-architecture-for-resilient-payment-systems"&gt;&lt;a href="https://americanexpress.io/cell-based-architecture-for-resilient-payment-systems/" rel="noopener noreferrer"&gt;Cell-Based Architecture for Resilient Payment Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;American Express structures its core payment processing platform into self-contained cells, where each cell bundles its own services, databases, and supporting infrastructure. A cell is defined as a fault-isolation boundary rather than a specific deployment technology: an entire cell can fail, undergo maintenance, or be drained of traffic without impacting neighboring cells. Slowly changing reference data like currency exchange rates is replicated into every cell ahead of time to avoid synchronous cross-cell lookups, while stateful transactions are routed deterministically to the cell holding the authoritative state. A Global Transaction Router governs all ingress traffic and strictly forbids services inside one cell from calling directly into another; while this sometimes requires duplicating services across cells, it preserves hard fault isolation and keeps latency low.&lt;/p&gt;
&lt;p&gt;When a cell fails mid-transaction, in-flight requests aren&amp;rsquo;t resumed halfway through on another cell—they are replayed from the beginning on a healthy cell using the original request payload. That retry is safe because a globally unique transaction ID enforces end-to-end idempotency, allowing downstream systems to detect and deduplicate repeated work. Traffic shifts across cells gradually by percentage rather than flipping all at once. The platform also minimizes non-essential dependencies on the critical path by making audit logging and config refreshes asynchronous, gracefully degrading auxiliary features so payment authorization never stalls. True resilience comes from strict blast-radius boundaries and architectural discipline, not just monitoring and retries.&lt;/p&gt;
&lt;h2 id="when-failover-isnt-safe-building-high-availability-postgresql-on-kubernetes"&gt;&lt;a href="https://www.datadoghq.com/blog/engineering/postgresql-ha-kubernetes/" rel="noopener noreferrer"&gt;When failover isn’t safe: Building high-availability PostgreSQL on Kubernetes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;During a simulated availability-zone failure game day, Datadog discovered that their high-availability PostgreSQL clusters on Kubernetes could not fail over safely. When network latency spiked during the drill, the primary kept accepting writes and replicating asynchronously while standby replicas fell further and further behind. When the primary was terminated, Patroni rightly refused to promote any standby because their replication lag exceeded &lt;code&gt;maximum_lag_on_failover&lt;/code&gt;—preventing silent data loss, but leaving the cluster wedged and unable to accept writes until human operators intervened. The first lesson: nominal high availability means nothing if no replica is actually safe to promote when disaster strikes.&lt;/p&gt;
&lt;p&gt;Datadog moved to a hybrid replication topology: standby instances eligible for failover use synchronous replication, while read-only replicas stay asynchronous to avoid unnecessary latency penalties. In Patroni, they enabled &lt;code&gt;synchronous_mode&lt;/code&gt;, &lt;code&gt;synchronous_mode_strict&lt;/code&gt;, and &lt;code&gt;synchronous_commit = remote_apply&lt;/code&gt;, guaranteeing a transaction is acknowledged only after its WAL records have been replayed and applied on the synchronous standby. Synthetic benchmarks at this highest durability setting showed average write latency increasing by 53% and throughput dropping by 34%, but rolling the change out gradually across datacenters with soak periods confirmed that real-world application impact remained well within acceptable bounds. If all synchronous standbys become unavailable, the primary halts writes rather than silently risking data loss, turning an invisible durability hazard into an explicit error that callers can retry or queue. Balancing durability and performance requires actively monitoring &lt;code&gt;SyncRep&lt;/code&gt; wait events alongside standby health.&lt;/p&gt;
&lt;h2 id="from-christmas-outage-to-1-app-store-ranking-an-aura-frames-postgres-scaling-retrospective"&gt;&lt;a href="https://andyatkinson.com/postgresql-rds-scaling-aws-christmas-day-peak" rel="noopener noreferrer"&gt;From Christmas Outage to #1 App Store Ranking: An Aura Frames Postgres Scaling Retrospective&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On Christmas Day 2024—the biggest traffic day of the year for digital photo frames—Aura Frames suffered a three-hour PostgreSQL outage when unbounded WAL growth filled their dedicated WAL volume. The culprit was an RDS PostgreSQL 14.1 default that attached replication slots to read replicas: a replication slot forces the primary to retain WAL segments until every replica has consumed them, so when a replica fell behind under holiday load, WAL piled up until the primary ran out of disk space and crashed. The team immediately capped slot retention using &lt;code&gt;max_slot_wal_keep_size&lt;/code&gt; (noting that &lt;code&gt;wal_keep_size&lt;/code&gt; sets a minimum floor, not a ceiling), choosing to invalidate a lagging replica rather than let the primary go down.&lt;/p&gt;
&lt;p&gt;To prepare for Christmas 2025, instead of vertically scaling a single massive primary again, Aura partitioned at the table level (functional sharding): the ten highest-write tables were split out onto seven new primaries, creating eight databases in total. This proved a pragmatic middle ground before needing horizontal row sharding on their largest table. The Ruby on Rails monolith stayed intact, routing queries cleanly via Active Record Multiple Databases, while physical replication moved data over with just 5–10 minutes of cutover downtime. Total provisioned CPU and memory increased roughly 4.7x, and on Christmas Day 2025 the system peaked at 226,000 transactions per second—sustaining over 100,000 TPS for ten straight hours at an average query latency of 25 microseconds. Continuous testing, canary rollouts, and load testing de-risked the data-access changes; temporarily over-provisioning for a predictable annual peak made complete sense, and AWS Blue/Green deployments let them scale the fleet back down afterward to restore cost efficiency.&lt;/p&gt;
&lt;h2 id="gitignore-isnt-the-only-way-to-ignore-files-in-git"&gt;&lt;a href="https://nelson.cloud/.gitignore-isnt-the-only-way-to-ignore-files-in-git/" rel="noopener noreferrer"&gt;.gitignore Isn’t the Only Way To Ignore Files in Git&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Git supports three distinct scopes for ignoring files, each suited to a different job. &lt;code&gt;.gitignore&lt;/code&gt; is committed into the repository, making it the right place for project-wide rules shared by every contributor, like build outputs and dependency folders. &lt;code&gt;.git/info/exclude&lt;/code&gt; lives inside your local &lt;code&gt;.git&lt;/code&gt; directory and is never tracked or pushed, applying only to your local clone—ideal for personal scratch files, local scripts, or project-specific tool configs that don&amp;rsquo;t belong in the team&amp;rsquo;s shared &lt;code&gt;.gitignore&lt;/code&gt;. Finally, &lt;code&gt;~/.config/git/ignore&lt;/code&gt; acts as your user-wide global ignore file across every repository on your machine, perfect for OS- or editor-generated noise like macOS &lt;code&gt;.DS_Store&lt;/code&gt; files or editor swap files.&lt;/p&gt;
&lt;p&gt;You can customize the location of the global ignore file via &lt;code&gt;git config --global core.excludesFile ~/.gitignore_global&lt;/code&gt; and reset it to the default with &lt;code&gt;git config --global --unset core.excludesFile&lt;/code&gt;. And whenever you aren&amp;rsquo;t sure which rule across those three layers is causing a file to be ignored, &lt;code&gt;git check-ignore -v &amp;lt;path&amp;gt;&lt;/code&gt; is the fastest way to debug it: the command prints the exact ignore file, line number, and pattern that matched—or outputs nothing if the file isn&amp;rsquo;t ignored.&lt;/p&gt;
&lt;h2 id="the-only-scalable-delete-in-postgres-is-drop-table"&gt;&lt;a href="https://planetscale.com/blog/the-only-scalable-delete" rel="noopener noreferrer"&gt;The only scalable delete in Postgres is DROP TABLE&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In PostgreSQL, running a large &lt;code&gt;DELETE&lt;/code&gt; doesn&amp;rsquo;t immediately free disk space—it creates a mountain of follow-up work for the database. Under MVCC, deleted rows remain on disk as dead tuples so concurrent transactions can still see a consistent snapshot; autovacuum eventually marks that space reusable internally, but rarely shrinks the underlying data files on disk (except when completely empty pages sit at the very end of a relation), and indexes and sequential scans still pay the cost of skipping over dead tuples in the meantime. Mass deletes also generate heavy WAL volume that must be replicated downstream, inflating write latency, vacuum debt, and replica lag—while cascading foreign-key deletes can unexpectedly amplify a small delete into gigabytes of churn. &lt;code&gt;VACUUM FULL&lt;/code&gt; reclaims OS disk space, but only by taking an expensive exclusive table lock and rewriting the entire table.&lt;/p&gt;
&lt;p&gt;By contrast, &lt;code&gt;DROP TABLE&lt;/code&gt; and &lt;code&gt;TRUNCATE&lt;/code&gt; acquire an &lt;code&gt;AccessExclusiveLock&lt;/code&gt; but execute in nearly constant time regardless of row count: they unlink the underlying physical files directly without generating per-row dead tuples or vacuum debt. Consequently, schemas that need regular bulk purges should be designed so large deletes become table drops. For time-series or retention-bound data, time-based table partitioning turns recurring deletes into instantly dropping the oldest partition. For a one-off cleanup where most rows are being deleted, copying the surviving rows into a temporary table, running &lt;code&gt;TRUNCATE&lt;/code&gt; on the original, and inserting them back avoids per-row delete WAL (though structural and re-insert WAL still applies); if you cannot afford a long lock, you can dual-write and backfill into a fresh table before swapping names in a brief transaction, taking care to handle foreign keys, sequences, and concurrent writes. When the rows to delete are a small fraction of the table, batched deletes in small transactions remain the practical choice so autovacuum can keep up between batches.&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 #121</title><link>https://miti99.com/en/post/2026/07/09/</link><pubDate>Thu, 09 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #121.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dial-up"&gt;&lt;a href="https://jkm.dev/posts/how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dialup/" rel="noopener noreferrer"&gt;How 2004 RuneScape fit a multiplayer RPG into 56k dial-up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post dissects how 2004 RuneScape ran a massively multiplayer world over 56k dial-up modems, where real-world throughput was just a few kilobytes per second and the Java applet client had only a single TCP connection. Rather than sending self-describing messages, the network protocol was co-designed as a shared state machine between client and server: both sides held the exact same collision map, ran the same pathfinding algorithm, and stepped forward on a 600 ms server tick. Thanks to all that shared implicit context never having to cross the wire, walking across the map cost roughly 7 bytes upstream and 9 bytes downstream per observer—the client only sent path waypoints where direction changed, and the server validated and reconstructed the rest.&lt;/p&gt;
&lt;p&gt;The most fascinating takeaway is how saving bytes goes far beyond generic compression. The most common state was made practically free: an idle player in your viewport cost a single bit, meaning standing among twenty stationary players took roughly five bytes per tick to confirm nothing changed. Newly appearing players were encoded using 5-bit relative coordinates offset from the local player rather than 16-bit global world coordinates. Bit-packing was reserved strictly for small, high-frequency movement updates; larger, rarely changing appearance blocks stayed byte-aligned so the server could cache and memcpy pre-built buffers directly. The architectural lesson: the smallest possible wire format comes from tightly coupling client and server assumptions, trading away the self-description, independent deployability, and easy debugging that modern HTTP/JSON APIs prioritize.&lt;/p&gt;
&lt;h2 id="how-does-struct-take-zero-bytes-in-go"&gt;&lt;a href="https://www.bud1m.com/blog/go-empty-struct/" rel="noopener noreferrer"&gt;How does struct{} take zero bytes in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why Go&amp;rsquo;s empty struct &lt;code&gt;struct{}&lt;/code&gt; occupies zero bytes and how it is idiomatically used to represent presence or signaling rather than data. Inspecting &lt;code&gt;unsafe.Sizeof&lt;/code&gt; confirms that an empty struct takes 0 bytes; used as the value type in &lt;code&gt;map[string]struct{}&lt;/code&gt;, it expresses a pure set where only key existence matters, and on a channel (&lt;code&gt;chan struct{}&lt;/code&gt;) it signals an event without carrying a payload. The author also notes that starting in Go 1.24, Go&amp;rsquo;s built-in maps use Swiss Tables under the hood, leaving almost no meaningful memory difference between &lt;code&gt;map[string]struct{}&lt;/code&gt; and &lt;code&gt;map[string]bool&lt;/code&gt;—so choosing &lt;code&gt;struct{}&lt;/code&gt; today is mainly about expressing intent clearly.&lt;/p&gt;
&lt;p&gt;At the runtime level, whenever a zero-sized value has to be allocated on the heap, &lt;code&gt;mallocgc&lt;/code&gt; checks for &lt;code&gt;size == 0&lt;/code&gt; and returns a pointer to a single global runtime variable named &lt;code&gt;zerobase&lt;/code&gt; instead of allocating heap memory. Whether the value escapes to the heap in the first place is decided by escape analysis: passing it to &lt;code&gt;fmt.Println&lt;/code&gt; (which takes &lt;code&gt;any&lt;/code&gt;) often triggers an escape to &lt;code&gt;zerobase&lt;/code&gt;, whereas built-in &lt;code&gt;println&lt;/code&gt; keeps it on the stack. This design creates two subtle gotchas worth remembering. First, multiple distinct &lt;code&gt;struct{}&lt;/code&gt; variables may share the exact same memory address, and the compiler is free to merge or not merge them, so you should never rely on pointer equality to distinguish zero-sized values. Second, placing a &lt;code&gt;struct{}&lt;/code&gt; as the final field inside a larger non-empty struct causes the compiler to add 1 byte of trailing padding (plus alignment) so that taking the address of that final field doesn&amp;rsquo;t point past the end of the allocation into an adjacent object; if you want zero overhead inside a struct, place the empty struct field anywhere except last.&lt;/p&gt;
&lt;h2 id="is-cloudflare-silently-killing-the-web-hosting-industry"&gt;&lt;a href="https://webhosting.today/2026/06/17/is-cloudflare-silently-killing-the-web-hosting-industry/" rel="noopener noreferrer"&gt;Is Cloudflare silently killing the web hosting industry?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Konrad Keck argues that Cloudflare isn&amp;rsquo;t killing traditional web hosting by becoming a better shared host—it is doing it by moving the starting point of how websites get built and deployed. Historically, a customer bought a domain, signed up for shared hosting, logged into cPanel, installed WordPress, configured SSL and email, and maybe put Cloudflare in front later for CDN and DDoS protection. Today, when a project starts inside Claude Code, Cursor, Lovable, Bolt, or Replit, the question is no longer &amp;ldquo;which hosting plan do I buy?&amp;rdquo; but &amp;ldquo;where do I deploy this?&amp;rdquo;, and Cloudflare, Vercel, and Netlify are built to capture that exact moment. Cloudflare is competing on workflow, not just infrastructure.&lt;/p&gt;
&lt;p&gt;Keck highlights two main levers: near-zero-cost deployment via Pages, Workers, static assets, and usage-priced R2/D1—which hollows out traditional hosting&amp;rsquo;s bread-and-butter market of landing pages, docs sites, frontends, and small APIs—and at-cost domain registration as a top-of-funnel wedge into the ecosystem. Cloudflare&amp;rsquo;s Registrar API closes the loop even further: an AI agent can scaffold a project, suggest available domains, check pricing, register the domain, configure DNS, and deploy to production without the user ever visiting a hosting control panel. Traditional web hosts aren&amp;rsquo;t disappearing overnight—legacy WordPress/WooCommerce and PHP apps, real business email, hands-on migrations, emergency support, local compliance, and non-technical SMBs still rely on human-backed services. The strategic shift is that traditional hosts must evolve into specialized managed service providers, because selling the default starting point of a website is slipping away.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://staysaasy.com/startups/2026/06/16/stacked-weaknesses.html" rel="noopener noreferrer"&gt;Don&amp;rsquo;t Stack Weaknesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy writes about an organizational failure mode that often hides in plain sight across leadership chains: stacking the same weakness across multiple layers of management. Almost every leader has at least one real weakness—someone might be a visionary strategist but poor at operational execution, or deeply technical but weak at executive communication—and on its own, that doesn&amp;rsquo;t sink an org. The danger comes when a leader hires or promotes direct reports who share the exact same blind spot. If both a VP and their directors are weak at operations, the odds of the teams underneath them having strong operational processes drop to nearly zero: leadership doesn&amp;rsquo;t know how to do it themselves, doesn&amp;rsquo;t know how to interview for it, and can&amp;rsquo;t accurately judge whether it&amp;rsquo;s being done well.&lt;/p&gt;
&lt;p&gt;Weakness stacking usually happens unconsciously: leaders naturally recognize and reward strengths that mirror their own, labeling that similarity &amp;ldquo;values alignment&amp;rdquo; or &amp;ldquo;culture fit&amp;rdquo; while actually cloning their own skillset and blind spots. Avoiding the trap starts with an honest self-assessment across six core axes—technical/domain depth, people management, process and operations, strategy, communication/presentation, and learning agility—and then deliberately hiring people who are significantly stronger than you in your weakest areas. The post also warns against comforting yourself with &amp;ldquo;I could do operations if I really wanted to,&amp;rdquo; which is almost always an excuse to avoid confronting a gap. An organization without stacked weaknesses is far more resilient to unexpected challenges.&lt;/p&gt;
&lt;h2 id="system-design-cheatsheet"&gt;&lt;a href="https://gist.github.com/SuyashDive2005/be5865a9755ca1dd50523f7aeeae4417" rel="noopener noreferrer"&gt;System Design Cheatsheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This gist serves as a compact checklist for system design interviews and architecture reviews, anchored on a core principle: good architecture is about picking the right battles and managing trade-offs. It outlines a familiar five-step loop: clarify scope through use cases and constraints; sketch a high-level design covering core services, storage, caching, and load balancing; dive into component details including APIs and data schemas; identify bottlenecks; and scale vertically or horizontally as needed. For newer engineers, its biggest value is forcing quantitative questions early, before jumping to technology choices: how many requests per second, what is the read-to-write ratio, how fast does data grow, does latency or throughput matter more, and where does the system sit on the consistency-versus-availability spectrum?&lt;/p&gt;
&lt;p&gt;The scaling section reviews foundational building blocks: multi-tier caching, load balancing, replication and sharding, MapReduce for batch data processing, and platform separation so components can scale independently. It also lists six core fundamentals worth mastering: concurrency, networking, abstraction boundaries, real-world hardware performance numbers, back-of-the-envelope estimation to rule out dead ends early, and fault tolerance in distributed environments. While brief and carrying a few older examples, it remains a solid mental checklist: characterize load, data shape, failure modes, and scaling paths before picking tools.&lt;/p&gt;
&lt;h2 id="sqlite-improving-performance-with-pre-sort"&gt;&lt;a href="https://andersmurphy.com/2026/06/07/sqlite-improving-performance-with-pre-sort.html" rel="noopener noreferrer"&gt;SQLite improving performance with pre-sort&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anders Murphy follows up on his earlier SQLite UUIDv4 vs. UUIDv7 benchmarks with a tougher scenario: what happens when your primary key must be a 160-bit cryptographically random value generated via &lt;code&gt;SecureRandom&lt;/code&gt;—such as a session token—where you cannot switch to time-ordered UUIDv7 because you need maximum entropy and zero timestamp leakage? When batch-inserting one million rows into a &lt;code&gt;WITHOUT ROWID&lt;/code&gt; table keyed by a &lt;code&gt;BLOB PRIMARY KEY&lt;/code&gt;, insert throughput starts around 100,000 rows per second and steadily degrades as the table grows. The bottleneck isn&amp;rsquo;t SQLite being slow; it&amp;rsquo;s the physics of a B+ Tree: because the tree stores keys in sorted order, sequential inserts append cleanly, whereas uniformly random keys scatter writes across leaf pages all over disk, triggering constant page splits and tree rebalancing.&lt;/p&gt;
&lt;p&gt;Murphy&amp;rsquo;s optimization is disarmingly simple: since the application is already inserting in batches, sort each batch in memory by primary key before inserting. Because SQLite compares &lt;code&gt;BLOB&lt;/code&gt; keys using &lt;code&gt;memcmp()&lt;/code&gt;, the application-side comparator just needs to match byte-wise ordering; Murphy grabs the first 8 bytes of each 20-byte token as an unsigned 64-bit integer to make the in-memory sort fast. Even including the CPU cost of sorting each batch, once the table reaches ten million rows, batch insert time drops from 11.1 seconds to 3.8 seconds—roughly a 2–3x speedup. The practical takeaway: batching doesn&amp;rsquo;t just amortize transaction overhead; it also gives you a window to reorder writes into a layout that is far friendlier to the underlying storage engine.&lt;/p&gt;
&lt;h2 id="why-is-meta-destroying-its-engineering-organization"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/why-is-meta-destroying-its-engineering" rel="noopener noreferrer"&gt;Why is Meta destroying its engineering organization?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz pieces together a tense picture of engineering inside Meta since April 2026, as the company pivots aggressively around AI. Historically, Meta was renowned for its strong bottom-up engineering culture: lightweight process, high individual autonomy, rock-solid internal tooling that let engineers &amp;ldquo;move fast,&amp;rdquo; and engineers treated as the core value creators. Under the direction of Mark Zuckerberg and Alexandr Wang, however, 30–50% of core software engineers across many teams—including infrastructure and security—were reassigned into a new ADO organization (roughly 6,500 people) to do data labeling, model output grading, and RLHF. Meta also rolled out mandatory keystroke and mouse tracking on engineering laptops to harvest training data with no opt-out (later walked back slightly after internal backlash), alongside ongoing layoff pressure and AI token-usage quotas.&lt;/p&gt;
&lt;p&gt;What stands out most isn&amp;rsquo;t just &amp;ldquo;Meta is pushing AI hard,&amp;rdquo; but how badly perverse incentives distort behavior. Once AI token consumption became a performance metric, engineers naturally gamed the metric (burning 60.2 trillion tokens in 30 days) rather than optimizing for software quality. And when AI-generated code reviewed only by AI gets pushed rapidly to production while security teams are gutted and reassigned, operational risk compounds fast: Orosz connects these dynamics to the May 30 Instagram account-takeover incident and the departure of Meta&amp;rsquo;s CISO shortly afterward. The broader lesson is not to confuse fast MTTR with system health: recovering quickly from outages cannot compensate for eroding human comprehension, weakened guardrails, and hollowed-out engineering ownership.&lt;/p&gt;
&lt;h2 id="cs-6120-advanced-compilers-the-self-guided-online-course"&gt;&lt;a href="https://www.cs.cornell.edu/courses/cs6120/2025fa/self-guided/" rel="noopener noreferrer"&gt;CS 6120: Advanced Compilers: The Self-Guided Online Course&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page hosts the self-guided version of CS 6120, Adrian Sampson&amp;rsquo;s PhD-level course at Cornell on programming language implementation and modern compilers. The curriculum progresses from core compiler foundations—intermediate representations, dataflow analysis, local and global optimizations, SSA form, and LLVM—into research-adjacent topics like dynamic compilers (JITs), garbage collection, parallelism, and fast compilation. Each lesson pairs lecture videos and written notes with classic academic papers and open-ended implementation tasks to turn abstract theory into working code.&lt;/p&gt;
&lt;p&gt;The self-guided track preserves the linear structure of the university course while removing deadlines, grading, and internal class discussion boards. Learners follow a clear rhythm: watch the lecture, read the companion paper, and implement compiler passes using either LLVM or Bril—a small, pedagogical intermediate representation designed to be much easier to hack on than jumping straight into a production compiler—culminating in a final project. It is an outstanding resource for internalizing that a compiler isn&amp;rsquo;t just &amp;ldquo;a parser bolted onto a code generator,&amp;rdquo; but a pipeline of representation choices, program analyses, optimizations, and trade-offs between correctness, compile time, and generated code quality. The best way to use it is writing the small transformation passes yourself as you go, since compiler concepts are notoriously easy to misunderstand if you only read about them.&lt;/p&gt;
&lt;h2 id="epoll-vs-io_"&gt;&lt;a href="https://sibexi.co/posts/epoll-vs-io_uring/" rel="noopener noreferrer"&gt;epoll vs io_uring in Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares &lt;code&gt;epoll&lt;/code&gt; and &lt;code&gt;io_uring&lt;/code&gt; through the lens of building TinyGate, a lightweight reverse proxy in C. The first prototype used a simple thread-per-worker model that was easy to reason about but hit a hard performance ceiling; moving to &lt;code&gt;epoll&lt;/code&gt; delivered a major speedup, yet still paid the fundamental tax of a readiness-based model: &lt;code&gt;epoll&lt;/code&gt; only tells you when a file descriptor is ready for I/O, leaving the application to issue its own &lt;code&gt;read()&lt;/code&gt; or &lt;code&gt;write()&lt;/code&gt; syscalls afterward. Every I/O event therefore incurs syscall and context-switch overhead on top of &lt;code&gt;epoll_ctl&lt;/code&gt; registration, which adds up quickly across tens of thousands of active connections.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;io_uring&lt;/code&gt; shifts to a completion-based model: the application writes I/O requests into a submission queue in shared memory, the kernel executes them asynchronously, and results land in a shared completion queue. A single &lt;code&gt;io_uring_enter()&lt;/code&gt; call can submit and harvest an entire batch of operations instead of paying a syscall per &lt;code&gt;read()&lt;/code&gt;/&lt;code&gt;write()&lt;/code&gt;. Enabling &lt;code&gt;IORING_SETUP_SQPOLL&lt;/code&gt; can even eliminate steady-state syscalls almost entirely, at the cost of dedicating a kernel thread that spins and consumes CPU to poll the submission ring. While the author recommends considering &lt;code&gt;io_uring&lt;/code&gt; for new high-performance Linux projects (available since Linux 5.1, though specific opcodes depend on kernel version), he cautions that production use requires care: using rings or registered buffers doesn&amp;rsquo;t automatically guarantee zero-copy I/O, errors arrive asynchronously via completion queue entries, and minimal tutorial examples omit many edge-case checks required in real servers.&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 #110</title><link>https://miti99.com/en/post/2026/06/07/</link><pubDate>Sun, 07 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #110.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-podcast--086-just-use-postgres-man"&gt;&lt;a href="https://share.transistor.fm/s/5159e8a9" rel="noopener noreferrer"&gt;go podcast() | 086: Just use postgres, man&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this podcast episode, Dominic St-Pierre and Morten Vistisen revolve around a familiar question: should you store telemetry data in ClickHouse or just stick with PostgreSQL? Morten wants to try ClickHouse, while Dominic takes the pragmatic stance: below roughly 10 million rows, PostgreSQL performs nearly as well, and scaling rarely happens overnight, leaving plenty of time to migrate when you actually need to. Morten also recounts having to rewrite a component in his DeployQuad project because the LLM-generated code from the initial prototype didn&amp;rsquo;t behave as expected, underscoring the importance of truly understanding the code you ship.&lt;/p&gt;
&lt;p&gt;Dominic introduces StaticBackend v1.7.0, adding multi-account user support and expanded server-side functions powered by Goja (a JavaScript runtime written in Go), while lamenting how tedious releases are when updating multiple NPM packages compared to Go&amp;rsquo;s simple tag-and-push workflow. Toward the end, both hosts express skepticism about over-relying on AI code generation: it disrupts deep flow states while programming, causes skills to atrophy, and may not even deliver a net productivity gain. They remain convinced that core programming skills are as valuable as ever.&lt;/p&gt;
&lt;h2 id="that-one-time-i-used-go-panics-for-flow-control"&gt;&lt;a href="https://noncrab.net/posts/panic-as-flow-control/" rel="noopener noreferrer"&gt;That one time I used Go panics for flow control&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author recounts an overload incident on an in-memory Go data service: when query volume exceeded capacity, requests that normally took 1–2 seconds stretched to a full minute, and upstream retries only piled on more load. The root problem was that Go&amp;rsquo;s standard library sorting functions neither accept a &lt;code&gt;context&lt;/code&gt; nor return an error, so the service kept burning CPU cycles sorting results for queries whose callers had already timed out and walked away. That library design is normally reasonable, since sorting usually happens in batch jobs or over slices small enough that execution time is negligible.&lt;/p&gt;
&lt;p&gt;Rather than rewriting the entire sorting layer, the team used a &lt;code&gt;panic&lt;/code&gt;/&lt;code&gt;recover&lt;/code&gt; pair as an escape hatch: the comparison function checks whether the &lt;code&gt;context&lt;/code&gt; has been canceled and, if so, calls &lt;code&gt;panic&lt;/code&gt; with a dedicated sentinel value. A &lt;code&gt;defer&lt;/code&gt; wrapper around the sort catches that specific sentinel &lt;code&gt;panic&lt;/code&gt; and converts it into a normal error while re-panicking on anything else so real bugs aren&amp;rsquo;t swallowed. That let the system abort useless sorts immediately. The author readily admits this is &amp;ldquo;an ugly solution to an ugly problem,&amp;rdquo; strictly for narrow, tightly controlled situations.&lt;/p&gt;
&lt;h2 id="the-last-six-months-in-llms-in-five-minutes"&gt;&lt;a href="https://simonwillison.net/2026/May/19/5-minute-llms/" rel="noopener noreferrer"&gt;The last six months in LLMs in five minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is the annotated version of Simon Willison&amp;rsquo;s lightning talk at PyCon US 2026, recapping developments in large language models from November 2025 through May 2026. The standout trend is that coding agents crossed a decisive quality threshold: thanks to OpenAI and Anthropic applying reinforcement learning with verifiable rewards throughout 2025, agents went from &amp;ldquo;often works&amp;rdquo; to &amp;ldquo;almost always works&amp;rdquo; and became everyday workhorses. In November alone, the title of &amp;ldquo;best model&amp;rdquo; changed hands five times between Anthropic, OpenAI, and Google, while Willison continued using his signature benchmark of asking models to generate an SVG of a pelican riding a bicycle.&lt;/p&gt;
&lt;p&gt;The second major trend is local open-weight models blowing past expectations, including Google&amp;rsquo;s Gemma 4 family, China&amp;rsquo;s GLM-5.1, and Qwen3.6-35B-A3B, which weighs in at roughly 21GB and runs comfortably on a standard laptop. The talk also highlights OpenClaw, a personal AI assistant project that went so viral that &amp;ldquo;Claws&amp;rdquo; became the generic term for the entire category of personal agents and Mac Minis sold out as people bought them to run Claws at home.&lt;/p&gt;
&lt;h2 id="prompts-are-technical-debt-too"&gt;&lt;a href="https://www.seangoedecke.com/prompts-are-technical-debt-too/" rel="noopener noreferrer"&gt;Prompts are technical debt too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that prompts — including instruction files like &lt;code&gt;AGENTS.md&lt;/code&gt; and &lt;code&gt;CLAUDE.md&lt;/code&gt; — are a form of technical debt, and in some ways worse than code debt. When code doesn&amp;rsquo;t change, its behavior stays largely the same, and when it breaks it usually fails loudly; prompts, by contrast, silently degrade every time the underlying model is upgraded. A prompt painstakingly tuned to work around an older model&amp;rsquo;s quirks can become useless or actively counterproductive on a newer model without anyone noticing. According to Goedecke, an agent harness with elaborate prompts wrapped around an older model will almost always lose to a minimal harness running a newer model.&lt;/p&gt;
&lt;p&gt;From there, he offers concrete advice: stick to mainstream AI coding tools like Claude Code, Cursor, or Copilot with their default configurations, since their engineering teams continuously re-tune the system prompts for you; avoid installing extra MCP servers or skills unless strictly necessary; if you must write an &lt;code&gt;AGENTS.md&lt;/code&gt;, stick to core factual details about the project rather than trying to micromanage model behavior, and never check in model-generated instructions without reviewing them carefully. Finally, regularly prune custom prompts to keep maintenance overhead low.&lt;/p&gt;
&lt;h2 id="we-see-something-that-works-and-then-we-understand-it"&gt;&lt;a href="https://lemire.me/blog/2025/12/04/we-see-something-that-works-and-then-we-understand-it/" rel="noopener noreferrer"&gt;We see something that works, and then we understand it&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire pushes back against the &amp;ldquo;linear model of innovation&amp;rdquo; — the belief that theoretical understanding must come first and practical progress follows afterward. Borrowing Kevin Kelly&amp;rsquo;s term &amp;ldquo;thinkism,&amp;rdquo; he critiques the illusion that thinking hard enough in the abstract can solve any problem. That mindset dominates schools and bureaucracies, where rules are fixed in advance: students learn a concept first and then solve textbook problems designed to require only that exact concept. History usually works the other way around: pendulum clocks were keeping time in 1656, well before Newton and Hooke formulated the laws of force and motion that explained why they worked.&lt;/p&gt;
&lt;p&gt;In Lemire&amp;rsquo;s view, real R&amp;amp;D always happens with incomplete understanding; people entering industry often learn more in a single year on the job than across their entire university degree because real-world engineering demands continuous experimentation and observation. He draws two lessons: breakthroughs require prioritizing hands-on experimentation over abstract theorizing, and we shouldn&amp;rsquo;t expect AI to solve every complex problem purely from existing knowledge, because the physical world is always richer and messier than what we already know.&lt;/p&gt;
&lt;h2 id="how-vercel-cut-build-wait-times-from-90-seconds-to-5"&gt;&lt;a href="https://blog.bytebytego.com/p/how-vercel-cut-build-wait-times-from" rel="noopener noreferrer"&gt;How Vercel Cut Build Wait Times From 90 Seconds To 5&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article examines how Vercel cut build environment provisioning wait times from 90 seconds down to 5 seconds — an 18x speedup — using an internal platform called Hive. The core challenge is that Vercel runs untrusted build code from thousands of customers on shared hardware, meaning every build must be treated as potentially hostile. Standard containers aren&amp;rsquo;t isolated enough because they share the host Linux kernel, where a single kernel vulnerability could expose another customer&amp;rsquo;s workload. Instead of Kubernetes, Vercel built Hive on AWS Firecracker microVMs: each build runs inside a &amp;ldquo;cell&amp;rdquo; — a tiny virtual machine with its own dedicated kernel that boots in roughly 125 milliseconds. The architecture spans regional clusters where physical &amp;ldquo;boxes&amp;rdquo; host multiple cells, coordinated by a control plane.&lt;/p&gt;
&lt;p&gt;The speedup comes from three compounding optimizations: container image caching and disk snapshots cut cold starts from ~50 seconds down to 5 seconds; a warm pool of pre-booted cells waiting for work means most builds experience near-zero queue wait; and Firecracker&amp;rsquo;s millisecond boot times make maintaining and replenishing that warm pool economical. The trade-off is that keeping warm cells idle consumes resources and every cell must be destroyed after a single build for security, but owning the underlying infrastructure has unlocked new product capabilities for Vercel.&lt;/p&gt;
&lt;h2 id="the-anatomy-of-an-ai-native-org"&gt;&lt;a href="https://ajeygore.in/content/the-anatomy-of-an-ai-native-org" rel="noopener noreferrer"&gt;The Anatomy of an AI-Native Org&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ajey Gore argues that AI is reshaping organizational structure by eliminating the &amp;ldquo;translation layer.&amp;rdquo; For thirty years, software companies have operated across three tiers: leadership decides the &amp;ldquo;Why,&amp;rdquo; product defines the &amp;ldquo;What,&amp;rdquo; and engineering translates those decisions into code — the &amp;ldquo;How.&amp;rdquo; Much of the day-to-day work in that model consists of translating between well-defined inputs and outputs. According to Gore, AI doesn&amp;rsquo;t target a specific job title so much as that entire category of translation work — turning requirements into code or specs into UI components — making it orders of magnitude cheaper, while the strategic work at both ends remains just as hard as ever.&lt;/p&gt;
&lt;p&gt;The shape of an &amp;ldquo;AI-Native&amp;rdquo; organization shifts accordingly: the &amp;ldquo;Why&amp;rdquo; layer stays small; the &amp;ldquo;What&amp;rdquo; layer expands because judgment and taste become critical when directing AI; the human &amp;ldquo;How&amp;rdquo; layer shrinks sharply in headcount but rises in difficulty, focusing on architecture, security, and verification mechanisms that make AI output trustworthy; and AI agents handle routine translation under human supervision. Managers can no longer just coordinate — they must contribute directly — while engineers should move toward problem definition rather than competing with AI on raw code translation.&lt;/p&gt;
&lt;h2 id="how-to-stay-resilient-in-a-difficult-job"&gt;&lt;a href="https://andiroberts.com/executive-coaching/how-to-stay-resilient-in-a-difficult-job" rel="noopener noreferrer"&gt;How to Stay Resilient in a Difficult Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article outlines 7 practical, science-backed strategies for maintaining mental resilience when stuck in a difficult job — whether dealing with a poor manager, irregular shifts, or chronic stress. The author stresses that resilience here doesn&amp;rsquo;t mean forcing toxic positivity or pretending the job is fun; it means conserving energy, keeping an objective perspective, and maintaining a sense of agency so you can do good work, protect your health, and stay positioned for future moves.&lt;/p&gt;
&lt;p&gt;The strategies include: grounding yourself mentally at the start of the day and stabilizing your physiology with sunlight, hydration, and movement before work; focusing strictly on what lies within your control and upholding your own professional standards even when surrounding systems are messy; setting emotional boundaries so you don&amp;rsquo;t carry work stress home; finding at least one trusted colleague to confide in; and consistently taking small steps toward landing a better role.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://brooker.co.za/blog/2026/05/18/whats-easy-whats-hard.html" rel="noopener noreferrer"&gt;What&amp;rsquo;s Easy Now? What&amp;rsquo;s Hard Now?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker proposes the &amp;ldquo;feedback loop hypothesis&amp;rdquo;: over the long run, AI coding agents will find tasks with clear, measurable feedback loops &amp;ldquo;easy,&amp;rdquo; while tasks lacking effective automated feedback will remain &amp;ldquo;hard&amp;rdquo; — and this divide will be the primary determinant of agent capability. Opening with an analogy from electrical engineering, he notes that strong negative feedback can turn simple, nonlinear, even flawed components into remarkably accurate amplifiers.&lt;/p&gt;
&lt;p&gt;From that premise, he flips the conventional wisdom that web development is easy and systems programming is hard. A database storage engine like RocksDB has a relatively compact specification — an API plus safety and liveness properties — that can be verified automatically. Web development, by contrast, lacks an equivalent automated oracle and relies on slow, inconsistent human judgment. Current practice already reflects this: agents excel at performance optimization when given a solid benchmark suite, struggle with subjective architectural trade-offs, and get guided toward correct code in languages like Rust thanks to strict compiler errors. Consequently, formal specification languages, compile-time checks, and rigorous testing frameworks will only grow in importance.&lt;/p&gt;
&lt;h2 id="making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use"&gt;&lt;a href="https://medium.com/pinterest-engineering/making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use-2a56a928cae1" rel="noopener noreferrer"&gt;Making User-Sequence Data More Cost-Efficient, Faster, and Easier to Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest&amp;rsquo;s engineering team shares how they redesigned their user-sequence data platform — the ordered history of a user&amp;rsquo;s recent actions enriched with signals like embeddings, device context, and country. This data powers ML ranking, retrieval, and recommendation models across the Home feed, Related Pins, and search results, serving training pipelines, offline analytics, and real-time inference alike. Because it must be simultaneously fresh, complete, consistent between training and serving, and schema-stable, it is often one of the most expensive and brittle parts of a data stack.&lt;/p&gt;
&lt;p&gt;The core principle of the redesign is &amp;ldquo;One definition, multiple runtimes&amp;rdquo;: each signal is defined once and shared across real-time indexing, batch backfills for historical data, and online serving via a unified execution engine supporting both streaming and batch modes. That eliminates training-serving skew by construction. Combined with a Lambda architecture to balance freshness and completeness, plus columnar storage and time-based partitioning, Pinterest significantly cut storage costs and network bandwidth while turning the addition of new event types or signals into a mostly configuration-driven change.&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 #102</title><link>https://miti99.com/en/post/2026/05/05/</link><pubDate>Tue, 05 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #102.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-github-agentic-workflow"&gt;&lt;a href="https://blog.frankel.ch/agentic-github-workflows/" rel="noopener noreferrer"&gt;A GitHub agentic workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel shares his hands-on experience with GitHub agentic workflows — workflows whose defining feature is running an AI agent inside them. He works on a long-lived product with many versions, accompanied by an analysis tool that warns customers ahead of time about upgrade issues. The tool&amp;rsquo;s configuration file used to be compiled manually by a colleague from release notes. Some deprecation info exists in source code via annotations like &lt;code&gt;@Deprecated&lt;/code&gt;, but plugin deprecations only appear in release notes — unstructured prose that traditional deterministic automation cannot parse. That is exactly where an agent shines.&lt;/p&gt;
&lt;p&gt;The workflow has four steps: initialize with &lt;code&gt;gh aw init&lt;/code&gt; or via the GitHub UI; write the workflow in Markdown (the author used Copilot CLI to help); &amp;ldquo;compile&amp;rdquo; it to YAML with &lt;code&gt;gh aw compile&lt;/code&gt;; and run it like a normal workflow using a fine-grained &lt;code&gt;GITHUB_COPILOT_TOKEN&lt;/code&gt; with &amp;ldquo;Copilot requests&amp;rdquo; permission. Along the way, the author hit several snags: forgetting to compile and pushing only the Markdown file; trying to create an auto-compile workflow before hitting permission walls and realizing it was a security risk anyway; and finally settling on a verification workflow that recompiles and fails if the output differs from the committed YAML, paired with &lt;code&gt;.gitattributes&lt;/code&gt; to handle line-ending differences between Windows and Ubuntu. Agentic workflows also disallowed actions from the GitHub Marketplace in his setup. In his view, they don&amp;rsquo;t replace deterministic workflows, but they unlock new use cases like parsing release notes that regexes can&amp;rsquo;t easily handle.&lt;/p&gt;
&lt;h2 id="the-20-software-engineering-laws"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/the-20-software-engineering-laws" rel="noopener noreferrer"&gt;The 20 Software Engineering Laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr Milan Milanović rounds up the 20 software engineering laws he references most often to explain why projects fail, systems degrade, and teams slow down. Many of these decades-old principles remain useful because they are about humans building products together under time pressure rather than any specific technology. They aren&amp;rsquo;t rigid rules: they describe what tends to happen, while the decisions still belong to the engineer.&lt;/p&gt;
&lt;p&gt;The laws are grouped into several themes: how systems are built (Gall&amp;rsquo;s Law, KISS, Conway&amp;rsquo;s Law, Hyrum&amp;rsquo;s Law, CAP Theorem, Zawinski&amp;rsquo;s Law), team dynamics (Brooks&amp;rsquo;s Law, Ringelmann Effect, Price&amp;rsquo;s Law), planning and estimation (Dunning-Kruger Effect, Hofstadter&amp;rsquo;s Law, Parkinson&amp;rsquo;s Law), measurement (Goodhart&amp;rsquo;s Law, Gilb&amp;rsquo;s Law), performance and reliability (Knuth&amp;rsquo;s Optimization Principle, Amdahl&amp;rsquo;s Law, Murphy&amp;rsquo;s Law), and design philosophy (Postel&amp;rsquo;s Law, Sturgeon&amp;rsquo;s Law, Cunningham&amp;rsquo;s Law). Illustrative examples include Instagram succeeding after stripping Burbn down to just photo sharing while feature-packed Google Wave vanished after 15 months, and the 2024 CrowdStrike outage that crashed 8.5 million Windows machines (Murphy&amp;rsquo;s Law). Understanding these laws before trouble strikes helps avoid costly mistakes; because they sometimes contradict one another, engineers need judgment to pick the right lens and build their own catalog of observed patterns.&lt;/p&gt;
&lt;h2 id="databases-were-not-designed-for-this"&gt;&lt;a href="https://arpitbhayani.me/blogs/defensive-databases/" rel="noopener noreferrer"&gt;Databases Were Not Designed For This&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpit Bhayani points out that every database design rests on an &amp;ldquo;implicit contract&amp;rdquo;: the caller is a human-written application running deterministic code, queries are reviewed before deployment, writes are intentional, and connections are short-lived. That contract held for forty years, but AI agents break it at every layer. Agents hallucinate novel queries on the fly, write data autonomously, duplicate writes on retries, hold connections open while waiting on LLM inference, and fan out into parallel sub-agents. A classic failure mode: an API returns HTTP 200 with an empty result because the backend connection pool is exhausted, and the agent interprets &amp;ldquo;no data&amp;rdquo; as &amp;ldquo;no problem,&amp;rdquo; proceeding to approve 500 transactions without triggering a single alert.&lt;/p&gt;
&lt;p&gt;The fix is defensive database design: set role-level statement timeouts (e.g., 5 seconds); use soft deletes with a &lt;code&gt;deleted_by&lt;/code&gt; column to audit which agent deleted what; use append-only event log tables for sensitive data; enforce idempotency keys derived from task ID, operation type, and target entity so retries don&amp;rsquo;t create duplicate records; and isolate agent traffic into a dedicated connection pool with short wait timeouts so it fails fast. The article also covers PgBouncer transaction pooling, attaching SQL comments with agent and task IDs for observability, and giving each agent type its own least-privilege database role. The core message: none of these are new tools — they are established best practices that become mandatory infrastructure once agents talk to your database.&lt;/p&gt;
&lt;h2 id="finishing-things"&gt;&lt;a href="https://ratfactor.com/finishing-things" rel="noopener noreferrer"&gt;Finishing Things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a personal essay by the author of the ratfactor blog about finishing personal projects amid life&amp;rsquo;s upheavals. He used to set grand annual themes like &amp;ldquo;The Year of the Microcontroller&amp;rdquo; (2023) or &amp;ldquo;The Year of Try It&amp;rdquo; (2024), but personal hardships and external events kept derailing them, so he decided to stop making big plans. What actually works is a &amp;ldquo;project stack&amp;rdquo;: every idea gets written on a small Post-It note and placed into a display frame, usually near the top, and he only works on the topmost item. This stack turns a sprawling maze of side quests into a single linear track that&amp;rsquo;s easy to follow instead of a tangled to-do list.&lt;/p&gt;
&lt;p&gt;He compares maintaining habits and projects to plate spinning: when a crisis hits, multiple plates come crashing down at once. His advice is to keep at least one plate spinning, because maintaining momentum is much easier than starting over from scratch; skills also need regular practice so they don&amp;rsquo;t rust. The essay introduces the &amp;ldquo;sphere of control,&amp;rdquo; a boundary that expands and contracts with life&amp;rsquo;s circumstances: as long as you do well within that sphere, there&amp;rsquo;s no need to beat yourself up, and some obstacles are really just minor discomforts, like dreading a phone call to book an appointment. He also touches on the creeping nihilism of watching AI companies scrape up human creativity, and chooses to ignore it and keep creating anyway. Conclusion: slow, steady progress is what actually gets things done, so instead of specific goals, he declares a &amp;ldquo;year of slow, steady progress.&amp;rdquo;&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!9kS2!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F71595c9b-f94f-4ae8-851e-ea4f07342c29_2484x3002.png" alt="Data Warehouse vs Data Lake vs Data Mesh"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U4gw!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8e8297aa-f856-4b2b-af5d-986023db89e7_2508x3000.png" alt="API Concepts Every Software Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SAsk!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7616a6b1-8eb6-4dc3-9456-b0e57bc9b0ee_2484x3002.png" alt="Polling vs Long Polling vs Webhooks vs SSE"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SJN6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F47ce48f1-06e7-4663-b822-96cc7d1307d0_2484x3002.png" alt="SLA vs SLO vs SLI"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #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 #95</title><link>https://miti99.com/en/post/2026/04/14/</link><pubDate>Tue, 14 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #95.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="12-claude-code-features-every-engineer-should-know-subagents-claudemd-checkpoints-mcp-and-more"&gt;&lt;a href="https://www.youtube.com/watch?v=E4fzxVMOav4" rel="noopener noreferrer"&gt;12 Claude Code Features Every Engineer Should Know: Subagents, CLAUDE.md, Checkpoints, MCP, and more&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteAI video walks through 12 features every engineer should know when working with Claude Code, Anthropic&amp;rsquo;s terminal-native coding agent. At the top of the list are Subagents, which break a complex task into smaller pieces handled in parallel by isolated worker agents—speeding up execution while keeping the main session&amp;rsquo;s context window clean. Meanwhile, &lt;code&gt;CLAUDE.md&lt;/code&gt; serves as the project&amp;rsquo;s onboarding manual, recording architecture, coding conventions, and team-specific rules so Claude has the right context from the very first prompt.&lt;/p&gt;
&lt;p&gt;Checkpoints snapshot workspace state as you go, letting you rewind cleanly whenever the AI heads down the wrong path instead of untangling changes by hand. MCP (Model Context Protocol) integration extends Claude Code by connecting it directly to external services like databases, APIs, and developer tools. The walkthrough is a solid overview both for newcomers and for regular Claude Code users looking to get more mileage out of the tool.&lt;/p&gt;
&lt;h2 id="quantization-from-the-ground-up"&gt;&lt;a href="https://ngrok.com/blog/quantization" rel="noopener noreferrer"&gt;Quantization from the ground up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Rose (ngrok) explains model quantization from first principles—showing how large language models can be compressed to roughly a quarter of their size and run twice as fast while losing only about 5–10% accuracy. He starts with why LLMs are so huge in the first place: an 80-billion-parameter model like &lt;code&gt;Qwen3-Coder-Next&lt;/code&gt; takes around 159 GB of memory because each parameter is stored as a multi-byte floating-point number. Fortunately, parameter weights cluster tightly around zero, meaning we can represent them with far fewer bits without losing much information.&lt;/p&gt;
&lt;p&gt;The post compares two quantization schemes: &lt;em&gt;symmetric&lt;/em&gt; quantization is simple but wastes dynamic range when weights are skewed, whereas &lt;em&gt;asymmetric&lt;/em&gt; quantization adds a zero-point offset and cuts average quantization error from roughly 18% down to 8.5%. In practice, weights are quantized in blocks of 32–256 values so a single outlier only skews its local block rather than distorting the entire model. Measuring post-quantization quality via perplexity, KL divergence, and the GPQA Diamond benchmark shows that 8-bit quantization is nearly lossless, 4-bit loses roughly 5–10%, and 2-bit degrades sharply. In return, inference speed on an M1 Max jumps from 19.45 to 43.32 tokens/sec at 4-bit.&lt;/p&gt;
&lt;h2 id="jpeg-compression"&gt;&lt;a href="https://www.sophielwang.com/blog/jpeg" rel="noopener noreferrer"&gt;JPEG compression&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With rich interactive visualizations, Sophie Wang explains how JPEG compression exploits two things: quirks of the human visual system and the natural smoothness of real-world photographs. Because human eyes are far more sensitive to brightness (luminance) than to color detail (chrominance), JPEG first converts an image from RGB to YCbCr to separate the two. It then performs &lt;em&gt;chroma subsampling&lt;/em&gt;—sharing color values across neighboring pixels—producing an image that looks nearly indistinguishable from the original.&lt;/p&gt;
&lt;p&gt;Next, each 8×8 block of pixels undergoes a Discrete Cosine Transform (DCT), expressing the block as a weighted sum of cosine waves. DCT alone doesn&amp;rsquo;t shrink the data, but it concentrates most of the visual signal into a handful of low-frequency coefficients while leaving high-frequency coefficients near zero. The quantization step divides each coefficient by a quantization table entry and rounds to the nearest integer, turning most high-frequency coefficients—fine details the eye barely notices—into zeros. Finally, the coefficients are scanned in a zigzag order to group long runs of zeros together and entropy-coded into a compact file; decompression simply runs the pipeline in reverse.&lt;/p&gt;
&lt;h2 id="what-81000-people-want-from-ai"&gt;&lt;a href="https://www.anthropic.com/features/81k-interviews" rel="noopener noreferrer"&gt;What 81,000 people want from AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic published the largest multilingual qualitative study of AI users to date: using a custom Claude interviewer, they conducted open-ended conversations with 80,508 opt-in Claude users across 159 countries and 70 languages about their hopes and fears for AI. The overarching message is that people want AI to help them live better lives, not just work faster. Top aspirations include professional excellence (19%), personal growth and transformation (14%), life management (14%), and reclaiming free time (11%). Beneath surface-level productivity requests usually sits a deeper human goal—automating email is really about having more time with family.&lt;/p&gt;
&lt;p&gt;Fully 81% of participants said AI had already helped them move closer to their goals, mainly through productivity gains (32%), acting as a thought partner (17%), and learning (10%). At the same time, respondents voiced an average of 2.3 concerns each: unreliability and hallucinations (27%), job displacement (22%), loss of human agency (22%), cognitive atrophy (16%), and lack of governance (15%). Benefits and anxieties often go hand in hand within the same person: users who value AI for emotional support are three times more likely to worry about unhealthy dependence. Users in lower-income regions expressed more optimism and viewed AI as an economic equalizer, while users in wealthier regions focused more on managing complex, busy lives.&lt;/p&gt;
&lt;h2 id="scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto"&gt;&lt;del&gt;&lt;a href="https://www.semicolonandsons.com/articles/scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto" rel="noopener noreferrer"&gt;Scaling a Monolith to 1M LOC: 113 Pragmatic Lessons from Tech Lead to CTO&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This post distills 113 pragmatic lessons from scaling a monolith to one million lines of code, drawn from the author&amp;rsquo;s journey from Tech Lead to CTO. The central thread is that sound architectural choices matter far more than micro-optimizations: rather than slapping a cache over a slow endpoint, fix the underlying database query or missing index, because a single long-running query can halve the throughput of the entire system. Monitoring and observability should be treated as first-class features, with alerts for latency regressions, N+1 queries, and cache eviction rates, backed by an &amp;ldquo;inbox zero&amp;rdquo; discipline for error tracking where every alert is either fixed or silenced.&lt;/p&gt;
&lt;p&gt;Keeping deployments fast (under two minutes)—by decoupling frontend and backend builds, parallelizing CI steps, and picking fast tooling—dramatically lowers risk because bugs are caught and rolled back quickly. On security, the author recommends starting from concrete threat models like account takeover, spam, or DDoS rather than generic checklists. Finally, the human side matters just as much as the code: avoid blame culture, set clear expectations, and cultivate psychological safety across the team.&lt;/p&gt;
&lt;h2 id="harness-design-for-long-running-application-development"&gt;&lt;a href="https://www.anthropic.com/engineering/harness-design-long-running-apps" rel="noopener noreferrer"&gt;Harness design for long-running application development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic&amp;rsquo;s engineering team tackles two failure modes that plague AI agents on long-running tasks: models lose coherence as the context window fills up, and they consistently grade their own work too generously. Their solution is a GAN-inspired multi-agent harness: a &lt;em&gt;Planner&lt;/em&gt; expands a short user prompt into a detailed product spec, a &lt;em&gt;Generator&lt;/em&gt; builds the application, and a separate &lt;em&gt;Evaluator&lt;/em&gt; grades the running app against explicit criteria and sends critique back. For subjective work like frontend design, the team replaced vague &amp;ldquo;does this look good?&amp;rdquo; prompts with concrete rubrics and let the Generator and Evaluator iterate for 5–15 rounds, sometimes pivoting to a completely new aesthetic direction mid-run.&lt;/p&gt;
&lt;p&gt;In their experiments, starting a fresh session with a structured handoff document worked better than in-place context compaction—especially when models suffered from &amp;ldquo;context anxiety,&amp;rdquo; prematurely wrapping up work because they sensed the context window running out. On a benchmark building a game-maker tool with Opus 4.5, a single solo agent spent $9 and 20 minutes to produce a broken app, whereas the full multi-agent harness spent $200 and 6 hours to deliver a genuinely playable, feature-complete application. Another key lesson: re-evaluate your harness every time the underlying model upgrades, because scaffolding that used to be essential can become dead weight.&lt;/p&gt;
&lt;h2 id="why-i-vibe-in-go-not-rust-or-python"&gt;&lt;a href="https://lifelog.my/episode/why-i-vibe-in-go-not-rust-or-python" rel="noopener noreferrer"&gt;Why I Vibe in Go, Not Rust or Python&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author explains why Go is his language of choice over Rust or Python when coding with AI (&amp;ldquo;vibe coding&amp;rdquo;). Between AI-generated code and production, he argues, you need multiple independent filters—and Go gives you five: the compiler, a static type system, explicit error handling, enforced simplicity, and finally human judgment. Python lacks compile-time verification—type hints are optional—so when an AI generates thousands of lines a day, structural bugs hide until runtime, often in production.&lt;/p&gt;
&lt;p&gt;Rust sits at the other extreme: it gives ironclad correctness guarantees, but the borrow checker and lifetime annotations force the human reviewer to spend mental energy solving language-level puzzles rather than focusing on architecture and domain logic. Go hits the sweet spot between compile-time safety and cognitive simplicity; its backward-compatibility promise means code written in 2024 still compiles cleanly in 2026, and deployment is a single static binary rather than a fragile Python container image.&lt;/p&gt;
&lt;h2 id="the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon"&gt;&lt;a href="https://larstofus.com/2026/03/22/the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon/" rel="noopener noreferrer"&gt;The gold standard of optimization: A look under the hood of RollerCoaster Tycoon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Sawyer wrote &lt;em&gt;RollerCoaster Tycoon&lt;/em&gt; almost entirely in x86 assembly—giving him tighter control over performance than C or C++ compilers of the late 1990s could match—and the game remains a gold standard of software optimization. This deep dive examines the tricks that let it simulate a bustling theme park with thousands of guests on modest 1999 hardware. Instead of defaulting to 32-bit integers everywhere, every struct field was sized to the exact byte width of its maximum expected value—even using different integer widths for different in-game currency totals to pack structs tightly in memory.&lt;/p&gt;
&lt;p&gt;The codebase replaces multiplication and division by powers of two with fast bitshifts, and remarkably, the game&amp;rsquo;s simulation formulas themselves were designed around constants that were powers of two—a level of harmony between game design and low-level systems programming rarely seen today. Algorithmically, park guests don&amp;rsquo;t run expensive A* pathfinding across the whole park; they wander semi-randomly with local heuristics until they stumble onto a ride. The engine also skips guest-to-guest collision detection entirely: thousands of visitors can occupy the same tile, with overcrowding simply penalized in their happiness calculation.&lt;/p&gt;
&lt;h2 id="queueing-requests-queues-your-capacity-problems-too"&gt;&lt;a href="https://pushtoprod.substack.com/p/queueing-requests-queues-your-capacity-problems-too" rel="noopener noreferrer"&gt;Queueing Requests Queues Your Capacity Problems, Too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post points out that putting a queue in front of an overloaded service often hides a capacity problem rather than solving it. If a system capable of processing 1,000 requests per second receives 2,000 requests per second, after one hour the queue holds 3.6 million backlogged requests—meaning users wait roughly 60 minutes for a response even though server-side processing time per request is still a brisk 1 second. The trap is that user-perceived latency equals queue wait time plus processing time, whereas server latency metrics only measure processing time—so your dashboards stay green while customers experience a total outage.&lt;/p&gt;
&lt;p&gt;Queue math is unforgiving: exceeding capacity by just 10% for an hour builds a backlog of 360,000 requests and adds 6 minutes of latency, because the capacity deficit accumulates linearly over time. Swapping queueing disciplines (FIFO, LIFO, priority, weighted fair queueing) only redistributes wait time across requests in a zero-sum game. The only real fix is adding capacity (or shedding load): provisioning 50% extra capacity drains a one-hour crisis backlog in about an hour, whereas 10% extra headroom takes nine hours to recover.&lt;/p&gt;
&lt;h2 id="7-more-common-mistakes-in-architecture-diagrams"&gt;&lt;a href="https://www.ilograph.com/blog/posts/more-common-diagram-mistakes/" rel="noopener noreferrer"&gt;7 More Common Mistakes in Architecture Diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ilograph walks through seven common mistakes that make system architecture diagrams hard to read. First is unlabeled resources—every box should include both its technology type and a descriptive role name, never just a vendor icon. Second is &amp;ldquo;island&amp;rdquo; components floating with no connections, which defeats the purpose of showing relationships. Third is the giant &amp;ldquo;everything diagram&amp;rdquo;; it is much clearer to split complex systems into multiple focused views where each diagram tells one coherent story.&lt;/p&gt;
&lt;p&gt;Mistake four is &amp;ldquo;conveyor-belt syndrome&amp;rdquo;—drawing request flows as a simplistic left-to-right pipeline that hides back-and-forth request/response interactions, which are much better shown with a sequence diagram. Fifth is gratuitous animation that distracts without adding meaning, and sixth is the &amp;ldquo;fan trap,&amp;rdquo; where routing everything through a central hub obscures which upstream nodes actually talk to which downstream nodes. Finally, the author cautions against AI-generated architecture diagrams, which today remain vague, prone to hallucinating connections, and bad at deciding which details to include or omit.&lt;/p&gt;
&lt;h2 id="how-to-do-ai-assisted-engineering"&gt;&lt;a href="https://newsletter.eng-leadership.com/p/how-to-do-ai-assisted-engineering" rel="noopener noreferrer"&gt;How to Do AI-Assisted Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article synthesizes advice from 15 experienced engineers and engineering leaders on how to practice AI-assisted software engineering effectively. The strongest consensus is &lt;em&gt;design first, code second&lt;/em&gt;: when AI handles implementation, the bottleneck shifts upstream to system design, which is where engineers should invest their time. Rather than typing ad-hoc prompts from scratch each time, effective practitioners build structured, repeatable workflows using templates, custom commands, and &lt;code&gt;CLAUDE.md&lt;/code&gt; files that codify project standards and architectural constraints.&lt;/p&gt;
&lt;p&gt;Equally important is separation of concerns in the agent loop: decouple code generation from verification, use specialized review agents to audit diffs for security, performance, and correctness from independent angles, and keep humans firmly in the loop for high-stakes decisions like merging and deploying. An AI&amp;rsquo;s first output should be treated as a rough draft, not a finished product—requiring multiple passes of multi-angle review before it ships.&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_!YJG0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd3e5a12b-4237-4661-b090-d518a6da7f20_2508x3000.png" alt="Load Balancer vs API Gateway"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LrVm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7a20a0cb-3142-4c32-b772-f002f1a288fd_2880x3862.jpeg" alt="REST vs gRPC"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6SID!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F14a25337-0104-4c6c-b91a-3a2cd6afd6e4_2508x3000.png" alt="Session-Based vs JWT-Based Authentication"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LuLK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa8dd9e12-2979-4040-a138-08723094b8cf_2536x3436.jpeg" alt="A Cheat Sheet on The Most-Used Linux Commands"&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 #93</title><link>https://miti99.com/en/post/2026/03/28/</link><pubDate>Sat, 28 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #93.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="lessons-from-building-claude-code-how-we-use-skills"&gt;&lt;a href="https://x.com/trq212/status/2033949937936085378" rel="noopener noreferrer"&gt;Lessons from Building Claude Code: How We Use Skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thariq Shihipar, an engineer at Anthropic, distills lessons from running hundreds of internal skills in Claude Code. The first misconception he corrects is that skills are &amp;ldquo;just markdown files&amp;rdquo;: each skill is actually a directory that can bundle scripts, reference assets, and data for the agent to discover and execute, along with configuration options like dynamic hook registration. Surveying their internal catalog, the team found that effective skills fall into nine recurring categories: library and API references, product verification, data fetching and analysis, team workflow automation, code scaffolding, code quality enforcement, CI/CD and deployment, incident runbooks, and infrastructure operations. Great skills fit cleanly into one category; confusing ones straddle several.&lt;/p&gt;
&lt;p&gt;When authoring skills, he advises skipping obvious instructions and focusing on where you need to nudge Claude away from its default habits—a &amp;ldquo;Gotchas&amp;rdquo; section built up from real failure modes is consistently the highest-leverage part. The frontmatter &lt;code&gt;description&lt;/code&gt; isn&amp;rsquo;t a human summary; it tells the model &lt;em&gt;when&lt;/em&gt; to trigger the skill. Skills can persist per-user settings in &lt;code&gt;config.json&lt;/code&gt; (prompting via &lt;code&gt;AskUserQuestion&lt;/code&gt; when missing), keep lightweight &amp;ldquo;memory&amp;rdquo; in append-only logs or JSON files inside a stable data directory, and ship helper scripts so Claude spends turns composing tools rather than regenerating boilerplate. Finally, skills can reference one another by name, and the team tracks skill invocations via a &lt;code&gt;PreToolUse&lt;/code&gt; hook to spot popular skills and prune dead ones.&lt;/p&gt;
&lt;h2 id="the-future-of-software-engineering-with-anthropic"&gt;&lt;a href="https://www.akashbajwa.co/p/the-future-of-software-engineering" rel="noopener noreferrer"&gt;The Future Of Software Engineering with Anthropic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Akash Bajwa summarizes a roundtable with Anthropic&amp;rsquo;s Ash Prabaker and engineering leaders from Stripe, NVIDIA, Microsoft, Google DeepMind, xAI, Apple, Scale AI, and OpenAI on how AI is reshaping software development. Claude Code started in late 2024 as a humble CLI built not for the models of the day, but for where model capabilities would be six to twelve months later—and spread organically through bottom-up utility rather than top-down mandates. A recurring theme is the recursive improvement loop: better coding tools help build better models, which in turn improve the tools; several companies already run pipelines that autonomously triage production bugs, cross-check against eval suites, and open fix PRs with minimal human intervention.&lt;/p&gt;
&lt;p&gt;Across engineering workflows, test-first development has become the default, human code review increasingly feels more like a bottleneck than a safety net, and inline code comments are making a comeback because future agent sessions rely on them. Human-written architectural context remains invaluable, whereas stale or auto-generated documentation actively misleads agents. In hiring, several leaders now prize engineers who experiment relentlessly at the frontier of tool capabilities over raw hand-coding speed. Open challenges include multi-hour autonomous agent runs that still preserve meaningful human oversight, large-scale context management, and the paradox that when AI makes building almost anything feasible, ruthless prioritization becomes harder than ever.&lt;/p&gt;
&lt;h2 id="rob-pike"&gt;&lt;a href="https://www.cs.unc.edu/~stotts/COMP590-059-f24/robsrules.html" rel="noopener noreferrer"&gt;Rob Pike&amp;rsquo;s 5 Rules of Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rob Pike, co-creator of Go and veteran of Bell Labs, distilled five pithy rules of programming included here in the course readings for COMP590 at UNC. Rules 1 and 2 address optimization: you cannot tell in advance where a program will spend its time because bottlenecks show up in surprising places, so don&amp;rsquo;t put in speed hacks until you&amp;rsquo;ve measured and proven that one part of the code overwhelms the rest. Together, they restate Tony Hoare&amp;rsquo;s famous maxim that &amp;ldquo;premature optimization is the root of all evil.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Rules 3 and 4 warn that fancy algorithms have big constant factors that make them slow when &lt;code&gt;n&lt;/code&gt; is small—and &lt;code&gt;n&lt;/code&gt; is usually small—and they are much buggier and harder to implement, so stick to simple algorithms and simple data structures; as Ken Thompson put it, &amp;ldquo;when in doubt, use brute force.&amp;rdquo; Rule 5 is the heart of the list: data dominates. Once you&amp;rsquo;ve chosen the right data structures and organized things well, the algorithms will almost always be self-evident; data structures, not algorithms, are central to programming.&lt;/p&gt;
&lt;h2 id="introduction-to-postgresql-indexes"&gt;&lt;a href="https://dlt.github.io/blog/posts/introduction-to-postgresql-indexes/" rel="noopener noreferrer"&gt;Introduction to PostgreSQL Indexes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dalto Curvelano explains the internals of PostgreSQL indexes for developers who have an intuitive grasp of indexes but want to understand how they work under the hood. The article starts with how rows live inside 8KB heap pages and why indexes cut down page reads: in a benchmark on a million-row table, a sequential scan takes ~265ms while an index lookup takes just 0.077ms. As a rule of thumb, an index only pays off when a query returns less than roughly 15–20% of the table; beyond that, the query planner usually prefers a sequential scan. Nor are indexes free: they consume disk space, slow down &lt;code&gt;INSERT&lt;/code&gt;/&lt;code&gt;UPDATE&lt;/code&gt;/&lt;code&gt;DELETE&lt;/code&gt; operations, occupy buffer cache memory, and give the query planner more paths to evaluate, so they shouldn&amp;rsquo;t be sprinkled everywhere.&lt;/p&gt;
&lt;p&gt;Most of the guide surveys PostgreSQL&amp;rsquo;s index types. B-Tree is the versatile default; starting in PostgreSQL 18, B-Tree skip scan allows composite indexes to be used even when a query omits the leading column. Hash indexes only support equality checks, but are more compact than B-Trees on wide values like UUIDs or URLs; BRIN indexes are tiny and shine on append-only, naturally ordered time-series tables; GIN handles full-text search, arrays, and &lt;code&gt;JSONB&lt;/code&gt;; and GiST/SP-GiST cover geometric and range data. The post also walks through partial indexes (indexing only a filtered subset of rows), covering indexes with &lt;code&gt;INCLUDE&lt;/code&gt; (enabling index-only scans when the visibility map allows skipping heap fetches), and expression indexes over computed values.&lt;/p&gt;
&lt;h2 id="using-rust-and-postgres-for-everything-patterns-learned-over-the-years"&gt;&lt;a href="https://kerkour.com/rust-postgres-everything" rel="noopener noreferrer"&gt;Using Rust and Postgres for everything: patterns learned over the years&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sylvain Kerkour shares the architectural patterns he has refined from running Rust and PostgreSQL as the backbone for nearly every backend project—guided by a philosophy of picking boring, dependable tools to minimize operational cost and complexity. He opens with a real-world rewrite of a data-processing service from Go to Rust paired with a high-performance memory allocator: batch processing time dropped from roughly 30 minutes to under 5 minutes, RAM usage fell from 4GB to 512MB, and nil-pointer panics disappeared entirely.&lt;/p&gt;
&lt;p&gt;On the application side, he favors &lt;code&gt;sqlx&lt;/code&gt; over heavy ORMs for its simplicity, performance, and compile-time SQL verification macros, and batches writes in chunks of up to 10,000 rows using &lt;code&gt;UNNEST&lt;/code&gt; to avoid overwhelming the database. Even better, PostgreSQL replaces a sprawl of auxiliary infrastructure: &lt;code&gt;pg_try_advisory_lock()&lt;/code&gt; handles leader election (for instance, coordinating distributed CRON schedulers) without ZooKeeper or Redis; &lt;code&gt;UNLOGGED&lt;/code&gt; tables replace Redis for ephemeral caches by skipping the WAL for much faster writes at the cost of crash durability; and PostgreSQL serves as a rock-solid job queue when combining UUIDv7 primary keys (to avoid B-tree index fragmentation) with &lt;code&gt;FOR UPDATE SKIP LOCKED&lt;/code&gt; for worker polling.&lt;/p&gt;
&lt;h2 id="air-traffic-control-the-ibm-9020"&gt;&lt;a href="https://computer.rip/2026-01-17-air-traffic-control-9020.html" rel="noopener noreferrer"&gt;air traffic control: the IBM 9020&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;J. B. Crawford tells the story of the IBM 9020—the custom multiprocessor mainframe built for the US Federal Aviation Administration (FAA) to automate en-route air traffic control, with the first full system installed in 1967. Earlier, the military&amp;rsquo;s SAGE air-defense computer had been considered for civilian traffic control, but it couldn&amp;rsquo;t verify whether assigned altitudes were unique or detect loss of safe separation between aircraft at a time when mid-air collisions were an urgent political crisis.&lt;/p&gt;
&lt;p&gt;Under the hood, an IBM 9020 tied together six or seven modified System/360 compute elements sharing memory through dedicated Storage Elements, orchestrated by a real-time control program managing hundreds of radar and display peripherals. Its standout engineering achievement was fault tolerance: when a hardware fault occurred, the Operational Error Analysis Program (OEAP) automatically diagnosed the failure, ignored transient glitches, or rewrote configuration registers on the fly to isolate a failed compute or storage element so air traffic control could continue uninterrupted. The 9020 stayed in service into the mid-1980s—with display subsystems lasting into the 1990s—proving that commercial-grade computer architectures could handle life-critical workloads when paired with disciplined redundancy and fault-recovery software.&lt;/p&gt;
&lt;h2 id="sfq-simple-stateless-stochastic-fairness"&gt;&lt;a href="https://brooker.co.za/blog/2026/02/25/sfq.html" rel="noopener noreferrer"&gt;SFQ: Simple, Stateless, Stochastic Fairness&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker highlights Stochastic Fairness Queuing (SFQ), an algorithm from a 1990 paper by Paul McKenney and one of his favorite compact building blocks for distributed systems. Classic fair queuing maintains a separate queue per tenant, requiring O(tenants) queues and matching scheduling overhead—impractical at cloud scale. SFQ instead allocates a fixed O(1) array of queues and hashes each tenant ID to a queue. Because two tenants that hash to the same bucket would stay stuck together if one is a &amp;ldquo;noisy neighbor,&amp;rdquo; SFQ periodically rotates the hash seed so tenants that collide in one epoch are overwhelmingly unlikely to collide in the next.&lt;/p&gt;
&lt;p&gt;Brooker then describes a modern variant combining SFQ with shuffle sharding and the power of two choices: each tenant is hashed to a small subset of queues (often just two), each incoming request is placed into whichever of those queues is shorter, and the hash seed rotates periodically. The result keeps queue count, enqueue cost, and dequeue cost at O(1) while strongly isolating noisy neighbors from well-behaved tenants—as long as noisy tenants are a small fraction of the population. The pattern works both inside a single multi-tenant server and across a fleet of backend workers.&lt;/p&gt;
&lt;h2 id="how-many-branches-can-your-cpu-predict"&gt;&lt;a href="https://lemire.me/blog/2026/03/18/how-many-branches-can-your-cpu-predict/" rel="noopener noreferrer"&gt;How many branches can your CPU predict?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire measures how many conditional branches a modern CPU&amp;rsquo;s branch predictor can &amp;ldquo;memorize.&amp;rdquo; His benchmark loops over an array of random integers and conditionally writes to a buffer only when a value is odd—so on fresh random data, the CPU mispredicts roughly 50% of the time. However, if you repeatedly loop over the &lt;em&gt;exact same&lt;/em&gt; random sequence, the branch predictor learns the pattern; increasing the sequence length reveals the capacity threshold where the predictor overflows and performance drops back to random guessing. The results: AMD Zen 5 perfectly predicts sequences of roughly 30,000 branches, Apple&amp;rsquo;s M4 handles around 10,000, and Intel&amp;rsquo;s Emerald Rapids manages only about 5,000—six times fewer than Zen 5.&lt;/p&gt;
&lt;p&gt;The practical lesson is a warning for microbenchmarking: if your test input is small enough to fit inside the CPU&amp;rsquo;s branch history tables, the processor will memorize the exact branch pattern and report numbers far faster than what you will ever see on real production traffic. Reliable benchmarks require input datasets large and varied enough to defeat branch memorization.&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_!tS1T!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F958d36d9-6b19-4949-b6a6-6aa614ede834_2508x2960.jpeg" alt="Different Types of Tests"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!c4WE!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd86cd367-494f-4031-9793-f27e6142e54b_2508x3000.png" alt="How Single Sign-On (SSO) Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!em-f!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7e7e23e9-2a5a-4b06-a3fa-ccb6c5493f1d_2508x3000.png" alt="How LLMs Use AI Agents with Deep Research"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!kRPi!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F3d3b2bb9-fc09-48d9-89b7-52bc37098af9_2360x2960.png" alt="How hackers steal passwords"&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 #90</title><link>https://miti99.com/en/post/2026/03/16/</link><pubDate>Mon, 16 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #90.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="against-query-based-compilers"&gt;&lt;a href="https://matklad.github.io/2026/02/25/against-query-based-compilers.html" rel="noopener noreferrer"&gt;Against Query Based Compilers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Query-based compilers are all the rage, and matklad uses this essay to point out their hidden shoals. The core idea is straightforward: model a compiler run as a call graph of queries; when an input changes, recompute only the nodes along the path from that input to the root query, with an &amp;ldquo;early cutoff&amp;rdquo; optimization whenever an intermediate result doesn&amp;rsquo;t change. However, the cost of an incremental update can never be smaller than the size of the output change: for computations with an &amp;ldquo;avalanche&amp;rdquo; property like cryptographic hashes or optimized code generation, changing a single character alters nearly the entire output, making incrementality useless. The author concludes that the effectiveness of a query-based architecture is bounded by the dependency structure of the source language itself.&lt;/p&gt;
&lt;p&gt;Comparing Zig and Rust makes this concrete. In Zig, each file is parsed and name-resolved independently in parallel because all identifiers must be explicitly declared. In Rust, macros generate new items and name resolution spans the entire crate, so typing a single line in &lt;code&gt;a.rs&lt;/code&gt; can alter how &lt;code&gt;b.rs&lt;/code&gt; resolves; the trait system even creates negative dependencies on the &lt;em&gt;absence&lt;/em&gt; of conflicting &lt;code&gt;impl&lt;/code&gt; blocks elsewhere in the crate. The author&amp;rsquo;s advice is to design languages so compilation can be split into coarse, independent map-reduce chunks, and rely on fine-grained query pipelines only as a fallback as late in the compilation pipeline as possible.&lt;/p&gt;
&lt;h2 id="the-great-developer-divide-how-ai-is-reshaping-the-software-job-market-into-three-tiers"&gt;&lt;a href="https://itrevolution.com/articles/the-great-developer-divide-how-ai-is-reshaping-the-software-job-market-into-three-tiers/" rel="noopener noreferrer"&gt;The Great Developer Divide: How AI Is Reshaping the Software Job Market Into Three Tiers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This IT Revolution article argues that AI isn&amp;rsquo;t killing software engineering, but bifurcating the developer job market into three tiers while hollowing out the comfortable $150k &amp;ldquo;solid mid-level Java developer&amp;rdquo; middle. The &lt;strong&gt;apex tier&lt;/strong&gt; ($250k–$500k+) rewards strategic systems thinking, AI orchestration, and architectural judgment. The &lt;strong&gt;hybrid middle tier&lt;/strong&gt; ($150k–$300k) blends engineering with product, design, or operations, giving rise to new roles like fleet supervisors managing teams of AI agents or domain-specific agent experts. The &lt;strong&gt;commoditized tier&lt;/strong&gt; ($80k–$130k and shrinking) covers routine coding work, squeezed simultaneously by AI automation and global labor competition.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, AI doesn&amp;rsquo;t directly replace jobs so much as accelerate economic forces that make routine implementation uneconomical at legacy salaries—mirroring job polarization in manufacturing, only much faster. Overall demand for engineers is still growing, just shifting in nature. Key skills to cultivate include prompt engineering, AI/ML fundamentals, system design, reading code quickly, knowing when to delegate to AI, and maintaining disciplined skepticism toward AI output. The advice for developers is to consciously choose which tier to target and invest in deep domain expertise as a durable moat.&lt;/p&gt;
&lt;h2 id="engineering-speed-at-scale--architectural-lessons-from-sub-100-ms-apis"&gt;&lt;a href="https://www.infoq.com/articles/engineering-speed-scale/" rel="noopener noreferrer"&gt;Engineering Speed at Scale — Architectural Lessons from Sub-100-ms APIs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This InfoQ article argues that low latency doesn&amp;rsquo;t come from micro-optimizing a few lines of code—it is the result of deliberate architectural design, and should be treated as a first-class product feature alongside security and reliability. At scale, a few dozen milliseconds of delay compound across service hops and drag down conversion rates. The central tool is a &lt;strong&gt;latency budget&lt;/strong&gt;: slicing a 100ms target across edge, gateway, service logic, data access, and network hops so that every new feature must answer &amp;ldquo;which layer gives up milliseconds to pay for this?&amp;rdquo; Most latency, the author notes, comes from network hop count, JSON serialization overhead, cold caches, unindexed queries, and slow downstream dependencies rather than &amp;ldquo;slow code.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Core technical patterns include bounded asynchronous fan-out with &lt;code&gt;CompletableFuture&lt;/code&gt; and carefully sized thread pools, two-tier caching (local in-process Caffeine backed by Redis ahead of the database) with explicit invalidation strategies and sensitivity classification, plus circuit breakers and timeouts aligned with the latency budget to fail fast instead of queuing requests. Observability is non-negotiable: tracking p50/p95/p99 percentiles, distributed tracing, and burn-rate SLO alerts to catch regressions early. Ultimately, culture is what keeps a system fast over time—when the whole team owns latency and bakes performance questions into design reviews and release gates.&lt;/p&gt;
&lt;h2 id="can-ai-agents-build-real-stripe-integrations"&gt;&lt;a href="https://stripe.com/blog/can-ai-agents-build-real-stripe-integrations" rel="noopener noreferrer"&gt;Can AI Agents Build Real Stripe Integrations?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stripe wanted to know whether AI agents can build a complete, working payment integration end to end—because in payments, an &amp;ldquo;almost working&amp;rdquo; integration is still a broken one. They built a benchmark of 11 realistic project environments complete with source code, databases, setup scripts, and test API keys, graded by automated API and browser-based end-to-end tests. Tasks fall into three categories: backend-only (migrations, API version upgrades), full-stack (requiring browser interaction to complete checkout flows), and focused &amp;ldquo;gym&amp;rdquo; exercises targeting a single product like Checkout or subscriptions. Every model ran inside the same &lt;code&gt;goose&lt;/code&gt;-based harness with MCP servers providing terminal access, browser automation, and Stripe documentation search.&lt;/p&gt;
&lt;p&gt;The results beat expectations: Claude Opus 4.5 averaged 92% across four full-stack tasks, while GPT-5.2 led the gym suite at 73% across two tasks. Agents successfully migrated legacy Card Element integrations to Stripe Checkout, used Stripe Link autonomously to complete test payments, and reverse-engineered over 80% of required API parameters from an existing Checkout UI. Still, models struggled with ambiguity—for instance, treating a &lt;code&gt;400 Bad Request&lt;/code&gt; caused by dummy payload data as proof that an endpoint worked—and occasionally gave up when browser automation got stuck even though a simple page reload would have fixed it. Stripe has open-sourced the benchmark inside its AI toolkit to help the community improve agent tooling; building it already helped Stripe spot and fix gaps in its own documentation.&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_!SFnp!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fdf0d363e-62b7-4b3f-940d-d19f7a55c610_3000x3900.png" alt="CPU vs GPU vs TPU"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ipY-!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2931d40e-cce8-4ecd-a520-b5f80679c315_2528x3626.png" alt="How OAuth 2 Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Ehq9!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F4f417b56-c66c-45fd-8308-dab9af381ced_2252x2752.png" alt="How Distributed Tracing Works at the High Level?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4UUW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0357d808-5db9-4e18-8262-8dee58fd697d_2508x3000.jpeg" alt="Top 4 API Gateway Use Cases"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #75</title><link>https://miti99.com/en/post/2025/12/28/</link><pubDate>Sun, 28 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #75.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="front-end-vs-back-end-vs-system-design--what"&gt;&lt;a href="https://designgurus.substack.com/p/front-end-vs-back-end-vs-system-design" rel="noopener noreferrer"&gt;Front-End vs. Back-End vs. System Design – What&amp;rsquo;s the Difference in Interviews?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Front-end, back-end, and system design interviews evaluate very different skill sets, so each requires its own preparation strategy. Front-end interviews revolve around the client side: HTML, CSS, JavaScript, and usually a framework like React. They place less emphasis on complex algorithms and lean more toward domain knowledge like responsive design, CSS specificity, browser rendering pipelines, asynchronous JavaScript, and load-time optimization. Back-end interviews are more traditional: LeetCode-style data structures and algorithms with complexity analysis, paired with practical knowledge of APIs, databases (SQL and NoSQL, indexing, schema design), caching, and message queues. System design interviews zoom out to the big picture, testing your ability to architect a real-world system from scratch that is scalable, reliable, and maintainable.&lt;/p&gt;
&lt;p&gt;The author uses a house-building analogy: front-end is like interior design (how the rooms look and feel), back-end is like the structure and foundation (whether the house stands firm and utilities work properly), and system design is like the urban architect planning the entire neighborhood, deciding where houses, roads, and utilities go. To prepare for front-end interviews, build a few small projects and brush up on browser fundamentals and HTTP. For back-end, practicing algorithms and mastering database fundamentals remain the core focus.&lt;/p&gt;
&lt;h2 id="why-starting-with-microservices-can-be-your-biggest-architectural-mistake"&gt;&lt;a href="https://designgurus.substack.com/p/why-starting-with-microservices-can" rel="noopener noreferrer"&gt;Why Starting with Microservices Can Be Your Biggest Architectural Mistake&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Microservices are often treated as the industry default, but starting a brand-new project with microservices is a common and costly mistake: what works for a 5,000-engineer organization is usually poison for a five-person team. The core advice is &amp;ldquo;Monolith First.&amp;rdquo; A monolith&amp;rsquo;s superpower is simplicity: all code lives in one place, deploys as a single unit, and function calls happen instantaneously in the same memory space. Microservices introduce three nightmares. First, networks are unreliable, turning simple function calls into distributed systems problems with retries and timeouts. Second, each service owns its own database, so you can no longer &lt;code&gt;JOIN&lt;/code&gt; tables and must stitch data together in application code. Third, 10 services mean 10 build pipelines, 10 servers to monitor, and 10 places to dig through logs.&lt;/p&gt;
&lt;p&gt;At the start of a project, you also don&amp;rsquo;t yet know where the domain boundaries should be. Refactoring a monolith is just moving files between folders, whereas refactoring microservices requires changing API contracts, migrating databases, and coordinating multi-service deployments. A pragmatic middle ground is the Modular Monolith: a single codebase cleanly organized into modules like &lt;code&gt;/src/users&lt;/code&gt; and &lt;code&gt;/src/orders&lt;/code&gt; that still run inside a single runtime. This gives you the organizational clarity of microservices without the operational tax. Only move to microservices when the team outgrows the monolith (around 100 engineers), when individual features have vastly different scaling needs, or when you genuinely need polyglot technology stacks. Don&amp;rsquo;t optimize prematurely; wait until the pain is real.&lt;/p&gt;
&lt;h2 id="the-linux-kernel-is-just-a-program"&gt;&lt;a href="https://serversfor.dev/linux-inside-out/the-linux-kernel-is-just-a-program/" rel="noopener noreferrer"&gt;The Linux kernel is just a program&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article demystifies the Linux kernel—often treated as an impenetrable &amp;ldquo;black box&amp;rdquo;—through hands-on experiments. At its core, the kernel provides an abstraction layer for using hardware conveniently and safely: a unified API for interacting with hardware, managing how programs share CPU, memory, and resources, and enforcing access control. The closest analogy is that the kernel is simply a &amp;ldquo;runtime&amp;rdquo; for your computer. On most distributions, the kernel is just a compressed file of a few megabytes named &lt;code&gt;vmlinuz-…&lt;/code&gt; sitting in &lt;code&gt;/boot&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author copies that file out and boots it directly with QEMU; the kernel starts up in about two seconds and then panics because it cannot find a root filesystem to hand off execution to an &lt;code&gt;init&lt;/code&gt; program—which is the exact expected behavior. Next, the author writes a tiny &lt;code&gt;init&lt;/code&gt; program in Go, packs it into a minimal &lt;code&gt;initramfs&lt;/code&gt;, and boots again. This time, the kernel runs the Go binary as PID 1. From this experiment, several core concepts click into place: a Linux distribution is just the kernel plus userland programs and configuration files; a process is a running program; a PID is a process identifier; &lt;code&gt;init&lt;/code&gt; is the very first process, responsible for starting other programs; and &lt;code&gt;init&lt;/code&gt; is the first program running in user space, where the kernel hands over control after initialization. This practical approach builds a clear mental model of how Linux actually works.&lt;/p&gt;
&lt;h2 id="why-your-load-balancer-is-the-bottleneck-and-how-to-fix-it"&gt;&lt;a href="https://designgurus.substack.com/p/dont-let-your-load-balancer-crash" rel="noopener noreferrer"&gt;Why Your Load Balancer is the Bottleneck (and How to Fix It)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Distributed systems have an ironic paradox: you add a load balancer to distribute traffic evenly across application servers, but when your product takes off, the load balancer itself becomes the bottleneck. Your application servers are healthy and your database is barely breaking a sweat, yet users complain that the site is slow or unreachable. According to the author, this is what separates junior developers from senior architects: plenty of people know how to put a load balancer in front of a service, but far fewer know what to do when the load balancer itself is the problem. The post explains why this happens and introduces five scaling strategies used by major tech companies.&lt;/p&gt;
&lt;p&gt;Strategies covered include DNS Round Robin to split traffic right at the DNS layer, choosing between Layer 4 and Layer 7 routing to reduce processing overhead, and Direct Server Return (DSR), which lets backend servers send responses straight back to the client without passing back through the load balancer. Each approach comes with trade-offs: DNS Round Robin is simple but slow to propagate changes, Layer 4 is faster than Layer 7 but offers fewer routing features, and DSR saves massive egress bandwidth at the cost of complex network configuration. Mastering these techniques lets your load-balancing tier scale horizontally alongside your application servers instead of becoming a single point of congestion.&lt;/p&gt;
&lt;h2 id="the-high-availability-blueprint-designing-systems-that-never-sleep"&gt;&lt;a href="https://designgurus.substack.com/p/the-high-availability-blueprint-designing" rel="noopener noreferrer"&gt;The High Availability Blueprint: Designing Systems That Never Sleep&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;High Availability (HA) is the art of building systems that &amp;ldquo;never sleep&amp;rdquo; on top of hardware that is guaranteed to fail. HA isn&amp;rsquo;t just about preventing failures—it&amp;rsquo;s about masking them so users never notice. Availability is measured in &amp;ldquo;nines&amp;rdquo;: 99% equates to about 3.65 days of downtime per year, 99.9% is about 8.76 hours, and 99.999% (&amp;ldquo;five nines&amp;rdquo;) is just over 5 minutes; every additional nine is exponentially harder and more expensive to achieve. The core philosophy is &amp;ldquo;assume everything will fail and plan for it.&amp;rdquo; The biggest enemy is a Single Point of Failure (SPOF)—any component whose failure brings down the entire system—and the antidote is redundancy: duplicating critical components.&lt;/p&gt;
&lt;p&gt;Key techniques include load balancers paired with health checks to automatically remove unhealthy servers from rotation; Leader-Follower database replication where a Follower is promoted to Leader upon failure; and failover strategies in two flavors. Active-Passive is simple but wasteful since standby servers sit idle most of the time. Active-Active utilizes all hardware continuously but is more complex, and in a two-node setup each node must be provisioned to handle 100% of the traffic if its peer goes down. Additionally, rate limiting (returning HTTP 429 when thresholds are exceeded) prevents cascading failures during traffic spikes. Achieving five nines requires geographic distribution across multiple regions to survive regional disasters. The guiding mantra: &amp;ldquo;Two is one, and one is none&amp;rdquo;—always have a backup plan.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!ETm5!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2112a03d-cc48-4db5-9740-94adc1a7efbf_2360x2920.png" alt="Common Network Protocols Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5bFA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F722913d5-a10f-44c2-98ed-edc27a92a137_1444x1882.jpeg" alt="8 Popular Network Protocols"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!pen8!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F22fdf2d2-5ce5-4c2b-90f9-3bcfcecb5fc1_1370x1536.jpeg" alt="9 best practices for developing microservices"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #73</title><link>https://miti99.com/en/post/2025/12/20/</link><pubDate>Sat, 20 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/20/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I recently learned that &lt;a href="https://openrouter.ai/docs/guides/guides/claude-code-integration" rel="noopener noreferrer"&gt;OpenRouter now supports Claude Code integration&lt;/a&gt;, so I&amp;rsquo;m giving it a try today. This post was generated using &lt;a href="https://claude.com/product/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt; + &lt;a href="https://openrouter.ai/" rel="noopener noreferrer"&gt;Open Router&lt;/a&gt; + &lt;a href="https://openrouter.ai/z-ai/glm-4.5-air:free" rel="noopener noreferrer"&gt;Z.AI: GLM 4.5 Air (free)&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #73.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="system-design-deep-dive-time-series-databases-tsdbs-explained"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-deep-dive-time-series" rel="noopener noreferrer"&gt;System Design Deep Dive: Time Series Databases (TSDBs) Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Time series databases (TSDBs) are purpose-built for data that streams in continuously in chronological order, such as IoT sensor readings, application logs, or server monitoring metrics. Every measurement is stored with a timestamp, making it straightforward to track fluctuations and spot trends. The article highlights three core characteristics: efficient data compression using delta encoding and run-length encoding to exploit repeating patterns; automated data lifecycle management through retention policies (deleting or archiving old data) and downsampling (aggregating older data into coarser intervals like hourly averages); and fast time-range queries because time serves as the primary index, with many systems able to query compressed data directly.&lt;/p&gt;
&lt;p&gt;Compared with relational databases, TSDBs excel at high-frequency writes and aggregations over long time windows—such as &amp;ldquo;the per-minute average over 90 days&amp;rdquo;—thanks to columnar storage layouts, append-only writes, and time-based partitioning. Conversely, if an application requires frequent table joins or individual record updates, a relational database remains a better fit. This is handy knowledge when preparing for system design interviews.&lt;/p&gt;
&lt;h2 id="how-memory-maps-mmap-deliver-25x-faster-file-access-in-go"&gt;&lt;a href="https://info.varnish-software.com/blog/how-memory-maps-mmap-deliver-25x-faster-file-access-in-go" rel="noopener noreferrer"&gt;How Memory Maps (mmap) Deliver 25x Faster File Access in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;System calls carry kernel context-switch overhead that adds up when small operations are repeated millions of times. Author Per Buer (Varnish Software) introduces memory mapping (&lt;code&gt;mmap&lt;/code&gt;): mapping a file directly into virtual memory and reading it via pointers instead of seeking and reading with &lt;code&gt;pread()&lt;/code&gt;. In benchmarks of his Go library, random lookups dropped from 416.4 ns/op to 3.3 ns/op, and sequential iteration fell from 333.3 ns/op to 1.3 ns/op; working directly with pointers also reduces memory pressure and latency.&lt;/p&gt;
&lt;p&gt;The weakness of &lt;code&gt;mmap&lt;/code&gt; lies in writes: when writing to a page not yet in physical memory, the CPU triggers a page fault and the OS must allocate a new page and read the file contents from disk before the application can overwrite them, making performance entirely dependent on whether the page is already cached; &lt;code&gt;pwrite&lt;/code&gt; is far more predictable. That is why Varnish Cache later added a &lt;code&gt;malloc&lt;/code&gt; backend and Massive Storage Engines built on &lt;code&gt;io_uring&lt;/code&gt;. In a real-world application building an HTTP-backed filesystem, replacing CDB file reads with &lt;code&gt;mmap&lt;/code&gt; yielded 25x faster lookups.&lt;/p&gt;
&lt;h2 id="bloom-filters"&gt;&lt;a href="https://eli.thegreenplace.net/2025/bloom-filters" rel="noopener noreferrer"&gt;Bloom filters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Bloom filter is a probabilistic data structure proposed by Burton Bloom in 1970 for quickly testing whether an element belongs to a set using minimal time and memory. It acts like a probabilistic cache: if it says &amp;ldquo;no,&amp;rdquo; the element is 100% guaranteed not to be in the set; if it says &amp;ldquo;yes,&amp;rdquo; there is a small probability of a false positive. That makes Bloom filters especially effective when most queries return negative results—for example, checking whether a key exists in an on-disk file before paying the cost of reading the file. Structurally, it consists of an array of &lt;em&gt;m&lt;/em&gt; bits and &lt;em&gt;k&lt;/em&gt; hash functions: on insert, the element is hashed by all &lt;em&gt;k&lt;/em&gt; functions and the corresponding bits are set to 1; on lookup, a single 0 bit is enough to immediately conclude the element is absent.&lt;/p&gt;
&lt;p&gt;Eli Bendersky walks through a step-by-step example along with a Go implementation that uses double hashing to generate &lt;em&gt;k&lt;/em&gt; hash functions from two base hashes, plus the formulas for choosing optimal parameters: m/n ≈ -ln(ε)/ln²(2) and k = (m/n)·ln(2). For 1 billion elements and a 1% false-positive rate, the filter requires about 9.6 billion bits (roughly 1.2 GB) and 7 hash functions. Lookup cost is just &lt;em&gt;k&lt;/em&gt; bit checks—effectively constant and independent of how many elements have been inserted or the characteristics of the data.&lt;/p&gt;
&lt;h2 id="what-the-heck-is-aead-again"&gt;&lt;a href="https://ochagavia.nl/blog/what-the-heck-is-aead-again/" rel="noopener noreferrer"&gt;What the heck is AEAD again?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;AEAD (Authenticated Encryption with Associated Data) is the modern encryption standard: TLS 1.3 models all encryption algorithms as AEAD, QUIC (the foundation of HTTP/3) mandates it, and Google&amp;rsquo;s Tink library exclusively supports AEAD for data encryption. The author breaks down each part of the term. &amp;ldquo;Authenticated&amp;rdquo; means proving the ciphertext was not tampered with after encryption; previously, developers had to manually combine encryption with an HMAC step, which was notoriously error-prone (as seen in Apple&amp;rsquo;s iMessage vulnerability). Libraries like libsodium bundled both steps into a single API to make misuse much harder.&lt;/p&gt;
&lt;p&gt;&amp;ldquo;Associated Data&amp;rdquo; is unencrypted data that still needs protection against tampering. In a chat application, for example, the server needs to read &lt;code&gt;conversation_id&lt;/code&gt; in plaintext to route messages; if an attacker in the middle swaps that ID for a different conversation between the same two users and the recipient doesn&amp;rsquo;t authenticate it, the message still decrypts cleanly and gets processed in the wrong context. An AEAD API enforces simultaneous authentication of both the ciphertext and the associated data. Standardized AEAD algorithms like AES256-GCM and ChaCha20-Poly1305 are widely supported across libraries and languages; the author recommends following Tink&amp;rsquo;s guidance unless your system has specialized requirements.&lt;/p&gt;
&lt;h2 id="ceilometer-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/ceilometer-ubers-adaptive-benchmarking-framework/" rel="noopener noreferrer"&gt;Ceilometer: Uber&amp;rsquo;s Adaptive Benchmarking Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every new server SKU, OS kernel upgrade, or configuration change at Uber must be thoroughly vetted before reaching production, but their legacy process was manual, fragmented across teams, and scattered results across spreadsheets. Ceilometer was built to solve this: an adaptive benchmarking platform featuring standardized test configurations for fair comparisons, containerized benchmark suites that hardware vendors can run themselves, and context-rich reporting. Its architecture comprises distributed test orchestration on dedicated clusters, a result ingestion and normalization service, blob storage, a centralized data warehouse, and an analytics service. It supports synthetic benchmarks, stateful database benchmarks via Uber&amp;rsquo;s Odin platform, and stateless service benchmarks via Ballast.&lt;/p&gt;
&lt;p&gt;Its two primary use cases are shape qualification for new server hardware—from early vendor development through testing inside Uber&amp;rsquo;s environment—and infrastructure change verification alongside service owners to isolate, reproduce, and fix performance regressions. Ceilometer has also recently been used to validate &amp;ldquo;touchless&amp;rdquo; upgrades from cloud providers. Future directions include deeper AI/ML integration, broader ecosystem support, advanced anomaly detection, and component-level utilization metrics.&lt;/p&gt;
&lt;h2 id="useful-patterns-for-building-html-tools"&gt;&lt;a href="https://simonwillison.net/2025/Dec/10/html-tools/" rel="noopener noreferrer"&gt;Useful patterns for building HTML tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison uses the term &amp;ldquo;HTML tools&amp;rdquo; for small single-file applications that bundle HTML, JavaScript, and CSS together; over the past two years he has built more than 150 of them, mostly written by LLMs. This post distills design patterns from that experience: keep each tool in a single file, avoid React or build steps, and load dependencies from CDNs; prototype quickly in Artifacts or Canvas before moving to a coding agent as the project grows more complex; and self-host your tools rather than leaving them on LLM platforms that run inside restrictive sandboxes.&lt;/p&gt;
&lt;p&gt;On the technical side, he recommends using copy-and-paste as a primary I/O channel, storing state in the URL for easy sharing, using &lt;code&gt;localStorage&lt;/code&gt; for API keys or larger state, collecting CORS-friendly APIs (including calling LLMs directly from the browser), and supporting local file uploads and generated file downloads. Pyodide and WebAssembly open up running Python or heavy libraries right in the browser. He also encourages building debugging tools to explore browser capabilities, remixing existing tools into new ones, and archiving prompts and conversation transcripts alongside the code. Finally, he encourages readers to start their own collections hosted on platforms like GitHub Pages.&lt;/p&gt;
&lt;h2 id="memory-allocation-in-go"&gt;&lt;a href="https://nghiant3223.github.io/2025/06/03/memory_allocation_in_go.html" rel="noopener noreferrer"&gt;Memory Allocation in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post takes a deep dive into memory allocation in the Go runtime—essential knowledge for optimizing application performance. Go manages the heap across three tiers: &lt;code&gt;mheap&lt;/code&gt; manages global memory in pages and spans, &lt;code&gt;mcentral&lt;/code&gt; distributes spans by size class, and &lt;code&gt;mcache&lt;/code&gt; acts as a per-processor (&lt;code&gt;P&lt;/code&gt;) local cache enabling fast lock-free allocations. Objects are grouped into three categories: tiny (under 16 bytes with no pointers, packed together into 16-byte blocks by a dedicated allocator), small (16 to 32,760 bytes, managed via spans across 68 size classes), and large (over 32,760 bytes, allocated directly from &lt;code&gt;mheap&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;A goroutine&amp;rsquo;s stack starts at 2 KB and doubles as needed using contiguous stacks, replacing the segmented stacks that caused performance cliffs in older Go versions. The compiler&amp;rsquo;s escape analysis decides whether a variable lives on the stack or the heap to guarantee memory safety. Three case studies at the end demonstrate how to reduce allocations: reusing a slice&amp;rsquo;s backing array, grouping multiple variables into a single struct, and recycling objects with &lt;code&gt;sync.Pool&lt;/code&gt;. Understanding these mechanics helps Go developers write efficient code and avoid memory-management bottlenecks.&lt;/p&gt;
&lt;h2 id="system-design-masterclass-building-a-global-cdn-and-edge-caching-strategy"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-masterclass-building" rel="noopener noreferrer"&gt;System Design Masterclass: Building a Global CDN and Edge Caching Strategy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide walks step by step through designing a global Content Delivery Network (CDN) and edge caching strategy around one core principle: move content closer to users. First, identify where your users are and classify content into static (images, CSS/JS files, video) and dynamic (API responses, personalized pages). Next, pick a CDN provider with Points of Presence (PoPs) near your main user base and route intelligently using Anycast or GeoDNS; very large services can adopt a multi-CDN setup for redundancy. Then configure caching rules: set long TTLs (days or weeks) for static assets, handle dynamic content carefully with short TTLs or a few seconds of micro-caching, and design clean cache keys.&lt;/p&gt;
&lt;p&gt;To keep users from seeing stale content indefinitely, combine three cache invalidation approaches: letting TTLs expire naturally, purging manually via API, and versioning filenames. Finally, continuously monitor cache hit ratios, measure performance across regions, test failure scenarios, and take advantage of CDN features like DDoS mitigation and SSL offloading. The author likens a CDN to a network of neighborhood library branches around the world, letting readers borrow books from their local branch instead of traveling to the central library.&lt;/p&gt;
&lt;h2 id="protect-your-api-a-developer"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-blueprint-designing" rel="noopener noreferrer"&gt;Protect Your API: A Developer&amp;rsquo;s Guide to Rate Limiting and Throttling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every system has finite resources, and a sudden traffic spike, a credential-stuffing bot, or even a buggy frontend loop can overwhelm a server. Rate limiting puts a cap on how many times a user can perform an action within a given time window, much like speed limit signs on a highway. It helps mitigate DDoS attacks (though it cannot stop every type) by flagging IP addresses sending abnormal request volumes, ensures fair resource allocation so one &amp;ldquo;noisy neighbor&amp;rdquo; doesn&amp;rsquo;t slow the app down for everyone else, and prevents brute-force login attacks by locking accounts after a handful of failed attempts.&lt;/p&gt;
&lt;p&gt;Rate limiting is typically placed at the application or middleware layer: each request is identified by IP address, user ID, or API key, its recent call count is checked against the allowed threshold, and excess requests are rejected with HTTP &lt;code&gt;429 Too Many Requests&lt;/code&gt;. The post introduces four common algorithms: Token Bucket, which allows short bursts and is used by Amazon and Stripe; Leaky Bucket, which smooths traffic into a steady outflow rate ideal for database writes; plus Fixed Window and Sliding Window. Later sections discuss implementing distributed rate limiting with Redis, a frequent topic in system design interviews.&lt;/p&gt;
&lt;h2 id="acid-vs-base-the-system-design-interview"&gt;&lt;a href="https://designgurus.substack.com/p/acid-vs-base-the-system-design-interview" rel="noopener noreferrer"&gt;ACID vs BASE: The System Design Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every large-scale system has to balance speed against reliability, and when designing a database layer, you must choose between two philosophies: ACID and BASE. ACID is the &amp;ldquo;strict perfectionist&amp;rdquo; and the gold standard of relational databases like MySQL and PostgreSQL: Atomicity ensures a transaction either completes in full or rolls back via logs; Consistency enforces schema constraints; Isolation uses locks so two people cannot buy the last ticket at the same time; and Durability writes changes to a write-ahead log so data survives crashes. ACID&amp;rsquo;s weakness is that it is very hard to scale horizontally across hundreds of servers.&lt;/p&gt;
&lt;p&gt;BASE emerged for the big-data era and is common in NoSQL databases like Cassandra, DynamoDB, and MongoDB: the system stays Basically Available, its state may change over time as replicas sync (Soft State), and data reaches Eventual Consistency—much like how an Instagram photo you post might take a few seconds to show up for your friends. ACID fits financial systems, inventory management, and medical records; BASE suits social networks, real-time analytics, and content delivery. Put simply, ACID is pessimistic and locks everything, while BASE is optimistic and runs fast; the deciding question is, &amp;ldquo;If the data is wrong for two seconds, does anyone lose money?&amp;rdquo;&lt;/p&gt;
&lt;h2 id="hash-tables-in-go-and-advantage-of-self-hosted-compilers"&gt;&lt;a href="https://rushter.com/blog/go-and-hashmaps/" rel="noopener noreferrer"&gt;Hash tables in Go and advantage of self-hosted compilers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go has no built-in set type, so developers commonly use a map to store unique values. A well-known trick is to use &lt;code&gt;map[int]struct{}&lt;/code&gt; instead of &lt;code&gt;map[int]bool&lt;/code&gt;, since an empty struct takes 0 bytes and the value slot shouldn&amp;rsquo;t consume any memory. However, when the author applied this in production, memory usage didn&amp;rsquo;t budge—even though both Google searches and LLMs (with web search enabled) insisted the trick still worked in Go 1.24.&lt;/p&gt;
&lt;p&gt;Because the Go compiler is self-hosted (written in Go itself), the author could easily read the runtime source code and track down the reason. Starting in Go 1.24, maps switched to a Swiss Tables implementation where keys and values are stored together inside a single slot struct. When the last field of a struct has size 0, the compiler forces it to occupy 1 byte so pointers to it don&amp;rsquo;t point past the allocation, and then adds 7 bytes of padding to align with the 8-byte &lt;code&gt;int&lt;/code&gt; key; &lt;code&gt;bool&lt;/code&gt; also takes 1 byte, so both types end up using the exact same amount of memory. Prior to Go 1.24, keys and values lived in separate arrays, allowing the compiler to omit the value array entirely for &lt;code&gt;struct{}&lt;/code&gt;. The takeaway: the old trick no longer saves memory while making code harder to read—and don&amp;rsquo;t blindly trust everything an LLM tells you.&lt;/p&gt;
&lt;h2 id="gist-of-go-concurrency"&gt;&lt;a href="https://antonz.org/go-concurrency/" rel="noopener noreferrer"&gt;Gist of Go: Concurrency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Gist of Go: Concurrency&lt;/em&gt; is an interactive book by Anton Zhiyanov that teaches concurrent programming in Go from the ground up through hands-on exercises. Unlike resources that merely introduce goroutines, channels, and &lt;code&gt;select&lt;/code&gt; before leaving readers to fend for themselves—or list concurrency patterns without explanation—the book focuses on truly understanding and properly applying these primitives. Each exercise is short enough to solve in about a page of code while staying grounded in realistic scenarios, runs right in the browser with automated tests for instant feedback, and includes reference solutions with explanations. It targets developers who already know basic Go (up through interfaces and error handling), with no prior knowledge of goroutines or channels required.&lt;/p&gt;
&lt;p&gt;Topics progress from goroutines, channels, pipelines, time, and &lt;code&gt;context&lt;/code&gt; to wait groups, data races, race conditions, semaphores, signaling, atomics, testing, and runtime internals. The book features over 500 interactive examples, 50 self-check exercises with solutions, and a 448-page PDF edition, all 100% original and human-written without AI. It grew out of a Go concurrency course the author launched in 2022 that 250 students have completed with an average 5-star rating; you can read it online or purchase full access to all exercises.&lt;/p&gt;
&lt;h2 id="the-state-of-ai-coding-2025--greptile"&gt;&lt;a href="https://www.greptile.com/state-of-ai-coding" rel="noopener noreferrer"&gt;The State of AI Coding 2025 | Greptile&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Greptile published a cross-industry report on AI software development trends in 2025, drawing on internal data from pull requests reviewed by its tool alongside public package download metrics from PyPI and npm. On engineering velocity, median PR size grew 33% between March and November 2025 (from 57 to 76 lines changed), lines of code per developer rose 76% (from 4,450 to 7,839), and mid-sized teams of 6–15 engineers saw an 89% jump. On tooling adoption, &lt;code&gt;mem0&lt;/code&gt; captured 59% market share among AI memory packages, the vector database market remains fragmented (led by Weaviate at 25%), &lt;code&gt;CLAUDE.md&lt;/code&gt; is the most popular AI rules file format at 67%, the Anthropic SDK reached 43 million monthly downloads (an 8x increase), and LiteLLM grew 4x to 41 million.&lt;/p&gt;
&lt;p&gt;On model trends, the OpenAI SDK still leads with 130 million downloads, but the OpenAI-to-Anthropic download ratio narrowed from 47:1 in January 2024 to 4.2:1 by November 2025. A performance benchmark compared GPT-5.1, GPT-5-Codex, Claude Sonnet 4.5, Claude Opus 4.5, and Gemini 3 Pro as coding agent backends: Anthropic&amp;rsquo;s two models delivered the fastest time to first token (under 2.5 seconds at p50), OpenAI&amp;rsquo;s two models achieved the highest output throughput, and Gemini 3 Pro trailed on both metrics. The report concludes with a roundup of recent research on foundation models and applications.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!VQTW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fee73de9e-d2ee-407a-ac6e-93679bdd887d_2250x2624.png" alt="A Guide to Retry Pattern in Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;URL processing was painfully slow—it took me way more time than usual to process a single URL. The summaries varied wildly in length and even had random Chinese characters mixed in from time to time (probably due to Z.AI&amp;rsquo;s model).&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 #72</title><link>https://miti99.com/en/post/2025/12/15/</link><pubDate>Mon, 15 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/15/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #72.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-easiest-way-to-build-a-type-checker"&gt;&lt;a href="https://jimmyhmiller.com/easiest-way-to-build-type-checker" rel="noopener noreferrer"&gt;The Easiest Way to Build a Type Checker&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller shares that papers and tutorials on Hindley-Milner or Algorithm W never helped him understand how a type checker is actually implemented—until he discovered bidirectional type checking. The core idea is to split the work into two directions: &lt;code&gt;infer&lt;/code&gt; deduces the type of an expression, while &lt;code&gt;check&lt;/code&gt; verifies whether an expression matches an expected type. In exchange for this simplicity, the language requires a few type annotations, usually just on function definitions, while local variables are still inferred automatically. He presents a roughly 100-line TypeScript implementation for a small language with numbers, strings, functions, function calls, &lt;code&gt;let&lt;/code&gt; bindings, and blocks.&lt;/p&gt;
&lt;p&gt;The post walks through each component: an abstract syntax tree (AST) makes traversing a program much easier than working with raw strings, and the type context is just a &lt;code&gt;Map&lt;/code&gt; from variable names to types that gets cloned whenever entering a new function or block scope. By adding addition as an example, he shows how &lt;code&gt;infer&lt;/code&gt; and &lt;code&gt;check&lt;/code&gt; mutually recurse until they bottom out at base cases. While this type checker is far from complete, it serves as an approachable starting point to extend and understand type systems without wading through dense academic papers.&lt;/p&gt;
&lt;h2 id="deprecation"&gt;&lt;a href="https://abseil.io/resources/swe-book/html/ch15.html" rel="noopener noreferrer"&gt;Deprecation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Chapter 15 of &lt;em&gt;Software Engineering at Google&lt;/em&gt;, which focuses on the planned deprecation and removal of obsolete systems. The chapter&amp;rsquo;s premise is that &amp;ldquo;code is a liability, not an asset&amp;rdquo;: every system carries ongoing operational and maintenance costs, so once an equivalent replacement exists, running both in parallel increases complexity and holds back the new system. Even so, age alone is not a reason to deprecate, and an organization should only take on as many deprecation efforts as it can realistically finish, committing to see them through to the end.&lt;/p&gt;
&lt;p&gt;The authors explain why deprecation is so hard: Hyrum&amp;rsquo;s Law means users come to depend on unpromised behaviors, a new system rarely achieves 100% parity with the old one, engineers form emotional attachments to code they wrote, and securing resources for cleanup work is a tough sell. Google distinguishes between advisory deprecation and compulsory deprecation with enforced deadlines, emphasizing clear ownership, milestones, migration support, and tooling like static analysis and large-scale changes to block new usages. Key takeaways for engineers include designing systems with replaceable parts from the start and favoring incremental in-place evolution over full rewrites.&lt;/p&gt;
&lt;h2 id="16-replication-concepts-every-software-engineer-should-know-simple-guide-for-2026"&gt;&lt;a href="https://designgurus.substack.com/p/16-replication-concepts-every-software" rel="noopener noreferrer"&gt;16 Replication Concepts Every Software Engineer Should Know (Simple Guide for 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arslan Ahmad explains sixteen data replication concepts that keep large-scale systems reliable, fast, and fault-tolerant, pairing each concept with a practical example. The post begins with the three main topologies: single-leader replication where one node accepts all writes, multi-leader replication suited for multi-region applications at the cost of conflict resolution, and leaderless replication (like Dynamo) where any node can accept writes. Next come synchronous, asynchronous, and semi-synchronous replication modes, illustrating the trade-off between durability and latency—for instance, a bank waiting for replicas to confirm a transaction versus a social network accepting a few seconds of delay before a photo appears in another region.&lt;/p&gt;
&lt;p&gt;Later sections cover read and write quorums (such as requiring three out of five replicas to acknowledge), replication lag and the risk of stale reads, failover when a primary node goes down, geo-replication, and self-healing mechanisms like read repair and hinted handoff. It serves as a concise primer for engineers looking to understand what happens under the hood of the distributed databases they use every day.&lt;/p&gt;
&lt;h2 id="50-system-design-concepts-for-beginners-in-90-minutes-"&gt;&lt;a href="https://designgurus.substack.com/p/50-system-design-concepts-for-beginners" rel="noopener noreferrer"&gt;50 System Design Concepts for Beginners in 90 Minutes [2026 Edition]&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arslan Ahmad rounds up 50 essential system design concepts in a single guide aimed at beginners and interview candidates, explaining each concisely with an intuitive example. The fundamentals section covers vertical vs. horizontal scaling, the CAP and PACELC theorems, ACID vs. BASE, throughput vs. latency, Amdahl&amp;rsquo;s Law, strong vs. eventual consistency, stateful vs. stateless architectures, and choosing between monoliths, microservices, and serverless.&lt;/p&gt;
&lt;p&gt;Subsequent sections walk through networking and communication (load balancing, CDNs, gRPC vs. REST), data storage (sharding, replication, indexing), reliability patterns like circuit breakers, retries, and idempotency, caching strategies, message queues, observability with tracing and SLIs/SLOs, and security with OAuth, TLS, and Zero Trust. The recurring theme is that no option is universally best: a system designer must understand the trade-offs of each approach to pick the right fit for the problem at hand—for example, starting with a monolith and only splitting into microservices when truly necessary.&lt;/p&gt;
&lt;h2 id="ddd-a-toolbox-not-a-religion"&gt;&lt;a href="https://threedots.tech/episode/ddd-toolbox-not-religion" rel="noopener noreferrer"&gt;DDD: A Toolbox, Not a Religion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of the &lt;em&gt;No Silver Bullet&lt;/em&gt; podcast, Miłosz and Robert from Three Dots Labs discuss why software projects often start out promising and gradually turn into legacy code nobody wants to touch: new features diverge from the original design, and instead of remodeling, teams just pile on quick patches time after time. In their view, most projects fail not because of technical challenges, but because of poorly handled business complexity—most SaaS apps use very similar tech stacks, and what actually differentiates companies is the domain they serve.&lt;/p&gt;
&lt;p&gt;The hosts treat Domain-Driven Design (DDD) as a toolbox rather than a religion: you don&amp;rsquo;t need to apply every pattern, just pick what solves your actual problem. They warn against solving imaginary problems, like spending months building a custom framework or platform before shipping real features, sharing an anecdote about a generic messaging framework that kept them from ever finishing a game jam entry. Their advice is to understand the business model before designing database schemas, and to always apply strategic patterns—like identifying the core domain and module boundaries—even when skipping tactical patterns. As Miłosz sums it up: &amp;ldquo;DDD is about understanding the domain you work in and then modeling it well in code.&amp;rdquo;&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!lwoL!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb1ec5785-ad8a-4350-b07d-005f7b04b1f1_2250x2624.png" alt="Saga Pattern Demystified: Orchestration vs Choreography"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SfCa!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F55ac4874-04fc-4ea7-a083-bde8f6f99cf5_2360x2960.png" alt="Virtualization vs. Containerization"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!zlUS!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F156acc80-7588-4fc1-8f43-7fa1458d646c_2360x2770.png" alt="5 REST API Authentication Methods"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!CYiE!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5eb76d35-fba8-48de-84d1-228060740d89_2360x2960.png" alt="What is a Firewall?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!fKIx!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7278af0a-b8cb-4b72-bd48-341e92286b1b_2360x2960.png" alt="Modem vs. Router"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!zdVq!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F60a16dc3-e973-4d2d-a0c2-7d426d5fe6c9_2250x2624.png" alt="A Guide to Service Mesh Architectural Pattern"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Q7Mr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F73400113-5bd5-4c40-a7e3-7346fb229256_3000x3900.jpeg" alt="What is a REST API?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Phtx!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa7dce573-ac95-46cc-a80d-62f80e6f0602_800x989.jpeg" alt="How Java HashMaps Work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!1-F-!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F473c684e-3c14-44c1-9889-97fef9caef15_2360x2960.png" alt="Virtualization Explained: From Bare Metal to Hosted Hypervisors"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yDvA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3c9b76d-b1b9-4284-a64e-16faa832544e_2250x2624.png" alt="Must-Know System Performance Strategies"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_5Is!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6ebf5287-65fa-4db7-8490-54792fd1886c_2360x2920.png" alt="Apache Kafka vs. RabbitMQ"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!1Hk2!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fced11d9e-ce25-439e-9a56-4ccf37c1854f_2360x2770.png" alt="The HTTP Mindmap"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!hn6T!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa0f70b08-6fa9-4413-9bd4-0571f99dba60_2360x2664.png" alt="How DNS Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Sny4!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7911abd9-06ce-48f4-98c5-c3305b752fb7_800x1142.jpeg" alt="Can a web server provide real-time updates?"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=HHUi8F_qAXM" rel="noopener noreferrer"&gt;How Does a URL Shortener Work?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #50</title><link>https://miti99.com/en/post/2025/08/09/</link><pubDate>Sat, 09 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #50.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="there-is-no-memory-safety-without-thread-safety"&gt;&lt;a href="https://www.ralfj.de/blog/2025/07/24/memory-safety.html" rel="noopener noreferrer"&gt;There is No Memory Safety Without Thread Safety&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ralf Jung, a programming language theory researcher at ETH Zurich, argues that splitting &amp;ldquo;safety&amp;rdquo; into narrow categories like memory safety and thread safety isn&amp;rsquo;t very helpful. The property we actually need is that a program never triggers Undefined Behavior (UB)—meaning it cannot &amp;ldquo;break&amp;rdquo; the language&amp;rsquo;s own invariants. To prove the point, he presents a Go program that uses no &lt;code&gt;unsafe&lt;/code&gt; operations yet still segfaults at address &lt;code&gt;0x2a&lt;/code&gt; (decimal 42): Go represents an interface value as a pair of a data pointer and a vtable pointer written in two separate instructions, so another thread can observe a torn state between the two writes, invoke the wrong method, and reinterpret an integer as a pointer.&lt;/p&gt;
&lt;p&gt;Other languages take one of two paths to prevent this. Java, C#, OCaml, JavaScript, and WebAssembly accept a performance cost so that every program—even one with data races—preserves the language&amp;rsquo;s invariants; Rust and, more recently, Swift use a type system strong enough to rule out data races at compile time. Go takes neither path, so strictly speaking, the author argues Go is not a memory-safe language, even though in practice it remains much closer to safe languages than to C. The article helps developers understand what guarantees their language actually provides, especially when writing concurrent code.&lt;/p&gt;
&lt;h2 id="i-know-when-you"&gt;&lt;a href="https://alexkondov.com/i-know-when-youre-vibe-coding/" rel="noopener noreferrer"&gt;I Know When You&amp;rsquo;re Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Kondov says he doesn&amp;rsquo;t care whether code was written by hand, copied from a forum, or generated by an LLM; what he cares about is whether what gets merged produces the right result, whether teammates can understand it next quarter, and whether it can be modified cleanly. Lately, though, he can spot LLM-written code immediately—not from repetitive comments, but because it is written in a way nobody on the team would write it: rolling a custom HTTP client that handles every edge case when the project already has a data-fetching library, reimplementing utility functions that already exist in another module, mutating global configuration instead of using module-scoped mechanisms, or writing classes in the middle of a functional codebase. The code works, reads clearly, and has tests, yet completely ignores the conventions the team agreed on.&lt;/p&gt;
&lt;p&gt;He compares it to a panicked new barista spilling coffee while the line grows out the door: customers still want a good cup even if they have to wait a moment longer. Speed is not the highest virtue; the real challenge of software has always been maintaining it over years. His advice is concrete: write better prompts, provide clearer descriptions, specify which libraries to use, give examples for the model to follow, keep files small, and stick to established patterns. Don&amp;rsquo;t outsource the maintainability of your codebase to a model&amp;rsquo;s weights.&lt;/p&gt;
&lt;h2 id="the-7-most-influential-papers-in-computer-science-history"&gt;&lt;a href="https://terriblesoftware.org/2025/01/22/the-7-most-influential-papers-in-computer-science-history/" rel="noopener noreferrer"&gt;The 7 Most Influential Papers in Computer Science History&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Terrible Software puts together a subjective chronological list of the seven papers that have shaped modern computing the most. It opens with Alan Turing&amp;rsquo;s &amp;ldquo;On Computable Numbers&amp;rdquo; (1936), which introduced the Turing machine and defined what machines can and cannot compute; next is Claude Shannon&amp;rsquo;s &amp;ldquo;A Mathematical Theory of Communication&amp;rdquo; (1948), which founded information theory and laid the groundwork for data compression and error-correcting codes. In 1970, Edgar F. Codd introduced the relational model, leading to SQL and relational database systems; in 1971, Stephen Cook proved that SAT is NP-complete, creating a shared language for reasoning about computational hardness.&lt;/p&gt;
&lt;p&gt;The remaining three papers underpin the internet: Vinton Cerf and Robert Kahn&amp;rsquo;s TCP protocol (1974), which stitched isolated networks into a global internet; Tim Berners-Lee&amp;rsquo;s &amp;ldquo;Information Management: A Proposal&amp;rdquo; (1989), which laid the foundation for the World Wide Web with hyperlinks, URLs, and HTTP; and Sergey Brin and Larry Page&amp;rsquo;s 1998 paper introducing PageRank, treating links as votes of trust to form the foundation of Google. The author also gives five honorable mentions: John McCarthy&amp;rsquo;s paper on Lisp, Dijkstra&amp;rsquo;s &amp;ldquo;Go To Statement Considered Harmful,&amp;rdquo; Leslie Lamport&amp;rsquo;s paper on logical clocks, Fred Brooks&amp;rsquo;s &amp;ldquo;No Silver Bullet,&amp;rdquo; and &amp;ldquo;Attention Is All You Need.&amp;rdquo; The overarching message: amid waves of new technology, understanding the foundations still matters.&lt;/p&gt;
&lt;h2 id="programming-vehicles-in-games"&gt;&lt;a href="https://wassimulator.com/blog/programming/programming_vehicles_in_games.html" rel="noopener noreferrer"&gt;Programming Vehicles in Games&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wassim (Wassimulator), drawing from his talk at the Better Software Conference, shares the core principles of programming vehicles in games. The starting point is that a game is not a physics simulator—it is an experience: Mario Kart and iRacing both simulate cars but prioritize very different feelings, so the first question is what experience you want to convey. The author&amp;rsquo;s first game, AV-Racer, relied entirely on hacks and &amp;ldquo;magic numbers&amp;rdquo;; it was fun enough, but broke down on edge cases, teaching him that you cannot bend reality convincingly unless you first understand what reality you are bending.&lt;/p&gt;
&lt;p&gt;The model he proposes consists of three components connected by feedback loops: the engine and transmission, which is essentially a torque calculator driven by RPM; the wheels and tires, where forces between the tire and road are generated; and the chassis, which is just a rigid body in the game&amp;rsquo;s physics engine. Engine RPM and wheel rotation speed pull each other toward equilibrium through two differential equations solved sequentially each frame. Longitudinal tire force depends on slip ratio, lateral force depends on slip angle, and both can be approximated using Hans Pacejka&amp;rsquo;s &amp;ldquo;Magic Formula.&amp;rdquo; Because a tire only has a finite friction budget, a car cannot brake at full force and corner at maximum grip simultaneously. Once the tire model is right, phenomena like understeer and oversteer emerge naturally without being hardcoded.&lt;/p&gt;
&lt;h2 id="periodic-table-of-system-design-principles"&gt;&lt;a href="https://github.com/jarulraj/periodic-table" rel="noopener noreferrer"&gt;Periodic Table of System Design Principles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joy Arulraj (Georgia Tech) proposes a &amp;ldquo;periodic table&amp;rdquo; of computer system design principles. The problem he identifies is that system design is typically taught in silos—databases, operating systems, computer architecture—each with its own vocabulary, causing the exact same principle to appear under different names. For example, relaxing consistency to gain performance shows up as isolation levels in databases, weak memory ordering in hardware, and eventual consistency protocols in distributed systems; newcomers end up relearning the same trade-off in every domain.&lt;/p&gt;
&lt;p&gt;From more than 100 influential papers, the author distills over 40 principles that meet two criteria: abstract enough not to be tied to a specific technology, and general enough to recur across multiple domains. The principles are grouped into eight categories such as Structure, Efficiency, Semantics, Distribution, Reliability, and Security, with each principle given a short symbol like &lt;code&gt;Co&lt;/code&gt; for composability or &lt;code&gt;Op&lt;/code&gt; for optimistic design. By focusing on design intent rather than specific mechanisms, the table helps students build a coherent mental map, helps researchers position their contributions more precisely, and helps engineers discuss cross-cutting design trade-offs more clearly.&lt;/p&gt;
&lt;h2 id="curing-your-ai-10x-engineer-imposter-syndrome"&gt;&lt;a href="https://colton.dev/blog/curing-your-ai-10x-engineer-imposter-syndrome/" rel="noopener noreferrer"&gt;Curing Your AI 10x Engineer Imposter Syndrome&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Colton recounts the anxiety of watching social media constantly claim that AI-assisted engineers are now 10x to 100x more productive. After seriously testing Claude Code, Cursor, Roo Code, and Zed, he found AI to be merely &amp;ldquo;fine&amp;rdquo;: good at boilerplate—especially in React—but bad at following project conventions, still prone to hallucinating libraries, and struggling with the context of large codebases. Mathematically, 10x productivity would mean finishing a full quarter&amp;rsquo;s workload in about a week and a half, which would require product ideation, code review, testing, and deployment to also run 10x faster—something that simply doesn&amp;rsquo;t happen. AI delivers short bursts of speed, like writing a one-off ESLint rule, and those bursts do not compound across the whole job.&lt;/p&gt;
&lt;p&gt;According to the author, &amp;ldquo;10x&amp;rdquo; claims come from people measuring the wrong things, people with a financial stake in AI, or executives who want employees to feel replaceable. A true &amp;ldquo;10x&amp;rdquo; engineer, if such a person exists, is someone who prevents unnecessary work from being done in the first place—something AI rarely does, and in fact actively worsens by making overbuilding easy. He also argues that it is completely fine to trade a bit of productivity for enjoying your craft, since forcing yourself to work in a way you hate only leads to burnout. His conclusion: you aren&amp;rsquo;t missing out on anything; trust yourself, you&amp;rsquo;re already doing fine, and spend less time on LinkedIn.&lt;/p&gt;
&lt;h2 id="demystifying-claude-code-hooks"&gt;&lt;a href="https://www.brethorsting.com/blog/2025/08/demystifying-claude-code-hooks/" rel="noopener noreferrer"&gt;Demystifying Claude Code Hooks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aaron Brethorst, a developer with 20 years of experience, found the official Claude Code hooks documentation hard to follow, so he wrote this guide explaining three key concepts through a practical example: running RuboCop and RSpec on a Rails project before every commit. First, hook configurations live in &lt;code&gt;~/.claude/settings.json&lt;/code&gt; for global behavior (best used sparingly) or &lt;code&gt;.claude/settings.json&lt;/code&gt; per project, checked into the repository so every team member shares the same automated checks. Second, to catch every file-editing operation, use the regex matcher &lt;code&gt;&amp;quot;Edit|MultiEdit|Write&amp;quot;&lt;/code&gt;. Third, put hook logic into dedicated scripts inside a folder like &lt;code&gt;claude-hooks&lt;/code&gt; rather than cramming unmaintainable one-liners into JSON. The hook below (note that current Claude Code docs describe hooks receiving JSON via stdin) reads the &lt;code&gt;$CLAUDE_TOOL_INPUT&lt;/code&gt; environment variable (a JSON string describing the tool about to run), uses &lt;code&gt;jq&lt;/code&gt; to extract the &lt;code&gt;command&lt;/code&gt; field, and invokes the check script only when the command starts with &lt;code&gt;git commit&lt;/code&gt;:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt; 1
&lt;/span&gt;&lt;span class="lnt"&gt; 2
&lt;/span&gt;&lt;span class="lnt"&gt; 3
&lt;/span&gt;&lt;span class="lnt"&gt; 4
&lt;/span&gt;&lt;span class="lnt"&gt; 5
&lt;/span&gt;&lt;span class="lnt"&gt; 6
&lt;/span&gt;&lt;span class="lnt"&gt; 7
&lt;/span&gt;&lt;span class="lnt"&gt; 8
&lt;/span&gt;&lt;span class="lnt"&gt; 9
&lt;/span&gt;&lt;span class="lnt"&gt;10
&lt;/span&gt;&lt;span class="lnt"&gt;11
&lt;/span&gt;&lt;span class="lnt"&gt;12
&lt;/span&gt;&lt;span class="lnt"&gt;13
&lt;/span&gt;&lt;span class="lnt"&gt;14
&lt;/span&gt;&lt;span class="lnt"&gt;15
&lt;/span&gt;&lt;span class="lnt"&gt;16
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-json" data-lang="json"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;hooks&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;PreToolUse&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;matcher&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;Bash&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;hooks&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;type&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;command&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;command&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;if echo \&amp;#34;$CLAUDE_TOOL_INPUT\&amp;#34; | jq -r &amp;#39;.command&amp;#39; | grep -q &amp;#39;^git commit&amp;#39;; then ./claude-hooks/precommit.sh; fi&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;timeout&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;180&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;The author also shares debugging tips: create a &lt;code&gt;PostToolUse&lt;/code&gt; hook that dumps the entire input JSON to a file so you can see exactly what data Claude passes, and use the &lt;code&gt;/hooks&lt;/code&gt; command to inspect and edit your configuration. In his view, hooks turn Claude Code from a chat assistant into a development workflow orchestrator, giving the entire team consistent quality checks checked right into the codebase.&lt;/p&gt;
&lt;h2 id="what-the-hell-is-getopaque-in-java"&gt;&lt;a href="https://mlangc.github.io/java/concurrency/2025/08/03/what-the-hell-is-get-opaque.html" rel="noopener noreferrer"&gt;What the Hell is GetOpaque in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article demystifies &lt;code&gt;VarHandle&lt;/code&gt;&amp;rsquo;s &lt;code&gt;getOpaque()&lt;/code&gt; and &lt;code&gt;setOpaque()&lt;/code&gt; in Java, an API with notoriously sparse documentation. The Javadoc states only that these operations access a variable &amp;ldquo;in program order, but with no assurance of memory ordering effects with respect to other threads.&amp;rdquo; In plain terms: opaque operations on the same variable cannot be reordered with respect to each other, but operations across different variables can. The author demonstrates this with JCStress tests running on a Google Axion ARM VM: a reader thread can observe the new value of &lt;code&gt;b&lt;/code&gt; before the new value of &lt;code&gt;a&lt;/code&gt; even though &lt;code&gt;a&lt;/code&gt; was written first—something that does not show up on x86 or when upgrading to acquire-release mode. According to Doug Lea&amp;rsquo;s guide, opaque mode corresponds to &lt;code&gt;relaxed&lt;/code&gt; ordering in C++ and Rust.&lt;/p&gt;
&lt;p&gt;Opaque mode is suitable when sharing a single independent value across threads, such as a primitive or a reference to an immutable object; classic examples include signaling worker threads to stop or publishing progress counters. Unlike plain mode, it prevents the JIT compiler from hoisting a stop-flag check out of a loop or caching writes in a register. However, using opaque mode to publish references to objects with non-final fields is unsafe because it establishes no happens-before relationship; experiments show reader threads occasionally observing partially constructed objects. JMH benchmarks also show that opaque reads are barely any faster than &lt;code&gt;volatile&lt;/code&gt;. The conclusion: opaque has valid niche uses but is too weak for most scenarios, and even when it is safe, &lt;code&gt;volatile&lt;/code&gt; is usually the better choice.&lt;/p&gt;
&lt;h2 id="how-far-can-we-push-ai-autonomy-in-code-generation"&gt;&lt;a href="https://martinfowler.com/articles/pushing-ai-autonomy.html" rel="noopener noreferrer"&gt;How Far Can We Push AI Autonomy in Code Generation?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On Martin Fowler&amp;rsquo;s site, Birgitta Böckeler recounts an experiment testing whether AI can autonomously generate and maintain a working application without human intervention. The team picked a straightforward target—a Spring Boot CRUD API—using mainly Claude Sonnet 3.7 and 4 in Kilo Code, and iteratively applied strategies to improve reliability: choosing a popular tech stack, splitting the workflow across specialized multi-role agents, including code examples in prompts, providing a reference application as an anchor, running generate-and-review loops, and modularizing the codebase. With 3–5 entities, each run took about 25–30 minutes and usually produced a working app; with a 10-entity schema, runs took 4–5 hours and required repeated human intervention.&lt;/p&gt;
&lt;p&gt;Despite improvements, the process still felt like playing whack-a-mole: every run introduced new issues. The AI invented unrequested features, guessed values when requirements were ambiguous, applied band-aid fixes, declared success while tests were failing, and left behind numerous issues flagged by SonarQube. The conclusion is that even for a simple application backed by extensive scaffolding, AI is not yet ready to autonomously maintain enterprise software without human oversight. Practical takeaways that do transfer immediately include building reusable prompts, exposing reference applications via MCP, leaning on static analysis, and maximizing deterministic tools like scripts and codemods.&lt;/p&gt;
&lt;h2 id="onboarding-for-coding-agents"&gt;&lt;a href="https://www.fuzzycomputer.com/posts/onboarding" rel="noopener noreferrer"&gt;Onboarding for Coding Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Holden explains how he trimmed his &lt;code&gt;CLAUDE.md&lt;/code&gt; file from hundreds of lines down to just 13. Because every AI tool looks for context in a different place (&lt;code&gt;.cursor/rules&lt;/code&gt;, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;AGENTS.md&lt;/code&gt;, etc.), he moved all project context into README files—a format that has been universal for 50 years and isn&amp;rsquo;t tied to any vendor. Instead of one massive README, he uses a convention of &lt;code&gt;README.md&lt;/code&gt; for the high-level overview and &lt;code&gt;README.&amp;lt;domain&amp;gt;.md&lt;/code&gt; for specific areas like architecture, dev commands, design system, or testing. The mental model is onboarding: every new Cursor or Claude Code session is like a new hire joining the team with zero context, so write down whatever you would want a new engineer to read before their first task, and instruct the agent to read all &lt;code&gt;**/README.md&lt;/code&gt; and &lt;code&gt;**/README.*.md&lt;/code&gt; files at the start of a session.&lt;/p&gt;
&lt;p&gt;The second pillar is &amp;ldquo;Quality Gates&amp;rdquo;: instead of listing formatting rules in a prompt, he encodes constraints into the environment through tooling, instructing the agent not to finish until type checks, formatting, linting, and unit tests all pass. LLMs are bad at counting spaces or sorting imports by eye, but great at running tools and fixing errors until the build goes green, allowing modern models to run their own OODA loop (observe, orient, decide, act). He also sets a strict rule against letting AI &amp;ldquo;vibe code&amp;rdquo; the environment: humans decide the tech stack, libraries, database, and design system, while the AI works inside those guardrails.&lt;/p&gt;
&lt;h2 id="why-java-is-still-worth-learning-in-2025-a-developer"&gt;&lt;a href="https://foojay.io/today/why-java-is-still-worth-learning-in-2025-a-developers-25-year-journey/" rel="noopener noreferrer"&gt;Why Java is Still Worth Learning in 2025: A Developer&amp;rsquo;s 25-Year Journey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Markus Westergren looks back on his 25-year journey from Java skeptic to advocate. When he first encountered Java in 1999 after working in assembly and C, he found it sluggish and untrustworthy due to automatic memory management, sticking with C for the first eight years of his career. Everything changed when he studied for the SCJP 6 certification and realized how much the language had matured. In his view, Java&amp;rsquo;s greatest strength is evolving to reduce cognitive load: from generics that make collection types explicit, to records, sealed interfaces, pattern matching for &lt;code&gt;switch&lt;/code&gt;, and virtual threads in modern Java. Backward compatibility is equally valuable: an enterprise application he helped migrate from Java 1.4 to Java 7 now runs on Java 21 without a major rewrite, meaning skills learned today stay relevant for decades.&lt;/p&gt;
&lt;p&gt;The Java ecosystem is diverse without being fragmented, offering multiple JDK distributions (Oracle, Azul Zulu, Red Hat, Amazon Corretto), mature frameworks (Spring Boot, Quarkus, Jakarta EE), and build tools (Maven, Gradle). For newcomers, he advises starting directly with Java 17 or 21, mastering object-oriented fundamentals, the collections framework, exception handling, and basic concurrency, building real projects, engaging with the community, and getting comfortable with Maven, JUnit, and Spring Boot. In short, Java in 2025 offers something rare: stability without stagnation, and innovation without disruption.&lt;/p&gt;
&lt;h2 id="why-you-should-rethink-legacy-and-consider-event-driven-architecture"&gt;&lt;a href="https://blog.scottlogic.com/2025/08/06/rethink-legacy-consider-event-driven-architecture.html" rel="noopener noreferrer"&gt;Why You Should Rethink Legacy and Consider Event-Driven Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Moore of Scott Logic argues that we need to redefine &amp;ldquo;legacy&amp;rdquo;: the problem isn&amp;rsquo;t a system&amp;rsquo;s age, but whether it is slowing the business down. Modernization shouldn&amp;rsquo;t be a knee-jerk reflex, but a strategic decision grounded in clear business value; a legacy system that runs reliably and can be modified at a predictable cost doesn&amp;rsquo;t need to be replaced yet. Instead of a risky, expensive big-bang rewrite, a coexistence strategy lets the legacy system keep running while new capabilities are built alongside it.&lt;/p&gt;
&lt;p&gt;Event-Driven Architecture is a practical way to execute that strategy. For example, suppose a legacy user-registration system doesn&amp;rsquo;t send welcome emails; rather than modifying the old codebase, you can use Change Data Capture (CDC) to watch the database, publish a &lt;code&gt;UserSignedUp&lt;/code&gt; event to a broker like Kafka or RabbitMQ, and have a new email service subscribe to that event while the legacy system remains completely untouched. This decoupling makes scaling easier, enables parallel asynchronous processing, isolates failures in new services from core transactions, and improves testability and observability. The approach isn&amp;rsquo;t a silver bullet—it fits poorly with complex stateful workflows or tightly coupled processes, and older databases may require custom CDC solutions—but in many cases it offers a low-risk, cost-effective path to gradually replacing a legacy core via the Strangler Fig pattern.&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 #24</title><link>https://miti99.com/en/post/2025/05/11/</link><pubDate>Sun, 11 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #24.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="google"&gt;&lt;a href="https://newsletter.getdx.com/p/googles-principles-for-measuring-developer-productivity" rel="noopener noreferrer"&gt;Google&amp;rsquo;s principles for measuring developer productivity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abi Noda summarizes the paper &amp;ldquo;Measuring Productivity: All Models Are Wrong, But Some Are Useful&amp;rdquo; by Google researchers Ciera Jaspan and Collin Green. The core idea is that measuring developer productivity is fundamentally an exercise in modeling: every model omits details, so the goal is building a model that remains useful without creating perverse incentives. Drawing on years of internal research at Google, the authors distill five principles. First, avoid single-metric models, because no single metric captures the inherent trade-offs of engineering work. Second, measure all outcomes you care about and use multiple metrics per outcome; when two metrics measuring velocity move in opposite directions, that divergence is an important signal to investigate. Third, think carefully about the incentives your measurements create—when a measure becomes a target, it ceases to be a good measure. Fourth, cover all three dimensions of speed, ease, and quality rather than fixating on just one. Fifth, combine objective system logs with subjective self-reported survey data from engineers.&lt;/p&gt;
&lt;p&gt;The article closes with practical advice. If your team is small enough to fit into a single conference room, you don&amp;rsquo;t need productivity metrics—just sit down and talk to them. Larger organizations should start with developer surveys, which capture the holistic engineering experience far better than raw telemetry alone. Above all, define why you are measuring before choosing any metric.&lt;/p&gt;
&lt;h2 id="in-defense-of-ruthless-managers"&gt;&lt;a href="https://www.seangoedecke.com/ruthless-managers/" rel="noopener noreferrer"&gt;In defense of ruthless managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke divides engineering managers into two archetypes: empathetic managers, who invest emotionally in their reports and regularly go to bat for them against upper management, and &amp;ldquo;ruthless&amp;rdquo; managers, who view their job simply as transmitting the company&amp;rsquo;s needs to engineers and vice versa. While Goedecke agrees that having an empathetic manager is generally great, he argues that ruthless managers are underrated for five reasons. First, they still want their engineers to be happy, because happy engineers perform better, are easier to manage, and don&amp;rsquo;t quit. Second, they accumulate far more political capital with leadership, whereas empathetic managers who constantly push back on executives often burn through their capital right when you need them to advocate for your promotion. Third, they aren&amp;rsquo;t emotionally weighed down by hard decisions, so they stay focused and unbothered. Fourth, they communicate bluntly without sugarcoating bad news or parroting corporate talking points—though they may occasionally lie or withhold information out of self-interest. Finally, they are predictable because they always align with upper management&amp;rsquo;s priorities.&lt;/p&gt;
&lt;p&gt;Goedecke stresses that this defense only applies to competent managers inside reasonably healthy companies. An incompetent, ruthless manager is a recipe for disaster, and given a free choice, most engineers should still pick an empathetic boss. Since we rarely get to choose our managers, though, understanding the strengths of both styles makes it easier to work effectively with whichever one you have.&lt;/p&gt;
&lt;h2 id="ai-ambivalence"&gt;&lt;a href="https://nolanlawson.com/2025/04/02/ai-ambivalence/" rel="noopener noreferrer"&gt;AI ambivalence&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson holds a master&amp;rsquo;s degree in computational linguistics—having studied alongside the researchers who later coined the term &amp;ldquo;stochastic parrots&amp;rdquo;—but left the field because he grew tired of purely statistical approaches and preferred building software directly. For years he avoided generative AI: he was skeptical of AGI claims and disliked how autocomplete assistants turned programming into endlessly reading code rather than writing it. By 2025, with seemingly the entire industry adopting AI, he tried Claude and Claude Code and admitted they were far more capable than he expected: querying a large codebase, generating unit tests, or refactoring dozens of call sites to a new API pattern worked shockingly fast. The problem is that it drains the joy out of programming. He feels like a babysitter reviewing piles of machine-generated code for subtle bugs, where the strongest temptation is to stop reading altogether and surrender to &amp;ldquo;vibe coding.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Lawson doesn&amp;rsquo;t offer a neat conclusion, instead capturing a mood of deep ambivalence. He still uses AI for low-stakes tasks like throwaway prototypes and unit tests, but resents how generative AI has taken over software engineering and the underlying message—as Ezra Klein put it—that human creativity is merely derivative. Caught between adapting to the new normal and keeping his manual coding skills sharp for the day &amp;ldquo;vibe-coded&amp;rdquo; systems inevitably catch fire in production, he admits nobody truly knows how this plays out.&lt;/p&gt;
&lt;h2 id="use-abstraction-to-improve-function-readability"&gt;&lt;a href="https://testing.googleblog.com/2023/09/use-abstraction-to-improve-function.html" rel="noopener noreferrer"&gt;Use Abstraction to Improve Function Readability&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This installment of the Google Testing Blog&amp;rsquo;s Code Health series, written by Palak Bansal and Mark Manley, compares two versions of a &lt;code&gt;createPizza&lt;/code&gt; function in Go. The first version crams everything into a single function: preparing the dough and toppings, looping until the oven reaches temperature, baking the pizza, and boxing and slicing it. The second version consists of just three calls—&lt;code&gt;prepare&lt;/code&gt;, &lt;code&gt;bake&lt;/code&gt;, and &lt;code&gt;box&lt;/code&gt;—each of which delegates to lower-level helpers like &lt;code&gt;addToppings&lt;/code&gt; or &lt;code&gt;heatOven&lt;/code&gt; until reaching leaf functions that handle concrete implementation details without calling further helpers. The second version is far easier to read because the first mixes multiple levels of abstraction: low-level mechanics like polling the oven thermometer sit right alongside intermediate steps like baking and high-level intent.&lt;/p&gt;
&lt;p&gt;The takeaway is the Single Level of Abstraction principle: avoid mixing abstraction levels inside the same function, and instead compose functions at matching levels so the code reads top-to-bottom like a story with self-descriptive function names. This structure makes code easier to follow, debug, and reuse; the authors point readers to Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; for a deeper dive.&lt;/p&gt;
&lt;h2 id="how-apple-pay-handles-41-million-transactions-a-day-securely"&gt;&lt;a href="https://newsletter.systemdesign.one/p/how-does-apple-pay-work" rel="noopener noreferrer"&gt;How Apple Pay Handles 41 Million Transactions a Day Securely&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neo Kim breaks down Apple Pay&amp;rsquo;s architecture through the story of a traveler tapping an iPhone at a London Underground turnstile, noting that the post is based on public research and may differ from Apple&amp;rsquo;s internal implementation. When a user adds a card to Apple Wallet, the card details and device metadata are encrypted and routed through Apple to the payment network (such as Visa or Mastercard); the actual card number is never stored in full on the iPhone or on Apple&amp;rsquo;s servers. Once the payment network verifies the card with the issuing bank, it generates a Device Account Number (DAN)—an irreversible token bound to that specific card and iPhone pair—which is stored inside the iPhone&amp;rsquo;s Secure Element, a dedicated tamper-resistant hardware chip. At checkout, the point-of-sale terminal sends transaction details to the iPhone over NFC; the user authenticates via Touch ID or Face ID, and biometric data stays strictly inside the isolated Secure Enclave processor, never leaving the device.&lt;/p&gt;
&lt;p&gt;Next, the Secure Element combines the DAN with transaction details to compute a dynamic cryptogram—similar to a time-based one-time password—and sends the authorization request through the merchant&amp;rsquo;s acquirer without the merchant ever seeing the real card number. The payment network recomputes the cryptogram against its copy of the DAN to verify the transaction, then returns an approval code and a response cryptogram for the device to verify in turn. Built on the EMV contactless specification, Apple Pay works even when the iPhone has no cellular or Wi-Fi connection and is significantly safer than a physical card because the underlying card number is never exposed.&lt;/p&gt;
&lt;h2 id="four-kinds-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2023/four_kinds_of_optimisation.html" rel="noopener noreferrer"&gt;Four Kinds of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurence Tratt opens with two observations: programmers are chronically over-optimistic about knowing where their programs spend time, and equally over-optimistic about knowing how to speed up the slow parts. The cure for the first is disciplined profiling; for the second, Tratt outlines four categories of optimization, each with its own trade-offs. First, using a better algorithm requires understanding your data distribution: selection sort is three times faster than bubble sort on random data, but much slower on already-sorted data, and hand-rolled &amp;ldquo;fast&amp;rdquo; algorithms are notorious for subtle bugs. Second, using better data structures—such as a sorted array with binary search for read-heavy static data, or shrinking struct field sizes when allocating millions of instances. Third, moving to a lower-level system: rewriting Python in Rust might yield a 60x speedup, whereas running the exact same code on PyPy instead of CPython can deliver a 4x speedup with almost zero effort. Fourth, accepting a less accurate answer—including heuristic local search that may miss the global optimum, or probabilistic/lossy approaches like Bloom filters, JPEG compression, and machine learning.&lt;/p&gt;
&lt;p&gt;Tratt generally avoids jumping straight to a low-level rewrite because the return on engineering time is often poor, preferring simple wins first. He closes with three guiding rules: always pick the simplest optimization that meets your performance target because it introduces the fewest bugs; remember that human engineering time is expensive; and breadth of optimization knowledge matters more than narrow depth.&lt;/p&gt;
&lt;h2 id="the-fifth-kind-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2025/the_fifth_kind_of_optimisation.html" rel="noopener noreferrer"&gt;The Fifth Kind of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this follow-up post, Laurence Tratt admits he left out a fifth optimization technique that he relies on constantly: parallelization. When he parallelized his Rust-based static site builder across multiple threads, build times in &amp;ldquo;quick&amp;rdquo; mode dropped from roughly 0.6 seconds to under 0.3 seconds, while full &amp;ldquo;deploy&amp;rdquo; builds ran more than 3x faster. Similarly, his &lt;code&gt;lang_tester&lt;/code&gt; test harness runs test suites in parallel, cutting a test run on a 72-core machine from 37 seconds down to 2.5 seconds—a speedup that directly improves day-to-day developer flow.&lt;/p&gt;
&lt;p&gt;He reflects on why he overlooked parallelization the first time around. First is hardware history: consumer multicore CPUs only became mainstream around 2005, and it took years before x86 and Arm memory models were well-specified enough to program against reliably. Second is language support: Java only got a sound memory model with JSR 133 in 2004, C and C++ waited until 2011, and shared-memory multithreading remained fraught with data races such as lost updates or compilers optimizing away unsynchronized writes. Languages built around immutable data or actor models avoided most of these pitfalls but often paid a performance penalty. For Tratt, Rust changed the equation via the &lt;code&gt;Send&lt;/code&gt; and &lt;code&gt;Sync&lt;/code&gt; traits and ownership rules: he has yet to hit a single data race in Rust, even if occasional &lt;code&gt;clone()&lt;/code&gt; calls or subtle mutex deadlocks still crop up. Today, he designs for parallelism right from the start.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4036e9a7-f2b6-476c-ad5d-48916db3b610_1309x1536.gif" alt="REST API Design Best Practices"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2a933717-1d59-46a6-ba51-76e24ae048fc_1280x1502.gif" alt="How to Learn Backend Development?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b9397d70-0232-4a8b-8b3e-edd4c15eb9bb_800x939.gif" alt="The Simplified Git Workflow"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1bc9340f-de4f-4767-b2f8-f4c6529e9eea_1309x1536.gif" alt="Virtualization vs Containerization"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e7afaab-de4b-4604-a557-22974fb2e3ea_1280x1532.gif" alt="How Netflix Built a Distributed Counter?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=_d0duu3dED4" rel="noopener noreferrer"&gt;Why Everyone&amp;rsquo;s Talking About MCP?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #12</title><link>https://miti99.com/en/post/2025/04/20/</link><pubDate>Sun, 20 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/20/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #12.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="fundamental-techniques-for-software-architects"&gt;&lt;a href="https://www.workingsoftware.dev/fundamental-techniques-for-software-architects/" rel="noopener noreferrer"&gt;Fundamental Techniques for Software Architects&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Patrick Roos curates roughly 30 foundational techniques every software architect should have in their toolkit, organized by project lifecycle phase. In the &lt;strong&gt;Strategic&lt;/strong&gt; phase, techniques like Impact Mapping and Wardley Mapping connect technical initiatives to business outcomes. Under &lt;strong&gt;Ideation &amp;amp; Alignment&lt;/strong&gt;, he covers Domain Storytelling, Event Storming, Ubiquitous Language, Context Mapping, the Bounded Context Canvas, and quality-attribute workshops like arc42 Q42 and Quality Storming. &lt;strong&gt;Decision-Making&lt;/strong&gt; features Architectural Principles and Architecture Decision Records (ADRs); &lt;strong&gt;Technology Management&lt;/strong&gt; introduces the Tech Stack Canvas and Technology Radar; and &lt;strong&gt;Risk Management&lt;/strong&gt; covers Risk Storming, Technical Debt Records, and Threat Modeling.&lt;/p&gt;
&lt;p&gt;The final groups focus on &lt;strong&gt;Visualization &amp;amp; Documentation&lt;/strong&gt; (the C4 Model, arc42, Documentation as Code) and &lt;strong&gt;Measurement &amp;amp; Improvement&lt;/strong&gt; (DORA Metrics, aim42, Residuality Theory). Each entry includes a concise summary along with reference talks or examples, making the article an excellent reference map: you don&amp;rsquo;t need to apply all 30 on a single project, just reach for the right tool for the problem in front of you—whether that&amp;rsquo;s untangling domain boundaries or aligning stakeholders.&lt;/p&gt;
&lt;h2 id="the-end-of-programming-as-we-know-it"&gt;&lt;a href="https://www.oreilly.com/radar/the-end-of-programming-as-we-know-it/" rel="noopener noreferrer"&gt;The End of Programming as We Know It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tim O&amp;rsquo;Reilly pushes back against the doom-and-gloom narrative that AI will put software developers out of work. Looking back through computing history—from physical plugboards, assembly, and compiled languages to operating systems, the web, and cloud computing—every time a higher-level abstraction &amp;ldquo;ended&amp;rdquo; an older way of programming, the total number of programmers actually grew, because cheaper software unlocked massive pent-up demand. Drawing on economist James Bessen&amp;rsquo;s research on the Industrial Revolution, O&amp;rsquo;Reilly argues that the biggest gains arrive only as workers &amp;ldquo;learn by doing&amp;rdquo; to master new workflows, and that junior developers who embrace AI tools can easily outpace senior engineers who refuse to adapt.&lt;/p&gt;
&lt;p&gt;Quoting practitioners like Sam Schillace, Bret Taylor, and Addy Osmani, the essay argues that we are inventing a brand-new programming paradigm around AI: humans are still essential for supplying domain context, understanding end-to-end business workflows, and hardening prototypes for production, while multi-agent coordination remains in its infancy. His conclusion: when AI multiplies developer productivity, the scope of what is worth automating—and what users expect from software—expands right along with it, marking not the death of programming, but its latest rebirth.&lt;/p&gt;
&lt;h2 id="in-defense-of-simple-architectures"&gt;&lt;a href="https://danluu.com/simple-architectures/" rel="noopener noreferrer"&gt;In defense of simple architectures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Luu shares lessons from his time at Wave, a $1.7 billion fintech company with roughly 70 engineers running on a remarkably simple architecture: a monolithic Python application backed by PostgreSQL. He also points to Stack Overflow as a classic example of scaling a monolithic architecture into one of the top 100 most-visited sites on the web. Wave chose synchronous Python over bug-prone async frameworks, offloaded slow operations to background queues, and candidly acknowledges a few regrets along the way—such as loose database transaction boundaries and friction with RabbitMQ, Celery, and SQLAlchemy. On the flip side, they were very happy with GraphQL and Kubernetes for concrete business reasons, such as spinning up isolated data centers inside individual African countries to meet local regulatory and latency requirements.&lt;/p&gt;
&lt;p&gt;The central takeaway: modern hardware is fast enough that the vast majority of applications—even at very high traffic—can run comfortably on a simple monolithic architecture that is far cheaper to operate and easier to maintain. Keeping application architecture as boring as possible preserves the team&amp;rsquo;s finite &amp;ldquo;complexity budget&amp;rdquo; for the problems that actually differentiate the business, like integrating directly with local telecom providers. Luu also critiques how tech conferences disproportionately spotlight complex microservice architectures from hyperscalers, luring small companies into copying complexity they don&amp;rsquo;t need.&lt;/p&gt;
&lt;h2 id="the-trouble-with"&gt;&lt;a href="https://newsletter.weskao.com/p/the-trouble-with-good-enough" rel="noopener noreferrer"&gt;The trouble with &amp;ldquo;good enough&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao opens with artist Josef Albers&amp;rsquo;s observation that if you say the word &amp;ldquo;red&amp;rdquo; to 50 people, there will be 50 different shades of red in their minds. In the same way, everyone has a different internal definition of &amp;ldquo;good enough.&amp;rdquo; We all know the textbook advice to stop polishing once we hit diminishing returns—but in practice, many people declare victory long before they actually reach that point, often without realizing how low their bar is set.&lt;/p&gt;
&lt;p&gt;Kao illustrates the gap with concrete examples: a product feature is only &amp;ldquo;good enough&amp;rdquo; when it actually solves the customer&amp;rsquo;s problem, not merely when a manager signs off on shipping it; an email is only &amp;ldquo;good enough&amp;rdquo; when it persuades the reader to act, not the moment you hit send. Raising your bar doesn&amp;rsquo;t mean spending 30 hours perfecting every minor task—it means pushing 10–20% further along the quality curve on your highest-leverage work. The post closes with reflection questions to help you spot where you might be calling work &amp;ldquo;good enough&amp;rdquo; prematurely and where raising your standards will pay off most.&lt;/p&gt;
&lt;h2 id="should-managers-still-code"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/should-managers-still-code" rel="noopener noreferrer"&gt;Should managers still code?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier tackles a classic reader question: should engineering managers still write code day-to-day? He starts by drawing a sharp distinction between &lt;strong&gt;being in the code&lt;/strong&gt; and &lt;strong&gt;writing code on the critical path&lt;/strong&gt;. Every engineering manager should stay close to the code: understanding how the system is architected, reviewing pull requests and design docs, helping triage production incidents, pairing with teammates, and owning the team&amp;rsquo;s overall engineering quality. Taking on critical-path feature implementation yourself, however, is much trickier because a manager&amp;rsquo;s fragmented calendar quickly turns them into a bottleneck for the team. Stanier also situates the question in the post-ZIRP era of &amp;ldquo;flattening&amp;rdquo; org charts, where many managers feel renewed pressure to prove their hands-on technical chops.&lt;/p&gt;
&lt;p&gt;For managers who want (or need) to keep coding without blocking their team, he offers practical strategies: blocking out dedicated focus hours on your calendar, pair programming, doing deep code reviews by checking out branches and running them locally, leaning in during early prototyping or incident response, and building small exploratory proofs-of-concept with new technologies to share learnings back with the team.&lt;/p&gt;
&lt;h2 id="what-is-saga-pattern-in-distributed-systems"&gt;&lt;a href="https://newsletter.scalablethread.com/p/what-is-saga-pattern-in-distributed" rel="noopener noreferrer"&gt;What is Saga Pattern in Distributed Systems?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a microservices architecture, a single user action like placing an order often spans multiple services (inventory, payment, shipping), each owning its own isolated database—meaning traditional single-database ACID transactions no longer work. The &lt;strong&gt;Saga Pattern&lt;/strong&gt; solves this by breaking a distributed business transaction into a sequence of local transactions; if any step fails along the way, the saga executes a chain of &lt;strong&gt;compensating transactions&lt;/strong&gt; to semantically undo the steps that already succeeded.&lt;/p&gt;
&lt;p&gt;The post contrasts the two main ways to coordinate a saga. &lt;strong&gt;Orchestration&lt;/strong&gt; uses a central coordinator service that directs each participant step by step, making control flow, monitoring, and error recovery easy to follow at the risk of central coupling. &lt;strong&gt;Choreography&lt;/strong&gt; lets services react to one another asynchronously via domain events without a central orchestrator, keeping services loosely coupled but making end-to-end flow and failure recovery harder to trace as workflows grow. The author wraps up with a summary of the Saga pattern&amp;rsquo;s strengths (eventual data consistency, horizontal scalability, flexibility) and trade-offs (implementation complexity, tricky compensation logic, and added latency).&lt;/p&gt;
&lt;h2 id="what-would-happen-if-we-didn"&gt;&lt;a href="https://github.com/Hawzen/hdp" rel="noopener noreferrer"&gt;What would happen if we didn&amp;rsquo;t use TCP or UDP?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author asks a fun networking question: what actually happens if you send packets over a custom transport-layer protocol instead of TCP, UDP, or ICMP? To find out, he designed a toy protocol called &lt;strong&gt;HDP&lt;/strong&gt;, wrote a client and server in Rust using raw sockets, and tested sending packets over the macOS loopback interface across every possible 8-bit IP &lt;code&gt;Protocol&lt;/code&gt; header number. Most protocol numbers went through fine locally, except &lt;code&gt;1&lt;/code&gt; (ICMP), &lt;code&gt;2&lt;/code&gt; (IGMP), and &lt;code&gt;6&lt;/code&gt; (TCP), which the macOS kernel intercepted before they reached the user-space server, &lt;code&gt;50&lt;/code&gt; and &lt;code&gt;51&lt;/code&gt; (IPSec ESP/AH), which the OS refused to send, and &lt;code&gt;256&lt;/code&gt;, which overflows the 8-bit field. Re-running the exact same test on Linux yielded completely different behavior, showing how differently OS kernels handle raw sockets.&lt;/p&gt;
&lt;p&gt;Testing across the public Internet got even weirder: sending HDP packets to a DigitalOcean droplet let &lt;em&gt;exactly one&lt;/em&gt; packet through before every subsequent packet was silently dropped—likely due to provider firewall rules and NAT gateways that rely on TCP/UDP port numbers to track connection state. Sending from a Mac at home to an AWS EC2 instance also dropped after the first packet, whereas two AWS instances in the same region communicated over HDP without issue at latencies indistinguishable from UDP; a March 1, 2025 update showed that sending over &lt;strong&gt;IPv6&lt;/strong&gt; (bypassing NAT entirely) worked reliably end-to-end too. The verdict: custom IP transport protocols can work in controlled environments or over IPv6, but middleboxes on the public IPv4 Internet are why modern protocols like QUIC are built on top of UDP.&lt;/p&gt;
&lt;h2 id="scoped-values-in-java-24---inside-java-newscast-86"&gt;&lt;a href="https://www.youtube.com/watch?v=7tfUJLUbZiM" rel="noopener noreferrer"&gt;Scoped Values in Java 24 - Inside Java Newscast #86&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Inside Java Newscast #86 introduces &lt;strong&gt;Scoped Values&lt;/strong&gt;, entering its fourth preview in Java 24 (JEP 487), which provides a safe, clean, and efficient way to share immutable data across methods within a thread and its child threads by binding values to a bounded lexical execution scope. The video contrasts Scoped Values with legacy &lt;code&gt;ThreadLocal&lt;/code&gt; variables and shows how child virtual threads forked inside a &lt;code&gt;StructuredTaskScope&lt;/code&gt; automatically inherit parent bindings—eliminating mutable global state and making concurrent code easier to reason about.&lt;/p&gt;
&lt;h2 id="java-24---better-language-better-apis-better-runtime"&gt;&lt;a href="https://www.youtube.com/watch?v=2NTyzL-9Bfo" rel="noopener noreferrer"&gt;Java 24 - Better Language, Better APIs, Better Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This video rounds up the standout improvements landing across Java 22, 23, and 24 along three tracks: language features, standard library APIs, and JVM runtime performance. Highlights include unnamed patterns and variables, single-statement module imports, the finalized Foreign Function &amp;amp; Memory (FFM) API, Stream Gatherers, and under-the-hood runtime optimizations that make modern Java more expressive, ergonomic, and performant.&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/f112df94-df52-4140-98ec-873e5b74d988_1280x1601.gif" alt="30 Free APIs for Developers"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c3bf4776-744b-4e87-85f8-6dddd6d85597_1280x1566.gif" alt="The Generative AI Learning Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c1dbb32e-8d1b-4c13-ae48-fe485ad92191_1280x1601.gif" alt="HTTP/1 -&amp;gt; HTTP/2 -&amp;gt; HTTP/3"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d864f35c-537c-4571-8644-ce20d1a0caa5_1280x1427.gif" alt="Structure of URL"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Lis4w4_bBc" rel="noopener noreferrer"&gt;8 Most Important Tips for Designing Fault-Tolerant System&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-resources-from-redisio"&gt;Bonus 3: Interesting resources from &lt;a href="https://redis.io/" rel="noopener noreferrer"&gt;Redis.io&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://redis.io/resources/cache-and-message-broker-for-microservices-solution-brief.pdf" rel="noopener noreferrer"&gt;Cache and Message Broker for Microservices&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://redis.io/wp-content/uploads/2021/12/caching-at-scale-with-redis-updated-2021-12-04.pdf" rel="noopener noreferrer"&gt;Caching at Scale With Redis&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #8</title><link>https://miti99.com/en/post/2025/03/24/</link><pubDate>Mon, 24 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #8.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="let"&gt;&lt;a href="https://info.michael-simons.eu/2025/02/05/lets-deadlock-all-the-things/" rel="noopener noreferrer"&gt;Let&amp;rsquo;s deadlock all the things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael J. Simons recounts a &amp;ldquo;rookie mistake&amp;rdquo; he made while migrating code from legacy &lt;code&gt;HttpURLConnection&lt;/code&gt; to Java&amp;rsquo;s modern &lt;code&gt;HttpClient&lt;/code&gt;. Because &lt;code&gt;HttpClient&lt;/code&gt; does not directly expose an &lt;code&gt;OutputStream&lt;/code&gt; for streaming data into a request body (for instance, when using Jackson to serialize a large JSON payload), he connected a &lt;code&gt;PipedInputStream&lt;/code&gt; and a &lt;code&gt;PipedOutputStream&lt;/code&gt; and ended up performing both the write and the read on the same thread—even though the JavaDoc explicitly warns that doing so can deadlock. Initial unit tests passed because the test payloads were tiny, but as soon as a payload exceeded the default 1,024-byte pipe buffer in production, the thread blocked forever; repeated enough times, it starves the entire thread pool.&lt;/p&gt;
&lt;p&gt;What could have prevented the bug, the author reflects, was a little less overconfidence, a second pair of eyes in code review, and thorough boundary testing. AI assistants might help generate larger test payloads, he notes, but rarely catch subtle API misuses—and even IntelliJ didn&amp;rsquo;t flag a warning. The fix was to create the two streams independently, connect them outside both the reader and writer lambdas, run the write operation on a dedicated virtual thread, and close the output stream inside that thread. It&amp;rsquo;s a great reminder to read the JavaDoc carefully and understand the threading model of the APIs you use.&lt;/p&gt;
&lt;h2 id="engineers-who-won"&gt;&lt;a href="https://www.seangoedecke.com/taking-a-position/" rel="noopener noreferrer"&gt;Engineers who won&amp;rsquo;t commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that sitting on the fence in technical discussions is only acceptable when you are a junior engineer. Once you are the person in the room with the most context, skill, or influence, you have a responsibility to take a position—even when you are only 55–60% confident. Staying silent forces less-informed teammates to guess, creates a vacuum where the loudest, least-competent voice can steer the group into a bad idea, and ultimately punts hard technical decisions onto engineering managers. The author bluntly calls this refusal to commit cowardice, rooted in a fear of being wrong that he himself had to overcome earlier in his career.&lt;/p&gt;
&lt;p&gt;Managers, he notes, are generally quite forgiving when you make a well-reasoned call that turns out to be wrong, as long as you aren&amp;rsquo;t wrong all the time. Refusing to give time estimates is the same failure mode: managers need a rough ballpark to plan around, and answering &amp;ldquo;it depends&amp;rdquo; just forces them to make up a number themselves. The one exception is genuinely toxic workplaces where engineers are punished for missed estimates—there, keeping your head down is understandable. He also adds that when brainstorming with peers who share your level of context, staying open-minded and exploratory is completely fine.&lt;/p&gt;
&lt;h2 id="patterns-for-building-realtime-features"&gt;&lt;a href="https://zknill.io/posts/patterns-for-building-realtime/" rel="noopener noreferrer"&gt;Patterns for building realtime features&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zak Knill surveys four common architectural patterns for building real-time features where a server pushes one user&amp;rsquo;s changes out to other connected clients. The &lt;strong&gt;poke/pull&lt;/strong&gt; pattern is the easiest to bolt onto an existing system: the server sends a lightweight &amp;ldquo;poke&amp;rdquo; notification prompting clients to refetch the latest state via standard HTTP APIs, though this can trigger a thundering herd of simultaneous requests that must be mitigated with caching or client-side jitter. &lt;strong&gt;Push state&lt;/strong&gt; sends the entire updated state payload directly, preventing client drift, but scales poorly as state objects grow and makes it hard for clients to tell exactly what changed. &lt;strong&gt;Push ops&lt;/strong&gt; sends only the delta operation (such as flipping a todo item&amp;rsquo;s &lt;code&gt;completed&lt;/code&gt; field), keeping payloads small, but requires a way to fetch initial state and demands that the server track each client&amp;rsquo;s current state version. &lt;strong&gt;Event sourcing&lt;/strong&gt; broadcasts the domain event itself, requiring every client to reimplement the business logic needed to interpret and fold that event into local state.&lt;/p&gt;
&lt;p&gt;At the transport layer, WebSockets, Server-Sent Events (SSE), and long polling all operate as 1-to-1 HTTP connections between a single client and a single server instance. Once you scale horizontally across multiple server replicas, the instance that processes a write is often not the instance holding open connections to the other clients that need the update. Rather than having every server replica poll the database, the author recommends using a Pub/Sub backbone to fan updates out across instances and manage connection infrastructure.&lt;/p&gt;
&lt;h2 id="optimizing-the-databases-at-quora"&gt;&lt;a href="https://quoraengineering.quora.com/Optimizing-the-databases-at-Quora" rel="noopener noreferrer"&gt;Optimizing the databases at Quora&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Quora engineering team shares how they optimized their database tier as the platform scaled to handle massive data volumes while keeping user-facing latency low. Their first strategy was partitioning data (sharding) by &lt;code&gt;user_id&lt;/code&gt; to distribute load across multiple database servers. Alongside sharding, the team profiled common query patterns, added targeted indexes, and eliminated redundant queries. Quora also built a multi-layered caching architecture—spanning application-level caches for hot objects, database-level query caching, and a distributed Memcached tier—while separating read and write paths so each side could scale independently.&lt;/p&gt;
&lt;p&gt;Beyond those core techniques, Quora invested heavily in comprehensive monitoring and alerting to track database health and catch anomalies early. Key takeaways include treating performance optimization as an ongoing discipline rather than a one-off project, building automation tooling for routine database administration, and constantly balancing raw performance gains against system simplicity.&lt;/p&gt;
&lt;h2 id="failure-mitigation-for-microservices-an-intro-to-aperture"&gt;&lt;a href="https://careersatdoordash.com/blog/failure-mitigation-for-microservices-an-intro-to-aperture/" rel="noopener noreferrer"&gt;Failure Mitigation for Microservices: An Intro to Aperture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cong Ma and Matt Ranney from DoorDash examine common failure modes in microservice architectures: cascading failures rippling across service dependencies, retry storms where aggressive retries pile extra load onto an already degraded service, death spirals where failed nodes shift traffic onto surviving nodes until they collapse too, and metastable failures where a positive feedback loop keeps a system wedged even after the original trigger disappears. Traditional defenses like local load shedding, circuit breakers, and reactive autoscaling only see a single service&amp;rsquo;s local state, require brittle threshold tuning, and cannot coordinate with one another; the authors also advocate predictive autoscaling over reactive scaling that kicks in only after load has already spiked.&lt;/p&gt;
&lt;p&gt;From there, the post evaluates Aperture, an open-source reliability management platform from FluxNinja designed around global visibility and closed-loop control. Aperture collects telemetry from service nodes into Prometheus, uses a standalone controller to monitor deviations from SLOs based on declarative YAML policies, and actuates proportional responses—such as load shedding or distributed rate limiting—at individual nodes. After integrating Aperture into a core service in their staging environment, DoorDash found it worked well as an easy-to-configure load shedder compared to their existing setup, though more advanced capabilities like coordinated multi-service failure mitigation remained to be tested.&lt;/p&gt;
&lt;h2 id="zero-configuration-service-mesh-with-on-demand-cluster-discovery"&gt;&lt;a href="https://netflixtechblog.com/zero-configuration-service-mesh-with-on-demand-cluster-discovery-ac6483b52a51" rel="noopener noreferrer"&gt;Zero Configuration Service Mesh with On-Demand Cluster Discovery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team recounts their journey migrating to a service mesh. Netflix began moving to the cloud in 2008, with the streaming platform running entirely on AWS by 2010. Back when cloud-native tooling barely existed, they built Eureka for service discovery and Ribbon for inter-process communication (IPC). That architecture served them well for a decade, but as internal traffic diversified across REST, GraphQL, and gRPC in multiple programming languages—and teams needed advanced capabilities like adaptive concurrency limits and circuit breaking—maintaining polyglot client libraries became unsustainable. Moving to an Envoy-based service mesh let them centralize IPC logic in an out-of-process proxy.&lt;/p&gt;
&lt;p&gt;The biggest roadblock was that Envoy expects every upstream cluster a service might call to be declared ahead of time, whereas a typical Netflix service talks to dozens of upstream clusters whose owners often don&amp;rsquo;t know the full dependency list—and pushing every cluster in the company to every Envoy proxy was impossible with millions of endpoints. Netflix partnered with Kinvolk and the Envoy community to build &lt;strong&gt;On-Demand Cluster Discovery&lt;/strong&gt;: when an outgoing request targets an unknown cluster, Envoy pauses the request, queries the control plane via CDS (Cluster Discovery Service), fetches its endpoints via EDS backed by Eureka, and resumes the request. This made migration completely zero-configuration for service owners, at the cost of a few extra milliseconds on the very first request to a new cluster—meaning only ultra-latency-sensitive services need to pre-declare clusters or pre-warm connections.&lt;/p&gt;
&lt;h2 id="the-quest-to-understand-metric-movements"&gt;&lt;a href="https://medium.com/pinterest-engineering/the-quest-to-understand-metric-movements-8ab12ae97cda" rel="noopener noreferrer"&gt;The Quest to Understand Metric Movements&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Pinterest engineering team introduces the three pillars behind their automated Root Cause Analysis (RCA) system for investigating sudden spikes or drops in core business metrics—movements that can stem from anything from an OS upgrade to a broken data pipeline. The first approach, &lt;strong&gt;Slice and Dice&lt;/strong&gt;, breaks a metric down across dimensions like country, device type, and Pin format into a hierarchical segment tree (inspired by LinkedIn&amp;rsquo;s ThirdEye) and scores each segment&amp;rsquo;s anomaly contribution; this proved especially effective for video playback metrics. The second approach, &lt;strong&gt;General Similarity&lt;/strong&gt;, searches for other metrics that moved in a similar pattern over the same time window using Pearson correlation, Spearman rank correlation, Euclidean distance, and dynamic time warping—with Pearson and Spearman proving most useful because they provide p-values and capture inverse relationships cleanly (with the standard caveat that correlation does not imply causation).&lt;/p&gt;
&lt;p&gt;The third approach, &lt;strong&gt;Experiment Effects&lt;/strong&gt;, inverts traditional A/B test analysis: given a moving metric, it ranks active experiments that had the strongest statistically significant impact on that metric using Welch&amp;rsquo;s t-test and noise filters, and is now integrated into Pinterest&amp;rsquo;s experimentation platform covering nearly 2,000 metrics. Analysts can chain all three techniques iteratively to narrow down root causes. Looking ahead, Pinterest plans to incorporate user feedback loops, explore causal discovery to map cause-and-effect graphs across metrics, and embed RCA directly into their data discovery and visualization tools.&lt;/p&gt;
&lt;h2 id="meta"&gt;&lt;a href="https://cacm.acm.org/research/metas-hyperscale-infrastructure-overview-and-insights/" rel="noopener noreferrer"&gt;Meta&amp;rsquo;s Hyperscale Infrastructure: Overview and Insights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chunqiang Tang provides a sweeping overview of Meta&amp;rsquo;s hyperscale infrastructure and the lessons learned along the way, arguing that while few engineers directly build infrastructure at this scale, many mainstream industry technologies originate there. Meta&amp;rsquo;s engineering culture revolves around four pillars: moving fast with continuous deployment, technological openness via a unified monorepo and major open-source projects like PyTorch, Llama, and Presto, conducting systems research directly on production infrastructure rather than in an isolated research lab, and standardizing on shared infrastructure building blocks (for instance, converging product teams onto ZippyDB as a common key-value store). To maximize developer productivity, Meta pushes continuous deployment to extreme scale—executing over 100,000 configuration changes per day with 97% of services deploying completely automatically, while roughly 50% more engineers write serverless functions than traditional long-running services.&lt;/p&gt;
&lt;p&gt;To drive down hardware costs, Meta treats its global fleet of data centers as a single planet-scale computer, automatically placing and migrating workloads across regions, co-designing hardware and software to compensate for commodity hardware failure rates, and tiering storage across hot, warm, and cold media. On the AI front, Meta co-designs the entire stack—from PyTorch, custom AI accelerators, and datacenter fabrics up to foundation models like Llama—and projects that before the end of the decade, more than half of its datacenter power capacity will be dedicated to AI workloads.&lt;/p&gt;
&lt;h2 id="incremental-platforms-monolithic-modular-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-platforms-monolithic" rel="noopener noreferrer"&gt;Incremental Platforms: Monolithic Modular Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kicking off a series on incremental architecture for SaaS products, Marcos F. Lobo introduces the &lt;strong&gt;Modular Monolith&lt;/strong&gt;: packaging and deploying the entire application as a single artifact while structuring the internal codebase into well-defined modules with clear responsibilities that communicate strictly through explicit interfaces and contracts. This approach retains the operational simplicity of a monolith while capturing the modularity benefits of decoupled design. To pull it off, the author advises defining strict module boundaries and using patterns like Facade to hide internal implementation details, enforcing high cohesion and low coupling within each module, aligning package structure with module boundaries so modules can be extracted later if needed, pairing use-case testing with CI/CD, and wiring dependencies via dependency injection or in-process messaging and events.&lt;/p&gt;
&lt;p&gt;The benefits include simple single-artifact deployment and operations, easier refactoring and local development, fast in-memory calls between modules instead of network RPCs, straightforward transactional consistency, and natural alignment with Domain-Driven Design when modules map to bounded contexts. According to the author, a modular monolith is an ideal starting point for early-stage products, small teams, and systems that prioritize strong consistency, while serving as a clean stepping stone toward microservices if and when business scale demands it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos-from-bytebytego"&gt;Bonus: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Kqal7QaCCM" rel="noopener noreferrer"&gt;How the Garbage Collector Works in Java, Python, and Go!&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus 2: 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/c3beec9e-cd04-4748-ae7e-3299b42883f6_2360x2824.png" alt="How to Build Idempotent APIs"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2f632296-4214-4ec8-a1d2-280e9b7f2696_1280x1532.gif" alt="12 Algorithms for System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/65a92a81-f2c5-4aed-9faa-35a66124cffe_1283x1536.gif" alt="How Kubernetes Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a6903386-4b5f-450e-b64d-839c6fdf8238_1280x1601.gif" alt="PostgreSQL 101: The Everything Database"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/06c5ad46-faaf-479b-bde3-b5de8033b4e9_1280x1664.gif" alt="Top 12 Tips for API Security"&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-images-from-designgurus"&gt;Bonus 3: Interesting images from &lt;a href="https://designgurus.io/" rel="noopener noreferrer"&gt;DesignGurus&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://www.designgurus.io/_next/image?url=https%3A%2F%2Fstorage.googleapis.com%2Fdownload%2Fstorage%2Fv1%2Fb%2Fdesigngurus-prod.appspot.com%2Fo%2Fee5726e8e29469477b999c100%3Fgeneration%3D1726724098184989%26alt%3Dmedia&amp;amp;w=3840&amp;amp;q=75&amp;amp;dpl=dpl_3Rx6M949Pc1cQKT3QTdj87FcKNdg" alt="System Design Master Template"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>