<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Reliability on miti99</title><link>https://miti99.com/en/tags/reliability/</link><description>Recent content in Reliability 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/reliability/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #133</title><link>https://miti99.com/en/post/2026/10/01/</link><pubDate>Thu, 01 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #133.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-go-is-an-ideal-language-for-ai-assisted-software-engineering"&gt;&lt;a href="https://developers.googleblog.com/why-go-is-an-ideal-language-for-ai-assisted-software-engineering/" rel="noopener noreferrer"&gt;Why Go is an Ideal Language for AI-Assisted Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with &lt;code&gt;gofmt&lt;/code&gt;, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.&lt;/p&gt;
&lt;p&gt;On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go&amp;rsquo;s checksum database guards against tampered dependencies, while &lt;code&gt;govulncheck&lt;/code&gt; alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and &lt;code&gt;go fix&lt;/code&gt; lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.&lt;/p&gt;
&lt;h2 id="how-does-programming-language-affect-token-efficiency-and-correctness"&gt;&lt;a href="https://danluu.com/pl-tokens/" rel="noopener noreferrer"&gt;How does programming language affect token efficiency and correctness?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete &lt;code&gt;zstd&lt;/code&gt; decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).&lt;/p&gt;
&lt;p&gt;The results tell a nuanced story: on &lt;code&gt;zstd&lt;/code&gt; at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed &lt;code&gt;byte&lt;/code&gt; coercion throws an exception on values &lt;code&gt;128–255&lt;/code&gt;. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren&amp;rsquo;t enough to draw universal laws, the blanket claim that &amp;ldquo;dynamic languages are better for LLMs&amp;rdquo; doesn&amp;rsquo;t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.&lt;/p&gt;
&lt;h2 id="my-agentic-coding-setup-july-2026"&gt;&lt;a href="https://domenic.me/agentic-coding-setup/" rel="noopener noreferrer"&gt;My Agentic Coding Setup, July 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a &amp;ldquo;semi-disposable&amp;rdquo; Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (&lt;code&gt;--dangerously-skip-permissions&lt;/code&gt; / &lt;code&gt;--yolo&lt;/code&gt;) mode with &lt;code&gt;gh&lt;/code&gt; pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn&amp;rsquo;t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.&lt;/p&gt;
&lt;p&gt;The remaining pieces solve each workflow friction point: &lt;code&gt;git worktree&lt;/code&gt; lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT&amp;rsquo;s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and &lt;code&gt;chezmoi&lt;/code&gt; syncs his &lt;code&gt;AGENTS.md&lt;/code&gt;, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.&lt;/p&gt;
&lt;h2 id="the-bedrock-of-software-design"&gt;&lt;a href="https://alex.draftist.io/blog/the-bedrock-of-software-design-ycqvcedsj" rel="noopener noreferrer"&gt;The Bedrock of Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. &lt;em&gt;Product types&lt;/em&gt; combine multiple fields into a single value, like a struct with an &lt;code&gt;id&lt;/code&gt; and a &lt;code&gt;role&lt;/code&gt;; &lt;em&gt;sum types&lt;/em&gt; (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either &lt;code&gt;Anonymous&lt;/code&gt; or &lt;code&gt;Authenticated(User)&lt;/code&gt;. When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with &lt;code&gt;Switchable&lt;/code&gt; and &lt;code&gt;Fixed&lt;/code&gt; variants, each holding only the fields that actually apply, making illegal states unrepresentable.&lt;/p&gt;
&lt;p&gt;The same thinking applies to errors and the absence of values. With unchecked exceptions, a function&amp;rsquo;s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via &lt;code&gt;Result&lt;/code&gt;, whose error type can itself be a domain-specific sum type carrying rich context. &lt;code&gt;Option&amp;lt;T&amp;gt;&lt;/code&gt; replaces &lt;code&gt;null&lt;/code&gt;, and a signature like &lt;code&gt;Result&amp;lt;Option&amp;lt;User&amp;gt;, FindUserError&amp;gt;&lt;/code&gt; cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive &lt;code&gt;match&lt;/code&gt; expressions force callers to handle every variant, so when a new &lt;code&gt;Staff&lt;/code&gt; role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev&amp;rsquo;s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.&lt;/p&gt;
&lt;h2 id="90--of-the-t-distribution"&gt;&lt;a href="https://entropicthoughts.com/ninety-percent-of-the-t-distribution" rel="noopener noreferrer"&gt;90 % of the t distribution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student&amp;rsquo;s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.&lt;/p&gt;
&lt;p&gt;With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you&amp;rsquo;re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-computer-not-a-container--introducing-cloudflarecomputer"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-computer/" rel="noopener noreferrer"&gt;Your agent needs a computer, not a container — introducing @cloudflare/computer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare has released a preview of &lt;code&gt;@cloudflare/computer&lt;/code&gt;, an open-source, npm-installable agent runtime that gives every AI agent its own virtual &amp;ldquo;computer&amp;rdquo; complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare&amp;rsquo;s target is for containers to handle less than 10% of an agent&amp;rsquo;s workload.&lt;/p&gt;
&lt;p&gt;Architecturally, the runtime decouples the agent&amp;rsquo;s &amp;ldquo;brain&amp;rdquo; from its &amp;ldquo;hands&amp;rdquo;: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a &lt;code&gt;node:fs&lt;/code&gt;-compatible wrapper. Two execution backends sit behind a unified &lt;code&gt;exec&lt;/code&gt; interface: the isolate backend uses &lt;code&gt;just-bash&lt;/code&gt; to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.&lt;/p&gt;
&lt;h2 id="notes-on-incidents"&gt;&lt;a href="https://www.seangoedecke.com/notes-on-incidents/" rel="noopener noreferrer"&gt;Notes on incidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic &amp;ldquo;firefighting&amp;rdquo; often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.&lt;/p&gt;
&lt;p&gt;When intervention &lt;em&gt;is&lt;/em&gt; needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.&lt;/p&gt;
&lt;h2 id="beyond-clean-code-why-your-comments-matter"&gt;&lt;a href="https://blog.moertel.com/posts/2026-07-27-beyond-clean-code-why-your-comments-matter.html" rel="noopener noreferrer"&gt;Beyond “Clean Code”: Why Your Comments Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express &lt;em&gt;what&lt;/em&gt; the machine is instructed to do, whereas human readers also need to know &lt;em&gt;what the author intended&lt;/em&gt; and &lt;em&gt;why&lt;/em&gt; the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn&amp;rsquo;t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; that comments shouldn&amp;rsquo;t be used as deodorant for needlessly tangled code, he argues that the dogma &amp;ldquo;every comment is a failure&amp;rdquo; goes way too far. Crucial &amp;ldquo;why&amp;rdquo; context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.&lt;/p&gt;
&lt;p&gt;Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. &lt;em&gt;&amp;ldquo;Comments lie&amp;rdquo;&lt;/em&gt;: without a comment stating the intent, buggy code leaves zero clue that it&amp;rsquo;s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. &lt;em&gt;&amp;ldquo;Comments rot&amp;rdquo;&lt;/em&gt;: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.&lt;/p&gt;
&lt;h2 id="relying-on-go"&gt;&lt;a href="https://antonz.org/relying-on-go/" rel="noopener noreferrer"&gt;Relying on Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many new programming languages pitch themselves as &amp;ldquo;like Go, but with more features&amp;rdquo; or &amp;ldquo;like Rust, but simpler.&amp;rdquo; Anton Zhiyanov takes the opposite path with Solod, a &amp;ldquo;systems language for C and Go programmers&amp;rdquo;: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, &lt;code&gt;gopls&lt;/code&gt; autocomplete, linters, formatters, and &lt;code&gt;go.mod&lt;/code&gt; package management. The developer workflow is identical to Go: install the &lt;code&gt;so&lt;/code&gt; CLI tool, initialize a Go module, import Solod&amp;rsquo;s standard library package, and write normal Go code; &lt;code&gt;so run .&lt;/code&gt; compiles and runs the binary just like &lt;code&gt;go run&lt;/code&gt;. Even Solod&amp;rsquo;s standard library reuses large swaths of Go&amp;rsquo;s standard library code and test suites, adapted for manual memory management.&lt;/p&gt;
&lt;p&gt;Zhiyanov is upfront about the trade-offs: standard Go tooling doesn&amp;rsquo;t know about Solod&amp;rsquo;s subset restrictions, so &lt;code&gt;gopls&lt;/code&gt; won&amp;rsquo;t warn you if you use unsupported Go features like closures or iterators—catching those is up to the &lt;code&gt;so&lt;/code&gt; compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, &lt;code&gt;so&lt;/code&gt; transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn&amp;rsquo;t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod&amp;rsquo;s greatest strength.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was reviewed and updated 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 #132</title><link>https://miti99.com/en/post/2026/09/10/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #132.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="perfection-is-not-over-engineering"&gt;&lt;a href="https://var0.xyz/posts/perfection-is-not-over-engineering.html" rel="noopener noreferrer"&gt;Perfection is not over-engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The phrase &amp;ldquo;we don&amp;rsquo;t want to aim for perfection&amp;rdquo; comes up in engineering meetings more times than the author can count. He understands the caution—over-engineering has burned out plenty of teams—but argues the industry is conflating two completely different things. Over-engineering is simply &lt;em&gt;solving the wrong problem&lt;/em&gt;, usually with good intentions and a pile of accidental complexity attached. A &amp;ldquo;perfect&amp;rdquo; solution, by contrast, is very real once requirements are clear and all constraints are on the table: tighten the constraints enough and only one design fits, making it perfect precisely because nothing else satisfies the actual problem. Picking Python on serverless to skip a build step might be ideal for one team and completely wrong for a team that doesn&amp;rsquo;t know Python or needs predictable low latency.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, every system is a product: internal libraries, APIs, and CLI tools all have real users with real needs. The clearest tell of over-engineering is asking &amp;ldquo;why did we build it this way?&amp;rdquo; and getting an answer that falls apart under scrutiny. A classic example is a three-person team maintaining five microservices that share the same underlying data: foreign keys once enforced by the database turn into loosely coupled string IDs, and one service deletes records without the others knowing—all to buy &amp;ldquo;independent deployability,&amp;rdquo; a problem the three-person team never actually had. The takeaway: that isn&amp;rsquo;t an excess of perfection, it&amp;rsquo;s a failure of requirements gathering. The enemy was never perfection; it was vague requirements.&lt;/p&gt;
&lt;h2 id="claude-is-not-a-compiler"&gt;&lt;a href="https://blog.exe.dev/claude-is-not-a-compiler" rel="noopener noreferrer"&gt;Claude Is Not a Compiler&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Josh Bleecher Snyder argues that Claude is not a compiler—because it is &lt;em&gt;better&lt;/em&gt; than one. In the idealized textbook view, software is built in neat horizontal layers: vision becomes strategy, product specs become engineering plans, source code becomes binaries, with each layer owned by a different role making thousands of micro-decisions. In reality, layers constantly leak and rub against one another, and working &lt;em&gt;across&lt;/em&gt; layers is where the biggest wins happen—just as the Empire State Building was designed and erected in under a year because the owners, architects, structural engineers, and contractors sat in the same room making cross-cutting trade-offs together. Claude can work vertically across all those layers at once—discussing strategy, architecture, source code, and assembly without needing to schedule a meeting.&lt;/p&gt;
&lt;p&gt;Snyder illustrates this with &lt;code&gt;exe.dev&lt;/code&gt;&amp;rsquo;s distributed DNS server. High-level strategic and architectural decisions were settled human-to-human; for the rest, he spun up multiple parallel agent loops to build full implementations with tests, then had another agent compare the resulting designs. What shocked him was how many consequential design decisions the agents quietly made on their own without asking—and how differently each agent resolved them, such as how to handle a database state rollback. Repeating this multi-agent exploration three times let him distill a concise design document that guided the final agent across every critical decision point. A week later, having barely read the raw code himself, he could answer every question from his teammates, and a month into production the DNS server had zero incidents. He calls this &amp;ldquo;vibe-engineering&amp;rdquo;—and predicts that soon we&amp;rsquo;ll just call it software engineering.&lt;/p&gt;
&lt;h2 id="in-defense-of-not-understanding-your-codebase"&gt;&lt;a href="https://www.seangoedecke.com/in-defense-of-not-understanding-your-codebase/" rel="noopener noreferrer"&gt;In defense of not understanding your codebase&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How thoroughly must an engineer understand their codebase? Sean Goedecke argues the answer depends entirely on the environment. Developers working on small, self-contained codebases like Redis will insist you must understand every line; engineers working on massive systems like Google or GitHub know that is literally impossible. Because the first group dominates online discourse, Goedecke steps up to defend the second: in a sufficiently large system, having only a &lt;em&gt;partial&lt;/em&gt; understanding isn&amp;rsquo;t a moral failing—it is the best anyone can ever achieve. At scale, everyone operates with an incomplete, slightly wrong mental model, so effective engineers must get comfortable making educated guesses.&lt;/p&gt;
&lt;p&gt;He pushes back against Peter Naur&amp;rsquo;s famous essay &lt;em&gt;&amp;ldquo;Programming as Theory Building.&amp;rdquo;&lt;/em&gt; While agreeing that a programmer&amp;rsquo;s most valuable asset is the mental &amp;ldquo;theory&amp;rdquo; of how the program works, Goedecke rejects Naur&amp;rsquo;s conclusion that once the original team leaves, a codebase is dead and ought to be rewritten from scratch. First, large legacy systems encode thousands of hard-won edge cases that a greenfield rewrite won&amp;rsquo;t rediscover until production breaks, and successful rewrites almost always happen incrementally by carving up the existing system. Second, &amp;ldquo;abandoned&amp;rdquo; codebases are successfully revived in industry all the time: you start by tracing one end-to-end flow and expand your mental map from there. Finally, preserving a pristine mental theory is just one business value among many, routinely traded off whenever teams collaborate or patch urgent security vulnerabilities. Being a professional engineer means aligning with your company&amp;rsquo;s trade-offs—even when that means working effectively in code you don&amp;rsquo;t fully understand.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-the-network"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-01-Beyond-Happy-Path-Engineering-the-Network/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: the Network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This opening installment of Gabor Koos&amp;rsquo;s &lt;em&gt;&amp;ldquo;Beyond Happy Path Engineering&amp;rdquo;&lt;/em&gt; series examines the assumptions that local development environments indulge but production mercilessly punishes, starting with the network. A network call looks like a simple function call, but it crosses a boundary into a system you do not control. Using checkout payment authorization as a running example, Koos notes that &amp;ldquo;clean&amp;rdquo; failures like a refused connection are easy to handle compared to a timeout &lt;em&gt;after&lt;/em&gt; the request was sent: the operation may have succeeded, failed, or still be sitting in a queue. The foundational rule of distributed systems is that &lt;em&gt;not receiving a response does not mean the operation didn&amp;rsquo;t happen&lt;/em&gt;. Latency is also a failure mode in disguise: a slow downstream service ties up threads and connection pools, averages hide catastrophic tail latency, and slowness cascades into full outages faster than hard errors.&lt;/p&gt;
&lt;p&gt;Koos outlines the essential defenses: treat timeouts as explicit design decisions derived from per-request latency budgets; retry only when safe, backing mutations with idempotency keys passed on every attempt alongside exponential backoff and jitter to prevent thundering herds; and propagate deadlines and cancellation contexts downstream so abandoned work stops immediately. Circuit breakers and load shedding protect overloaded services, while graceful degradation separates critical path steps (like taking payment) from deferrable side effects (like sending confirmation emails) using explicit order states like &lt;code&gt;&amp;quot;pending&amp;quot;&lt;/code&gt;. GitHub&amp;rsquo;s October 2018 outage—where a network partition lasting under a minute caused over 24 hours of degraded service—vividly illustrates the cost of happy-path network assumptions.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-time"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-19-Beyond-Happy-Path-Engineering-Time/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of the series turns to time—seemingly the simplest dependency of all: grab the current timestamp, compare two values, and make a decision. The running example is a checkout flow that holds inventory for fifteen minutes using &lt;code&gt;if now() &amp;gt; reservation.expiresAt&lt;/code&gt;. If the cleanup worker&amp;rsquo;s clock drifts two minutes ahead of the checkout server&amp;rsquo;s clock, items get released back to inventory while the customer is mid-payment. Wall clocks can jump forward or backward mid-execution via NTP adjustments, turning elapsed durations negative, and timestamps across different machines cannot reliably establish event ordering. Worst of all, time bugs fail silently: services stay up, dashboards stay green, and the system quietly makes wrong business decisions.&lt;/p&gt;
&lt;p&gt;The core lesson is that &amp;ldquo;time&amp;rdquo; actually answers four distinct questions: &lt;em&gt;wall-clock time&lt;/em&gt; records when an event happened in the real world, &lt;em&gt;monotonic time&lt;/em&gt; measures elapsed durations and timeouts on a single machine, &lt;em&gt;logical time&lt;/em&gt; (versions or sequence numbers) orders competing updates, and &lt;em&gt;business time&lt;/em&gt; governs billing periods, cutoff windows, and user time zones. Expiration should be modeled as an explicit &lt;em&gt;state transition&lt;/em&gt; rather than a passive timestamp comparison: use timestamps only to find candidate rows, then execute a conditional write that transitions the row to &lt;code&gt;expired&lt;/code&gt; only if its status is still &lt;code&gt;reserved&lt;/code&gt;, making late or duplicate cleanup runs harmless. When local clocks aren&amp;rsquo;t enough to arbitrate, reconcile against the authoritative external source, such as the payment provider. Cloudflare&amp;rsquo;s New Year&amp;rsquo;s 2017 leap-second DNS outage—when subtracting two &lt;code&gt;time.Now()&lt;/code&gt; readings yielded a negative number and triggered a panic—serves as a classic cautionary tale.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-databases"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-01-Beyond-Happy-Path-Engineering-Databases/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Databases&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part three tackles databases, the layer developers most often treat as an infallible black box. Using an e-commerce checkout flow that works flawlessly on a developer&amp;rsquo;s laptop because there is zero concurrent traffic, Koos shows how production changes everything: checkouts, admin dashboards, background jobs, analytics queries, and schema migrations all compete for the same connections and locks. A single slow query can exhaust the connection pool, causing incoming requests to queue up, users to hit refresh, and &amp;ldquo;checkout to go down&amp;rdquo; even though the database hasn&amp;rsquo;t crashed. Two concurrent requests can both read &lt;code&gt;stock = 1&lt;/code&gt; and both sell the last item; wrapping code in a transaction doesn&amp;rsquo;t magically prevent race conditions unless business invariants are enforced explicitly. On top of that come lagging read replicas, commit timeouts that leave the caller unsure whether the write succeeded, deadlocks, and schema migrations running alongside multiple live application versions.&lt;/p&gt;
&lt;p&gt;Koos recommends starting from the invariant that must never be violated—such as &amp;ldquo;never sell more than available inventory&amp;rdquo;—and enforcing it directly in the atomic write statement (&lt;code&gt;UPDATE ... WHERE stock &amp;gt;= quantity&lt;/code&gt;) backed by database constraints rather than application-level checks alone. Keep transactions short, never make network calls inside a transaction, and retry only transient errors. Make writes idempotent, define explicit data-freshness requirements per endpoint before routing reads to replicas, run schema migrations in backward-compatible expand-and-contract phases, and rehearse backup restores regularly. Atlassian&amp;rsquo;s 2022 outage and GitHub&amp;rsquo;s 2018 incident both prove that recovery speed matters just as much as data durability.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-storage"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-11-Beyond-Happy-Path-Engineering-Storage/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Storage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part four examines object storage, which looks simpler than a relational database but hides a fundamental trap: your database and your object store are two separate systems with no shared transaction coordinator. Consider a document upload flow: write the file to S3, insert a metadata row in the database, and return the URL. If the blob upload succeeds but the database insert fails, you get an invisible orphaned object; flip the order and a failed upload leaves a database row pointing to a missing blob that serves &lt;code&gt;404&lt;/code&gt;s. Abandoned multipart uploads quietly rack up storage bills, presigned URLs remain valid even after the database record is deleted, concurrent uploads to the same key silently overwrite each other, and CDNs keep serving stale cached files. High durability also doesn&amp;rsquo;t equal recoverability, because an accidental &lt;code&gt;DELETE&lt;/code&gt; is replicated just as durably as a valid write.&lt;/p&gt;
&lt;p&gt;Koos advises ordering upload steps so failures fail safe, tracking lifecycle state explicitly in the database (&lt;code&gt;pending&lt;/code&gt;, &lt;code&gt;confirmed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;), and serving only &lt;code&gt;confirmed&lt;/code&gt; records. Object keys should use immutable UUIDs or content hashes rather than user-supplied filenames; large files should upload directly from the client via short-lived presigned URLs; and deletions should soft-delete the database row first before a background job purges the blob, backed by a periodic reconciliation sweeper. The 2014 demise of Code Spaces—which shut down permanently after an attacker gained access to their AWS control panel and wiped both production storage and backups—underscores why backups must live outside the blast radius of production credentials.&lt;/p&gt;
&lt;h2 id="everyone-should-know-simd"&gt;&lt;a href="https://mitchellh.com/writing/everyone-should-know-simd" rel="noopener noreferrer"&gt;Everyone Should Know SIMD&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SIMD has a reputation for being arcane, and Mitchell Hashimoto regularly meets strong engineers who write it off as too hard to learn or useful only in niche high-performance computing. He argues that reputation is undeserved: the vast majority of practical &amp;ldquo;process N items at a time&amp;rdquo; SIMD code follows a single five-step template, and once you internalize that template, writing SIMD is almost as straightforward as writing a standard &lt;code&gt;for&lt;/code&gt; loop. Because SIMD lets the CPU process multiple data elements in a single instruction, any loop scanning bytes, characters, or array elements is a candidate once inputs reach thousands or millions of bytes.&lt;/p&gt;
&lt;p&gt;The five-step template is: broadcast constants into vectors and initialize accumulators if needed; loop over the input in chunks equal to the vector width; perform parallel comparisons or arithmetic across all lanes; reduce or store the vector result; and handle the trailing remainder elements using your original scalar loop. Hashimoto walks through a real example from the Ghostty terminal emulator written in Zig: finding the end of a run of printable ASCII characters by scanning until a byte is &lt;code&gt;&amp;lt;= 0xF&lt;/code&gt;. The scalar loop is a one-liner; the SIMD version adds about 12 lines of code and delivers a theoretical 4x speedup on ARM NEON, 8x on AVX2, and 16x on AVX-512, measuring roughly 5x faster in real benchmarks on an Intel AVX2 machine. While compilers can sometimes auto-vectorize simple loops, whenever a hot path cares about a 5x speedup, Hashimoto prefers explicit, portable SIMD that won&amp;rsquo;t silently regress after a compiler upgrade or minor code tweak.&lt;/p&gt;
&lt;h2 id="htop-explained"&gt;&lt;a href="https://peteris.rocks/blog/htop/" rel="noopener noreferrer"&gt;htop explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pēteris Ņikiforovs admits that for years he used &lt;code&gt;htop&lt;/code&gt; without truly understanding half the numbers on screen—for instance, assuming a load average of &lt;code&gt;1.0&lt;/code&gt; on a dual-core machine meant the CPUs were 50% busy. So he dug into the Linux kernel sources and wrote a comprehensive visual guide breaking down every single bar and column in &lt;code&gt;htop&lt;/code&gt;. What makes the guide stand out is that he traces every metric back to its exact kernel source: uptime comes from &lt;code&gt;/proc/uptime&lt;/code&gt;, load average comes from &lt;code&gt;/proc/loadavg&lt;/code&gt;, and you can verify how &lt;code&gt;htop&lt;/code&gt; gathers them yourself by running it under &lt;code&gt;strace&lt;/code&gt; to see which files it opens.&lt;/p&gt;
&lt;p&gt;Load average isn&amp;rsquo;t CPU percentage at all—it is the exponentially damped moving average of runnable threads plus threads stuck in uninterruptible sleep waiting on disk or network I/O; the 1-minute figure reflects roughly 63% of the past minute&amp;rsquo;s load and 37% of the prior average. The guide then demystifies process states (&lt;code&gt;R&lt;/code&gt; running/runnable, &lt;code&gt;S&lt;/code&gt; interruptible sleep, &lt;code&gt;D&lt;/code&gt; uninterruptible sleep, &lt;code&gt;Z&lt;/code&gt; zombie terminated but not yet reaped by its parent), &lt;code&gt;NI&lt;/code&gt; nice values from &lt;code&gt;-20&lt;/code&gt; to &lt;code&gt;19&lt;/code&gt; and their relation to kernel priority (&lt;code&gt;PR = 20 + NI&lt;/code&gt;), and the memory columns: &lt;code&gt;VIRT&lt;/code&gt; includes unbacked virtual reservations and memory-mapped files so it&amp;rsquo;s rarely actionable, &lt;code&gt;RES&lt;/code&gt; is actual resident RAM (though shared libraries and copy-on-write pages get double-counted across processes), and &lt;code&gt;MEM%&lt;/code&gt; is simply &lt;code&gt;RES&lt;/code&gt; divided by total RAM. He wraps up by auditing every default background process on a fresh Ubuntu Server install to see which ones can be safely stripped out.&lt;/p&gt;
&lt;h2 id="the-productivity-experience-paradox"&gt;&lt;a href="https://annievella.com/posts/the-productivity-experience-paradox/" rel="noopener noreferrer"&gt;The Productivity-Experience Paradox&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the second article from her master&amp;rsquo;s research on how AI coding tools affect software engineers, Annie Vella shares findings from a longitudinal study tracking the exact same cohort of engineers across two waves six months apart (October 2024 to April 2025). On the productivity front, the news is consistently positive: 84% of respondents reported that AI helped them get more done in both waves. Yet developer experience—measured across the DevEx framework dimensions of feedback loops, cognitive load, and flow state—moved in the opposite direction: the share of engineers reporting a net-negative experience nearly doubled from 14% to 27%, and not a single engineer who fell into the negative group in Wave 1 recovered to an all-positive experience by Wave 2.&lt;/p&gt;
&lt;p&gt;The central finding is that productivity and developer experience—long assumed to rise and fall together—are decoupling: tracking the same individuals over time, experience degraded while output held steady, with a near-zero correlation ($r = 0.02$) between changes in flow state and changes in perceived productivity. That decoupling is dangerous because the business case for investing in DevEx has historically been &amp;ldquo;happy developers are productive developers&amp;rdquo;; when output stays high, rising cognitive strain stays invisible until it turns into burnout. Flow suffered the sharpest drop (negative reports rose from 7% to 20%) even as feedback loops sped up, and Vella suspects the two are linked: every fast AI response triggers a micro-context switch from creator to reviewer. Borrowing the term &amp;ldquo;junk flow&amp;rdquo; to describe a slot-machine-like loop of rapid prompting that mimics flow without deep satisfaction, she concludes that while AI boosts extrinsic output, it risks eroding the intrinsic craft and joy of software engineering.&lt;/p&gt;
&lt;h2 id="prefactoring-clear-the-way-for-your-new-feature"&gt;&lt;a href="https://testing.googleblog.com/2026/07/prefactoring-clear-way-for-your-new.html" rel="noopener noreferrer"&gt;Prefactoring: Clear the Way for Your New Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post from Google&amp;rsquo;s &lt;em&gt;&amp;ldquo;Tech on the Toilet&amp;rdquo;&lt;/em&gt; series opens with Kent Beck&amp;rsquo;s famous advice: &lt;em&gt;&amp;ldquo;First make the change easy (warning: this may be hard), then make the easy change.&amp;rdquo;&lt;/em&gt; When you try to bolt a new feature directly onto code that wasn&amp;rsquo;t structured to accommodate it, things get messy fast: tweaking one file forces changes in three others, and soon you&amp;rsquo;re knee-deep in unrelated modules. &lt;em&gt;Prefactoring&lt;/em&gt;—short for preparatory refactoring—is the discipline of restructuring existing code to fit the upcoming requirement &lt;em&gt;before&lt;/em&gt; writing the new feature, rather than promising yourself you&amp;rsquo;ll clean it up afterward.&lt;/p&gt;
&lt;p&gt;The payoffs are immediate: the new feature slots in naturally, code reviews go much faster because structural refactoring and behavioral changes live in separate commits, fewer bugs slip in because cleanup is isolated from new logic, and rollbacks are safer because each change is small and self-contained. In the post&amp;rsquo;s example, the first CL simply extracts a &lt;code&gt;get_display_name(user)&lt;/code&gt; helper to deduplicate name-formatting logic across the profile page and email templates; the second CL adds middle-name support with a one-line edit inside that helper. Even if you only spot the right abstraction mid-implementation, you can still split the cleanup into a preparatory CL—or spin off reviewer-suggested cleanups in parallel while your main CL is under review. Not every cleanup belongs up front, though: if a refactoring doesn&amp;rsquo;t directly unblock your feature, save it for later, or fold it in if it&amp;rsquo;s truly trivial.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #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 #5</title><link>https://miti99.com/en/post/2025/03/04/</link><pubDate>Tue, 04 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/04/</guid><description>&lt;i&gt;
Hello everyone, MiTi was a bit lazy last weekend and didn't put out a post. Enjoy Newsletter #5!
&lt;/i&gt;
&lt;h2 id="5-advanced-java-reflection-techniques-for-dynamic-programming"&gt;&lt;a href="https://dev.to/nithinbharathwaj/5-advanced-java-reflection-techniques-for-dynamic-programming-4ph1" rel="noopener noreferrer"&gt;5 Advanced Java Reflection Techniques for Dynamic Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article introduces five advanced techniques centered around Java&amp;rsquo;s Reflection API, the toolkit for inspecting and modifying the structure and behavior of classes, interfaces, and objects at runtime. The first technique is accessing private members: retrieving a &lt;code&gt;Field&lt;/code&gt; or &lt;code&gt;Method&lt;/code&gt; via &lt;code&gt;getDeclaredField()&lt;/code&gt;/&lt;code&gt;getDeclaredMethod()&lt;/code&gt; and calling &lt;code&gt;setAccessible(true)&lt;/code&gt; to bypass access checks—handy for testing or working with legacy code, though it breaks encapsulation (and is subject to Java 9+ module system restrictions). The second is dynamic object instantiation from a class name known only at runtime using &lt;code&gt;Class.forName()&lt;/code&gt; and a matching constructor, which forms the backbone of plugin architectures in the spirit of the Open-Closed Principle. The third combines custom annotations with reflection to attach metadata to code and process it at runtime—for instance, logging every method invocation—which is how frameworks implement validation, dependency injection, and ORMs. The fourth uses &lt;code&gt;java.lang.reflect.Proxy&lt;/code&gt; to create dynamic proxies for interfaces, weaving in cross-cutting concerns like logging, transaction management, or access control without modifying the target class. The fifth covers runtime bytecode manipulation with libraries like ByteBuddy (outside the standard Reflection API), generating subclasses that intercept method calls on concrete classes as well as interfaces.&lt;/p&gt;
&lt;p&gt;While the examples illustrate how to build extensible plugins, process metadata, and layer on behaviors like logging, there are important caveats: &lt;code&gt;setAccessible(true)&lt;/code&gt; is still constrained by the Java module system, so it cannot guarantee access to every private member; annotations do not intercept calls on their own unless reflective code explicitly inspects them and invokes the target method; JDK &lt;code&gt;Proxy&lt;/code&gt; only works with interfaces; and the ByteBuddy example works by subclassing and intercepting overridable methods. These mechanisms are powerful when dynamic flexibility is needed, but their impact on encapsulation, maintainability, and runtime performance must be weighed carefully.&lt;/p&gt;
&lt;h2 id="mistakes-you-apparently-just-have-to-make-yourself"&gt;&lt;a href="https://medium.com/@mcfunley/mistakes-you-apparently-just-have-to-make-yourself-cc2dd2bfc25c" rel="noopener noreferrer"&gt;Mistakes You Apparently Just Have to Make Yourself&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan McKinley compiles a list of mistakes he calls &amp;ldquo;non-transferable knowledge&amp;rdquo;: no matter how many times seasoned engineers warn you against them, people apparently still have to touch the hot stove themselves to believe it burns. The list hits on classic industry tropes: the legacy codebase is such a mess that we have to rewrite it from scratch; our software is hard to manage, so adding operational complexity will somehow make it easier; our problem is completely novel, so we must adopt bleeding-edge technology; adding network hops will magically make the system faster; running a production system is just like maintaining an open-source project; writing a thin wrapper around a CLI tool adds real value; coding is the bulk of the work; functional tests are all the testing you need; deploying directly from version control is fine; logical separation requires physical separation; bureaucracy solves everything—or solves nothing; and if two teams use the same noun, they should share the same code.&lt;/p&gt;
&lt;p&gt;The final item is self-deprecating: everyone thinks they are the first person to make all 13 mistakes and that the author is writing specifically about them. The post wraps up with a tongue-in-cheek plug for the author&amp;rsquo;s startup, Skyliner, pitching it as a &amp;ldquo;straitjacket&amp;rdquo; to keep you from hurting yourself. For newer engineers, it&amp;rsquo;s a list worth revisiting whenever you&amp;rsquo;re about to make a major architectural bet.&lt;/p&gt;
&lt;h2 id="service-reliability-mathematics"&gt;&lt;a href="https://addyosmani.com/blog/service-reliability/" rel="noopener noreferrer"&gt;Service Reliability Mathematics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that service reliability is too often reduced to a single uptime percentage, when reality is far more nuanced. Even with the exact same total annual downtime, a single 8-hour outage has a very different business impact than 480 one-minute blips, and five minutes of downtime during peak traffic can hurt more than an hour in the middle of the night. Each additional &amp;ldquo;nine&amp;rdquo; of availability demands exponentially more engineering effort and operational complexity: at 99.9% (about 8 hours 46 minutes of downtime per year), a single-region deployment with basic failover may suffice; reaching 99.99% typically requires multi-region active-active or automated failover; and 99.999% and beyond demands redundancy at every layer with real-time monitoring. These percentages also quietly assume that failures are uniformly distributed, independent, and immediately detected, while ignoring partial degradation and cascading failures. A service responding in 500ms instead of 5ms may still count as &amp;ldquo;up,&amp;rdquo; yet be practically unusable.&lt;/p&gt;
&lt;p&gt;Pursuing higher reliability always involves trade-offs between feature velocity and stability, infrastructure cost and redundancy, and on-call burnout for the team. Instead of blindly chasing extra nines, engineers should ask which failure modes actually hurt the business; modern practice favors error budgets, SLOs (Service Level Objectives), and user-centric telemetry to deliver dependable value while keeping engineering pace sustainable.&lt;/p&gt;
&lt;h2 id="how-to-write-a-good-design-document"&gt;&lt;del&gt;&lt;a href="https://grantslatton.com/how-to-design-document" rel="noopener noreferrer"&gt;How to write a good design document&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;The article &amp;ldquo;How to Design Document&amp;rdquo; offers practical advice on writing effective design documents. According to the author, a design document is a technical report that outlines the implementation strategy for a system within the context of trade-offs and constraints. Its primary goal is to convince the reader (and most importantly, the author themselves) that the proposed design is optimal given the current situation.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author compares writing a design document to writing a mathematical proof. To achieve maximum effectiveness, it requires strong organization, much like organizing code. Writers should avoid creating &amp;ldquo;spaghetti design docs&amp;rdquo; by ensuring every sentence connects logically and is easy to follow. The goal is to never surprise the reader, making the solution feel obvious even when it required complex thinking to reach.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The post also emphasizes the importance of understanding the reader&amp;rsquo;s mindset and anticipating potential objections. Furthermore, writers should edit ruthlessly to remove unnecessary words, because the reader&amp;rsquo;s attention is a scarce resource. The author encourages practicing by critiquing other documents and distilling complex ideas into concise tweets.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Finally, the article suggests structuring documents into bullet points that can each be summarized in a single sentence and using footnotes for complex tangents so they don&amp;rsquo;t disrupt the main flow of the document.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="picking-your-battles-when-you-are-hyper-rational"&gt;&lt;a href="https://newsletter.weskao.com/p/picking-your-battles-hyper-rational" rel="noopener noreferrer"&gt;Picking your battles when you are hyper-rational&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao highlights a common habit among hyper-rational people: getting so caught up in proving they are &amp;ldquo;technically correct&amp;rdquo; that they sacrifice practical effectiveness—winning a minor skirmish while losing the war. She illustrates this with two emails she almost sent. In the first example, a recruiter asked to chat &amp;ldquo;this morning&amp;rdquo; when it was already nearly 1:00 PM in Wes&amp;rsquo;s time zone; instead of lecturing on all the ways &amp;ldquo;this morning&amp;rdquo; could be interpreted across time zones, she simply confirmed the time zone and offered a few open slots to lock in the meeting quickly. In the second, a client&amp;rsquo;s finance team told her she didn&amp;rsquo;t need to fill out a vendor onboarding form even though their own billing system had just emailed her demanding it; she nearly wrote a multi-paragraph explanation defending why she had asked, but caught herself and sent a one-line &amp;ldquo;thanks for clarifying.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The lesson is to resist the urge to prove you noticed every nuance or to nitpick someone else&amp;rsquo;s phrasing, which wastes time and makes you look difficult to work with. Before sending a corrective explanation, ask yourself: does this move us closer to the goal, does it actually help the recipient or just prove I&amp;rsquo;m right about an irrelevant detail, and am I serving the conversation or my own ego? There are times when clarifying a misunderstanding matters, of course, but on the small stuff, it&amp;rsquo;s almost always better to let it go and stay focused on the main objective.&lt;/p&gt;
&lt;h2 id="measuring-programmer-influence-kinda-sorta"&gt;&lt;a href="https://tidyfirst.substack.com/p/measuring-programmer-influence-kinda" rel="noopener noreferrer"&gt;Measuring Programmer Influence, Kinda Sorta&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck asks whether data can tell us who contributes the most on a large engineering team. His blunt answer is no—not if you want certainty—though data can hint at where influence lives. He opens with a clear warning: the first time you tie bonuses, promotions, or layoffs to these metrics is the last time they will ever be trustworthy. Analyzing the Git history of the React repository, he observes that both the number of files created per author and the number of times each file is modified follow a Pareto distribution: most contributors create only a single file, while a small handful create hundreds or thousands. Plotting those two dimensions together—files an author created versus how often other people later modified those files—reveals a clear trend line; the engineers in the upper-right corner, who create foundations that others keep building upon, are strong candidates for high-influence contributors.&lt;/p&gt;
&lt;p&gt;Used well, this kind of analysis helps engineers calibrate themselves against peers, find mentors to learn from, and spot people whose real-world impact exceeds their formal title. Used poorly, it gets weaponized for compensation, quotas, promotions, or stack ranking. The data has obvious blind spots too: many vital contributions never show up in commit graphs, and long-tenured team members naturally accumulate higher numbers. The takeaway: never lose sight of the real goal—making a meaningful impact—and always sanity-check your results, because programming with data is still programming.&lt;/p&gt;
&lt;h2 id="building-personal-software-with-claude"&gt;&lt;a href="https://blog.nelhage.com/post/personal-software-with-claude/" rel="noopener noreferrer"&gt;Building personal software with Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nelson Elhage recounts using Claude to port a bottleneck in Emacs&amp;rsquo;s &lt;code&gt;obsidian.el&lt;/code&gt; package to Rust, speeding it up by more than 1,000x (in one specific benchmark, dropping from 90 seconds to roughly 15ms) while barely writing a line of code himself. The culprit was &lt;code&gt;obsidian-update&lt;/code&gt;, which rescanned his entire note vault in Emacs Lisp and had grown painfully slow. With a single prompt, Claude read roughly 1,000 lines of Elisp, identified the ~200 relevant lines, and wrote a Rust program to extract the note metadata as JSON; the generated Rust code compiled and worked on the first try. Next, Claude wrote the Elisp glue using Emacs&amp;rsquo;s &lt;code&gt;advice&lt;/code&gt; mechanism to patch &lt;code&gt;obsidian.el&lt;/code&gt;, hitting only one minor bug that was fixed in minutes. The entire project took a single afternoon. Even though Elhage works at Anthropic, he had previously thought of Claude mostly as a better Stack Overflow.&lt;/p&gt;
&lt;p&gt;Reflecting on the experience, he draws several conclusions. First, the tooling and UX around LLMs are still lagging behind the raw capabilities of the models themselves. Second, he noticed that he naturally decomposed the problem along clean, easily testable interface boundaries: the human handles system decomposition, while Claude fills in the &amp;ldquo;meat&amp;rdquo; in between. Most importantly, while code is now cheaper than ever to produce, deep understanding, architecture, and good design are only becoming more valuable; writing &amp;ldquo;easy-to-delete&amp;rdquo; code may matter even more when an LLM can regenerate an implementation from scratch on demand. Above all, he rediscovered the joy of building small personal tools now that Claude can shoulder the tedious parts.&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/1112c07d-db40-484e-917b-0071ed7cf354_1280x1532.gif" alt="Git vs GitHub"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5fd8bdda-52dd-454f-be79-ad548f17810b_1280x1557.gif" alt="A Cheatsheet on Database Performance"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/35ae3f82-afa0-47b9-a2a0-58b6c6d8cfb1_1280x1476.gif" alt="18 Common Ports Worth Knowing"&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>