<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Software Architecture on miti99</title><link>https://miti99.com/en/tags/software-architecture/</link><description>Recent content in Software Architecture 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/software-architecture/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #135</title><link>https://miti99.com/en/post/2026/10/03/</link><pubDate>Sat, 03 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #135.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="git-at-any-scale"&gt;&lt;a href="https://cursor.com/blog/git-at-any-scale" rel="noopener noreferrer"&gt;Git at any scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vicent Martí explains why hosting centralized Git repositories at massive scale is notoriously difficult: Git packfiles are large binary blobs that expect to live on a local POSIX filesystem with fast &lt;code&gt;mmap&lt;/code&gt; random access. Early attempts to ditch packfiles and store loose Git objects in distributed key-value stores made &lt;code&gt;git clone&lt;/code&gt; unusably slow, because walking the commit and tree graph incurred a network round trip at every hop. Shared network filesystems like NFS, GFS, or DRBD proved slow, brittle, and operationally painful. GitHub&amp;rsquo;s Spokes replicates repositories at the application layer using a three-phase commit for reference transactions, but push throughput is bottlenecked by the slowest replica, and fixing every repo at three copies over-provisions cold repos while under-provisioning hot CI monorepos—all while requiring a massive central routing database.&lt;/p&gt;
&lt;p&gt;Cursor&amp;rsquo;s &lt;em&gt;Continuity&lt;/em&gt; engine flips the architecture by making a write-ahead log (WAL) on S3-compatible object storage the single source of truth. Every &lt;code&gt;git push&lt;/code&gt; writes its pack data and ref update to the WAL before acknowledging the client, becoming visible only after the reference transaction succeeds and updates the WAL index—making all pushes strictly linearizable. Standard on-disk Git repositories on local NVMe drives act purely as stateless, disposable caches reconstructed on demand from the WAL, eliminating consensus protocols entirely. Nodes are selected via rendezvous hashing, while write safety relies on S3&amp;rsquo;s conditional compare-and-swap (&lt;code&gt;If-Match&lt;/code&gt; / &lt;code&gt;If-None-Match&lt;/code&gt;). Read replicas receive invalidation hints over UDP gossip and verify freshness via conditional &lt;code&gt;GET&lt;/code&gt; requests with ETags in under 10 ms. Only the primary node runs packfile compaction; replicas simply download compacted packs from S3. Benchmarks on Cursor&amp;rsquo;s own monorepo show linear read scaling up to 100 replicas, ~120 pushes/sec on S3 Standard, and over 300 pushes/sec on S3 Express One Zone—laying the foundation for Origin, Cursor&amp;rsquo;s Git hosting platform built for high-concurrency agent workloads.&lt;/p&gt;
&lt;h2 id="regressive-jpegs"&gt;&lt;a href="https://maurycyz.com/projects/bad_jpeg/" rel="noopener noreferrer"&gt;Regressive JPEGs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maurycy explores a delightfully cursed trick with progressive JPEGs, a format designed to transmit low-frequency image components first so a partially downloaded photo appears blurry rather than half-blank. Inside a progressive JPEG, compressed image data is divided into multiple &amp;ldquo;scans,&amp;rdquo; each with its own header specifying which color channels (&lt;code&gt;Y&lt;/code&gt;, &lt;code&gt;Cb&lt;/code&gt;, &lt;code&gt;Cr&lt;/code&gt;), which range of DCT frequency bins, and which bit-precision slice it contains. The first scan normally carries the DC (average color) bin for all three channels, while subsequent scans progressively fill in high-frequency AC detail. Because each scan declares its own spectral range, the author realized nothing stops a later scan from &lt;em&gt;overwriting&lt;/em&gt; frequency bins that were already rendered—meaning you can concatenate multiple same-resolution images into a single JPEG file (stripping their intermediate &lt;code&gt;SOI&lt;/code&gt;, &lt;code&gt;SOF&lt;/code&gt;, and &lt;code&gt;EOI&lt;/code&gt; markers) so the image morphs from one picture into another as it loads over a slow connection.&lt;/p&gt;
&lt;p&gt;The catch is that browsers cap the maximum number of scans they will decode before giving up (likely as a defense against decompression bombs), limiting full-detail progressive overwrites to about nine frames. To cram a real animation into a single JPEG, you have to minimize the number of scans per frame. Because the JPEG spec forbids mixing DC and AC coefficients in the same progressive scan, the smallest possible frame is a single DC-only scan—producing a blocky 8×8-pixel-per-block low-res image. Using one DC scan per frame, Chrome renders roughly 90 frames before bailing out, Firefox keeps going even longer, and ghosting artifacts vanish because there are no leftover AC coefficients from earlier frames bleeding through. The result is an entire multi-second video inside a valid &lt;code&gt;.jpg&lt;/code&gt; file—utterly useless in production since playback speed is dictated entirely by network bandwidth, but prime material for a rickroll.&lt;/p&gt;
&lt;h2 id="a-quick-look-at-zero-knowledge-proofs"&gt;&lt;a href="https://bernsteinbear.com/blog/zkp/" rel="noopener noreferrer"&gt;A quick look at zero-knowledge proofs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein and Chris Gregory demystify zero-knowledge proofs (ZKPs) through a classic example that has nothing to do with cryptocurrency: proving a graph is 3-colorable, following Goldreich, Micali, and Wigderson&amp;rsquo;s 1986 paper. In a ZKP, a &lt;em&gt;prover&lt;/em&gt; claims to know a secret solution to a hard problem, and a &lt;em&gt;verifier&lt;/em&gt; wants to be convinced the prover truly knows it without learning a single bit about the solution itself. Graph 3-coloring—assigning one of three colors to every vertex so no two connected vertices share a color—is NP-complete to solve but trivial to check locally along any single edge. Each round of the interactive protocol runs in four steps: the prover randomly permutes the three color names, &amp;ldquo;locks&amp;rdquo; each vertex&amp;rsquo;s permuted color inside a sealed box, and sends all the locked boxes to the verifier; the verifier picks one random edge &lt;code&gt;(u, v)&lt;/code&gt; and challenges the prover; the prover sends back the keys to only boxes &lt;code&gt;u&lt;/code&gt; and &lt;code&gt;v&lt;/code&gt;; and the verifier opens those two boxes to verify that their colors are valid and different.&lt;/p&gt;
&lt;p&gt;In Python code, a &amp;ldquo;locked box&amp;rdquo; is a cryptographic commitment: the hash of the vertex&amp;rsquo;s color concatenated with a random cryptographic nonce (using &lt;code&gt;hashlib.sha256&lt;/code&gt; and &lt;code&gt;secrets&lt;/code&gt;), since hashing the color alone without a random nonce would produce identical hashes for same-colored vertices and leak the coloring structure. Because a cheating prover who doesn&amp;rsquo;t actually have a valid 3-coloring can still get lucky unless the verifier picks the exact edge that violates the rules, a single round catches a cheater with probability at least $1/m$ (where $m$ is the number of edges). Repeating the protocol with fresh random color permutations and nonces for $m^2$ rounds drives the probability of forgery down exponentially: on a 1,000-edge graph, ~4,600 rounds reduce the soundness error below 1%, and 10,000 rounds drop it to 0.0045%. The authors build a working client-server demo and note that because 3-coloring is NP-complete, any NP problem—from Sudoku to integer factorization—can theoretically be reduced to it, even if the resulting circuit graph balloons quickly in size.&lt;/p&gt;
&lt;h2 id="the-pulse-we-need-to-talk-about-migrations-with-ai"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-we-need-to-talk-about-migrations-with-ai/" rel="noopener noreferrer"&gt;The Pulse: We need to talk about migrations with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this free edition of &lt;em&gt;The Pulse&lt;/em&gt;, Gergely Orosz argues that AI coding tools have fundamentally changed the economics of large-scale code migrations that teams previously put off for years as prohibitively expensive. The headline example comes from Asana: according to an OpenAI case study, Asana used Codex to rip out Enzyme and migrate their test suite to React Testing Library in roughly 1.5 engineer-weeks and ~$12,000 in model and compute costs—a migration previously estimated at $6 million and five years of background effort. Similarly, Airbnb migrated 3,500 Enzyme test files in six weeks (versus a 1.5 engineer-year manual estimate), Uber migrated 600,000 JUnit 4 tests to JUnit 5 in four months with two engineers, and Bun ported 530,000 lines of Zig to Rust in two weeks for $165,000 in API spend. By contrast, back in 2021 Sentry spent 1.5 years and roughly ten engineers migrating 95,000 lines of JavaScript to TypeScript.&lt;/p&gt;
&lt;p&gt;Across these successes, the same engineering patterns recur: automated retry loops when a migrated file fails to build or pass tests, multi-phase per-file pipelines, engineer-designed verification harnesses, starting with leaf files or frequently touched files first, and refactoring the codebase beforehand so patterns are uniform for the LLM. Orosz notes that Asana&amp;rsquo;s &amp;ldquo;$6M saved&amp;rdquo; headline is likely inflated—manual estimates rarely account for humans getting much faster after the first hundred files—and stresses that every single migration still required experienced engineers to design the pipeline, build the verification gates, and handle edge cases. Even so, the cost-benefit curve for paying down massive technical debt has shifted permanently.&lt;/p&gt;
&lt;h2 id="the-accidental-application-runtime"&gt;&lt;a href="https://adventures.michaelfbryan.com/posts/accidental-application-runtime" rel="noopener noreferrer"&gt;The Accidental Application Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael F. Bryan describes how a small Go service managing a 3D-printer farm gradually grew into an tangled mess. It started as a simple dashboard where the HTTP server spawned a single background goroutine to poll printer status. Over time, polling jobs from a cloud backend, persisting state to SQLite, scheduling print jobs, streaming G-code, and reporting telemetry were all bolted onto that same initialization block until &lt;code&gt;NewServer&lt;/code&gt; was spawning five long-running background goroutines. When the team needed to add graceful shutdown on &lt;code&gt;SIGTERM&lt;/code&gt;, figuring out which goroutines were running, in what order they needed to stop, and who owned closing which Go channels required reading the entire startup file line by line. Bryan calls this an &amp;ldquo;accidental application runtime&amp;rdquo;: the service had a real concurrent pub/sub architecture, but nothing in the code&amp;rsquo;s structure made that topology explicit.&lt;/p&gt;
&lt;p&gt;Inspired by the PX4 drone autopilot&amp;rsquo;s uORB messaging layer, Bryan built a lightweight Go library called &lt;code&gt;backplane&lt;/code&gt;. Each subsystem becomes a plain Go function &lt;code&gt;func(ctx, deps...) error&lt;/code&gt; whose typed parameters declare its communication topology: a &lt;code&gt;chan&amp;lt;- T&lt;/code&gt; parameter publishes to topic &lt;code&gt;T&lt;/code&gt;, &lt;code&gt;&amp;lt;-chan T&lt;/code&gt; subscribes to a stream of &lt;code&gt;T&lt;/code&gt;, and &lt;code&gt;*backplane.Latest[T]&lt;/code&gt; polls the latest state snapshot. Topics are keyed by Go types rather than error-prone string names. &lt;code&gt;backplane.New&lt;/code&gt; validates the dependency graph before startup, and &lt;code&gt;Run&lt;/code&gt; supervises the modules like an &lt;code&gt;errgroup&lt;/code&gt; with in-process, backpressured delivery. Rebuilding the printer service as six explicit modules—anchored by a strict &lt;em&gt;commit-then-notify&lt;/em&gt; rule where the scheduler commits job state to SQLite before publishing a wake-up message—even let the team auto-generate accurate Mermaid architecture diagrams straight from the function signatures.&lt;/p&gt;
&lt;h2 id="generic-methods-in-go-127"&gt;&lt;a href="https://dominik.info/blog/go-generic-methods" rel="noopener noreferrer"&gt;Generic Methods in Go 1.27&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When Go 1.18 introduced generics in 2022, functions and types could declare type parameters, but methods could not declare additional type parameters of their own. Go 1.27 finally lifts that restriction: methods can now introduce their own type parameters without polluting the receiver struct. Dominik Braun illustrates why this matters using a generic graph node &lt;code&gt;Node[T]&lt;/code&gt;. Previously, if you wanted a &lt;code&gt;Map&lt;/code&gt; method that transforms a &lt;code&gt;Node[T]&lt;/code&gt; into a &lt;code&gt;Node[U]&lt;/code&gt;, you either had to pollute the struct definition itself as &lt;code&gt;Node[T, U]&lt;/code&gt;—forcing every unrelated method on &lt;code&gt;Node&lt;/code&gt; to carry &lt;code&gt;U&lt;/code&gt; around—or give up on method syntax and write a standalone package-level function &lt;code&gt;Map[T, U any](n *Node[T], ...)&lt;/code&gt;. Starting in Go 1.27, you can simply write &lt;code&gt;func (n *Node[T]) Map[U any](...) Node[U]&lt;/code&gt;, scoping &lt;code&gt;U&lt;/code&gt; strictly to the &lt;code&gt;Map&lt;/code&gt; method.&lt;/p&gt;
&lt;p&gt;Why did this take four years to land? The hurdle lay in how Go compiles generics versus how it dispatches interfaces. Go&amp;rsquo;s compiler primarily uses &lt;em&gt;monomorphization&lt;/em&gt; (stenciling specialized machine code for concrete type shapes at compile time), whereas Go interfaces rely on runtime dynamic dispatch via an &lt;code&gt;itable&lt;/code&gt; of function pointers. Those two models collide if an interface is allowed to declare a generic method like &lt;code&gt;type Mapper interface { Map[U any]() Node[U] }&lt;/code&gt;: the compiler cannot pre-populate a fixed-size runtime vtable for an unbounded set of potential type arguments &lt;code&gt;U&lt;/code&gt;, especially when reflection can look up methods dynamically at runtime. Go&amp;rsquo;s pragmatic compromise in 1.27 is to allow generic methods on concrete types while forbidding them in interface definitions—and a generic method cannot be used to satisfy an interface.&lt;/p&gt;
&lt;h2 id="your-executable-is-a-sqlite-database"&gt;&lt;a href="https://fzakaria.com/2026/08/23/your-executable-is-a-sqlite-database" rel="noopener noreferrer"&gt;Your executable is a SQLite database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria, author of &lt;code&gt;sqlelf&lt;/code&gt;, takes his previous experiment to its logical conclusion: replacing ELF entirely with SQLite as a native Linux executable format. His prototype, &lt;strong&gt;SELF&lt;/strong&gt; (&lt;em&gt;Structured Executable &amp;amp; Linkable Format&lt;/em&gt;), produces real SQLite database files that you can &lt;code&gt;chmod +x&lt;/code&gt; and run directly from the shell. His core argument is that ELF is already an ad-hoc, bespoke relational database in denial: &lt;code&gt;.strtab&lt;/code&gt; is string interning, &lt;code&gt;.gnu.hash&lt;/code&gt; is a hash index, section headers are a catalog table, and symbol versioning is a foreign-key schema. In SELF, an executable&amp;rsquo;s schema consists of a &lt;code&gt;self_meta&lt;/code&gt; table for the ELF header, a &lt;code&gt;segments&lt;/code&gt; table storing each program header row with its raw machine code/data as a SQLite &lt;code&gt;BLOB&lt;/code&gt;, and a &lt;code&gt;symbols&lt;/code&gt; table indexed by standard SQLite B-trees in place of &lt;code&gt;.dynsym&lt;/code&gt; and &lt;code&gt;.gnu.hash&lt;/code&gt;. Registering the SQLite magic header with Linux&amp;rsquo;s &lt;code&gt;binfmt_misc&lt;/code&gt; lets the kernel hand &lt;code&gt;./my_app&lt;/code&gt; directly to &lt;code&gt;self-exec&lt;/code&gt;, a tiny C loader that queries the segments, maps them into memory, performs relocations, and jumps to the entry point.&lt;/p&gt;
&lt;p&gt;For dynamic linking, SELF supports two modes: keeping glibc&amp;rsquo;s standard &lt;code&gt;ld.so&lt;/code&gt; and using an &lt;code&gt;rtld-audit&lt;/code&gt; hook so a SQL query resolves shared libraries, or using &lt;code&gt;self-ld&lt;/code&gt;, an experimental SQL-native dynamic linker. Even cooler, &lt;code&gt;self closure&lt;/code&gt; bundles a binary and all its transitive shared-library dependencies into a single self-contained SQLite database file—turning &lt;code&gt;ldd&lt;/code&gt; into a simple SQL &lt;code&gt;JOIN&lt;/code&gt;. Packing all 723 executables in &lt;code&gt;/usr/bin&lt;/code&gt; into a single shared SELF database shrank total size from 644.4 MiB (ELF) down to 611.9 MiB thanks to cross-binary library and symbol deduplication, even though individual standalone SELF files are 2.2x to 3.6x larger than their ELF counterparts. While copying segments out of SQLite blobs prevents cross-process &lt;code&gt;mmap&lt;/code&gt; page sharing for &lt;code&gt;.text&lt;/code&gt; segments and slows cold start on massive binaries, being able to inspect, strip, or atomically patch executables with &lt;code&gt;UPDATE&lt;/code&gt; and &lt;code&gt;ROLLBACK&lt;/code&gt; is a fascinating glimpse into an alternate Unix universe.&lt;/p&gt;
&lt;h2 id="what-happens-when-a-gpu-reads-memory"&gt;&lt;a href="https://blog.doubleword.ai/what-happens-when-a-gpu-reads-memory" rel="noopener noreferrer"&gt;What happens when a GPU reads memory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doubleword founder Fergus Finn traces the exact hardware journey of a single global memory load instruction (&lt;code&gt;LDG.E&lt;/code&gt;) inside an NVIDIA RTX 4090. Because NVIDIA documents very little of its microarchitectural memory pipeline publicly, Finn reverse-engineered the path using custom cycle-accurate microbenchmarks and hardware performance counters. When a 32-thread warp issues a 4-byte load per thread, the hardware coalescer groups those 32 requests into four 32-byte sectors—one 128-byte cache line. On an L1 miss, the virtual address passes through a 16-entry per-SM L1 TLB (backed by 2 MiB pages) to translate into a physical address, because the L2 cache is physically indexed. From there, the chip-wide crossbar routes the request to one of 36 L2 cache slices selected by an undocumented hash of the physical address bits, which in turn forwards L2 misses to one of 12 memory controllers wired to 12 GDDR6X chips—where the controller must issue an expensive DRAM row &lt;code&gt;ACTIVATE&lt;/code&gt; command to open a 1 KiB row before bursting the four 32-byte sectors back.&lt;/p&gt;
&lt;p&gt;The latency ladder is stark: an L1 hit takes ~15.4 ns, an L2 hit takes ~127 ns, and a full miss down to GDDR6X DRAM takes ~255 ns—roughly 660 GPU clock cycles during which that warp sits stalled. Activating a new DRAM row costs roughly 15x more time than reading from an already-open row, and hammering a single L2 slice caps throughput at 1,957 million loads/sec versus ~68,000 million loads/sec when spread evenly across all 36 slices (a 34.8x difference). GPUs hide that 660-cycle latency through massive warp-level parallelism—switching to other ready warps every cycle—which is why memory-bound kernels live or die by coalesced access patterns that spread traffic evenly across L2 slices and DRAM banks.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-calculate-the-day-of-the-week"&gt;&lt;a href="https://www.benjoffe.com/fast-day-of-week" rel="noopener noreferrer"&gt;A faster way to calculate the day-of-the-week&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Joffe tackles a deceptively simple problem: converting a signed 32-bit Unix epoch day count (&lt;code&gt;1970-01-01&lt;/code&gt; = Thursday) into a day of the week (&lt;code&gt;0..6&lt;/code&gt;) as fast as possible across the entire 32-bit integer range. Cassio Neri&amp;rsquo;s 2024 algorithm serves as the state-of-the-art baseline, but requires an extra correction step because 7 is an awkward divisor in binary. Joffe&amp;rsquo;s key insight is to exploit the fact that $7 = 2^3 - 1$ is a Mersenne number, which means $N \bmod 7 = \lfloor N \cdot \frac{8}{7} \rfloor \bmod 8$. Multiplying by $\frac{8}{7}$ can be approximated by a single fixed-point multiplication by a magic constant &lt;code&gt;M&lt;/code&gt;, and taking $\bmod 8$ comes almost for free by masking or shifting to keep only the top three bits of the fractional part. A bounded 32-bit version reduces to a one-liner—&lt;code&gt;((u32(rd) * M + Z) &amp;gt;&amp;gt; 29)&lt;/code&gt;—valid across $\pm 242,000$ years, which sped up weekday calculations in the Rust &lt;code&gt;jiff&lt;/code&gt; datetime crate by ~40%.&lt;/p&gt;
&lt;p&gt;To cover the full signed 32-bit domain without overflow, Joffe presents several variants: widening to a 64-bit multiply (already adopted by WebKit), adding a bit-shifted correction term that executes in parallel with the multiply, using two multiplies for higher instruction throughput, or collapsing the entire calculation into three x86 instructions via &lt;code&gt;LEA&lt;/code&gt;. Switching between Sunday-indexed (&lt;code&gt;0..6&lt;/code&gt;) and ISO Monday-indexed (&lt;code&gt;1..7&lt;/code&gt;) output only requires swapping the additive constant &lt;code&gt;Z&lt;/code&gt;. Better yet, the same Mersenne identity generalizes to any divisor of the form $2^N - 2^K$, including &lt;code&gt;x % 24&lt;/code&gt; and &lt;code&gt;x % 60&lt;/code&gt; for extracting hours, minutes, and seconds. Benchmarks show Joffe&amp;rsquo;s variants taking just 0.17x to 0.39x the runtime of Neri&amp;rsquo;s algorithm on an Apple M4 Pro and 0.27x to 0.59x on a Ryzen 9 9950X3D, with patches already merged into WebKit, Elixir, Rust&amp;rsquo;s &lt;code&gt;jiff&lt;/code&gt;, and Zig&amp;rsquo;s &lt;code&gt;zeit&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="dark-mode-toggles-two-states-are-enough"&gt;&lt;a href="https://lea.verou.me/blog/2026/dark-mode-toggles/" rel="noopener noreferrer"&gt;Dark mode toggles: two states are enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lea Verou argues that website header dark-mode toggles should only expose two visible states to the user, even though the underlying state machine has three (&lt;code&gt;System&lt;/code&gt;, &lt;code&gt;Light&lt;/code&gt;, and &lt;code&gt;Dark&lt;/code&gt;). In her view, exposing a three-way segmented control or dropdown in the navbar solves an imaginary user goal: nobody visits a website thinking &amp;ldquo;my OS is in light mode and this page looks great in light mode, let me proactively pin it to Light just in case my OS switches to dark mode tonight.&amp;rdquo; Users click a theme toggle for one reason: &lt;em&gt;the current appearance is uncomfortable to read right now, make it the opposite&lt;/em&gt;. Exposing all three states in the header is classic &amp;ldquo;implementation-model UI&amp;rdquo; that adds visual clutter, extra clicks, and unnecessary cognitive load. At the same time, a naive two-state toggle is even worse if clicking it once permanently locks &lt;code&gt;localStorage&lt;/code&gt; into an override with no way to return to following the OS theme.&lt;/p&gt;
&lt;p&gt;Verou&amp;rsquo;s solution is a single two-state button that cleanly traverses all three underlying states. By default (when following the OS), the button displays the currently active theme and stores nothing in &lt;code&gt;localStorage&lt;/code&gt;. Clicking it once switches to the opposite theme and saves that explicit override. Clicking it a second time switches back to the theme that matches the user&amp;rsquo;s current OS preference—and instead of saving a hard override, it &lt;em&gt;clears&lt;/em&gt; the stored setting, returning the site to &lt;code&gt;System&lt;/code&gt; mode. Because the override is only re-evaluated when the user clicks the toggle, users whose OS automatically flips between light and dark at sunset can still override a site whenever they want without getting stuck permanently out of sync. Reserve explicit three-way &lt;code&gt;Light / Dark / Auto&lt;/code&gt; selectors for dedicated settings pages—not the top navigation bar.&lt;/p&gt;</description></item><item><title>Newsletter #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 #114</title><link>https://miti99.com/en/post/2026/07/01/</link><pubDate>Wed, 01 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #114.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-errors-are-a-story-most-teams-lose-the-plot"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-errors/" rel="noopener noreferrer"&gt;Go errors are a story, most teams lose the plot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Robin Siep examines a fundamental difference in how Go handles errors: unlike Java and many other languages, Go errors do not automatically carry stack traces. Instead, developers wrap errors with context at each layer they pass through—such as &lt;code&gt;fmt.Errorf(&amp;quot;unable to get user: %w&amp;quot;, err)&lt;/code&gt;—ultimately producing a chain like &lt;code&gt;unable to get user: failed to query users table: connection refused&lt;/code&gt;. The author calls this a &amp;ldquo;logical trace&amp;rdquo;: when maintained well, it is easier to read than a multi-dozen-line stack trace and stays intact even when errors cross channels, goroutines, or other handoff boundaries where call stacks can get lost.&lt;/p&gt;
&lt;p&gt;The catch is that a logical trace requires relentless discipline from the entire team. Forget to wrap an error at just one call site, and your logs may be left with a bare &lt;code&gt;connection refused&lt;/code&gt;; and much like code comments, an error-wrapping message written two years ago can drift out of date or become misleading. In the author&amp;rsquo;s observation, most teams fail to keep up with this maintenance burden, leaving production errors without enough context to diagnose root causes. The proposed middle ground is to attach a stack trace the moment the application creates an error or first receives one from a third-party library, and then add manual context only when it genuinely clarifies the problem. That way, the stack trace serves as a cheap, always-present fallback. Implementing this yourself is straightforward, or you can reach for Dave Cheney&amp;rsquo;s &lt;code&gt;pkg/errors&lt;/code&gt; or &lt;code&gt;cockroachdb/errors&lt;/code&gt; if you want an actively maintained library.&lt;/p&gt;
&lt;h2 id="the-last-technical-interview"&gt;&lt;a href="https://steve-yegge.medium.com/the-last-technical-interview-bc13ddcf4564" rel="noopener noreferrer"&gt;The Last Technical Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Yegge—who has conducted technical interviews for nearly 35 years, serving as an Amazon Bar Raiser and a Google Hiring Committee member—argues that the traditional technical interview loop is reaching the end of the line. The model of cramming several one-hour interviews into a single day has barely changed in fifty years despite terrible results: interviewers routinely disagree with one another, interview scores barely correlate with actual on-the-job performance, and resumes are becoming increasingly useless now that AI writes them. His most memorable anecdote comes from Google, where recruiting handed the hiring committee a batch of anonymized interview packets disguised as a &amp;ldquo;calibration exercise&amp;rdquo;; the committee voted to reject roughly two-thirds of them, only to learn afterward that the packets were their own historical interview files.&lt;/p&gt;
&lt;p&gt;According to Yegge, the strongest hiring signal has always come from real work—internships, six-month co-ops at Geoworks, or contract-to-hire trials—so it is time to stop &amp;ldquo;simulating work.&amp;rdquo; A new &amp;ldquo;campfire&amp;rdquo; model is emerging in San Francisco: inviting candidates for a paid multi-day stint working on real code, real requirements, and alongside the real team. To make this fair, every stint should &amp;ldquo;count twice&amp;rdquo;: the company gets high-signal evaluation and real output, while the candidate walks away with a durable, company-verified record of what they built and how well they performed, whether or not they receive an offer. Such a system only works if those &amp;ldquo;stamps of approval&amp;rdquo; are issued honestly.&lt;/p&gt;
&lt;h2 id="guidelines-for-respectful-use-of-ai"&gt;&lt;a href="https://www.elidedbranches.com/2026/05/guidelines-for-respectful-use-of-ai.html" rel="noopener noreferrer"&gt;Guidelines for Respectful Use of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Camille Fournier argues that many leaders view AI policies purely through the lens of security, compliance, or cost, overlooking how teams actually work together when AI enters the picture. AI lets an individual generate far more output, but if that person doesn&amp;rsquo;t review it themselves, the quality-control burden simply gets pushed onto teammates and overall team productivity drops. Her first rule is therefore simple: never ask someone else to read or review something you haven&amp;rsquo;t read yourself. This applies to code and even more so to documents, since the context in your head while chatting with an AI may be completely absent from the final text; if you cannot explain and discuss a document yourself, you shouldn&amp;rsquo;t send it out.&lt;/p&gt;
&lt;p&gt;Her second rule is &amp;ldquo;shorter is better&amp;rdquo;: AI-generated code often reads like verbose tutorial code, pull requests balloon to thousands of lines, three-page documents turn into 10-to-20-page essays, and Slack messages and emails become walls of text. She suggests a litmus test: if this change breaks at 3 a.m. and every AI tool is down, can you debug it yourself? For long documents, put a concise summary of the key points right at the top; if you find yourself writing a massive email to explain something, you should probably hop on a call instead. Ultimately, AI is not an excuse to turn off your brain or your empathy: use the productivity gains to ship simpler, better-tested work.&lt;/p&gt;
&lt;h2 id="software-after-ai"&gt;&lt;a href="https://tomtunguz.com/harnessing-ai/" rel="noopener noreferrer"&gt;Software After AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz argues that the familiar software era—where SaaS products manage databases through fixed workflows—is giving way to the era of the &amp;ldquo;harness&amp;rdquo;: the surrounding layer that turns a raw LLM into a reliable agent. He compares an LLM to a wild horse that needs to be broken in. When every company has access to the exact same foundation models, competitive advantage no longer lives in the model itself, but in whoever builds the best harness.&lt;/p&gt;
&lt;p&gt;The post outlines seven components of an AI harness. Context and memory require domain-specific retrieval alongside a &amp;ldquo;context database&amp;rdquo; capturing how a business actually operates. Tools and actions are exposed through a registry with parameter validation and approval gates for sensitive operations, with MCP acting as the connective tissue. Orchestration is the think-act-observe-repeat loop, complete with planning, subagents, and stopping conditions. State and persistence allow a mid-flight failure to resume from the last verified checkpoint (for instance, finishing step 7 and resuming at step 8) instead of starting over from scratch. Sandboxing isolates the execution environment. Observability and governance—traces, logs, evals, and human-in-the-loop approvals for high-stakes decisions—turn a demo into a production system. Finally, cost and workflow optimization decide which steps belong in deterministic code and which call for large or small models. Frontier labs will win the markets they prioritize, but thousands of vertical markets remain wide open for startups.&lt;/p&gt;
&lt;h2 id="design-patterns-are-dead-long-live-design-patterns"&gt;&lt;a href="https://medium.com/google-cloud/design-patterns-are-dead-long-live-design-patterns-b2c2602fbdc4" rel="noopener noreferrer"&gt;Design Patterns Are Dead. Long Live Design Patterns.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christina Lin, a veteran developer, asks whether classic design patterns still matter when AI writes most of the code. Patterns like Singleton, Factory, and Observer were created for human comprehension rather than compilers, so at first she wondered if they had become obsolete. Once a codebase grows large enough, however, AI starts to ramble because it has limits of its own: Chroma&amp;rsquo;s research across 18 models showed reliability degrading as input length grows (&amp;ldquo;context rot&amp;rdquo;), with the drop-off varying by model. As a result, design patterns aren&amp;rsquo;t dead—they&amp;rsquo;ve been promoted from implementation blueprints to ways of compressing intent into prompts and enforcing architectural guardrails around probabilistic models.&lt;/p&gt;
&lt;p&gt;Lin reclassifies patterns around a single question: is this pattern here to help humans read code, or to constrain AI? Patterns that merely patched missing language features, like Iterator or Prototype, are dead; speculative abstractions built &amp;ldquo;just in case&amp;rdquo; should also be pared back now that code is cheap and intent is expensive. Conversely, three patterns matter more than ever: Adapter forces AI outputs into strict schemas before touching the database and feeds validation errors back for self-correction; Decorator wraps retries, timeouts, and token-cost tracking around core logic; and Facade hides complex multi-step agent workflows behind a clean, auditable interface. The unifying principle is treating AI output as untrusted input: isolate it, validate at the boundary, and trust it only once proven valid.&lt;/p&gt;
&lt;h2 id="merge-intervals"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/merge-intervals-89l" rel="noopener noreferrer"&gt;Merge Intervals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh walks through Merge Intervals, a classic interview problem: given an array of &lt;code&gt;[start, end]&lt;/code&gt; intervals, merge all overlapping intervals and return the disjoint result. At first glance it looks like a simulation problem, and the brute-force approach checks every subsequent interval to extend the current end point in &lt;code&gt;O(N²)&lt;/code&gt; time. The key insight is that once intervals are sorted by start time, any overlapping intervals are guaranteed to sit adjacent to one another, so you only ever need to compare the current interval against the most recently merged one.&lt;/p&gt;
&lt;p&gt;That makes the optimal algorithm clean and compact: sort by &lt;code&gt;start&lt;/code&gt; and scan left to right; if the end of the last interval in the result list is smaller than the current interval&amp;rsquo;s start, append the current interval as a new entry; otherwise, update the last interval&amp;rsquo;s end to the maximum of both ends. For input &lt;code&gt;[[1,3],[2,6],[8,10],[15,18]]&lt;/code&gt;, this produces &lt;code&gt;[[1,6],[8,10],[15,18]]&lt;/code&gt;. Overall time complexity is &lt;code&gt;O(N log N)&lt;/code&gt; due to sorting, while the linear scan takes &lt;code&gt;O(N)&lt;/code&gt;. The author also shares interview tips: clearly explain why sorting makes overlapping intervals contiguous, and remember the &amp;ldquo;sort first, then sweep left to right&amp;rdquo; pattern for related problems like Insert Interval, Meeting Rooms, and Non-overlapping Intervals.&lt;/p&gt;
&lt;h2 id="best-time-to-buy-and-sell-stock"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/best-time-to-buy-and-sell-stock-3792" rel="noopener noreferrer"&gt;Best Time to Buy and Sell Stock&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh follows up with another classic LeetCode problem, Best Time to Buy and Sell Stock: given an array of daily stock prices where you may buy once and sell once on a later day, find the maximum profit. For &lt;code&gt;[7,1,5,3,6,4]&lt;/code&gt;, buying at 1 and selling at 6 yields a profit of 5. The brute-force approach treats every day as a buy day, checks every subsequent sell day, and tracks the maximum profit—correct, but &lt;code&gt;O(N²)&lt;/code&gt; because it evaluates far too many redundant buy-sell pairs.&lt;/p&gt;
&lt;p&gt;The key observation is that on any given day, you don&amp;rsquo;t need to remember every prior price—only the lowest price seen so far, because the best profit you could make by selling today is today&amp;rsquo;s price minus that historical minimum. The author notes that he initially considered a dynamic programming array &lt;code&gt;dp[i]&lt;/code&gt;, before realizing that the minimum price is the only state that matters, collapsing the array into two scalar variables: &lt;code&gt;minPrice&lt;/code&gt; and &lt;code&gt;maxProfit&lt;/code&gt;. A single pass that computes today&amp;rsquo;s potential profit, updates the best answer, and updates the running minimum achieves &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space. This is the classic &amp;ldquo;prefix minimum&amp;rdquo; pattern: whenever a problem asks for a maximum profit, maximum difference, or future outcome relative to past values, think about maintaining a running minimum or maximum during a single sweep.&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 #105</title><link>https://miti99.com/en/post/2026/05/27/</link><pubDate>Wed, 27 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/27/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #105.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="virtual-memory-a-deep-dive-into-page-tables-tlbs-and-linux-internals"&gt;&lt;a href="https://blog.codingconfessions.com/p/virtual-memory" rel="noopener noreferrer"&gt;Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abhinav Upadhyay (of the blog &lt;em&gt;Confessions of a Code Addict&lt;/em&gt;) wrote a massive ~25,000-word deep dive explaining virtual memory on x86-64 Linux from first principles down to kernel implementation details. Framed as a dialogue between a process named &amp;ldquo;Alloca&amp;rdquo; and the &amp;ldquo;Kernel,&amp;rdquo; each question from Alloca unlocks a new concept, guiding the reader naturally from &amp;ldquo;why do we need virtual memory?&amp;rdquo; (process isolation, memory protection, the illusion of abundant memory) to the underlying mechanisms. Each process gets a 128 TiB user-space half of the 48-bit virtual address space, divided into text, data, BSS, heap, memory-mapped, and stack segments.&lt;/p&gt;
&lt;p&gt;The centerpiece is the address translation journey: the CR3 register points to a four-level page table (PGD, PUD, PMD, PTE), where each level consumes 9 bits of the address and the final 12 bits index into a 4 KB page. Because walking four levels on every memory access would be prohibitively slow, the TLB (Translation Lookaside Buffer) caches translations, making TLB hit rate a direct driver of application performance. The article then covers demand paging (allocating physical frames only on first access, distinguishing minor faults that require no I/O from major faults that must read from disk), copy-on-write after &lt;code&gt;fork()&lt;/code&gt; (parent and child share read-only frames and only copy on write), &lt;code&gt;mmap()&lt;/code&gt; mapping files through the page cache to skip &lt;code&gt;read()&lt;/code&gt;&amp;rsquo;s extra copy, and how the MMU enforces permissions via page table bits, including the NX bit used for W^X protection.&lt;/p&gt;
&lt;h2 id="orchestrating-ai-code-review-at-scale"&gt;&lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;Orchestrating AI Code Review at scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares how they brought AI code review into CI across their entire engineering organization, using OpenCode to orchestrate multiple specialized agents rather than asking a single giant model to inspect everything. Each merge request can be evaluated by up to seven domain-specific agents covering security, performance, code quality, documentation, release management, and compliance; an orchestrator agent aggregates the findings, deduplicates them, and makes the final call. Each agent&amp;rsquo;s prompt is narrowly scoped and explicitly lists &amp;ldquo;what NOT to flag&amp;rdquo; to keep noise down. A plugin architecture behind a &lt;code&gt;ReviewPlugin&lt;/code&gt; interface decouples version control systems, AI providers, and internal standards, avoiding vendor lock-in.&lt;/p&gt;
&lt;p&gt;To balance cost and quality, the system tiers its models: frontier models (Claude Opus 4.7, GPT-5.4) handle orchestration only, standard models (Claude Sonnet 4.6, GPT-5.3) do the bulk of the reviewing, and lightweight models handle text-heavy tasks like documentation. Merge requests are triaged by risk into trivial, lite, or full, so minor edits don&amp;rsquo;t spin up all seven agents while security-sensitive files always receive a full review. Circuit breakers, timeouts, and a control plane running on Cloudflare Workers keep the system resilient. In its first 30 days, the system ran 131,246 reviews at an average cost of $1.19 per review and an 85.7% cache hit rate.&lt;/p&gt;
&lt;h2 id="the-8-levels-of-agentic-engineering"&gt;&lt;a href="https://www.bassimeledath.com/blog/levels-of-agentic-engineering" rel="noopener noreferrer"&gt;The 8 Levels of Agentic Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bassim Eledath proposes an eight-level framework describing how development teams progressively get more leverage out of AI in software engineering, starting from the observation that &amp;ldquo;AI&amp;rsquo;s coding ability is outpacing our ability to harness it.&amp;rdquo; Levels 1 and 2 are autocomplete and AI-first IDEs like Cursor; Level 3 is context engineering, optimizing every token fed into the model; Level 4 is compounding engineering, with a loop of planning, delegating, evaluating, and recording lessons so each session improves on the last; Level 5 uses MCP and skills to connect databases, APIs, and CI; Level 6 is harness engineering, building environments with automated feedback loops so agents can self-correct; Level 7 is asynchronous background agents; and Level 8 is autonomous agent teams coordinating directly without a central orchestrator — an early, still-challenging frontier.&lt;/p&gt;
&lt;p&gt;The author highlights several cross-cutting lessons. A &amp;ldquo;multiplayer&amp;rdquo; effect means an individual&amp;rsquo;s productivity depends heavily on their teammates&amp;rsquo; level: a Level 7 engineer is still bottlenecked if colleagues manually review PRs at Level 2. Giving agents constraints works better than giving step-by-step instructions, because agents tend to follow instructions rigidly while missing unstated requirements. Finally, using different models for different roles yields better overall results, and the implementing model should never review its own output to avoid self-preference bias.&lt;/p&gt;
&lt;h2 id="hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away"&gt;&lt;a href="https://dev.to/bing_yu/hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away-4dln" rel="noopener noreferrer"&gt;Hexagonal Architecture is Not a Layered Architecture: Topology, Safety, and When to Walk Away&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article points out that the core difference between hexagonal architecture and layered architecture lies in the direction of dependencies rather than complexity. Layered architecture lets dependencies flow vertically down a chain of controller, service, and repository; in hexagonal architecture, dependencies point inward toward the center: adapters depend on ports, ports belong to the domain, and business logic has no idea what implements an outbound port. Alistair Cockburn&amp;rsquo;s original 2005 model split ports into driving and driven sides while allowing multiple ports by communication purpose; many modern implementations influenced by Clean Architecture add concentric inner rings, and each ring adds data-mapping overhead that wasn&amp;rsquo;t part of the original design.&lt;/p&gt;
&lt;p&gt;Port ownership matters too: in the author&amp;rsquo;s chosen layout, Inbound Ports belong to the application layer while Outbound Ports belong to the domain layer, and keeping that distinction clear helps tell whether a change reflects a shift in business requirements or merely a swapped implementation. Adapters handle protocol translation and structural validation like JSON syntax or field types, whereas the domain handles semantic validation like business invariants; if a rule still holds after swapping out the underlying technology, it belongs in the domain. The author is also candid that hexagonal architecture does not automatically give you deployment isolation, input sanitization, or security hardening, and for a CRUD system with 3 controllers, 5 services, and 2 tables, its indirection is a concrete tax paid for abstract benefits; the payoff only grows as complexity grows.&lt;/p&gt;
&lt;h2 id="spec-driven-development-how-ai-coding-moves-beyond-vibe-coding"&gt;&lt;a href="https://www.vitaliihonchar.com/insights/spec-driven-development" rel="noopener noreferrer"&gt;Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitalii Honchar introduces spec-driven development as the next step beyond &amp;ldquo;vibe coding&amp;rdquo;: instead of steering AI through an endless series of small conversational nudges, the developer writes a detailed technical specification up front and lets the AI implement from it autonomously. The workflow follows four sequential stages: co-author a requirements specification in Markdown with the AI, have the AI generate an implementation plan from the spec, break the plan into small manageable tasks, and let the AI execute the whole thing with minimal intervention. The author uses GitHub Spec Kit to bootstrap projects around this workflow.&lt;/p&gt;
&lt;p&gt;Compared to vibe coding, this approach keeps the AI aligned with defined requirements, produces documentation from day one, and frees the developer to focus on other work while the AI builds. As a practical example, the author built AgentD — a local service for scheduling and running AI agents — in about five hours without writing code by hand, a project that would have taken weeks manually. In his view, software engineers should shift their focus toward architectural thinking, requirements definition, and quality verification rather than competing with AI on raw coding speed.&lt;/p&gt;
&lt;h2 id="go-vs-java-the-minimalist-vs-the-enterprise-veteran"&gt;&lt;a href="https://dev.to/adamthedeveloper/go-vs-java-the-minimalist-vs-the-enterprise-veteran-1gg3" rel="noopener noreferrer"&gt;Go vs Java: The Minimalist vs The Enterprise Veteran&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two languages built on opposite philosophies: Go embraces radical minimalism (no classes, no inheritance, and no generics until 2022), while Java offers a rich toolkit of generics, inheritance, interfaces, and annotations. According to the author, Go&amp;rsquo;s minimalism lets new team members read and understand a codebase from day one. On performance, Go compiles to native binaries that start in milliseconds, making it a natural fit for containerized workloads; Java runs on the JVM, starting slower but warming up to high peak throughput thanks to JIT compilation in long-running services.&lt;/p&gt;
&lt;p&gt;The concurrency gap has narrowed considerably: Go&amp;rsquo;s goroutines and channels have long been lightweight and ergonomic, but Virtual Threads in Java 21 now bring M:N scheduling to Java&amp;rsquo;s familiar thread API, even if the underlying mechanics and trade-offs still differ from goroutines. In terms of ecosystem, Java boasts millions of mature libraries with Spring dominating enterprise development, while Go favors quality over quantity with a standard library sufficient for most tasks. Go shines for infrastructure, CLIs, microservices, and cloud-native apps; Java excels in complex enterprise systems. The author concludes that neither language is universally superior — the right choice depends on project requirements and team expertise.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-goal"&gt;&lt;a href="https://x.com/Saboo_Shubham_/status/2054988166541770782" rel="noopener noreferrer"&gt;The ultimate guide to /goal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shubham Saboo argues that &lt;code&gt;/goal&lt;/code&gt; is not just a feature, but is emerging as a foundational primitive for coding agents, much like HTTP or JSON. With normal prompting, you steer turn by turn: read the response, evaluate it, and nudge the agent to the next step. &lt;code&gt;/goal&lt;/code&gt; flips that model: you describe what &amp;ldquo;done&amp;rdquo; looks like, send it once, and the agent loops autonomously until it gets there — for example, &amp;ldquo;build the app according to SPEC.md; done means tests pass, build passes, README is accurate, and git status is clean.&amp;rdquo; It shifts the interaction from micromanaging steps to delegating against a clear objective. Notably, three separate ecosystems — OpenAI Codex CLI, Claude Code, and the Hermes Agent orchestrator — have converged on the same command pattern, making them composable.&lt;/p&gt;
&lt;p&gt;Saboo outlines three enduring roles regardless of how tools evolve: the orchestrator that coordinates, selects workers, manages the Kanban board, and performs final verification (Hermes); the builder that takes a spec and generates code (Codex&amp;rsquo;s strength); and the reviewer that hunts for bugs in plausible-looking code (Claude Code&amp;rsquo;s strength). The golden rule is independent verification: Hermes never trusts Codex&amp;rsquo;s self-reported completion and instead runs &lt;code&gt;npm test&lt;/code&gt; and &lt;code&gt;npm run build&lt;/code&gt; itself — turning &lt;code&gt;/goal&lt;/code&gt; from a promise into a contract. Multiple goals can run in parallel, though each file should only have a single writing agent at a time to avoid conflicts.&lt;/p&gt;
&lt;h2 id="the-ai-native-developer"&gt;&lt;a href="https://newsletter.getdx.com/p/the-ai-native-developer" rel="noopener noreferrer"&gt;The AI-Native Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck presents research on how AI is reshaping the developer role, drawing on a survey of more than 1,300 developers and interviews with 22 practitioners. Developer work falls into three buckets: core tasks like coding, debugging, and testing score high across every dimension and represent the biggest opportunity for AI; cross-component debugging and environment provisioning are areas where developers want deeper AI help, though current tools still fall short; and relational work like stakeholder communication sits in the &amp;ldquo;low priority for AI&amp;rdquo; zone where developers want to retain their own voice and final accountability.&lt;/p&gt;
&lt;p&gt;The study identifies four stages of AI maturity: Skeptics, who adopt only when competitive pressure forces their hand; Explorers, who build confidence through small wins; Collaborators, who bring AI into their workflow much earlier; and Strategists, who orchestrate multiple agents in parallel, shifting from code producers to &amp;ldquo;architects of intent.&amp;rdquo; Alongside this progression sit three unresolved tensions: the learning paradox (are we becoming better engineers or just better prompt writers?), the risk of skill atrophy among junior developers, and an accountability gap when verification standards fail to keep pace with generation speed. Houck sketches three possible futures: maintaining deep craft at AI speed, focusing on orchestration and judgment, or becoming a &amp;ldquo;Clerical Coder&amp;rdquo; who rubber-stamps generated code without truly understanding it.&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 #86</title><link>https://miti99.com/en/post/2026/03/01/</link><pubDate>Sun, 01 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #86.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="do-not-surrender-to-the-tech-tree"&gt;&lt;a href="https://www.macroscience.org/p/do-not-surrender-to-the-tech-tree" rel="noopener noreferrer"&gt;Do Not Surrender to the Tech Tree&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tao Burga defends &amp;ldquo;strong technological determinism&amp;rdquo;: technology unfolds according to the internal logic of a &amp;ldquo;tech tree,&amp;rdquo; driven more by prerequisites, market incentives, and efficiency than by lone genius. The evidence is that independent, near-simultaneous invention is pervasive (Hall–Héroult aluminum smelting, the jet engine, calculus), and isolated societies still converge on the wheel, intensive agriculture, metallurgy, and writing. Yet the author rejects &amp;ldquo;Technocalvinism&amp;rdquo;—the fatalistic belief that humans are powerless before this progression. In the short run, deliberate choices, especially altering the order in which technologies arrive, can have lasting consequences: non-proliferation efforts kept the number of nuclear-armed states at nine, Permissive Action Links prevented unauthorized detonations, and COVID-19 vaccines arrived in 10 months instead of 10–15 years.&lt;/p&gt;
&lt;p&gt;Turning to AI, the author stresses that it is a dual-use technology: useful for both cyber defense and cyber offense, for discovering vaccines and for engineering dangerous pathogens. Rather than accepting the default branch of the tree, we need differential technological development that builds risk-mitigating technologies in parallel—like inventing seatbelts alongside the automobile. The essay highlights &amp;ldquo;The Launch Sequence,&amp;rdquo; a portfolio of 16 concrete projects including Operation Patchlight and The Great Refactor (using AI to harden critical software infrastructure before AI-powered attacks hit), hardware-based verification, and defenses against &amp;ldquo;sleeper agents&amp;rdquo; embedded in models. In the author&amp;rsquo;s view, AI is right inside such a window of agency now, and that window is closing fast.&lt;/p&gt;
&lt;h2 id="how-to-make-architecture-decisions-rfcs-adrs-and-getting-everyone-aligned"&gt;&lt;a href="https://lukasniessen.medium.com/how-to-make-architecture-decisions-rfcs-adrs-and-getting-everyone-aligned-ab82e5384d2f" rel="noopener noreferrer"&gt;How to Make Architecture Decisions: RFCs, ADRs, and Getting Everyone Aligned&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen shares an architecture decision-making process designed to avoid two familiar failure modes: decisions rushed through in a hallway chat, or polished documents nobody reads—both of which lead to months of rework. The process has four steps: write an RFC (1–2 days), gather asynchronous feedback (2–3 days), hold a decision meeting (30–60 minutes), and write the ADR the same day. The RFC lays out context, options (including &amp;ldquo;do nothing&amp;rdquo;), stakeholders, and open questions; the crucial trick is explicitly ranking priorities rather than just listing pros and cons, because once priorities are clear, the right choice is usually obvious. The async review phase gives everyone time to think and research, and gives quieter teammates a voice.&lt;/p&gt;
&lt;p&gt;The decision meeting is not a presentation: everyone has already read the RFC, the group is kept to 5–8 people, and the time is spent resolving open questions, debating, and committing—whether by consensus, consent (no paramount objections), or a single accountable decision-maker. An ADR is the short, permanent record of what was decided and why; the RFC explores options, while the ADR captures the outcome. The author advises including an incremental rollout plan in the RFC, using LLMs as thinking partners rather than ghostwriters, and avoiding common traps: analysis paralysis, too many cooks, skipping the ADR, and ignoring quiet voices.&lt;/p&gt;
&lt;h2 id="the-cost-of-a-function-call"&gt;&lt;a href="https://lemire.me/blog/2026/02/08/the-cost-of-a-function-call/" rel="noopener noreferrer"&gt;The cost of a function call&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire measures the overhead of a function call and the payoff of inlining, an optimization where the compiler copies a function&amp;rsquo;s body directly into the call site. Function calls are cheap but not free: they may require saving and restoring registers on the stack, jumping into and back out of the function, plus prologue and epilogue instructions. On an M4 MacBook with LLVM, a loop summing an integer array through a non-inlined &lt;code&gt;add&lt;/code&gt; function takes 0.7 ns per element, versus just 0.03 ns when inlined—over 20 times faster. The reason: once the call is inlined, the compiler vectorizes the loop with SIMD instructions, processing 16 integers in 8 instructions, or half an instruction per number instead of six. Even with SIMD disabled, the inlined version is still roughly 10 times faster.&lt;/p&gt;
&lt;p&gt;For a more complex function like counting spaces in a string, the outcome depends on input size. On a 1,000-character string, call overhead is negligible and the inlined version is even slightly slower (115 ns vs. 111 ns); on short strings of 0–6 characters, inlining is noticeably faster (1.0 ns vs. 1.6 ns). The takeaway: tiny, simple functions should be inlined when performance matters, whereas for functions with variable runtime, the inlining decision should be guided by realistic input sizes.&lt;/p&gt;
&lt;h2 id="the-perfect-code-review-how-to-reduce-cognitive-load-while-improving-quality"&gt;&lt;a href="https://bastrich.tech/perfect-code-review/" rel="noopener noreferrer"&gt;The PERFECT Code Review: How to Reduce Cognitive Load While Improving Quality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich introduces PERFECT, a framework of principles to make code reviews less cognitively taxing. Without structure, reviews easily devolve into vague, subjective commentary—causing delays, bike-shedding over trivia, or rubber-stamp approvals. PERFECT orders seven principles by priority: Purpose (the code solves the right problem—a prerequisite), Edge Cases (handling boundary conditions, including &amp;ldquo;impossible&amp;rdquo; ones), Reliability (no performance or security regressions), Form (sound design principles, centered on high cohesion and low coupling), Evidence (tests and CI pass), Clarity (the code clearly expresses intent), and Taste (personal preferences are noted as non-blocking).&lt;/p&gt;
&lt;p&gt;The author stresses that code review isn&amp;rsquo;t an all-or-nothing checklist, but a spectrum of techniques that can be applied independently; even a lightweight, structured review delivers high value for little effort. To make it stick, teams should maintain a living written review guide (turning recurring review comments into documented conventions), require self-review before requesting peers, build review into the workflow with clear ownership and SLAs, automate everything possible, stop rubber-stamping with &amp;ldquo;LGTM,&amp;rdquo; and practice reviewing regularly. Good review comments state the issue, explain the reasoning, and suggest a concrete alternative.&lt;/p&gt;
&lt;h2 id="semantic-search-without-embeddings"&gt;&lt;a href="https://softwaredoug.com/blog/2026/01/08/semantic-search-without-embeddings.html" rel="noopener noreferrer"&gt;Semantic Search Without Embeddings&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doug Turnbull argues that semantic search is not synonymous with vector search. Semantic search requires three ingredients: a shared representation for queries and documents, a similarity function, and a matching criterion to decide whether a result actually belongs in the user&amp;rsquo;s intended scope. Embeddings handle the first two well but struggle with the third: there is no universal similarity threshold across queries, so searching for &amp;ldquo;fruit that grows on trees&amp;rdquo; can still return a baseball. Instead, the author proposes using a controlled vocabulary or taxonomy—a hierarchy of domain concepts, like the category tree in the Wayfair WANDS dataset. A taxonomy provides all three: the category tree is the representation, exact category matches rank above parent and sibling categories, and anything beyond a chosen tree distance can be filtered out.&lt;/p&gt;
&lt;p&gt;Best of all, no vector index is required: you simply use hierarchical path tokenization (emitting the full ancestor path for every category) inside a standard BM25 index. Because BM25 rewards rarer terms, broad root categories appear frequently and score low, while specific leaf categories are rare and score high—naturally ranking exact matches above parents and grandparents. Taxonomies should start simple and split incrementally as categories grow, and LLMs make classifying both products and queries easier and cheaper than ever. In the author&amp;rsquo;s view, embeddings may be most useful for building classifiers rather than for direct retrieval and ranking.&lt;/p&gt;
&lt;h2 id="my-ai-adoption-journey"&gt;&lt;a href="https://mitchellh.com/writing/my-ai-adoption-journey" rel="noopener noreferrer"&gt;My AI Adoption Journey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mitchell Hashimoto—creator of Vagrant, Terraform, and Ghostty—shares his pragmatic journey toward finding real value in AI tools. Adopting any tool, he notes, goes through three phases: inefficiency, adequacy, and finally workflow-changing discovery. His early steps included: dropping chat interfaces in favor of agents that can read files, run programs, and make HTTP requests; forcing himself to reproduce every manual commit with an agent to learn principles like breaking work into small tasks, separating planning sessions from execution sessions, and giving agents a way to verify their own work; spending the last 30 minutes of each day kicking off agents for deep research, fuzzy ideation, and issue/PR triage; and delegating slam-dunk tasks to agents while focusing on deep work himself with notifications turned off to avoid context switching.&lt;/p&gt;
&lt;p&gt;Step five is &amp;ldquo;harness engineering&amp;rdquo;: whenever the agent makes a mistake, add instructions to &lt;code&gt;AGENTS.md&lt;/code&gt; or build custom tooling so it never repeats that error. The final step is keeping one agent running in the background as much as possible, paired with slower, more thorough models. Right now he runs just a single agent at a time—striking a balance between the deep manual craft he loves and babysitting a machine—and reaches that background-agent goal for about 10–20% of his workday. He emphasizes never running an agent just for the sake of it, only when there is genuinely useful work, and notes that whatever you delegate to an agent is a skill you stop practicing yourself.&lt;/p&gt;
&lt;h2 id="software-engineering-is-back"&gt;&lt;a href="https://blog.alaindichiappari.dev/p/software-engineering-is-back" rel="noopener noreferrer"&gt;Software Engineering is back&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alain Di Chiappari argues that &amp;ldquo;automatic programming&amp;rdquo;—Antirez&amp;rsquo;s term in place of the shallow label &amp;ldquo;vibe coding&amp;rdquo;—is bringing real software engineering back. Building products ranging from network configuration to pricing engines with frontier models and coding agents every day, the author noticed a decisive shift starting in December 2025. Thinking through architecture, trade-offs, and edge cases still belongs to humans; what vanished is the manual labor of typing out every line of code. He gets to be the architect without laying every brick by hand, while still drawing on twenty years of bricklaying experience to understand and fix things when needed.&lt;/p&gt;
&lt;p&gt;In his view, frameworks historically solved three problems. &amp;ldquo;Simplification&amp;rdquo; was often intellectual surrender: buying someone else&amp;rsquo;s thinking instead of sharpening your own mental models, like wrapping a broken leg in silk. Automating boilerplate was the only legitimate reason, and agents now make custom code cheaper than ever—he builds small purpose-built tools tailored to the problem, where a simple Makefile covers most needs. The third, rarely spoken reason is labor commoditization: companies hire interchangeable &amp;ldquo;React Developers&amp;rdquo; instead of software engineers. Meanwhile, agents excel at battle-tested tools like Bash (born in 1989), which is becoming a universal adapter. The essay is a call to stop letting Google, Meta, or Vercel be your architect and start building things you truly own.&lt;/p&gt;
&lt;h2 id="art-of-roads-in-games"&gt;&lt;a href="https://sandboxspirit.com/blog/art-of-roads-in-games/" rel="noopener noreferrer"&gt;Art of Roads in Games&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fascinated by road systems ever since playing SimCity 2000, the author examines why roads in city-building games, despite steady progress, still look subtly wrong: highway ramps kink or wobble unnaturally, high-speed lanes bend too sharply, and intersection corner radii look off. The root cause is the Bézier curve, game developers&amp;rsquo; go-to tool: elegant and flexible, yet unable to preserve its shape and curvature under parallel offsetting. In the real world, two wheels on the same axle stay a fixed distance apart, tracing parallel paths; a curve parallel to a Bézier curve is no longer a Bézier curve, so on tight turns the road mesh distorts or self-intersects.&lt;/p&gt;
&lt;p&gt;The solution is circular arcs: offset an arc in parallel (as long as the radius stays valid) and you get another circular arc concentric with the original, and chaining arcs of different radii can form complex shapes that follow real civil-engineering principles. Circular arcs also allow O(1) closed-form intersection math instead of the expensive iterative solvers Bézier curves require. Their limitation is constant curvature, which causes lateral acceleration to jump abruptly when entering a turn at high speed; highway engineers use transition curves like clothoids whose curvature ramps up linearly, though the math is much heavier. For lower-speed urban roads, circular arcs are more than good enough. The author built his own road system out of curiosity and because resources for indie developers were so scarce, and hopes to share a better foundation with the community.&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/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7712ce10-d199-49ef-94f9-e983e47a92d9_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&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 #74</title><link>https://miti99.com/en/post/2025/12/27/</link><pubDate>Sat, 27 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/27/</guid><description>&lt;p&gt;&lt;em&gt;It&amp;rsquo;s been a while since I paid for anything AI-related (not since my Claude subscription to test out Claude Code). Today I decided to subscribe to &lt;a href="https://z.ai" rel="noopener noreferrer"&gt;Z.ai&lt;/a&gt;&amp;rsquo;s &lt;a href="https://z.ai/subscribe" rel="noopener noreferrer"&gt;GLM Coding Plan&lt;/a&gt; to give it a spin. The plan currently gives access to Z.ai&amp;rsquo;s latest model, GLM-4.7. From now on I&amp;rsquo;ll be pairing &lt;a href="https://claude.com/product/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt; with the &lt;a href="https://z.ai/model-api" rel="noopener noreferrer"&gt;Z.ai API&lt;/a&gt; to squeeze every bit of value out of what I paid for^^. Enjoy Newsletter #74.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="goodbye-microservices-from-100s-of-problem-children-to-1-superstar"&gt;&lt;a href="https://www.twilio.com/en-us/blog/developers/best-practices/goodbye-microservices" rel="noopener noreferrer"&gt;Goodbye Microservices: From 100s of problem children to 1 superstar&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Twilio Segment recounts why they moved away from a microservices architecture for forwarding events to server-side destinations. Initially, all events flowed through a single shared queue, so whenever one destination slowed down or failed, retries caused head-of-line blocking across the entire system. To isolate failures, the team created a dedicated service and queue per destination and split each destination&amp;rsquo;s code into its own repository. That worked well at first, but once the number of destinations grew past 140, shared libraries drifted out of sync across repositories, each service had a distinct traffic profile that made autoscaling painful to configure, and three engineers were spending most of their time just keeping the lights on.&lt;/p&gt;
&lt;p&gt;Their solution was to consolidate everything back into a single service inside a monorepo, unify 120 dependencies onto a single version each, and build a Traffic Recorder to record and replay HTTP traffic during tests—shrinking the test suite for all 140+ destinations from an hour down to a few milliseconds. The result: noticeably faster development velocity (46 shared library improvements in a year compared to 32 previously), simpler scaling, and no more middle-of-the-night pages from traffic spikes. The trade-offs are harder fault isolation, less effective in-process caching, and the risk that upgrading a shared library can break multiple destinations at once. The lesson: moving back to a monolith requires a rock-solid test suite and a clear-eyed acceptance of the trade-offs.&lt;/p&gt;
&lt;h2 id="5-engineering-dogmas-it"&gt;&lt;a href="https://newsletter.manager.dev/p/5-engineering-dogmas-its-time-to" rel="noopener noreferrer"&gt;5 engineering dogmas it&amp;rsquo;s time to retire&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides proposes rethinking five familiar &amp;ldquo;truths&amp;rdquo; in software engineering. First, &amp;ldquo;don&amp;rsquo;t reinvent the wheel, use a library&amp;rdquo;: over-relying on third-party dependencies exposes projects to security vulnerabilities and constant update churn, famously illustrated when the ~11-line &lt;code&gt;left-pad&lt;/code&gt; package was unpublished from npm and broke builds at Facebook, Spotify, and Netflix. Second, &amp;ldquo;every PR must be reviewed&amp;rdquo;: code reviews are valuable, but rigid mandatory review gates slow teams down; at Pylon, engineers merge their own PRs and only request reviews when they want feedback, when a change is risky, or when onboarding, and pair programming is a strong alternative. Third, &amp;ldquo;2–4 week sprints are the modern way to work&amp;rdquo;: Basecamp&amp;rsquo;s Shape Up—with 6-week cycles followed by a 1–2 week scheduled cool-down off project work—shows there are viable ways to organize work beyond Scrum and Kanban.&lt;/p&gt;
&lt;p&gt;Fourth, &amp;ldquo;every change should be behind a feature flag&amp;rdquo;: when overused, hundreds of active flags make the codebase complex, combinatorially hard to test, and create a false sense of security; sometimes thorough testing in staging followed by a direct release is all you need. Fifth, &amp;ldquo;if your code needs comments, it&amp;rsquo;s too complex&amp;rdquo;: extremes in either direction miss the mark, as a one- or two-line comment can save hours for the next person reading the code. He concludes that none of these dogmas are completely wrong, but a good engineering manager knows how to balance them against their team&amp;rsquo;s reality.&lt;/p&gt;
&lt;h2 id="what-does-a-database-for-ssds-look-like"&gt;&lt;a href="https://brooker.co.za/blog/2025/12/15/database-for-ssd.html" rel="noopener noreferrer"&gt;What Does a Database for SSDs Look Like?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker asks what a relational database designed from scratch for SSDs in 2025 would look like, given that Postgres and MySQL were born in the era of spinning disks while modern NVMe SSDs are roughly 1,000x faster in both throughput and latency. Re-evaluating Jim Gray&amp;rsquo;s &amp;ldquo;five-minute rule&amp;rdquo; against current EC2 pricing, a buffer pool should cache pages expected to be re-read within about 30 seconds to optimize cost. Because SSDs are throughput-bound for transfers above ~32 KB and IOPS-bound for smaller blocks, average transfer sizes shouldn&amp;rsquo;t be much smaller than 32 KB. And since writing to a local SSD only provides single-machine durability, a modern database should synchronously replicate across Availability Zones (AZs)—paying cross-AZ latency only at commit time—while using high-precision hardware clocks to support strongly consistent scale-out reads.&lt;/p&gt;
&lt;p&gt;On write-ahead logging (WAL), he argues that flushing to a local disk on a single machine is both unnecessary and insufficient; instead, transactions should commit to a distributed log that guarantees durability across multiple machines and AZs, recovering by replaying the log on any replica. His conclusion: keep the relational model, SQL, atomicity, isolation (defaulting to SNAPSHOT), and strong consistency, but turn durability, read/write scalability, and high availability into distributed problems while stripping out most legacy optimizations built around local disk durability and recovery.&lt;/p&gt;
&lt;h2 id="the-economics-of-system-design-finops-auto-scaling-and-spot-instances"&gt;&lt;a href="https://designgurus.substack.com/p/cloud-cost-optimization-101-5-strategies" rel="noopener noreferrer"&gt;The Economics of System Design: FinOps, Auto-Scaling, and Spot Instances&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post emphasizes that cost is often an afterthought in system design, even though an estimated 30% of cloud spend is wasted on underutilized resources. Small inefficiencies like a redundant query or an idle server might be negligible with 100 users, but balloon into massive bills at millions of users. Cost should therefore be treated as a first-class concern from the initial design phase, because retrofitting cost efficiency onto an inherently expensive architecture is far harder.&lt;/p&gt;
&lt;p&gt;The author outlines five strategies: design for efficiency from day one by weighing the overhead of microservices and favoring simplicity; right-size resources and use autoscaling and pay-per-use serverless offerings; add caching layers like Redis and optimize queries (fetching only needed fields and indexing properly) to reduce database load; regularly hunt down and terminate idle resources like forgotten test environments and schedule non-production systems to shut down overnight; and finally, monitor spend, set cost alerts, and build a FinOps culture where engineers treat cost as a performance metric. A well-designed system isn&amp;rsquo;t just scalable and fast—it&amp;rsquo;s also cost-effective.&lt;/p&gt;
&lt;h2 id="the-big-o-complexity-of-vibe-coders"&gt;&lt;a href="https://www.shiveesh.com/thoughts-and-ideas/the-big-o-complexity-of-vibe-coders" rel="noopener noreferrer"&gt;The Big-O Complexity of Vibe Coders&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Today, vibe coding (programming by conversing with an LLM) is mostly judged by how quickly it produces results, but the author predicts that as enterprise LLM adoption scales, the question will shift to how costs grow—much like analyzing an algorithm&amp;rsquo;s Big-O complexity. Teams that don&amp;rsquo;t use vibe coding move slowly, while teams that abuse it with rapid fire-and-retry prompting rack up huge token bills without understanding why. Every prompt and every correction consumes tokens, so a workflow with many quick retry loops can exhibit closer to O(n²) token complexity rather than O(n). Vague prompts widen the solution space and force repeated corrections, whereas precise prompts that state constraints up front converge much faster.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, the best vibe coders aren&amp;rsquo;t the ones who iterate the fastest, but the ones with the lowest token &amp;ldquo;Big-O&amp;rdquo; per shipped outcome; vibe coding makes individuals faster, while token-efficient vibe coding lets whole teams scale. That said, this lens doesn&amp;rsquo;t apply to creative or exploratory work like brainstorming or exploring dead ends, which is inherently token-inefficient yet still valuable and shouldn&amp;rsquo;t be forced into an optimization metric.&lt;/p&gt;
&lt;h2 id="design-is-more-than-code"&gt;&lt;a href="https://linear.app/now/design-is-more-than-code" rel="noopener noreferrer"&gt;Design is more than code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Karri Saarinen, co-founder of Linear, argues that the &amp;ldquo;should designers code?&amp;rdquo; debate is far too narrow. The bigger question is how the designer&amp;rsquo;s role evolves with AI and modern tools, and what we lose if we push designers to jump straight into code. Design takes many forms depending on the domain, customers, and people involved—and even engineers regularly step away from code to sketch architecture or weigh trade-offs. In his view, the first step is &amp;ldquo;problem design&amp;rdquo;: questioning whether the problem is real and who defines it rather than taking it as a given, since the most common reason design projects drag on or fail is an unclear problem where everyone has a different mental model.&lt;/p&gt;
&lt;p&gt;Next comes &amp;ldquo;solution design,&amp;rdquo; which has two phases: a conceptual phase to find the overall shape (at Linear, for example, a project is modeled as a distinct entity with its own properties rather than just a label grouping issues), and an execution phase that brings the idea to the screen, where code and real materials are essential. He likens the upfront work to preparing the goal, context, and prompt for an agent. What worries him isn&amp;rsquo;t the tooling itself, but the erosion of deliberate thought when building straight in production becomes the default; to him, design is always about finding the right problem, the right intent, and the right vision.&lt;/p&gt;
&lt;h2 id="how-we-saved-70-cpu-and-60-memory-in-refinery"&gt;&lt;a href="https://www.honeycomb.io/blog/how-we-saved-70-cpu-60-memory-refinery" rel="noopener noreferrer"&gt;How we saved 70% CPU and 60% memory in Refinery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Honeycomb shares how Refinery 3.0, their Go-based tail-based trace sampling proxy, cut CPU usage by 70% and memory usage by 60% on their internal cluster—enough to shrink a 72-node cluster in half. Profiling revealed that the root cause was deserializing every incoming span in full into a &lt;code&gt;map[string]any&lt;/code&gt; with hundreds of fields: roughly 50% of CPU time went to memory allocation and nearly a quarter to garbage collection, while the actual sampling logic took only about 12%—and most spans were ultimately discarded anyway.&lt;/p&gt;
&lt;p&gt;The fix was to stop deserializing altogether: Refinery now selectively extracts only the handful of fields needed for sampling directly from the serialized MessagePack payload and keeps the span in its compact serialized form. In benchmarks, selective extraction took about 17 ns with zero allocations, compared to roughly 296 ns and 9 allocations when unmarshaling into a map. Other input formats (JSON, OTLP) are transcoded directly into MessagePack on ingest. The team also optimized metrics instrumentation, pooled large buffers for reuse, and parallelized the decision loop. The resulting code is longer and more complex, but it didn&amp;rsquo;t require fancy algorithms or a rewrite in Rust—just redefining what the process actually needed to do and doing only that.&lt;/p&gt;
&lt;h2 id="from-junior-to-senior-7-api-design-patterns-that-scale"&gt;&lt;a href="https://designgurus.substack.com/p/from-junior-to-senior-7-api-design" rel="noopener noreferrer"&gt;From Junior to Senior: 7 API Design Patterns That Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through seven architectural decisions that help APIs scale—and that distinguish junior developers (who focus on internal logic) from seniors (who focus on how systems communicate). First, resource-oriented design: instead of RPC-style endpoints like &lt;code&gt;POST /updateUserEmail&lt;/code&gt;, use nouns like &lt;code&gt;/users&lt;/code&gt; and let HTTP methods (&lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, &lt;code&gt;PATCH&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;) express the action, making the API predictable. Second, return proper HTTP status codes instead of always returning &lt;code&gt;200 OK&lt;/code&gt; with an error message in the body, since monitoring tools, load balancers, and caches rely on status codes; distinguishing &lt;code&gt;4xx&lt;/code&gt; (client error) from &lt;code&gt;5xx&lt;/code&gt; (server error) is crucial during debugging. Third, pagination: offset pagination slows down as datasets grow because the database still has to scan past skipped rows, whereas cursor-based pagination uses an indexed value to keep performance steady.&lt;/p&gt;
&lt;p&gt;Fourth, idempotency keys prevent duplicate processing of retried requests, such as charging a customer twice when they tap submit again on a flaky connection. Fifth, rate limiting protects the system from overload. Sixth, API versioning prevents breaking existing clients. Seventh, comprehensive documentation with OpenAPI/Swagger keeps teams aligned. Good API design lays a stable foundation for business growth, while poor design quickly becomes a bottleneck.&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_!3GQA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F82f1e76a-8fbf-4e8f-b030-e20037c66f70_3000x3900.png" alt="Evolution of HTTP"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Zyn0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F063ae714-8714-4695-8b0e-16a765c5c1a8_2360x2960.png" alt="System Performance Metrics Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ta7a!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe42382d5-9be5-443a-9f75-56ecfa22569c_2360x2960.png" alt="Why Is Nginx So Popular?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!sXIK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa25e1401-cc6f-49f1-9ed1-6f093a01ac6c_2360x2664.png" alt="Network Debugging Commands Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!BXWB!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F09a8b52f-2b80-4762-92cd-c5d18d5a7a3c_2360x2960.png" alt="Hub, Switch, &amp;amp; Router Explained"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;Z.ai processes individual URLs relatively quickly and looked pretty decent at first, though the more URLs I added, the longer and more English-heavy the summaries became. I had to ask it to trim them down a bit. Hopefully I can tune it further (since I already paid for it and it&amp;rsquo;s non-refundable, haha).&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 #69</title><link>https://miti99.com/en/post/2025/12/12/</link><pubDate>Fri, 12 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #69. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; GLM-4.6&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-and-why-netflix-built-a-real-time-distributed-graph-part-1--ingesting-and-processing-data-streams-at-internet-scale"&gt;&lt;a href="https://netflixtechblog.com/how-and-why-netflix-built-a-real-time-distributed-graph-part-1-ingesting-and-processing-data-80113e124acc" rel="noopener noreferrer"&gt;How and Why Netflix Built a Real-Time Distributed Graph: Part 1 — Ingesting and Processing Data Streams at Internet Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;As Netflix expanded beyond on-demand video streaming into ad-supported tiers, live events, and mobile games, understanding a member&amp;rsquo;s journey across devices and business lines grew increasingly difficult. A microservices architecture with hundreds of services—each managing its own data store—fragmented the data and forced analytics teams to stitch records together manually. In response, Netflix&amp;rsquo;s data engineering team built the Real-Time Distributed Graph (RDG): modeling domain entities as a graph so relationships can be queried via multi-hop traversals across nodes and edges rather than expensive relational &lt;code&gt;JOIN&lt;/code&gt;s, making it easy to onboard new entity types and spot behavioral patterns or anomalies.&lt;/p&gt;
&lt;p&gt;Part 1 focuses on the ingestion and stream-processing pipeline. User interactions flow through the API Gateway into Kafka topics (some handling up to ~1 million messages per second, encoded in Avro and simultaneously archived to Apache Iceberg tables for historical backfills). Apache Flink jobs filter out noise, enrich events with metadata, transform raw events into graph nodes and edges, and batch and deduplicate updates within a short time window before writing over 5 million records per second into Netflix&amp;rsquo;s Data Mesh. A key operational lesson: running a single monolithic Flink job across all topics proved nearly impossible to tune, so the team moved to one Flink job per Kafka topic—accepting higher operational overhead in exchange for isolation and independent tuning.&lt;/p&gt;
&lt;h2 id="start-small-scale-smart-the-real-value-of-incremental-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-architecture-what-you" rel="noopener noreferrer"&gt;Start Small, Scale Smart: The Real Value of Incremental Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Incremental architecture is the practice of designing systems so they can evolve gracefully, grounded in Gall&amp;rsquo;s Law: if you start with a complex system from scratch, you will end up with a complex system that doesn&amp;rsquo;t work. In the author&amp;rsquo;s view, team organization matters more than technology: cross-functional teams that own a business domain end-to-end outperform layer-siloed teams, and if you want microservices, you must first build independent teams. Architects should act as mentors who still write code and steward system coherence rather than handing down mandates from an ivory tower, spreading knowledge through pair and mob programming. Instead of asking &amp;ldquo;how long will this take?&amp;rdquo;, ask &amp;ldquo;how can we make this smaller?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;On the technical side, the post advises applying architectural patterns only when you actually feel the pain they solve, using the Strangler Fig pattern to incrementally extract cleaner modules out of legacy monoliths, and building small, single-responsibility, replaceable components with firm boundaries—which naturally become candidates for future microservices. Event-driven architecture reduces coupling by letting components emit events instead of relying on central orchestration, while Domain-Driven Design and a shared Ubiquitous Language clarify events, consequences, and actors before anyone writes a line of code.&lt;/p&gt;
&lt;h2 id="java-interview-question---why-collection-doesn"&gt;&lt;a href="https://javabulletin.substack.com/p/java-interview-question-why-collection" rel="noopener noreferrer"&gt;Java Interview Question - Why Collection doesn&amp;rsquo;t extend Cloneable and Serializable interfaces?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interview question explores a classic Java design decision: why the root &lt;code&gt;Collection&lt;/code&gt; interface does not extend &lt;code&gt;Cloneable&lt;/code&gt; or &lt;code&gt;Serializable&lt;/code&gt;. The core reason is that not every collection can—or should—be cloned or serialized, so forcing both interfaces at the top of the hierarchy would impose unrealistic constraints on specialized implementations. For example, &lt;code&gt;Collections.unmodifiableList()&lt;/code&gt; is just a read-only view where deep cloning would break its semantics, &lt;code&gt;WeakHashMap&lt;/code&gt; relies on JVM-managed weak references that don&amp;rsquo;t make sense to serialize, and a &lt;code&gt;TreeMap&lt;/code&gt; configured with a non-serializable &lt;code&gt;Comparator&lt;/code&gt; cannot be serialized either. (Note that &lt;code&gt;ConcurrentSkipListMap&lt;/code&gt; actually &lt;em&gt;does&lt;/em&gt; implement both &lt;code&gt;Cloneable&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt;, so it isn&amp;rsquo;t an example of this restriction.)&lt;/p&gt;
&lt;p&gt;Furthermore, both &lt;code&gt;Cloneable&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt; are flawed marker interfaces from Java 1.0: &lt;code&gt;Cloneable&lt;/code&gt; declares no methods of its own and encourages error-prone shallow copies, while &lt;code&gt;Serializable&lt;/code&gt; creates versioning headaches and security vulnerabilities. When the Collections Framework was introduced in Java 1.2, its designers left it up to concrete classes like &lt;code&gt;ArrayList&lt;/code&gt; or &lt;code&gt;HashMap&lt;/code&gt; to opt in where appropriate, keeping the core abstraction clean. In modern Java, it&amp;rsquo;s better to copy collections via copy constructors like &lt;code&gt;new ArrayList&amp;lt;&amp;gt;(list)&lt;/code&gt; or &lt;code&gt;List.copyOf()&lt;/code&gt;, and use explicit formats like JSON instead of default Java serialization.&lt;/p&gt;
&lt;h2 id="we-stopped-roadmap-work-for-a-week-and-fixed-189-bugs"&gt;&lt;a href="https://lalitm.com/fixits-are-good-for-the-soul/" rel="noopener noreferrer"&gt;We stopped roadmap work for a week and fixed 189 bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares the story of a quarterly &amp;ldquo;Fixit Week,&amp;rdquo; where an organization of roughly 45 engineers paused all roadmap work for a full week. Across two time zones, 40 participating engineers squashed 189 bugs—averaging more than 4 bugs per person, with the top contributor fixing 12. The ground rules were strict: no single bug could take more than 2 days, work had to focus on small end-user papercuts or developer-productivity improvements, and all regular meetings, design reviews, and roadmap tasks were canceled. The event was gamified with point values scaled by task size, a live leaderboard, daily recaps, and custom t-shirts for awards like &amp;ldquo;first bug fixed&amp;rdquo; and &amp;ldquo;most annoying bug squashed.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Standout wins included closing a four-year-old feature request in a single day and shipping a 25-line GitHub Action that saved frontend engineers repetitive daily toil. Key ingredients for success were prepping a triaged, t-shirt-sized backlog ahead of time, reaching critical mass so the whole team felt the energy, keeping Fixit points strictly separate from performance reviews, and leaning on AI coding tools to lower the context-switching cost of jumping into unfamiliar directories. As the author concludes, Fixit Weeks restore pride in craftsmanship, the joy of shipping immediate improvements, and team camaraderie.&lt;/p&gt;
&lt;h2 id="the-math-of-why-you-can"&gt;&lt;a href="https://justoffbyone.com/posts/math-of-why-you-cant-focus-at-work/" rel="noopener noreferrer"&gt;The Math of Why You Can&amp;rsquo;t Focus at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post models knowledge-worker productivity using three parameters: λ, the rate of interruptions per hour (modeled as a Poisson process); Δ, the number of minutes needed to regain focus after each interruption; and θ, the minimum contiguous block of focused time required to make meaningful progress (typically 30–60 minutes for complex engineering work). Effective work capacity is the number of θ-sized blocks that fit inside the uninterrupted gaps—meaning that the same total number of hours, when chopped into fragments, yields drastically less output than contiguous blocks. Cited workplace studies suggest knowledge workers are interrupted every 2–3 minutes on average and take 10–16 minutes to refocus.&lt;/p&gt;
&lt;p&gt;Plug those typical workplace numbers into the math and deep work becomes nearly impossible—yet small shifts in any of the three parameters produce massive gains. The author points to three practical levers: lower λ by setting communication boundaries and defending calendar blocks, shrink θ to fit your environment by decomposing tasks into smaller self-contained steps, and reduce Δ through better context management, such as leaving yourself breadcrumb notes so you can resume work quickly after an interruption.&lt;/p&gt;
&lt;h2 id="tech-predictions-for-2026-and-beyond"&gt;&lt;a href="https://www.allthingsdistributed.com/2025/11/tech-predictions-for-2026-and-beyond.html" rel="noopener noreferrer"&gt;Tech predictions for 2026 and beyond&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels outlines five technology predictions for 2026 and beyond. First, physical AI will redefine companionship for vulnerable populations: loneliness affects one in six people worldwide and raises mortality risk by 32%, whereas clinical studies with the Paro robotic seal showed positive engagement in 95% of dementia patients. Second is the rise of the &amp;ldquo;renaissance developer&amp;rdquo;: generative AI will elevate rather than replace developers—just as compilers and cloud computing did before—because humans still own business constraints, customer empathy, and systems thinking. Third, quantum-safe security becomes urgent as the estimated qubit count needed to break 2048-bit RSA has dropped below one million, and Vogels predicts quantum computers capable of breaking RSA and elliptic-curve cryptography could arrive within roughly five years.&lt;/p&gt;
&lt;p&gt;Fourth, modern defense tech is being built as dual-use from day one, crossing over into civilian applications far faster than the 10–20-year lag of previous decades, with companies like Anduril reaching $1 billion in revenue in 2024. Finally, AI-powered personalized education will go mainstream: AI tutors cost around $4 a month, Khanmigo reached 1.4 million students in its first year, and teachers using AI tools save roughly 5.9 hours per week to reinvest in direct human teaching.&lt;/p&gt;
&lt;h2 id="why-i-still-love-linux"&gt;&lt;a href="https://it-notes.dragas.net/2025/11/24/why-i-still-love-linux/" rel="noopener noreferrer"&gt;Why I (still) love Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Marinelli reflects on nearly 30 years with Linux, starting in 1996 after his DOS and Commodore 64 days, when Linux gave him his first real taste of Unix and a sense of freedom no prior OS had offered. By 1998 he was actively contributing to the community as a speaker and translator. Even though the fabled &amp;ldquo;Year of the Linux Desktop&amp;rdquo; never quite arrived, Linux conquered mobile via Android, servers, and embedded devices, while Ubuntu helped bring Linux to everyday PCs and drew major enterprises into open source.&lt;/p&gt;
&lt;p&gt;Marinelli doesn&amp;rsquo;t hold back on criticisms either: many modern distributions have drifted away from the Unix philosophy of &amp;ldquo;do one thing and do it well,&amp;rdquo; most notably with &lt;code&gt;systemd&lt;/code&gt;; novelty for its own sake often sacrifices stability; corporate interests sometimes steer development toward their own agendas; and software quality has suffered from &amp;ldquo;vibe coding&amp;rdquo; and fragile dependency chains. Although he prefers BSD and illumos for many server workloads today, he still appreciates distributions like Alpine and openSUSE, notes how much better Linux hardware support has become, remains grateful to Linux for launching his career and lifelong learning, and expects to keep using it for another 30 years.&lt;/p&gt;
&lt;h2 id="why-senior-engineers-struggle-to-build-ai-agents"&gt;&lt;a href="https://www.philschmid.de/why-engineers-struggle-building-agents" rel="noopener noreferrer"&gt;Why (Senior) Engineers Struggle to Build AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phil Schmid explains why senior engineers often struggle more than juniors when building AI agents: traditional software engineering is deterministic, whereas LLM-backed agents are inherently probabilistic. Junior engineers tend to trust the model and ship quickly, while seasoned engineers instinctively try to &amp;ldquo;code away&amp;rdquo; the non-determinism. Schmid highlights five mindset shifts. First, natural language is the new state: a nuance like &amp;ldquo;the plan looks good, but focus on the US market&amp;rdquo; should be kept as rich text rather than squeezed into a rigid boolean or enum schema. Second, hand over control flow: let the model navigate unpredictable multi-turn conversations—like a user asking to cancel a subscription and changing their mind after hearing a retention offer—instead of hardcoding every branch.&lt;/p&gt;
&lt;p&gt;Third, errors are just another input: catch tool failures and feed the error message back into the agent&amp;rsquo;s context so it can self-correct, rather than throwing an unhandled exception. Fourth, move from unit tests to evals: alongside deterministic tests, measure end-to-end reliability, use LLM-as-a-judge for output quality, and inspect intermediate reasoning traces. Fifth, agents evolve while APIs stay fixed: because agents interpret tool schemas literally, APIs need clear docstrings and explicit parameter names like &lt;code&gt;user_email_address&lt;/code&gt; instead of &lt;code&gt;email&lt;/code&gt; to prevent hallucinations. Ultimately, engineers must trade a degree of rigid certainty for semantic flexibility.&lt;/p&gt;
&lt;h2 id="how-java-achieves-zero-copy-file-transfer"&gt;&lt;a href="https://javabulletin.substack.com/p/how-java-achieves-zero-copy-file" rel="noopener noreferrer"&gt;How Java Achieves Zero-Copy File Transfer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zero-copy is the technique of transferring file data from disk to a network socket without copying bytes through JVM user-space memory. Traditional file serving reads data from disk into the OS kernel page cache, copies it into a user-space JVM buffer, and copies it right back into a kernel socket buffer before sending it to the NIC; zero-copy lets the kernel move data directly between kernel buffers (from page cache to socket buffer and out via DMA to the network card), cutting CPU usage, context switches, and JVM garbage-collection pressure from temporary &lt;code&gt;byte[]&lt;/code&gt; allocations.&lt;/p&gt;
&lt;p&gt;Java exposes three main mechanisms here. &lt;code&gt;FileChannel.transferTo()&lt;/code&gt; delegates to the OS&amp;rsquo;s &lt;code&gt;sendfile&lt;/code&gt; syscall when the platform and target channel support it (&lt;code&gt;transferFrom()&lt;/code&gt; works in the opposite direction without the same universal syscall guarantee). &lt;code&gt;MappedByteBuffer&lt;/code&gt; maps file pages directly into the process&amp;rsquo;s virtual address space with read-only, read-write, or copy-on-write modes, avoiding user-space read copies though not automatically creating a zero-copy path to a network socket. For high-performance network servers, Netty&amp;rsquo;s &lt;code&gt;DefaultFileRegion&lt;/code&gt; wraps file channels to exploit native transport zero-copy. The technique does have limits: user-space TLS encryption usually breaks the direct kernel path because bytes must be encrypted before transmission, tiny files rarely justify the syscall setup overhead, and any in-flight data transformation like compression requires touching the bytes in memory anyway.&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://substack-post-media.s3.amazonaws.com/public/images/20ed383c-5900-4f31-9041-afb5581b1ad4_2250x2624.png" alt="Top Strategies to Build High Availability Systems"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Eyti!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F862d0649-d77b-410f-95a5-6505c9eeb15a_2250x2814.png" alt="Cloudflare vs. AWS vs. Azure"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!52bX!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F65613a28-2320-4bb6-a610-5ab96b13240d_800x903.jpeg" alt="Popular Backend Tech Stack"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!JV_9!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa95473e0-5a68-43c6-841e-540a6b198d6d_2360x2960.png" alt="HTTP vs. HTTPS"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5rGo!,w_550,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fac99f98d-49a7-4933-b06f-8da0901d210e_800x939.gif" alt="Forward Proxy versus Reverse Proxy"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!qtkE!,w_550,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F4646c2e2-a6fb-44e7-a091-73fcbd8fa498_800x1040.gif" alt="Things Every Developer Should Know: Concurrency is NOT parallelism"&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 #66</title><link>https://miti99.com/en/post/2025/12/09/</link><pubDate>Tue, 09 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I&amp;rsquo;ve used iFlow&amp;rsquo;s free API quite a lot already, so today I&amp;rsquo;m trying out iFlow&amp;rsquo;s CLI—&lt;a href="https://github.com/iflow-ai/iflow-cli" rel="noopener noreferrer"&gt;iFlow CLI&lt;/a&gt;—to see how it goes, using the GLM-4.6 model.&lt;/del&gt; Enjoy Newsletter #66.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-ultimate-list-of-best-software-architecture-books-2026"&gt;&lt;a href="https://www.workingsoftware.dev/the-ultimate-list-of-software-architecture-books/?&amp;amp;aid=recmw058VtqAJCyyK" rel="noopener noreferrer"&gt;The Ultimate List of Best Software Architecture Books (2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Software architecture is the foundation that determines a product&amp;rsquo;s quality: good design reduces bug risk and makes adding features later far easier. Patrick Roos curates a reading list of software architecture books for 2026, spanning classics like Richards and Ford&amp;rsquo;s &lt;em&gt;Fundamentals of Software Architecture&lt;/em&gt;, &lt;em&gt;Software Architecture in Practice&lt;/em&gt; (4th edition), &lt;em&gt;Designing Data-Intensive Applications&lt;/em&gt;, and &lt;em&gt;Enterprise Integration Patterns&lt;/em&gt;, as well as modern practical guides like &lt;em&gt;Software Architecture: The Hard Parts&lt;/em&gt; on distributed-systems trade-offs and &lt;em&gt;Building Multi-Tenant SaaS Architectures&lt;/em&gt; for cloud platforms.&lt;/p&gt;
&lt;p&gt;The list also emphasizes the human and organizational side of architecture: Susanne Kaiser&amp;rsquo;s &lt;em&gt;Architecture for Flow&lt;/em&gt; combines Wardley Mapping, Domain-Driven Design, and Team Topologies to align business strategy with architecture; Gregor Hohpe&amp;rsquo;s &lt;em&gt;The Software Architect Elevator&lt;/em&gt; helps architects bridge the gap between engineering and the business; &lt;em&gt;Collaborative Software Design&lt;/em&gt; shows how to involve stakeholders in the design process; and &lt;em&gt;Facilitating Software Architecture&lt;/em&gt; and &lt;em&gt;Reviewing Software Systems&lt;/em&gt; (introducing the lightweight LASR architecture review method) help architects and developers collaborate more effectively. The list also highlights two new/upcoming titles for late 2025–2026: Lilienthal and Schwentner&amp;rsquo;s &lt;em&gt;Domain-Driven Transformation&lt;/em&gt;, offering a roadmap for modernizing legacy systems, and Simon Brown&amp;rsquo;s &lt;em&gt;The C4 Model&lt;/em&gt; on communicating software architecture through structured diagrams.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-oct-2025"&gt;&lt;a href="https://ben.stolovitz.com/posts/how_use_ai_oct_2025/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;How I use AI (Oct 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Stolovitz shares how he uses AI—primarily large language models (LLMs)—in his daily work as of October 2025. Coding is where AI has made the biggest difference: he calls GitHub Copilot&amp;rsquo;s autocomplete &amp;ldquo;magical&amp;rdquo; for finishing boilerplate and discovering idiomatic patterns in unfamiliar languages, even if it struggles with complex algorithms. Agent mode is increasingly helpful for larger changes, though it still requires solid tests, clear documentation, and human oversight. For search and research, AI excels at tracking down tip-of-the-tongue articles or explaining general concepts, but falls short when shopping for products or finding academic papers, and remains prone to hallucinating citations or sycophantically validating whatever assumption the user feeds it.&lt;/p&gt;
&lt;p&gt;Summarization and transcription are standout strengths: AI can condense hundreds of pages of documentation or an entire meeting recording in minutes. Conversely, Stolovitz refuses to let AI write for him because he views his blog as personal self-expression; he uses AI only as a tough copy editor to suggest better phrasing, then rewrites the text in his own voice. He is most skeptical of AI-generated visual art and music, finding them lacking in creative depth and genuine human connection.&lt;/p&gt;
&lt;h2 id="stop-vibe-coding-your-unit-tests"&gt;&lt;a href="https://www.andy-gallagher.com/blog/stop-vibe-coding-your-unit-tests/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Stop Vibe Coding Your Unit Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Gallagher warns against handing unit test writing over to LLMs on autopilot. Left to their own devices, LLMs tend to generate far too many tests that merely assert what the code currently does rather than verifying what the code &lt;em&gt;should&lt;/em&gt; do. Given a simple React button component, for instance, Claude Sonnet 4 generated roughly 30 tests spanning ~200 lines, mostly testing trivialities like default rendering, prop passthrough, or HTML attributes that React and the browser already guarantee. Such tests lock the codebase to its current implementation so every refactor breaks a pile of tests, while polluting the agent&amp;rsquo;s context window, degrading semantic code search, and turning pull requests into a slog for teammates to review.&lt;/p&gt;
&lt;p&gt;Gallagher&amp;rsquo;s remedy is intentional, test-by-test authoring: explicitly specify which behavior you want to test, carefully review what the AI generates, and keep test files lean and focused. LLMs still do well on self-contained, algorithmic code, but for everyday product code, what actually needs testing is whether the team is building the right thing. The core principle: fewer, higher-quality tests beat bloated test suites every time.&lt;/p&gt;
&lt;h2 id="game-design-is-simple-actually"&gt;&lt;a href="https://www.raphkoster.com/2025/11/03/game-design-is-simple-actually/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Game design is simple, actually&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raph Koster outlines a systematic 12-step framework for understanding game design. At their core, games are about mastering problems: fun comes from making progress in our ability to predict outcomes, not from surface-level flash. A toy is a system with constraints; add a goal and it becomes a game, centered on a core mechanic—a &amp;ldquo;problem object&amp;rdquo; to be solved. Players interact through loops: an operational loop (act, receive feedback, learn) and a progression loop where situations continually escalate and shift so old strategies stop working. Good feedback must tell players what they can do, what they just did, what happened as a result, and whether they are getting closer to their goal, while difficulty must match their learning curve.&lt;/p&gt;
&lt;p&gt;At the macro level, a game is assembled from smaller sub-games whose loops interlock to form economies and value chains. How a problem is dressed up—through narrative, visuals, audio, and metaphor—strongly shapes the player&amp;rsquo;s experience, making game design a synthetic art form that demands both systems design and experience design. Player motivations vary widely too, which is why no single game appeals to everyone. The individual principles sound simple, but executing all 12 well at the same time is the real challenge.&lt;/p&gt;
&lt;h2 id="architectural-debt-is-not-just-technical-debt"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2025-10-31-architectural-debt-is-not-just-technical-debt/?&amp;amp;aid=recufcl24hU9MXCJC" rel="noopener noreferrer"&gt;Architectural debt is not just technical debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Frederick Van Brabant distinguishes architectural debt from technical debt. While technical debt usually refers to localized shortcuts inside a codebase, architectural debt consists of structural decisions with long-term consequences that reach far beyond code. He breaks architectural debt down across three layers. At the application and infrastructure layer, enterprise architects should focus on integration patterns, overlapping systems, and vendor lock-in, because debt here inflates costs and slows delivery. The business layer involves ownership, governance responsibilities, and outdated processes—where inaccurate documentation can create serious trouble during audits. The strategic layer is the most dangerous: poorly defined capabilities or half-baked framework rollouts plant flawed assumptions across the organization for the next three to five years.&lt;/p&gt;
&lt;p&gt;Enterprise architects have the vantage point and time horizon to spot this kind of debt, but merely raising the alarm isn&amp;rsquo;t enough: they need to build a compelling business case laying out the current state, target state, and business upside backed by concrete numbers to win leadership buy-in. Van Brabant also advises picking your battles wisely: it&amp;rsquo;s fine to tolerate more debt in experimental innovation systems than in systems of record, provided you clean it up once the experiment concludes and secure real resources to pay the debt down.&lt;/p&gt;
&lt;h2 id="the-search-problem-why-your-computer-finds-things-faster-than-you-do"&gt;&lt;a href="https://deyaa1251.github.io/deyaa1251/posts/b_tree/?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;The Search Problem: Why Your Computer Finds Things Faster Than You Do&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why B-trees are so foundational in modern storage systems. The author recounts implementing a binary search tree (BST) from scratch and watching it fall apart once simulated disk reads and writes were introduced. A BST&amp;rsquo;s lookup cost scales with its height: O(log n) when balanced, but degrading to O(n) when unbalanced. Under a model where each node visit costs one disk read, searching across 100,000 files takes roughly 17 disk reads with a balanced BST, whereas a B-tree needs only 3. That&amp;rsquo;s because a B-tree packs many keys into each node (&amp;ldquo;fat nodes&amp;rdquo;) sized to fit a single 4KB disk block, keeping the tree extremely shallow. In the author&amp;rsquo;s simulation, inserting 100,000 sequential items caused the BST to degenerate into a 40,000-level linked list that took roughly 23.5 minutes, while the B-tree stayed 3 levels tall and finished in 3 seconds.&lt;/p&gt;
&lt;p&gt;Because they guarantee predictable worst-case performance regardless of insertion order, B-trees and their variants power indexes in MySQL, PostgreSQL, MongoDB, and countless filesystems. The broader lesson extends beyond data structures: hardware context dictates optimal design. B-trees trade away theoretical best-case simplicity in exchange for rock-solid worst-case guarantees—which is what matters in production systems.&lt;/p&gt;
&lt;h2 id="kafka-is-fast"&gt;&lt;a href="https://topicpartition.io/blog/postgres-pubsub-queue-benchmarks?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;Kafka is fast &amp;ndash; I&amp;rsquo;ll use Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks PostgreSQL as a pub/sub and job queue system in place of dedicated message brokers like Kafka. With 1 KiB messages in a pub/sub workload, a 4-vCPU instance in the author&amp;rsquo;s test setup achieved roughly 5,000 messages per second on writes (4.8 MiB/s) and 24.6 MiB/s on reads with a 5x fan-out, at a 60ms p99 latency. A three-node replicated cluster maintained the same throughput while increasing p99 latency to 186ms. Scaling up to a 96-vCPU instance reached 238 MiB/s on writes and 1.16 GiB/s on reads while using only about 10% CPU. In a work-queue pattern, the 4-vCPU machine handled roughly 2.81 MiB/s at a 17.7ms p99 latency, while the 96-vCPU machine reached 19.7 MiB/s.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s takeaway is simple: use Postgres until you genuinely outgrow it. For the vast majority of organizations operating below a few megabytes per second, Postgres covers 80% of use cases with 20% of the effort, whereas the operational overhead and organizational complexity of adopting a separate distributed broker usually outweigh its benefits at modest scale. That simplicity and reliability are exactly why the &amp;ldquo;Just Use Postgres&amp;rdquo; movement keeps gaining traction.&lt;/p&gt;
&lt;h2 id="you-need-to-become-a-full-stack-person"&gt;&lt;a href="https://den.dev/blog/full-stack-person/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;You Need To Become A Full Stack Person&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Den Delimarsky argues that in the AI era, everyone needs to become a &amp;ldquo;full-stack person.&amp;rdquo; As LLMs commoditize many narrow coding skills, combining creativity, critical thinking, and execution speed becomes the durable career moat. Boundaries between traditional roles are blurring, reflected in the rise of the product engineer who owns frontend, backend, and customer empathy end to end. In Delimarsky&amp;rsquo;s view, the T-shaped skill model (one deep specialty atop a broad base) is obsolete; replacing it is the Pi-shaped model with two deep pillars—product sense and technical craft—resting on broad interdisciplinary knowledge.&lt;/p&gt;
&lt;p&gt;The post highlights ten skills to cultivate: creativity and taste, critical thinking, communication, interdisciplinary breadth, AI leverage, product sense, execution speed, rapid learning, systems thinking, and agency. AI cannot replace taste or judgment; it is a vehicle for turning ideas into reality, lowering the cost of writing code without lowering the cost of deciding what is worth building. Typing code is no longer the bottleneck, and a high-agency &amp;ldquo;start doing, then figure it out&amp;rdquo; mindset is what sets people apart.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;iFlow CLI did a pretty good job on the first few articles, though toward the end it started leaving too many English words untranslated. A nice plus is that iFlow CLI can fetch many URLs by bypassing blocks through a proxy (though it&amp;rsquo;s a Chinese proxy, which feels a bit sketchy). While running it I also saw a bunch of log lines in Chinese, which was confusing and slightly unnerving :v I&amp;rsquo;ll try to refine &lt;code&gt;AGENTS.md&lt;/code&gt; and test it again later.&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 #32</title><link>https://miti99.com/en/post/2025/07/21/</link><pubDate>Mon, 21 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/21/</guid><description>&lt;p&gt;&lt;em&gt;It&amp;rsquo;s been a while since I last wrote a post. And honestly, my earlier newsletters felt a bit like &amp;ldquo;chasing KPIs&amp;rdquo;—&lt;del&gt;I just stuffed in a ton of links and let an AI Agent do the rest&lt;/del&gt;. This time I&amp;rsquo;ll curate the articles more carefully, &lt;del&gt;though I&amp;rsquo;m still letting AI do the writing because I&amp;rsquo;m lazy hehe =)))&lt;/del&gt;. Hope you enjoy it. Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="claude-code-best-practices-for-agentic-coding"&gt;&lt;a href="https://code.claude.com/docs/en/best-practices" rel="noopener noreferrer"&gt;Claude Code: Best Practices for Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official guide distilling effective workflows for Claude Code—an agentic coding environment that can read files, run commands, edit code, and work through problems while you supervise or steer. Most of its advice stems from a single constraint: the context window fills up fast, and response quality degrades as it fills. That makes giving Claude a way to verify its own work—such as a test suite, a build command, or screenshots to compare against—the single highest-leverage thing you can do, letting it iterate until the check passes instead of forcing you to catch every mistake yourself. For complex tasks, split the work into four phases: explore, plan (using plan mode), implement, and commit; for small fixes like a typo, just ask it to make the change directly.&lt;/p&gt;
&lt;p&gt;The guide also recommends writing specific prompts (naming files, edge cases, and existing project patterns) and configuring the environment thoughtfully: a concise &lt;code&gt;CLAUDE.md&lt;/code&gt; with project commands, conventions, and gotchas; an allowlist of safe permissions; CLI tools like &lt;code&gt;gh&lt;/code&gt;; MCP servers; hooks for deterministic checks; and skills or subagents for specialized knowledge. During a session, course-correct early, run &lt;code&gt;/clear&lt;/code&gt; between unrelated tasks, and delegate exploratory research to subagents to keep the main context clean. Once you have the basics down, you can scale out with non-interactive &lt;code&gt;claude -p&lt;/code&gt; runs, parallel sessions, and an independent review pass before considering a task done.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="openai-windsurf-and-the-future-of-work"&gt;&lt;a href="https://www.subtle.so/openai-windsurf-and-the-future-of-ai-workspaces.html" rel="noopener noreferrer"&gt;OpenAI, Windsurf, and the future of work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on Subtle analyzes reports that OpenAI wants to acquire Windsurf for around $3 billion, after previously eyeing Cursor. Technically, Windsurf&amp;rsquo;s core product (a VS Code fork with an AI agent and code autocomplete) isn&amp;rsquo;t uniquely hard to build, so the real value lies elsewhere: tools like this can become general-purpose AI workspaces far beyond coding. They give AI direct access to files and folders to assist with writing, research, and content management, while baking in Git for version history—something traditional productivity suites still lack. For instance, The Pragmatic Engineer connected Windsurf to a PostgreSQL database to query business metrics in plain English. The author compares this trajectory to how IRC evolved from a niche developer tool into Slack&amp;rsquo;s $27 billion business.&lt;/p&gt;
&lt;p&gt;On top of that, interaction data from millions of Windsurf sessions provides valuable training signal that could help OpenAI&amp;rsquo;s models catch up with Anthropic on coding benchmarks. The competitive web is tangled too: Microsoft owns both VS Code and GitHub Copilot while backing OpenAI, even as OpenAI&amp;rsquo;s startup fund has invested in Cursor. All of it points to a rapidly consolidating AI developer-tools market with massive commercial expectations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="vibe-coding-is-not-an-excuse-for-low-quality-work"&gt;&lt;a href="https://addyo.substack.com/p/vibe-coding-is-not-an-excuse-for" rel="noopener noreferrer"&gt;Vibe Coding is Not an Excuse for Low-Quality Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that &amp;ldquo;vibe coding&amp;rdquo; with AI is a useful accelerator, but not an excuse to abandon software engineering rigor. AI can generate huge amounts of code in minutes, yet volume does not equal quality: vibe-coded projects routinely skip error handling, miss security flaws, resist maintenance, and collapse like a &amp;ldquo;house of cards.&amp;rdquo; As Osmani puts it, speed means nothing if the wheels come off mid-drive, because technical debt compounds quickly when nobody is watching the architecture.&lt;/p&gt;
&lt;p&gt;His recommended mental model is to treat AI like a blazingly fast junior developer: a human still needs to review every output, refactor when needed, cover edge cases, and write thorough tests. He lays out practical rules: always review AI-generated code, enforce coding standards, use AI for acceleration rather than decision-making, prioritize testing, iterate and refine, recognize when to write code by hand, and document carefully. Vibe coding shines for rapid prototypes, throwaway scripts, learning a new stack, or generating boilerplate, but falls short for enterprise systems, mission-critical software, or long-lived codebases. That is also why experienced engineers get more out of AI—they know enough to spot flaws and refine its suggestions.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="event-hidden-architectures"&gt;&lt;a href="https://skiplabs.io/blog/event-hidden-arch" rel="noopener noreferrer"&gt;Event-Hidden Architectures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Zedlewski, an advisor to SkipLabs, argues that event-driven architecture—long treated as the default for distributed cloud applications—is showing its age, and proposes replacing it with &amp;ldquo;event-hidden&amp;rdquo; architectures. Distributed applications aren&amp;rsquo;t going away, but forcing developers to manage events by hand creates constant friction: juggling complex asynchronous flows, maintaining queues and schemas, and debugging across service boundaries. In his view, that complexity was a necessary tax around 2020, but no longer has to be.&lt;/p&gt;
&lt;p&gt;Three categories of technology make this shift possible: on the frontend, React and modern state-management libraries; on the backend write path, durable execution engines like Temporal, Restate, and DBOS that guarantee correctness across service boundaries; and on the read path, reactive frameworks like Skip that aggregate distributed data efficiently. What they share is hiding infrastructure plumbing, handling asynchrony transparently, and treating state as a first-class concern. That lets developers write simpler, more maintainable code while gaining better observability, cleaner state management, and the ability to replay application execution. Zedlewski predicts event-hidden architectures will become the default for web applications over the next decade.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="lessons-from-distributed-systems"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2025/04/19/lessons-from-distributed-systems/" rel="noopener noreferrer"&gt;Lessons from Distributed Systems&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from 16elt.com shares practical lessons from building and operating distributed systems at scale. The author distills hard-won experience around common failure modes and how to handle them when working with distributed architectures.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Isolate cache clusters: avoid sharing a single cache cluster across multiple services because a heavy workload from Service A can evict critical data needed by Service B, causing hard-to-diagnose performance issues&lt;/del&gt;
&lt;del&gt;- Use message queues: queues absorb traffic spikes and smooth service load, providing buffering and resilience between services like &amp;ldquo;a responsible adult in the room&amp;rdquo; that prevents service overload&lt;/del&gt;
&lt;del&gt;- Measure end-to-end latency: look beyond service response times to include &amp;ldquo;dequeue latency&amp;rdquo;—how long messages sit waiting in a queue before processing begins&lt;/del&gt;
&lt;del&gt;- Design for failure: expect and plan for network and service failures by implementing retry policies, circuit breakers, and dead-letter queues for failed messages&lt;/del&gt;
&lt;del&gt;- Ensure idempotency: assume duplicate messages will happen and design handlers to process repeated events gracefully, since message queues typically guarantee &amp;ldquo;at least once&amp;rdquo; delivery&lt;/del&gt;
&lt;del&gt;- Distributed systems demand proactive design, robust monitoring, and resilient architecture to keep complexity and failure points under control&lt;/del&gt;
&lt;del&gt;- Monitoring and observability are key to understanding how a system actually behaves in production&lt;/del&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="better-error-handling"&gt;&lt;del&gt;&lt;a href="https://meowbark.dev/Better-error-handling" rel="noopener noreferrer"&gt;Better error handling&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from meowbark.dev explores modern error-handling approaches in software development, from traditional try/catch blocks to Go-style error returns and monadic Result types. The author weighs the pros and cons of each style and offers guidance on choosing the right fit.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Three main approaches to error handling: traditional try/catch, Go-style return tuples, and monadic Result types&lt;/del&gt;
&lt;del&gt;- Challenges of traditional error handling: lack of type safety, unpredictable control flow, and limited integration with the type system&lt;/del&gt;
&lt;del&gt;- Go-style approach: return errors as part of a tuple, handle failure scenarios explicitly, and attach clear error context&lt;/del&gt;
&lt;del&gt;- Monadic Result approach: treat errors as values using container types like &lt;code&gt;Result&amp;lt;T,E&amp;gt;&lt;/code&gt;, enabling functional-style error chaining&lt;/del&gt;
&lt;del&gt;- Core best practices: distinguish recoverable from unrecoverable errors, wrap external library errors early, and use type-safe error-handling mechanisms&lt;/del&gt;
&lt;del&gt;- Weigh performance and developer experience when picking a strategy&lt;/del&gt;
&lt;del&gt;- Recommended techniques: use libraries like &lt;code&gt;neverthrow&lt;/code&gt; for structured error management, and implement error mapping and transformation&lt;/del&gt;
&lt;del&gt;- Build centralized error-handling layers to manage failures systematically&lt;/del&gt;
&lt;del&gt;- Choose an error-handling strategy that balances type safety, readability, and team familiarity&lt;/del&gt;
&lt;del&gt;- Maintain clear error communication and recovery paths across the application&lt;/del&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 #17</title><link>https://miti99.com/en/post/2025/05/04/</link><pubDate>Sun, 04 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #17.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="to-fork-or-not-to-fork"&gt;&lt;a href="https://www.augmentcode.com/blog/to-fork-or-not-to-fork" rel="noopener noreferrer"&gt;To fork or not to fork?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Dietzen, CEO of Augment Code (and former CEO of Pure Storage), discusses a key architectural decision facing AI coding assistants: running as a plugin inside standard IDEs versus forking VS Code outright. GitHub Copilot and Augment chose the former, operating as plugins in VS Code, JetBrains, or Vim. Cursor and Windsurf (by Codeium) chose the latter, modifying the VS Code source directly for deeper AI integration.&lt;/p&gt;
&lt;p&gt;According to Dietzen, forking yields short-term advantages, but users pay the price: they are forced out of their familiar IDEs (especially painful for JetBrains users), lose official Microsoft support, run into issues with official plugins like Python, C++, Docker, or Jupyter, lose access to the official VS Code extension marketplace, and have to wait for the fork maintainers to port upstream features. For the long-term benefit of customers, Augment chose the plugin route and focused on its core strength of supporting large, complex codebases. Dietzen also notes that Cursor is the third most popular IDE among users trialing Augment, showing that the two products can complement each other.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://blog.container-solutions.com/why-im-no-longer-talking-to-architects-about-microservices" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m No Longer Talking to Architects About Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ian Miell explains why he no longer wants to debate microservices with software architects. The first problem is that nobody agrees on what &amp;ldquo;microservices&amp;rdquo; actually means: some measure it by lines of code, others tie it to team structure, and others equate it with container deployments. Like DevOps or Agile, the term has lost much of its original meaning through overuse.&lt;/p&gt;
&lt;p&gt;The second problem is that discussions are typically abstract and disconnected from business goals: promises of scalability, agility, or reduced cognitive load rarely go tested. The third problem is that microservices only pay off when the organization changes alongside them—requiring cross-functional teams, decentralized decision-making, and a mature DevOps culture—and changing organizational structure is far harder than changing software architecture. Even Sam Newman advises that most organizations shouldn&amp;rsquo;t adopt microservices without a compelling reason. Miell suggests starting from concrete problems like shortening release cycles, improving reliability, or removing bottlenecks, and only then asking whether microservices are the right solution.&lt;/p&gt;
&lt;h2 id="not-all-ai-assisted-programming-is-vibe-coding-but-vibe-coding-rocks"&gt;&lt;a href="https://simonwillison.net/2025/Mar/19/vibe-coding/" rel="noopener noreferrer"&gt;Not all AI-assisted programming is vibe coding (but vibe coding rocks)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison argues that the term &amp;ldquo;vibe coding,&amp;rdquo; coined by Andrej Karpathy in February 2025, is being misused as a catch-all for any AI-assisted programming. By Karpathy&amp;rsquo;s original definition, vibe coding means &amp;ldquo;forgetting that the code even exists&amp;rdquo;: accepting every change generated by an LLM without reading it. Responsible AI-assisted programming, by contrast, still involves reviewing, testing, and understanding every implementation detail. Willison&amp;rsquo;s golden rule: never commit code to a repository if you couldn&amp;rsquo;t explain exactly what it does to someone else.&lt;/p&gt;
&lt;p&gt;Even so, Willison is a fan of vibe coding. It lowers the barrier for beginners, helps them build useful tools on their own, and is a great way for experienced developers to build intuition for what LLMs can and cannot do. The key is restricting it to low-stakes, disposable projects—ideally inside a sandbox like Claude Artifacts—and avoiding anything involving security, privacy, or financial risk. He also hopes to see safer tools emerge so newcomers can experiment without causing harm.&lt;/p&gt;
&lt;h2 id="career-advice-in-2025"&gt;&lt;a href="https://lethain.com/career-advice-2025" rel="noopener noreferrer"&gt;Career advice in 2025.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson surveys the 2025 tech job market and identifies four major shifts. First, managers who advanced between 2010 and 2020 through strong hiring and team morale now face new expectations: getting into the details, driving faster execution, and leading the transition to AI. Second, the wave of foundation models has invalidated many old playbooks; products now need to be designed around progressive validation with human-in-the-loop verification for critical data, while staying prepared for models either making massive leaps forward or plateauing right where they are.&lt;/p&gt;
&lt;p&gt;Third, non-AI companies are struggling to raise funding, leading to fewer promotions and raises, while equity at AI startups is far from a guaranteed payout. Fourth, companies are pushing existing teams harder to find growth, turning once-comfortable roles into high-pressure ones. Today it is rare to find great colleagues, prestige, and learning opportunities all in the same job. Larson&amp;rsquo;s advice: don&amp;rsquo;t sit on the sidelines waiting for the market to recover—make your current work count, and remember that these headwinds are industry-wide, not a reflection of your personal ability.&lt;/p&gt;
&lt;h2 id="tips-for-better-interactions"&gt;&lt;a href="https://staysaasy.com/saas/2025/03/17/interactions.html" rel="noopener noreferrer"&gt;Tips For Better Interactions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy shares six practical tips for more effective workplace meetings and interactions. When someone says you seem &amp;ldquo;frustrated,&amp;rdquo; don&amp;rsquo;t accept that framing—restate calmly that you are escalating an issue or need more information so you aren&amp;rsquo;t dismissed as acting out of emotion. Volunteer to take notes in meetings: it signals humility, lets you help steer the discussion, gives you a natural pause to stay composed, and shows people their points are being heard. Avoid pushing back with extreme slippery-slope hypotheticals like &amp;ldquo;if we let everyone choose their own project, it&amp;rsquo;ll be chaos,&amp;rdquo; which implicitly insults the proposer&amp;rsquo;s judgment and wastes time.&lt;/p&gt;
&lt;p&gt;Don&amp;rsquo;t interrupt someone mid-thought just to correct an immaterial detail; follow up privately afterward if needed. Schedule important meetings thoughtfully—avoid Mondays, Fridays, lunch hours, and the end of the day—and keep a consistent weekly slot for 1:1s. Finally, order meeting agendas by priority: thoroughly resolving two important topics is far better than rushing through five without reaching a conclusion.&lt;/p&gt;
&lt;h2 id="code-is-the-new-no-code"&gt;&lt;a href="https://lumberjack.so/code-is-the-new-no-code/" rel="noopener noreferrer"&gt;Code is the new no-code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Szabo-Stuban and Evan Boyle (CEO of GenSX) argue that the promise of the no-code movement is finally being realized in an unexpected way: through code itself. Visual programming tools are easy at first, but complexity balloons rapidly—a marketing automation workflow in n8n can easily sprawl into a spiderweb of 47 interconnected nodes. Abstractions inevitably leak, forcing users to learn technical concepts anyway, and power users usually end up migrating back to code.&lt;/p&gt;
&lt;p&gt;According to the authors, AI coding assistants like Claude, ChatGPT, and GitHub Copilot have flipped the script: users describe their goal in plain language, the AI generates working code and explains each piece, and learning happens gradually instead of hitting a wall. Combined with familiar component models like React, code becomes even more intuitive than node-based visual editors. The post illustrates this with GenSX, where a workflow that fetches CRM data, filters it, and generates a report is written as readable JavaScript components, arguing that because most workflows are sequential, the tree structure of code is naturally easier to follow than a graph.&lt;/p&gt;
&lt;h2 id="how-to-improve-jvm-based-application-startup-time"&gt;&lt;a href="https://softwaremill.com/how-to-improve-jvm-based-application-startup-time/" rel="noopener noreferrer"&gt;How to Improve JVM-Based Application Startup Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michał Zyga (SoftwareMill) compares five approaches to shortening JVM application startup time, a critical metric for serverless and microservices. The JVM starts slowly because it has to load, verify, and initialize a large number of classes. Class Data Sharing (CDS) pre-packages core JDK classes and has been enabled by default since JDK 12; Application Class Data Sharing (AppCDS) extends this to application classes and became easier to use in JDK 19. GraalVM compiles ahead-of-time (AOT) into a native binary, CRaC snapshots a running JVM process using CRIU (Linux-only) for fast restore, and Project Leyden is a newer JDK effort that caches additional optimization data.&lt;/p&gt;
&lt;p&gt;Benchmarks on a sample Netty application across two machines (a personal Intel i5 laptop and a Google Cloud Xeon instance, 50 runs per configuration) show that AppCDS more than doubles startup speed over the default, CRaC and GraalVM are the fastest overall, and Project Leyden sits in the middle while still under active development. Zyga recommends choosing based on context: AppCDS is an easy win with moderate gains, CRaC suits long-running services since it retains full runtime JIT optimizations, and GraalVM fits short-lived workloads that need near-instant startup.&lt;/p&gt;
&lt;h2 id="domain-driven-design"&gt;&lt;a href="https://dev.to/lovestaco/domain-driven-design-3i2j" rel="noopener noreferrer"&gt;Domain Driven Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Athreya (Maneshwar) introduces Domain-Driven Design (DDD), an approach to software design that puts the business domain at the center rather than focusing purely on technical concerns. The article walks through core DDD building blocks: domains and subdomains; Bounded Contexts that draw clear boundaries so models stay independent; Entities with distinct identities versus immutable Value Objects defined by their attributes; Aggregates that group related objects under an Aggregate Root; Domain Events that decouple system components; Repositories, Services, and Factories for persistence, domain operations, and object creation; and Ubiquitous Language, a shared vocabulary between developers and domain experts.&lt;/p&gt;
&lt;p&gt;These concepts are illustrated through an e-commerce platform where order management is separated from the product catalog, accompanied by TypeScript examples of an &lt;code&gt;Order&lt;/code&gt; class managing state and an &lt;code&gt;OrderRepository&lt;/code&gt; handling persistence. The author notes that DDD shines in complex, long-lived projects requiring close collaboration between engineering and business teams, but can easily lead to over-engineering for simple CRUD apps; applying it well requires a solid grasp of design patterns and object-oriented principles.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/66d12ddc-2abe-4a98-82d5-ee177e80487c_1470x1600.png" alt="Monolith vs Microservices vs Modular Monoliths"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #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 #11</title><link>https://miti99.com/en/post/2025/04/12/</link><pubDate>Sat, 12 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #11.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="enabling-near-real-time-data-analytics-on-the-data-lake"&gt;&lt;a href="https://engineering.grab.com/enabling-near-realtime-data-analytics" rel="noopener noreferrer"&gt;Enabling near real-time data analytics on the data lake&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grab shares how they brought data lake ingestion latency down to just a few minutes instead of waiting on hourly or daily batch jobs. Their legacy Hive-and-Parquet pipeline worked well for analytical scans but made record-level updates and upserts prohibitively expensive, since modifying a single record required rewriting entire Parquet files. Grab migrated to &lt;strong&gt;Apache Hudi&lt;/strong&gt;, tailoring table types to each source&amp;rsquo;s workload: for high-throughput Kafka event streams, they use &lt;strong&gt;Merge On Read (MOR)&lt;/strong&gt; tables where Apache Flink appends fast Avro row logs and Spark runs periodic background compaction into columnar Parquet files; for lower-throughput sources, they use simpler &lt;strong&gt;Copy On Write (COW)&lt;/strong&gt; tables, accepting a 10–15 minute ingestion latency.&lt;/p&gt;
&lt;p&gt;The article dives into practical production lessons: partitioning high-volume Kafka event tables by event hour to speed up writes and bound compaction scope, using Flink CDC to stream binlog changes directly from relational databases, and choosing Hudi&amp;rsquo;s Bucket Index for deterministic hashing without external index lookups (despite the trade-off that bucket counts are hard to resize later). As a result, business analysts get much fresher operational dashboards, and the fraud detection team can query near-real-time transaction data on the lake without putting extra load on production OLTP databases.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-software-architecture-documentation"&gt;&lt;a href="https://www.workingsoftware.dev/software-architecture-documentation-the-ultimate-guide/" rel="noopener noreferrer"&gt;The Ultimate Guide To Software Architecture Documentation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This comprehensive guide covers how to write, structure, visualize, and maintain software architecture documentation. The author pushes back against the &amp;ldquo;the code is the documentation&amp;rdquo; myth: source code tells you &lt;em&gt;what&lt;/em&gt; the system does at the lowest level, but cannot tell you &lt;em&gt;why&lt;/em&gt; architectural trade-offs were made, what non-functional quality attributes drove the design, or how the system fits into the broader business context. Good architecture documentation aligns stakeholders around a shared mental model, speeds up onboarding for new engineers, guides teams when building new features, and streamlines communication with external partners and auditors.&lt;/p&gt;
&lt;p&gt;For structure, the author recommends the open-source, process-agnostic &lt;strong&gt;arc42&lt;/strong&gt; template, advising teams not to fill out every section up front on day one, but to grow the document incrementally as decisions are made. For visualization, the &lt;strong&gt;C4 model&lt;/strong&gt; provides a clean hierarchy across four zoom levels: Context, Containers, Components, and Code. Finally, the post champions &amp;ldquo;Documentation as Code&amp;rdquo; and &amp;ldquo;Diagrams as Code&amp;rdquo; using tools like AsciiDoc, PlantUML, and Structurizr so architecture docs live in Git alongside the codebase and evolve in lockstep with pull requests.&lt;/p&gt;
&lt;h2 id="beyond-the-basics-designing-for-a-million-users"&gt;&lt;a href="https://javarevisited.substack.com/p/beyond-the-basics-designing-for-a" rel="noopener noreferrer"&gt;Beyond the Basics: Designing for a Million Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post summarizes the opening chapter of Alex Xu&amp;rsquo;s &lt;em&gt;System Design Interview&lt;/em&gt;, walking through the foundational building blocks for scaling a web application from a handful of users to millions. It starts with a single-server deployment: as traffic grows, latency spikes, a single hardware failure takes the entire site offline, vertical scaling hits cost and physical ceilings, and geographically distant users suffer slow page loads.&lt;/p&gt;
&lt;p&gt;The first step is scaling horizontally rather than vertically, pairing a stateless web tier (moving user session data out into a shared persistent store or cache) with a load balancer to distribute traffic across multiple web servers. Next comes choosing the right database (relational SQL vs. NoSQL), adding read replicas and database sharding, placing a cache tier in front of hot database reads, offloading static assets to a CDN, introducing message queues for asynchronous background processing, using geo-routing for global users, and rounding out the stack with centralized logging, metrics, and automation. It serves as a solid primer for anyone preparing for system design interviews.&lt;/p&gt;
&lt;h2 id="decision-making-pitfalls-for-technical-leaders"&gt;&lt;a href="https://chelseatroy.com/2024/10/16/decision-making-pitfalls-for-technical-leaders/" rel="noopener noreferrer"&gt;Decision-Making Pitfalls for Technical Leaders&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chelsea Troy points out that the software industry routinely promotes strong individual contributors into technical leadership roles with zero training in how decision-making changes at scale, highlighting three habits that are harmless as an IC but destructive once you hold authority. The first is &lt;strong&gt;assuming context&lt;/strong&gt;: applying a &amp;ldquo;best practice&amp;rdquo; without examining what problem it was designed to solve, leading to mismatched architectures that the leader can&amp;rsquo;t justify to their team or executives. The second is &lt;strong&gt;treating every criterion as an optimization target&lt;/strong&gt;, which causes decisions to drag on forever or get reopened repeatedly, whipsawing downstream teams. The third is &lt;strong&gt;manufacturing false urgency&lt;/strong&gt;, subjecting the team to constant fire drills over foreseeable problems that should have been planned for.&lt;/p&gt;
&lt;p&gt;Her remedies are straightforward: understand the concrete trade-offs of every option within your specific project context, explicitly separate criteria you want to &lt;em&gt;maximize&lt;/em&gt; from constraints that only need to meet a &amp;ldquo;good enough&amp;rdquo; threshold (satisficing), and actively absorb pressure rather than amplifying it—because people rarely do their best thinking in a panic. Most &amp;ldquo;emergencies&amp;rdquo; in software engineering, she argues, are actually leadership failures in disguise.&lt;/p&gt;
&lt;h2 id="how-i-know-i"&gt;&lt;a href="https://www.seangoedecke.com/thoughts-about-engineers/" rel="noopener noreferrer"&gt;How I know I&amp;rsquo;m working with a strong engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares a simple gut-check for telling whether you&amp;rsquo;re working with a strong engineer: count how often two specific thoughts cross your mind while collaborating with them. The first thought is, &lt;em&gt;&amp;ldquo;Oh, good catch—I hadn&amp;rsquo;t thought of that!&amp;quot;&lt;/em&gt;—triggered when they spot a subtle bug, improve the user experience, or simplify a design, rather than when they pedantically nitpick edge cases that don&amp;rsquo;t matter. If you find yourself thinking that constantly around someone, you should probably defer to their judgment on big technical calls.&lt;/p&gt;
&lt;p&gt;The second thought is, &lt;em&gt;&amp;ldquo;Nice, that&amp;rsquo;ll work,&amp;rdquo;&lt;/em&gt; when they propose the exact sensible approach you would have come up with yourself. That reaction signals reliability and steady execution—which the author notes is actually high praise. Engineers can be great in many different ways, of course, but this two-question heuristic is a surprisingly reliable intuitive litmus test.&lt;/p&gt;
&lt;h2 id="ugly-code-and-dumb-things"&gt;&lt;a href="https://lucumr.pocoo.org/2025/2/20/ugly-code/" rel="noopener noreferrer"&gt;Ugly Code and Dumb Things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, Jinja, and Werkzeug, reflects on two competing passions in software: crafting clean, reusable library abstractions versus hacking together fast, pragmatic solutions for real users. He points to &lt;strong&gt;Flamework&lt;/strong&gt;—an open-source PHP framework capturing Flickr&amp;rsquo;s early engineering ethos of &amp;ldquo;doing the simplest thing that could possibly work.&amp;rdquo; Its code looks messy to modern eyes, concatenating raw SQL strings and using global state, yet it nailed the problems that actually mattered for scaling Flickr: user-based sharding, database replication, and production observability.&lt;/p&gt;
&lt;p&gt;Clean, aesthetically pleasing code doesn&amp;rsquo;t guarantee product success if it doesn&amp;rsquo;t solve a real problem for real people, while &amp;ldquo;ugly&amp;rdquo; code that ships often embodies the exact right compromises needed to iterate quickly. Both mindsets are valid, though they rarely coexist peacefully in the same codebase. The real art, Ronacher concludes, is knowing when to transition from duct-tape pragmatism to solid architectural foundations—because successful projects eventually grow up and need to be re-engineered.&lt;/p&gt;
&lt;h2 id="development-philosophy"&gt;&lt;a href="https://develop.sentry.dev/getting-started/philosophy/" rel="noopener noreferrer"&gt;Development Philosophy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page from Sentry&amp;rsquo;s engineering handbook distills over a decade of lessons into their core development philosophy. Sentry emphasizes that code is not art—it is a tool for solving customer problems—so engineers must constantly weigh building clean abstractions against shipping pragmatic &amp;ldquo;duct tape,&amp;rdquo; and ask experienced teammates when unsure where on that spectrum a task falls. Even &amp;ldquo;correctness&amp;rdquo; can be a trap: for instance, forcing rigid static typing gymnastics onto Python can slow down iteration without delivering commensurate value. Duct tape is great for validating ideas quickly, but you can&amp;rsquo;t build a lasting business on it alone—Sentry is equally willing to invest in multi-year foundational bets, such as replacing shell-outs to &lt;code&gt;llvm-symbolizer&lt;/code&gt; with their own custom Rust-based &lt;code&gt;symbolicator&lt;/code&gt; service.&lt;/p&gt;
&lt;p&gt;Other guiding principles include: avoiding overly &amp;ldquo;clever&amp;rdquo; code that future readers (including yourself six months later) will struggle to decipher; encouraging anyone to open a pull request against any repository in the company; standardizing primarily on Python, Rust, and TypeScript; avoiding proprietary database lock-in so Sentry remains easy to self-host; weighing the long-term maintenance cost of every third-party dependency; and keeping &lt;code&gt;main&lt;/code&gt; green and deployable at all times.&lt;/p&gt;
&lt;h2 id="ai-is-stifling-tech-adoption"&gt;&lt;a href="https://vale.rocks/posts/ai-is-stifling-tech-adoption" rel="noopener noreferrer"&gt;AI is Stifling Tech Adoption&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that AI coding assistants are quietly stifling the adoption of newer web technologies for two reasons. The first is the &lt;strong&gt;knowledge cutoff trap&lt;/strong&gt;: because foundation models are trained on historical snapshots (at the time of writing, Anthropic&amp;rsquo;s latest models had a cutoff around April 2024), they know little or nothing about newly released frameworks or major version upgrades. That creates a vicious cycle: poor AI support discourages developers from adopting a new tool, fewer users means fewer blog posts and forum answers, and less public writing leaves future model training runs starved of examples. The second culprit is &lt;strong&gt;system prompt bias&lt;/strong&gt;: many AI coding tools explicitly instruct the model behind the scenes to default to React and Tailwind CSS—to the point where Claude once rewrote the author&amp;rsquo;s vanilla HTML/CSS/JS snippet into React despite explicit instructions not to.&lt;/p&gt;
&lt;p&gt;To test this, the author asked four major AI chatbots to &amp;ldquo;build a web app&amp;rdquo; with no stack specified: Claude and ChatGPT defaulted straight to React + Tailwind every time, Gemini used vanilla HTML/CSS/JS but immediately suggested migrating to React, and DeepSeek was more flexible but took several prompts to produce working code. The net effect is that technologies that were dominant right before ChatGPT launched are having their dominance locked in, newcomers are being steered toward a monoculture without realizing it, and AI vendors ought to be far more transparent about the stack biases baked into their system prompts.&lt;/p&gt;
&lt;h2 id="february---the-rest-of-the-story---jvm-weekly-vol-119"&gt;&lt;a href="https://www.jvm-weekly.com/p/february-the-rest-of-the-story-jvm" rel="noopener noreferrer"&gt;February - The Rest of the Story - JVM Weekly vol. 119&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This February 27, 2025 issue of JVM Weekly rounds up notable stories from February that didn&amp;rsquo;t fit into earlier editions. The headline news is that the next LTS release of &lt;strong&gt;Scala 3&lt;/strong&gt;, slated for Q4 2025, will officially drop support for JDK 8; the Scala team is currently debating between JDK 11 and JDK 17 as the new minimum baseline, driven largely by the upcoming removal of memory-access methods in &lt;code&gt;sun.misc.Unsafe&lt;/code&gt;, which forces a redesign of how &lt;code&gt;lazy val&lt;/code&gt; is compiled under the hood. The issue also highlights a set of J.P. Morgan Java Lead interview questions, a series on SOLID principles in Kotlin, a draft JEP under Project Leyden that streamlines creating AOT caches into a single command-line step, and a bytecode-level auto-parallelization prototype that achieved up to a 9x speedup in the author&amp;rsquo;s benchmarks.&lt;/p&gt;
&lt;p&gt;Rounding out the issue is part two of a series on building agentic AI systems with Quarkus—where application control flow is handed over to an LLM—alongside fresh ecosystem releases including KotlinPoet 2.0, Dokka 2.0, the Ktor CLI, Pulumi Java 1.0, and CheerpJ 3.1, a WebAssembly-powered JVM that runs full Java applications directly in the browser.&lt;/p&gt;
&lt;h2 id="manager-antipatterns"&gt;&lt;a href="https://blogs.newardassociates.com/blog/2024/management-antipatterns.html" rel="noopener noreferrer"&gt;Manager Antipatterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ted Neward catalogs twelve common engineering management antipatterns—dysfunctional archetypes that companies repeatedly create through poor hiring, promotion, or org design. The roster includes the &lt;strong&gt;Absentee Manager&lt;/strong&gt; (never around), &lt;strong&gt;The Radical&lt;/strong&gt; (wants to burn everything down and rewrite from scratch), &lt;strong&gt;The Nepotist&lt;/strong&gt; (given the team because they&amp;rsquo;re friends with an executive), &lt;strong&gt;The Mouthpiece&lt;/strong&gt; (merely parrots upper management), &lt;strong&gt;The One-Trick Pony&lt;/strong&gt; (applies the same hammer to every problem), &lt;strong&gt;The Chicken Little&lt;/strong&gt; (panics constantly), &lt;strong&gt;The Pushover&lt;/strong&gt; (avoids all conflict), &lt;strong&gt;The Transplant&lt;/strong&gt; (dropped in from an unrelated domain), &lt;strong&gt;The Perfectionist&lt;/strong&gt; (micromanages every detail), &lt;strong&gt;The Promoted Superstar&lt;/strong&gt; (the best coder forced into management), &lt;strong&gt;The Riddler&lt;/strong&gt; (communicates in cryptic hints instead of clear expectations), and &lt;strong&gt;The Player-Coach&lt;/strong&gt; (stretched thin trying to manage and code simultaneously).&lt;/p&gt;
&lt;p&gt;For each archetype, Neward sketches the behavior and offers practical survival strategies from three vantage points: when you report to that manager, when that manager reports to you, and when you realize &lt;em&gt;you&lt;/em&gt; have become that manager yourself. It&amp;rsquo;s a handy field guide for diagnosing leadership dysfunction wherever you sit on the org chart.&lt;/p&gt;
&lt;h2 id="pause--decision-making-superpower"&gt;&lt;a href="https://read.perspectiveship.com/p/pause" rel="noopener noreferrer"&gt;Pause – Decision-Making Superpower&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that even if you master every mental model and decision-making framework in the book, none of them will save you if you react on impulse. Recalling an early-career mistake—giving a snap feature estimate live on a client call and then pulling all-nighters to hit the impossible deadline—the author adopted a personal rule: never give an immediate commitment in the room; always ask to follow up after the meeting. Taking a deliberate pause creates space to step back from emotional hijacking, check for blind spots, and gather missing context—and people rarely push back when you simply tell them it&amp;rsquo;s a personal rule of yours. Nobel laureate Daniel Kahneman famously used the same tactic to stop himself from saying yes to requests on the spot that he would later regret.&lt;/p&gt;
&lt;p&gt;Pausing is especially powerful when you receive an infuriating Slack message or email—wait a few hours or sleep on it before replying—or when fielding high-stakes questions during a crisis, such as right after a layoff. And when you genuinely don&amp;rsquo;t have all the answers yet, state clearly what is within your control and what isn&amp;rsquo;t, and share the concrete steps currently underway so your team knows you are taking their concerns seriously.&lt;/p&gt;
&lt;h2 id="aposd-vs-clean-code"&gt;&lt;a href="https://github.com/johnousterhout/aposd-vs-clean-code/blob/main/README.md" rel="noopener noreferrer"&gt;APOSD vs Clean Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub repository records a written debate between John Ousterhout, author of &lt;em&gt;A Philosophy of Software Design&lt;/em&gt; (APOSD), and Robert &amp;ldquo;Uncle Bob&amp;rdquo; Martin, author of &lt;em&gt;Clean Code&lt;/em&gt;, hashing out their sharpest disagreements on software design. While both agree that the ultimate goal is making software easier to understand and modify, they clash across three main areas. On &lt;strong&gt;method length&lt;/strong&gt;, &lt;em&gt;Clean Code&lt;/em&gt; famously advocates tiny functions of just a few lines, whereas Ousterhout argues that decomposing functions too aggressively creates &amp;ldquo;shallow&amp;rdquo; interfaces and tangles of tiny coupled methods that force readers to jump back and forth to reconstruct the control flow.&lt;/p&gt;
&lt;p&gt;On &lt;strong&gt;code comments&lt;/strong&gt;, &lt;em&gt;Clean Code&lt;/em&gt; treats most comments as a failure to express intent in code, while APOSD views comments as indispensable for capturing high-level interface contracts and design intent that code alone cannot express. On &lt;strong&gt;Test-Driven Development (TDD)&lt;/strong&gt;, Martin champions strict red-green-refactor micro-cycles before writing implementation code, whereas Ousterhout worries that strict TDD encourages tactical, line-by-line hacking at the expense of upfront design thinking. Reading the two authors challenge each other over concrete code examples is a masterclass in software design trade-offs and well worth reading to form your own view.&lt;/p&gt;
&lt;h2 id="the-software-engineer-spectrum-speed-vs-accuracy"&gt;&lt;a href="https://benhowdle.im/software-engineer-spectrum" rel="noopener noreferrer"&gt;The Software Engineer Spectrum: Speed vs. Accuracy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on 15 years of experience ranging from IC engineer to CTO, Ben Howdle observes that every software engineer sits somewhere along a spectrum between &lt;strong&gt;Speed&lt;/strong&gt; and &lt;strong&gt;Accuracy&lt;/strong&gt;. Speed-leaning engineers live by &amp;ldquo;ship now, refine later&amp;rdquo;—excelling at rapid iteration and getting MVPs in front of users, at the risk of accumulating technical debt and missing edge cases. Accuracy-leaning engineers live by &amp;ldquo;make sure it&amp;rsquo;s right before it goes live&amp;rdquo;—excelling at rock-solid reliability, edge-case coverage, and scalable architecture, at the risk of moving slowly and over-engineering. Neither end of the spectrum is inherently superior; what matters is alignment with the company&amp;rsquo;s current stage.&lt;/p&gt;
&lt;p&gt;Different business stages demand different balances: an early-stage seed startup needs Speed to validate product-market fit before the runway runs out; a scaling Series B company needs a balanced mix as testing and architecture start to matter; and a large enterprise or regulated fintech needs Accuracy where downtime or compliance failures are existential. The post offers self-reflection prompts—such as whether you get more frustrated by slow decisions or by shipping imperfect code—and advises engineering leaders to build balanced teams where both archetypes respect each other and can shift along the spectrum as the product matures.&lt;/p&gt;
&lt;h2 id="llm-ecosystem-predictions"&gt;&lt;a href="https://www.moderndescartes.com/essays/llm_predictions/" rel="noopener noreferrer"&gt;LLM Ecosystem Predictions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Kihoon Lee, an engineer at Databricks, lays out his predictions for the LLM ecosystem over the next 5–10 years. The cost of LLM inference at a fixed quality level is dropping roughly three times faster than Moore&amp;rsquo;s Law—halving every six months—driven by hardware advances, systems optimizations, and algorithmic breakthroughs; because all three favor capital-intensive hyperscalers, only a handful of frontier model providers will survive, competing at razor-thin margins. Just as high-level languages beat C and Java on developer iteration speed, simple agent architectures will beat complex, brittle orchestration frameworks: simply swapping in the latest frontier model every 6–12 months, backed by a solid evaluation suite, will beat months of custom prompt-chain tuning on both quality and cost.&lt;/p&gt;
&lt;p&gt;He also predicts the market will bifurcate between managed enterprise AI platforms and DIY tooling, with an &amp;ldquo;Excel for LLMs&amp;rdquo; emerging to let non-programmers build their own AI workflows. Cost per query will span orders of magnitude—from 100-million-parameter small models to 1-trillion-parameter frontier models—while the economic value unlocked will vary even more wildly: LLMs are poised to replace expensive human coordination overhead inside organizations, personalized tutoring, and customer support with 24/7 availability and consistent quality. By 2030, he argues, the world will look as different from today as the mobile and Internet era looked compared to the 1990s.&lt;/p&gt;
&lt;h2 id="the-right-kind-of-stubborn"&gt;&lt;a href="https://www.paulgraham.com/persistence.html" rel="noopener noreferrer"&gt;The Right Kind of Stubborn&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paul Graham distinguishes between two very different traits that often get lumped together: &lt;strong&gt;persistence&lt;/strong&gt; and &lt;strong&gt;obstinacy&lt;/strong&gt;. Both make people hard to stop, but in opposite ways: the persistent person is like a boat whose engine can&amp;rsquo;t be throttled back, while the obstinate person is like a boat whose rudder can&amp;rsquo;t be turned. Persistent people are fiercely attached to the &lt;em&gt;goal&lt;/em&gt; and happily change tactics when something isn&amp;rsquo;t working—in fact, they listen intently to criticism because they want to know if their current approach is flawed; obstinate people are attached to their &lt;em&gt;initial plan&lt;/em&gt;—which is almost always the least-informed version of the idea—and reflexively dismiss feedback. Obstinacy only works on simple problems where the first idea happens to be right by luck.&lt;/p&gt;
&lt;p&gt;True persistence, Graham argues, has a much richer internal structure built on five distinct qualities: &lt;strong&gt;energy&lt;/strong&gt; to keep trying, &lt;strong&gt;imagination&lt;/strong&gt; to invent new approaches when blocked, &lt;strong&gt;resilience&lt;/strong&gt; to keep morale intact after setbacks, &lt;strong&gt;good judgment&lt;/strong&gt; to weigh expected value, and a &lt;strong&gt;specific focus&lt;/strong&gt; on a concrete problem. For less experienced founders and makers, his advice is to start with a small, well-defined goal and expand your ambition as you gain traction. Because it requires all five ingredients at once, the right kind of stubbornness is much rarer than mere obstinacy—and vastly more powerful.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/ae95d38c-41f8-4eb7-885e-f7fafa4ca45d_2250x2624.png" alt="Data Consistency Strategies For Microservices"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>