<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Distributed Systems on miti99</title><link>https://miti99.com/en/tags/distributed-systems/</link><description>Recent content in Distributed Systems 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/distributed-systems/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #139</title><link>https://miti99.com/en/post/2026/10/07/</link><pubDate>Wed, 07 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #139.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-go-taught-us-about-java-garbage-collection"&gt;&lt;a href="https://dev.to/codenameone/what-go-taught-us-about-java-garbage-collection-25ha" rel="noopener noreferrer"&gt;What Go Taught Us About Java Garbage Collection&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Comparing ParparVM (Codename One&amp;rsquo;s ahead-of-time Java-to-C virtual machine) against Go&amp;rsquo;s runtime, the author initially assumed Go&amp;rsquo;s low memory footprint and snappy pauses came down to escape analysis and stack allocation—only to discover how much came from &lt;em&gt;when&lt;/em&gt; Go triggers a GC cycle and how it shares marking work across threads. ParparVM&amp;rsquo;s first win was lowering its hardcoded 24 MB minimum allocation floor before triggering a GC: throughput and p99 latency barely budged, while resident memory (RSS) dropped from 98 MB down to 38 MB. An attempt to pace GC dynamically against the live heap size failed because internal counters missed objects in partial pages, thread-local mutator pages, and large-object allocations, so the team exposed the allocation floor as a build-time tunable instead. On their &lt;code&gt;GcPause&lt;/code&gt; benchmark, scaling parallel mark threads from one to four cut worst-case pause times from 2.2–3.3 seconds down to 0.3–0.9 seconds (compared to ~20 ms in Go), and adding Go-style &lt;em&gt;mutator assist&lt;/em&gt;—where an allocating thread that outruns the background collector pitches in to mark a small batch of objects itself—smoothed out allocation spikes further.&lt;/p&gt;
&lt;p&gt;The second half tackles image caching and reference types. Previously, ParparVM implemented &lt;code&gt;WeakReference&lt;/code&gt; by storing the referent as a normal struct field that the GC traced as a strong reference, while iOS apps relied on a separate strong-reference cache table that simply dumped everything on an OS memory warning. A new PR moves the referent pointer into &lt;code&gt;java.lang.ref.Reference&lt;/code&gt; directly, teaches the C translator to register reference discovery hooks instead of tracing referents strongly, and lets the collector decide whether to preserve or clear soft references based on memory pressure. The trickiest concurrency hazard occurs when a mutator thread calls &lt;code&gt;ref.get()&lt;/code&gt; mid-mark phase and resurrects a pointer the GC is about to sweep; logging &lt;code&gt;get()&lt;/code&gt; reads through a snapshot-at-the-beginning (SATB) read barrier and filtering already-marked objects dropped mark-termination passes from 32 down to 1. Updating a recency timestamp on each &lt;code&gt;get()&lt;/code&gt; so frequently used images survive longer boosted cache hit rates under a 160 MB cap from 87.99% to 97.44% while simultaneously shrinking memory footprint from 91 MB to 82.1 MB.&lt;/p&gt;
&lt;h2 id="how-we-built-a-real-time-stock-pricing-system-at-scale"&gt;&lt;a href="https://itnext.io/how-we-built-real-time-stock-pricing-at-mofid-brokerage-031015ce1301" rel="noopener noreferrer"&gt;How We Built a Real-Time Stock Pricing System at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mofid Securities, Iran&amp;rsquo;s largest stock brokerage, needed to stream real-time stock and fund price ticks to tens of thousands of concurrent traders. Market ticks from the exchange core are ingested in C++ and published to Kafka as Protobuf messages at roughly 1,900 messages per second—spiking to 3x that during volatile market opens. For fan-out distribution, the team chose Redis Pub/Sub over heavier durable brokers: stock prices are ephemeral state where a missed tick is immediately superseded by the next tick a moment later, making &lt;code&gt;at-most-once&lt;/code&gt; delivery semantics ideal, and Redpanda Connect pipes messages from Kafka into Redis without writing custom glue services. On the browser side, they picked Server-Sent Events (SSE) over WebSockets because price streaming is strictly unidirectional, runs over standard HTTP, and handles reconnection natively; they used the &lt;code&gt;eventsource&lt;/code&gt; package to attach auth headers, batched UI updates on the client to avoid layout thrashing, closed streams when tabs navigated away, and fetched an initial REST snapshot before applying the live delta stream.&lt;/p&gt;
&lt;p&gt;Inside the .NET backend, a single hosted background service per Redis channel writes incoming ticks into a bounded &lt;code&gt;System.Threading.Channels&lt;/code&gt; ring buffer (capacity 100,000, configured with &lt;code&gt;DropOldest&lt;/code&gt; backpressure), while a connection coordinator spins up lightweight per-user channels that filter and forward only the specific ticker symbols currently visible on that user&amp;rsquo;s screen. Rolled out gradually from 30% to 100% of traffic behind an Unleash feature flag, the production cluster serves tens of thousands of concurrent streams across just &lt;strong&gt;six pods&lt;/strong&gt;, each using ~55 MB of RAM and ~20% CPU at peak market hours with maximum queue depth never exceeding 15 messages. Key operational lessons: disable reverse-proxy response buffering via &lt;code&gt;X-Accel-Buffering: no&lt;/code&gt;, dispose per-client channels immediately on disconnect to prevent memory leaks, and send a lightweight heartbeat comment every 20 seconds so intermediate load balancers don&amp;rsquo;t drop idle connections.&lt;/p&gt;
&lt;h2 id="saving-another-100tb-of-ram-with-math-and-rust"&gt;&lt;a href="https://blog.cloudflare.com/saving-100-tb-of-ram-with-math/" rel="noopener noreferrer"&gt;Saving another 100TB of RAM with math (and Rust)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare freed up another 100+ TB of RAM across its global edge fleet by shrinking &lt;code&gt;pingora-ketama&lt;/code&gt;, the consistent hashing library that Pingora Backend Router uses to route requests to cache servers by URL. Because compliance rules and tiered caching configurations require maintaining a separate consistent hash ring for every unique combination of cache features, some router processes were burning up to 6 GB of RAM just holding Ketama rings in memory. Step one was shrinking each point on the ring in Rust. The original &lt;code&gt;Point&lt;/code&gt; struct stored &lt;code&gt;hash: u32&lt;/code&gt; and &lt;code&gt;index: u32&lt;/code&gt; (8 bytes per point). Simply changing &lt;code&gt;index&lt;/code&gt; from &lt;code&gt;u32&lt;/code&gt; to &lt;code&gt;u16&lt;/code&gt; saved zero bytes because Rust aligns the struct to a multiple of its largest field (&lt;code&gt;u32&lt;/code&gt;, 4-byte alignment), adding 2 bytes of tail padding; packing each entry into a byte array &lt;code&gt;[u8; 6]&lt;/code&gt; with helper accessors bypassed the alignment padding and immediately cut ring memory by 25%.&lt;/p&gt;
&lt;p&gt;Step two used probability theory to slash the &lt;em&gt;number&lt;/em&gt; of virtual nodes (points) placed on the ring per server. Deriving the exact closed-form formula for load variance across $n$ servers with $k$ points each revealed steeply diminishing returns: for 100 servers, NGINX&amp;rsquo;s default of 160 points per server already drops load standard deviation from ~99% down to ~8%, whereas scaling all the way to 100,000 points per server spends the last 90,000 points buying just a 0.7% reduction in variance—and at extreme point counts, 32-bit hash collisions actually cause load imbalance to &lt;em&gt;worsen&lt;/em&gt; again. Dropping the point count by 90% left load distribution virtually unchanged. Because changing hash rings in place would invalidate cached assets and trigger a thundering herd to origin servers, Cloudflare held both the old and new rings in memory temporarily—saving 65% net RAM even while dual-running—and shifted traffic gradually by hashing requests into rollout buckets across data center tiers.&lt;/p&gt;
&lt;h2 id="postgres-delete-can-actualy-scale"&gt;&lt;a href="https://www.dbos.dev/blog/scaling-deletions-in-postgres" rel="noopener noreferrer"&gt;Postgres DELETE Can Actualy Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In high-throughput PostgreSQL systems, &lt;code&gt;DELETE&lt;/code&gt; has a reputation for being so slow that conventional wisdom says to avoid it altogether in favor of &lt;code&gt;TRUNCATE&lt;/code&gt; or dropping time-partitioned tables. The team at DBOS, however, needed row-level &lt;code&gt;DELETE&lt;/code&gt; for their Postgres-backed durable workflow engine, which executes tens of thousands of workflows and steps per second while enforcing granular, per-workflow retention policies. What makes &lt;code&gt;DELETE&lt;/code&gt; expensive in Postgres is MVCC: deleting a row doesn&amp;rsquo;t free space immediately—it merely stamps the tuple&amp;rsquo;s &lt;code&gt;xmax&lt;/code&gt; header with the deleting transaction ID, leaving a &amp;ldquo;dead tuple&amp;rdquo; behind for &lt;code&gt;autovacuum&lt;/code&gt; to clean up later, and because Postgres indexes don&amp;rsquo;t store visibility metadata, every index scan still has to visit heap pages to check whether matching rows are dead.&lt;/p&gt;
&lt;p&gt;DBOS&amp;rsquo;s initial schema relied on foreign keys with &lt;code&gt;ON DELETE CASCADE&lt;/code&gt; from the parent &lt;code&gt;workflow_status&lt;/code&gt; table to child tables like &lt;code&gt;operation_outputs&lt;/code&gt;. While convenient, cascading deletes scattered random I/O across thousands of heap pages because a long-running workflow&amp;rsquo;s steps are spread out over time—to the point where deleting expired workflows took longer than executing them! The team dropped the foreign keys and rewrote retention as a two-step batch job: first delete expired rows from &lt;code&gt;workflow_status&lt;/code&gt;, then batch-delete orphaned rows from each child table ordered by creation time (maximizing page cache locality) using a &lt;code&gt;NOT EXISTS&lt;/code&gt; anti-join against &lt;code&gt;workflow_status&lt;/code&gt; so active long-running workflows are never touched. When they hit a second wall—finding the retention cutoff timestamp on the &lt;code&gt;created_at&lt;/code&gt; B-tree index occasionally stalled for 20 minutes scanning millions of unvacuumed dead tuples piled up at the front of the index—running an explicit &lt;code&gt;VACUUM&lt;/code&gt; right before and after each deletion batch eliminated the stall completely, speeding up retention deletes by &lt;strong&gt;10x&lt;/strong&gt;.&lt;/p&gt;
&lt;h2 id="where-postgresql-stores-row-locks"&gt;&lt;a href="https://boringsql.com/posts/row-locks-on-the-page/" rel="noopener noreferrer"&gt;Where PostgreSQL stores row locks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Unlike many databases that maintain an in-memory lock table for row-level locks, PostgreSQL stores row locks &lt;strong&gt;directly inside the tuple header on the data page itself&lt;/strong&gt;. Specifically, the &lt;code&gt;t_xmax&lt;/code&gt; field—which normally records the transaction ID that deleted or updated a tuple—does double duty by storing the XID of the transaction currently locking the row, while bit flags in &lt;code&gt;t_infomask&lt;/code&gt; indicate the lock strength and clarify that &lt;code&gt;t_xmax&lt;/code&gt; is a lock rather than a deletion. That design means PostgreSQL can lock millions of rows without exhausting shared RAM, at the cost of dirtying the data page (and generating WAL) even on a read-only &lt;code&gt;SELECT ... FOR SHARE&lt;/code&gt;. When the locking transaction commits, Postgres doesn&amp;rsquo;t go back to clear &lt;code&gt;t_xmax&lt;/code&gt;; future readers simply check the commit log, see the transaction has finished, and ignore the expired lock marker until &lt;code&gt;VACUUM&lt;/code&gt; or a subsequent locker overwrites it. Postgres supports four row-lock modes so foreign-key checks don&amp;rsquo;t stall updates: inserting a child row takes the weakest &lt;code&gt;FOR KEY SHARE&lt;/code&gt; lock on the parent row, a normal &lt;code&gt;UPDATE&lt;/code&gt; that doesn&amp;rsquo;t touch key columns takes &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt;, while &lt;code&gt;DELETE&lt;/code&gt; and key-modifying updates take &lt;code&gt;FOR UPDATE&lt;/code&gt; (which conflicts with everything—meaning developers who reflexively write &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; on parent rows unnecessarily block concurrent child inserts that &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt; would allow).&lt;/p&gt;
&lt;p&gt;When a second transaction tries to lock an already-locked row, it waits on the holder&amp;rsquo;s &lt;code&gt;transactionid&lt;/code&gt; lock in &lt;code&gt;pg_locks&lt;/code&gt; and acquires a heavyweight &lt;code&gt;tuple&lt;/code&gt; lock solely to establish fair queue ordering—which is why &lt;code&gt;pg_locks&lt;/code&gt; only shows &lt;em&gt;waiting&lt;/em&gt; row lockers, never the session actively holding an uncontended row lock. And when multiple transactions concurrently hold shared locks (&lt;code&gt;FOR KEY SHARE&lt;/code&gt; or &lt;code&gt;FOR SHARE&lt;/code&gt;) on the same tuple, &lt;code&gt;t_xmax&lt;/code&gt; stores a &lt;code&gt;MultiXactId&lt;/code&gt; pointing to an on-disk member list in &lt;code&gt;pg_multixact/&lt;/code&gt;. The post demonstrates how a single long-running transaction holding &lt;code&gt;FOR NO KEY UPDATE&lt;/code&gt; on parent rows while 5,000 autocommit transactions insert child rows creates 5,000 distinct multixacts; at ~5 bytes per member and a hard $2^{32}$ member offset limit (~20 GB), runaway multixact creation can trigger &lt;code&gt;multixact &amp;quot;members&amp;quot; limit exceeded&lt;/code&gt; outages or emergency anti-wraparound vacuums even when a table has zero dead tuples—making &lt;code&gt;mxid_age()&lt;/code&gt;, &lt;code&gt;relminmxid&lt;/code&gt;, and &lt;code&gt;next_multi_offset&lt;/code&gt; critical production metrics to monitor.&lt;/p&gt;
&lt;h2 id="a-40ms-go-gc-pause-caused-by-swap"&gt;&lt;a href="https://frn.sh/go-gc/" rel="noopener noreferrer"&gt;A 40ms Go GC pause caused by swap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After enabling Linux swap on production nodes to absorb brief memory spikes gracefully, the author noticed something alarming in their Go service metrics: stop-the-world (STW) garbage collection pauses were occasionally spiking to &lt;strong&gt;40 ms&lt;/strong&gt;—roughly 800x slower than the normal 51 µs median pause. The container cgroup hosted two processes: the latency-sensitive Go service (which read request payloads via &lt;code&gt;io.ReadAll&lt;/code&gt; and decoded them with &lt;code&gt;proto.Unmarshal&lt;/code&gt;) and a nearly idle helper HTTP server. Initially, the author assumed that because the Linux kernel tracks memory pressure per cgroup, cold pages from the idle helper process would be swapped out first, or that if the Go process itself got swapped out, normal mutator threads would fault those pages back in during everyday execution rather than inside a sub-millisecond STW window. Both assumptions turned out to be wrong.&lt;/p&gt;
&lt;p&gt;Attaching a custom eBPF probe between the Go runtime&amp;rsquo;s STW start and stop tracepoints to count major page faults while all goroutines were frozen revealed the smoking gun: the worst 39,902 µs STW pause suffered &lt;strong&gt;228 major page faults&lt;/strong&gt;, which alone accounted for 39,013 µs (97.8%) of the pause! Resolving the faulting instruction pointers with &lt;code&gt;addr2line&lt;/code&gt; pointed straight to &lt;code&gt;runtime.(*spanSet).reset&lt;/code&gt; and &lt;code&gt;runtime.nextMarkBitArenaEpoch&lt;/code&gt; inside &lt;code&gt;sweepTerm&lt;/code&gt;—the brief STW phase at the start of a new GC cycle. Because the Go runtime stores off-heap GC bookkeeping metadata (like span sets and mark-bit arenas) in memory regions that are reused across cycles but touched &lt;em&gt;only&lt;/em&gt; during GC transitions, the Linux kernel&amp;rsquo;s LRU page reclaimer saw those pages sitting untouched between GC cycles, classified them as cold, and paged them out to disk. The moment the next GC cycle froze every goroutine to reset those metadata structures, the STW thread had to page-fault 228 pages back in from disk sequentially while the entire program sat frozen. Swap also degraded normal heap allocations (&lt;code&gt;io.ReadAll&lt;/code&gt; on a 511 KiB payload jumped from 3–5 ms to 105 ms on local NVMe swap and 903 ms on network block storage). The takeaway: swap and garbage-collected runtimes with off-heap metadata are a dangerous mix for latency-sensitive services.&lt;/p&gt;
&lt;h2 id="how-to-optimize-when-you-cant-do-anything"&gt;&lt;a href="https://hdombrovskaya.wordpress.com/2026/08/25/how-to-optimize-when-you-cant-do-anything/" rel="noopener noreferrer"&gt;How to optimize when you can’t do anything!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Database veteran Hettie Dombrovskaya shares a real-world PostgreSQL war story where every textbook optimization was off the table. The culprit was an unpartitioned &lt;strong&gt;750 GB table holding 16 billion rows&lt;/strong&gt;. A critical production query that found all records whose &lt;code&gt;[start_date, end_date]&lt;/code&gt; interval covered a given target date alongside three equality filters (&lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt;, &lt;code&gt;c&lt;/code&gt;) had started timing out, taking anywhere from several seconds to several minutes. The textbook fix—a GiST range index on &lt;code&gt;(a, b, c, daterange(start_date, end_date))&lt;/code&gt;—was impossible during an active incident because building a new index on 16 billion rows would take well over 24 hours. Meanwhile, the best existing B-tree index was on &lt;code&gt;(a, start_date, end_date)&lt;/code&gt;, where &lt;code&gt;a&lt;/code&gt; had terrible selectivity and filtering &lt;code&gt;start_date &amp;lt;= target_date&lt;/code&gt; for a recent target date matched nearly the entire 16-billion-row history.&lt;/p&gt;
&lt;p&gt;Every standard SQL rewrite hit a wall: adding an arbitrary lower bound like &lt;code&gt;start_date &amp;gt;= target_date - interval '1 year'&lt;/code&gt; wasn&amp;rsquo;t allowed because the customer genuinely needed long-lived historical records; computing &lt;code&gt;MIN(start_date)&lt;/code&gt; grouped by &lt;code&gt;a&lt;/code&gt; didn&amp;rsquo;t help because each &lt;code&gt;a&lt;/code&gt; bucket contained ancient rows; and creating a partial index covering only the customer&amp;rsquo;s specific &lt;code&gt;(a, b, c)&lt;/code&gt; combinations brought execution under 100 ms in staging, but only helped that single customer. The breakthrough came from looking closely at a spreadsheet the customer had sent over: it happened to list the exact date each of their ~2,000 &lt;code&gt;(a, b, c)&lt;/code&gt; combinations was first created! Loading those ~2,000 rows into a tiny lookup table (and in production, exposing the table from another database via a read-only &lt;code&gt;postgres_fdw&lt;/code&gt; foreign table since DDL on the primary database was restricted) allowed the query to join against the lookup table and pass that exact per-combination inception date as a tight lower bound &lt;code&gt;start_date &amp;gt;= lookup.first_seen_date&lt;/code&gt; into the existing &lt;code&gt;(a, start_date, end_date)&lt;/code&gt; index. Query runtime immediately dropped from minutes to &lt;strong&gt;under 100 ms&lt;/strong&gt;. Her takeaway: when you can&amp;rsquo;t build an index on a massive table, a tiny auxiliary lookup table encoding domain knowledge can act as your &amp;ldquo;index.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="four-ways-to-do-super-fast-packet-processing-in-go"&gt;&lt;a href="https://toonk.io/packetio/" rel="noopener noreferrer"&gt;Four ways to do super fast packet processing in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andree Toonk notes that parsing network packets in Go is easy—the hard part is moving tens of millions of packets per second between the physical NIC and your Go userspace process without the Linux kernel network stack melting your CPU. Because each high-speed packet I/O mechanism has a completely different C API and memory model, Toonk built &lt;strong&gt;&lt;code&gt;packetio&lt;/code&gt;&lt;/strong&gt;, a unified Go library that puts four backends behind a single clean interface. &lt;strong&gt;AF_PACKET&lt;/strong&gt; (the standard raw socket used by &lt;code&gt;tcpdump&lt;/code&gt;) works everywhere out of the box, but traverses most of the kernel networking stack. &lt;strong&gt;AF_XDP&lt;/strong&gt; hooks an eBPF program into the NIC driver early to redirect frames straight into a shared userspace/kernel ring buffer (&lt;code&gt;UMEM&lt;/code&gt;) while leaving normal kernel networking (like SSH and ARP) intact. &lt;strong&gt;DPDK&lt;/strong&gt; bypasses the kernel entirely via poll-mode drivers in userspace at the cost of taking over the whole NIC and a steep learning curve, while &lt;strong&gt;mlx5 Direct Verbs&lt;/strong&gt; talks directly to the hardware queues of NVIDIA/Mellanox ConnectX NICs via &lt;code&gt;rdma-core&lt;/code&gt; without needing the massive DPDK runtime. Switching backends in &lt;code&gt;packetio&lt;/code&gt; is practically a one-line change to &lt;code&gt;Open()&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Toonk benchmarked all four backends in Go across two AMD EPYC servers wired back-to-back with 100 GbE NVIDIA ConnectX-6 Dx NICs blasting minimum-size 64-byte UDP packets at full line rate (&lt;strong&gt;148.8 million packets per second&lt;/strong&gt;), carefully measuring &lt;em&gt;system-wide&lt;/em&gt; CPU utilization including kernel &lt;code&gt;softirq&lt;/code&gt; cores. On receive (RX), &lt;code&gt;AF_PACKET&lt;/code&gt; topped out at just 2.3 Mpps while burning 52.8 CPU cores; &lt;code&gt;AF_XDP&lt;/code&gt; hit 146.5 Mpps using 11.4 cores; and both &lt;code&gt;Direct Verbs&lt;/code&gt; and &lt;code&gt;DPDK&lt;/code&gt; saturated the full 100 GbE line rate at &lt;strong&gt;148.6 Mpps&lt;/strong&gt; using just 10 and 8 cores respectively. On transmit (TX), &lt;code&gt;DPDK&lt;/code&gt; hit line rate using only 3 cores while &lt;code&gt;AF_XDP&lt;/code&gt; needed 20 cores. On full L2 packet forwarding (RX + TX), &lt;code&gt;Direct Verbs&lt;/code&gt; took first place at &lt;strong&gt;147.4 Mpps across 12 cores&lt;/strong&gt;. Notably, measuring only the Go process&amp;rsquo;s CPU hides the fact that &lt;code&gt;AF_XDP&lt;/code&gt; spends over half its CPU budget inside kernel &lt;code&gt;softirq&lt;/code&gt; handlers driving the NIC ring. Toonk&amp;rsquo;s rule of thumb: use &lt;code&gt;Direct Verbs&lt;/code&gt; on Mellanox/NVIDIA ConnectX hardware, &lt;code&gt;AF_XDP&lt;/code&gt; on general Linux NICs when you still need kernel coexistence, &lt;code&gt;DPDK&lt;/code&gt; when you need broad multi-vendor poll-mode driver support, and &lt;code&gt;AF_PACKET&lt;/code&gt; only for low-rate packet capture.&lt;/p&gt;
&lt;h2 id="how-uber-protects-against-retry-storms"&gt;&lt;a href="https://www.uber.com/us/en/blog/protecting-against-retry-storms/" rel="noopener noreferrer"&gt;How Uber Protects Against Retry Storms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;At Uber&amp;rsquo;s microservice scale, naive retries are a recipe for self-inflicted outages: when a caller service receives an error from a downstream dependency, it typically has no idea whether that downstream service failed on its own or is merely forwarding an error from five hops deeper in the call graph. Retrying transient network blips works fine in isolation, but when a deep leaf service is overloaded, independent retries at every layer of a 7-hop call chain multiply exponentially: if each of the 6 upstream layers retries just once (&lt;code&gt;2x&lt;/code&gt;), load on the struggling leaf service amplifies by &lt;strong&gt;$2^6 = 64\times$&lt;/strong&gt; (or $8\times$ across a 4-hop chain). Even enforcing a standard per-client 10% retry budget still compounds across hops ($1.1^3 \approx 1.33\times$ or higher during partial brownouts) because each caller evaluates its budget locally without realizing upstream callers are &lt;em&gt;also&lt;/em&gt; retrying the exact same failed request.&lt;/p&gt;
&lt;p&gt;Uber solved this cascading amplification by introducing &lt;strong&gt;Error Ownership&lt;/strong&gt; (&lt;code&gt;x-uber-error-claim&lt;/code&gt;). The core insight is simple: any given failure in a call tree has exactly one &lt;em&gt;originating&lt;/em&gt; service, and only the immediate parent of that originating service should ever be allowed to retry it. A background control-plane component called &lt;em&gt;Service Dependency Analysis&lt;/em&gt; correlates inbound and outbound error rates across Uber&amp;rsquo;s service mesh to determine whether a service is generating errors internally or passively propagating downstream failures; when a service is the true origin of an error, the shared RPC middleware attaches an &lt;code&gt;x-uber-error-claim&lt;/code&gt; header to its error response. Its immediate caller sees the claim, performs its configured retries, and—if all retries still fail—&lt;strong&gt;strips the claim header&lt;/strong&gt; before propagating the error further upstream, signaling every ancestor in the call chain not to retry again. Because the logic lives inside Uber&amp;rsquo;s standard Go/Java RPC middleware, services got protection automatically without application code changes. During a major production incident on November 18, 2025, when a core leaf service sitting 5+ hops deep began failing, retry budgets alone would have amplified its traffic by 46–135%; Error Ownership blocked &lt;strong&gt;9.5 million redundant retry requests&lt;/strong&gt;, shrinking the maximum retry-storm blast radius from 25 hops down to 3 (and the average from 20 down to 2).&lt;/p&gt;
&lt;h2 id="the-real-cost-of-a-single-insert-in-postgres"&gt;&lt;a href="https://www.tigerdata.com/blog/real-cost-of-single-insert-in-postgres" rel="noopener noreferrer"&gt;The Real Cost of a Single Insert in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How many bytes does PostgreSQL actually write to disk when you insert a single 40-byte row? Tiger Data (the creators of TimescaleDB) measures the exact &lt;strong&gt;write amplification factor&lt;/strong&gt; of single-row &lt;code&gt;INSERT&lt;/code&gt; statements in PostgreSQL 16 on a realistic table with three B-tree indexes. First comes storage layout overhead: every heap tuple carries a 23-byte MVCC header (&lt;code&gt;t_xmin&lt;/code&gt;, &lt;code&gt;t_xmax&lt;/code&gt;, &lt;code&gt;t_cid&lt;/code&gt;, &lt;code&gt;t_ctid&lt;/code&gt;, infomasks) padded to 24 bytes, plus a 4-byte line pointer (&lt;code&gt;ItemIdData&lt;/code&gt;) in the page header—turning a 40-byte payload into 68 bytes on the heap (1.7x amplification before touching an index). Next, PostgreSQL updates every index synchronously inside the same transaction: three indexes mean three B-tree traversals and three modified 8 KiB index leaf pages. While a monotonically increasing timestamp index concentrates inserts into the rightmost leaf page sitting hot in shared buffers, a high-cardinality index (like a random UUID or device ID) scatters writes across the entire B-tree, dirtying cold pages all over the buffer pool. And for durability, inserting into the heap plus three indexes emits &lt;strong&gt;four separate WAL records&lt;/strong&gt; per row, each carrying its own 24-byte WAL record header and block reference metadata.&lt;/p&gt;
&lt;p&gt;Running a controlled benchmark of 100,000 single-row &lt;code&gt;INSERT&lt;/code&gt; transactions and measuring exact WAL generation via &lt;code&gt;pg_current_wal_lsn()&lt;/code&gt; and &lt;code&gt;pg_stat_wal&lt;/code&gt; reveals the true multiplier. Immediately after a &lt;code&gt;CHECKPOINT&lt;/code&gt;, write amplification hits &lt;strong&gt;10.74x&lt;/strong&gt; because the first modification to any 8 KiB heap or index page after a checkpoint must write a &lt;em&gt;Full Page Image&lt;/em&gt; (FPI) into the WAL to guard against torn pages. Even in a warm steady state with zero checkpoints, write amplification is &lt;strong&gt;8.73x&lt;/strong&gt; (~345 bytes of WAL per 40-byte row—meaning 50,000 inserts/sec generates ~17 MB/s of raw WAL stream alone, before counting dirty 8 KiB buffer flushes by the checkpointer). Dropping all three indexes drops steady-state WAL amplification down to &lt;strong&gt;2.44x&lt;/strong&gt;, proving that roughly &lt;strong&gt;70% of write volume comes from index maintenance&lt;/strong&gt;. To tame write amplification, the author recommends a prioritized playbook: batch inserts via &lt;code&gt;COPY&lt;/code&gt; or multi-row &lt;code&gt;INSERT ... VALUES (), ()&lt;/code&gt; so multiple rows share page locks and WAL overhead; drop unused indexes (check &lt;code&gt;pg_stat_user_indexes.idx_scan&lt;/code&gt;); enable &lt;code&gt;wal_compression = lz4&lt;/code&gt; or &lt;code&gt;zstd&lt;/code&gt; to shrink full-page writes; and tune &lt;code&gt;max_wal_size&lt;/code&gt; and &lt;code&gt;checkpoint_timeout&lt;/code&gt; to spread checkpoints further apart.&lt;/p&gt;</description></item><item><title>Newsletter #138</title><link>https://miti99.com/en/post/2026/10/06/</link><pubDate>Tue, 06 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #138.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i-believe-about-the-future-of-software-development"&gt;&lt;a href="https://thorstenball.com/blog/2026/09/19/what-i-believe-about-the-future-of-software-development/" rel="noopener noreferrer"&gt;What I believe about the future of software development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball reposts to his blog a series of predictions that sparked intense debate on X, capturing a snapshot of what he believes in September 2026. In his view, line-by-line human code review is effectively dead: humans will stop hunting for syntax or logic bugs in model-generated diffs and instead review system architecture and how components fit together. Unit tests as we know them may fade too, now that frontier models can one-shot 900 lines of working Arduino C on the first try. The craft of hand-writing code will atrophy much like cobbling shoes by hand, while the craft of &lt;em&gt;building software&lt;/em&gt;—solving real business problems, knowing when to ship, and tightening feedback loops—will matter more than ever. Most future bugs will be specification bugs (&amp;ldquo;you asked for the wrong thing&amp;rdquo;) rather than implementation bugs, and hand-crafted performance optimization by humans will remain a rare specialty.&lt;/p&gt;
&lt;p&gt;His spicier predictions go further: terminals, shells, and CLIs will cease to be human-first interfaces; tokens are the new compute primitive of the &amp;ldquo;post-binary&amp;rdquo; era; the classic PM/Design/Engineering triad alongside Agile and Scrum rituals will dissolve, and engineers who act merely as &amp;ldquo;meat proxies&amp;rdquo; translating Jira tickets into agent prompts will lose their jobs. Even our notion of &amp;ldquo;clean, maintainable code&amp;rdquo; exists primarily to serve human working-memory limits, so it may stop mattering once agents perform the vast majority of edits. Developers priced out of frontier token budgets risk getting left behind, and bespoke UIs will be generated on the fly. Still, Ball acknowledges it will take a full generation for &amp;ldquo;new software&amp;rdquo; to replace &amp;ldquo;old software&amp;rdquo;—ten years from now people will still be hired to write code by hand, though the real question is whether you&amp;rsquo;ll want that job.&lt;/p&gt;
&lt;h2 id="trying-the-software-factory-pattern"&gt;&lt;a href="https://lethain.com/software-factory-experiment/" rel="noopener noreferrer"&gt;Trying the Software Factory pattern.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson reflects that in 2026, effective AI engineering patterns are emerging faster than he can adopt them. At his company Imprint, the year&amp;rsquo;s progression moved rapidly: in January, getting every engineer using Claude Code daily; in March, expanding Claude Code and Claude Cowork to every non-engineering function; in April, hitting the limits of local &lt;code&gt;git worktree&lt;/code&gt; setups and provisioning ~10 full multi-repo workspace checkouts per developer so agents could open coordinated PRs across monorepos; in June, migrating the entire company off Jira onto Linear so agents had clean, low-friction access to task context without permission headaches; and in July, launching &amp;ldquo;Agent Fleet,&amp;rdquo; an internal cloud orchestration harness inspired by Stripe&amp;rsquo;s Minions for autonomously knocking out small tickets.&lt;/p&gt;
&lt;p&gt;The next frontier Larson is experimenting with is the &lt;strong&gt;Software Factory&lt;/strong&gt; pattern: pointing a long-running harness at a broad multi-week project goal and letting it drive progress continuously. His first prototype, a &lt;code&gt;/linear-project-loop&lt;/code&gt; skill, reads a Linear project and checks whether it has both a Notion RFC (defining goals, metrics, and technical approach) and a Datadog dashboard or Snowflake query tracking those metrics—collaborating with the human to create them if missing. On subsequent runs, the loop checks live metrics and open issues, files missing follow-up tasks, and picks up unblocked work like drafting PRs, nudging reviewers, or posting clarifying questions. Running the loop immediately exposed how much project context Larson had been keeping in his own head rather than writing down, and proved especially valuable &lt;em&gt;after&lt;/em&gt; launch—automatically flagging a spike in passkey error rates and queueing up remediation tasks. His takeaway: these pieces only compound when wired together—Datadog MCP, Snowflake, Linear as a single source of truth, and a cloud harness that keeps running when your laptop closes.&lt;/p&gt;
&lt;h2 id="back-to-coupling-and-cohesion"&gt;&lt;a href="https://bastrich.tech/coupling-and-cohesion/" rel="noopener noreferrer"&gt;Back to Coupling and Cohesion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich argues that junior developers and Clean Code zealots routinely over-apply acronyms like SOLID, GRASP, and KISS, producing labyrinthine codebases that look impressive on a whiteboard but are miserable to maintain. In his view, every one of those principles is really just a specialized corollary of managing &lt;strong&gt;coupling&lt;/strong&gt; and &lt;strong&gt;cohesion&lt;/strong&gt; across different scales. Coupling measures how tightly components are entangled such that changing one forces changes in others; cohesion measures the degree to which everything inside a single component serves one unified purpose. To move past hand-wavy intuition, Bastrich proposes quantifying both directly from real development history: for every task, log the effort spent across each touched component; for each component, log the effort spent across each business concern. Using formulas analogous to the Gini-Simpson diversity index and Herfindahl-Hirschman index, coupling is $1 - \frac{\sum e_i^2}{(\sum e_i)^2}$ across components for a task, while cohesion is $\frac{\sum e_i^2}{(\sum e_i)^2}$ across concerns inside a component.&lt;/p&gt;
&lt;p&gt;For example, if changing a password-length rule requires editing both the registration form (effort 4) and the password-reset form (effort 6), the task&amp;rsquo;s coupling score is &lt;code&gt;0.48&lt;/code&gt;, even though each form has a cohesion of &lt;code&gt;1.0&lt;/code&gt;. Framing design around these two forces maps every classic rule back to first principles: Single Responsibility is simply high cohesion; Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, DRY, and the Law of Demeter all exist to reduce coupling or raise cohesion; and KISS bounds the working memory required to hold a component in your head. Even so, Bastrich reminds readers that low coupling and high cohesion aren&amp;rsquo;t free—in ultra-low-latency trading systems, embedded firmware, or throwaway scripts, tightly coupled code is often the right engineering trade-off.&lt;/p&gt;
&lt;h2 id="introducing-system-one-models--jev"&gt;&lt;a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev" rel="noopener noreferrer"&gt;Introducing System One Models &amp;amp; Jev&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diogo Almeida—founder of TypeSafe AI and an early OpenAI researcher who worked on the foundations of ChatGPT—poses a pointed question: LLMs surpassed human-level chat years ago, so why hasn&amp;rsquo;t enterprise automation caught up? Coming out of two years in stealth, TypeSafe AI introduces &lt;strong&gt;System One Models&lt;/strong&gt;, a new class of frontier models purpose-built to make fast, structured, calibrated decisions inside software pipelines rather than chatting with humans. Built on a custom architecture, a parallel sampler, and a training methodology called &lt;em&gt;Reinforcement Learning for Calibrated Decisions&lt;/em&gt; (RLCD), their debut model &lt;strong&gt;Jev&lt;/strong&gt; (now in early access) acts like a &amp;ldquo;frontier-intelligence function call&amp;rdquo;: it ingests unstructured context and returns strongly typed decisions paired with calibrated probabilities. By abandoning token-by-token autoregressive text generation, Jev cannot produce syntax/type errors or free-form hallucinations, evaluates multiple structured questions in parallel in a single pass, responds in 70–500 ms, and costs just &lt;code&gt;$0.042&lt;/code&gt; per million input tokens with &lt;strong&gt;free output&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To benchmark real-world utility, the team built a code-level workflow evaluation suite comparing Jev against an ensemble consensus of &lt;code&gt;GPT-6 Astra&lt;/code&gt; and &lt;code&gt;Fable 5.1&lt;/code&gt;. Across those workflows, Jev ran &lt;strong&gt;193.6x faster&lt;/strong&gt; and &lt;strong&gt;444.6x cheaper&lt;/strong&gt; at matching accuracy (though the team transparently notes that benchmark figure sits at the upper end of their target distribution). Ideal use cases include acting as a &amp;ldquo;smart &lt;code&gt;if&lt;/code&gt; statement&amp;rdquo; inside application control flow, massive map-reduce classification over unstructured data, real-time interactive agents, and fast guardrail verification over LLM outputs—illustrated by live demos of Jev playing &lt;em&gt;DOOM&lt;/em&gt; at 10 queries per second for ~$7/hour and playing Wikipedia &lt;em&gt;Wikiracing&lt;/em&gt;. The category name nods to Daniel Kahneman&amp;rsquo;s &lt;em&gt;Thinking, Fast and Slow&lt;/em&gt;, while &amp;ldquo;Jev&amp;rdquo; honors economist William Stanley Jevons: make machine intelligence orders of magnitude faster and cheaper, and entirely new software architectures become viable.&lt;/p&gt;
&lt;h2 id="system-one-models--explained"&gt;&lt;a href="https://unzip.dev/0x025-system-one-models/" rel="noopener noreferrer"&gt;System One Models 🚦 Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Agam More breaks down how System One models—led by TypeSafe AI&amp;rsquo;s Jev—work in practice, describing them as a fast, dirt-cheap &lt;code&gt;if&lt;/code&gt; statement that knows exactly how confident it is. Instead of asking a model to generate an essay, you pass unstructured context alongside a typed schema of closed-ended questions, and the model returns a JSON object with calibrated probabilities for every option, like grading a multiple-choice exam in a single forward pass. Jev exposes three primitives: &lt;code&gt;Choice&lt;/code&gt; (picking one option from an enum), &lt;code&gt;Score&lt;/code&gt; (rating along a defined rubric scale), and &lt;code&gt;Noul&lt;/code&gt; (estimating the boolean probability that a proposition is true). Given a support ticket complaining that a Stripe integration has been broken for three days, for instance, Jev routes it to &lt;code&gt;technical&lt;/code&gt; with probability &lt;code&gt;0.85&lt;/code&gt; and flags &lt;code&gt;urgent: true&lt;/code&gt; in under 100 ms. Under the hood, Jev undergoes standard pretraining followed by RLCD post-training on synthetic data that explicitly rewards Brier-score calibration so a &lt;code&gt;0.80&lt;/code&gt; confidence score genuinely means the model is right 80% of the time.&lt;/p&gt;
&lt;p&gt;More advises reaching for a System One model whenever your backend asks an LLM the exact same closed-ended routing, triage, moderation, or extraction question thousands of times a second—letting you auto-execute high-confidence predictions (&lt;code&gt;p &amp;gt; 0.95&lt;/code&gt;) and route low-confidence edge cases to a heavier reasoning model or human queue. On the public &lt;code&gt;JevBench&lt;/code&gt; suite, Jev is 6x to 7x cheaper per decision than &lt;code&gt;GPT-5.6 Luna&lt;/code&gt; or &lt;code&gt;Gemini 3.1 Flash-Lite&lt;/code&gt;. Conversely, don&amp;rsquo;t use it when the answer space isn&amp;rsquo;t known up front, when you need free-form text generation, or when deep multi-step reasoning matters more than latency; also remember to include an explicit &lt;code&gt;&amp;quot;none_of_the_above&amp;quot;&lt;/code&gt; enum variant if inputs can fall outside your categories. Competing approaches in this emerging space include SemIf, Laya, Kev, GLiNER2, and grammar-constrained decoding via Outlines.&lt;/p&gt;
&lt;h2 id="how-data-is-replicated-in-distributed-systems--raft-from-scratch---part-1"&gt;&lt;a href="https://sushantdhiman.dev/blog/raft/" rel="noopener noreferrer"&gt;How Data Is Replicated In Distributed Systems | Raft From Scratch - Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sushant Dhiman kicks off a two-part hands-on series with a foundational distributed systems problem: when you replicate a stateful service like a database across five machines for fault tolerance, how do the nodes agree on a single leader without split-brain? His answer walks through &lt;strong&gt;Raft&lt;/strong&gt;, the consensus algorithm designed by Diego Ongaro and John Ousterhout specifically to be easier to understand and implement than Paxos. Consensus ensures that a cluster of replicas agrees on a single ordered sequence of operations even in the face of crashes and network partitions, preventing scenarios where one replica commits 10 transactions while another only sees 7. Part 1 focuses entirely on &lt;strong&gt;Leader Election&lt;/strong&gt;. In Raft, every node is in one of three states at any moment: the &lt;em&gt;Leader&lt;/em&gt; handles client writes and coordinates replication, &lt;em&gt;Followers&lt;/em&gt; passively respond to RPCs from the leader, and a &lt;em&gt;Candidate&lt;/em&gt; is a follower that steps up to call an election after its leader heartbeat times out. Two RPCs drive the entire protocol: &lt;code&gt;AppendEntries&lt;/code&gt; (used both to replicate log entries and to send periodic empty heartbeats) and &lt;code&gt;RequestVote&lt;/code&gt; (sent by candidates campaigning for leadership).&lt;/p&gt;
&lt;p&gt;When a leader crashes or gets partitioned away, followers stop receiving heartbeats; once a follower&amp;rsquo;s randomized election timeout (say, between 150 ms and 300 ms) expires, it increments its monotonic &lt;em&gt;election term&lt;/em&gt; (which acts as a Lamport logical clock), transitions to Candidate, votes for itself, and sends &lt;code&gt;RequestVote&lt;/code&gt; RPCs to all peers. Randomized timeouts ensure nodes rarely campaign at the exact same millisecond, preventing endless split votes; within any given term, each node grants its vote to at most one candidate on a first-come, first-served basis, and any node that observes a message carrying a higher term number immediately steps down to Follower. Dhiman concludes with a clean educational implementation in Go and gRPC—wiring up the election timer loop, &lt;code&gt;RequestVote&lt;/code&gt;, heartbeat &lt;code&gt;AppendEntries&lt;/code&gt;, and protobuf definitions across three local nodes on ports &lt;code&gt;5001–5003&lt;/code&gt;—saving log replication and persistence for Part 2.&lt;/p&gt;
&lt;h2 id="jev-means-structured-output-is-interesting-again"&gt;&lt;a href="https://www.seangoedecke.com/jev-means-structured-output-is-interesting-again/" rel="noopener noreferrer"&gt;Jev means structured output is interesting again&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke rarely writes about new model releases, but makes an exception for TypeSafe AI&amp;rsquo;s &lt;strong&gt;Jev&lt;/strong&gt;. Standard LLMs generate text autoregressively one token at a time, which makes them wonderfully general-purpose at the cost of high latency and occasional formatting quirks. Jev accepts arbitrary natural-language prompts but &lt;em&gt;only&lt;/em&gt; emits structured classification/scoring outputs—and leaning completely into that constraint unlocks compelling systems properties. Because Jev doesn&amp;rsquo;t generate tokens sequentially and instead evaluates multiple structured decisions in parallel within a single pass, its latency is tightly bounded between 70 ms and 500 ms—fast enough to play &lt;em&gt;DOOM&lt;/em&gt; in real time from text descriptions of the screen state. To Goedecke, sub-100 ms, dirt-cheap structured intelligence feels like a genuine new computing primitive: once you can sprinkle 100 ms probabilistic judgements directly into standard control flow, you can build software that looks nothing like a chatbot.&lt;/p&gt;
&lt;p&gt;That said, Goedecke offers a sober technical reality check: fast structured output from small models was already possible if you cared to optimize for it. Most structured-output pipelines feel slow only because developers ask frontier chat models to emit massive nested JSON schemas via grammar-constrained decoding. For closed-ended classification, you can simply prefill the assistant response up to &lt;code&gt;&amp;quot;choice&amp;quot;: &amp;quot;&lt;/code&gt; and run a single forward pass constrained to valid option tokens—an experiment Goedecke ran locally with &lt;code&gt;Qwen2.5-1.5B-Instruct&lt;/code&gt; that immediately sped up classification by 2x to 3x. Consequently, Jev&amp;rsquo;s architectural moat may be shallower than advertised (though post-training specifically for calibrated probabilities via RLCD is a real differentiator), it will never match frontier reasoning models on problems that require test-time chain-of-thought compute, and calling wrong answers &amp;ldquo;classification errors&amp;rdquo; instead of &amp;ldquo;hallucinations&amp;rdquo; is mostly semantics. Even so, he hopes Jev succeeds and pressures the major labs to ship dedicated ultra-low-latency structured-output endpoints of their own.&lt;/p&gt;
&lt;h2 id="why-do-we-listen-to-people-with-no-skin-in-the-game"&gt;&lt;a href="https://rednafi.com/zephyr/no-skin-in-the-game/" rel="noopener noreferrer"&gt;Why do we listen to people with no skin in the game?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from the trenches of industrial software engineering, Redowan Delowar argues a simple rule borrowed from Nassim Taleb: if someone doesn&amp;rsquo;t bear the consequences of running the software in production, their opinions about how to build it are probably wrong. Influence does not equal correctness, and talking about code online is a completely different sport from shipping and maintaining production systems under real organizational constraints. A classic culprit is the &amp;ldquo;AI-pilled&amp;rdquo; executive or director who spends a Saturday afternoon vibe-coding a throwaway greenfield app, concludes that software engineering is completely solved, and shows up Monday demanding 10x feature velocity while dismissing compliance, legacy integration, and operational friction as excuses. Delowar uses LLMs heavily every day, which is precisely why he hits their sharp edges far more often than someone who only one-shots toy todo apps. You still have to humor your management chain to keep your paycheck, he notes, but never confuse organizational authority with technical truth—the person with real skin in the game is the one holding the pager when &amp;ldquo;vibe-slop&amp;rdquo; catches fire at 3 a.m.&lt;/p&gt;
&lt;p&gt;The second group with zero skin in the game is software influencers peddling engagement-bait absolutes like &lt;em&gt;&amp;ldquo;rewrite everything in Rust,&amp;rdquo;&lt;/em&gt; &lt;em&gt;&amp;ldquo;TypeScript is dead,&amp;rdquo;&lt;/em&gt; or &lt;em&gt;&amp;ldquo;Kotlin is Temu Java&amp;rdquo;&lt;/em&gt;—because nuanced engineering trade-offs don&amp;rsquo;t please social media algorithms, and selling hot takes and courses is far more lucrative than maintaining a five-year-old billing service. Podcast guests who actually built systems are often worth listening to, while professional hosts and course-sellers—many of whom pivoted seamlessly from JS framework bootcamps to Web3/NFTs and now to &amp;ldquo;AI agent mastery&amp;rdquo;—should be tuned out. Real companies choose tech stacks based on local hiring pools, iteration speed, and what the founding engineers already know, and LLMs haven&amp;rsquo;t changed that fundamental reality. Talk is cheap; always check whether the speaker will be around when the pager goes off.&lt;/p&gt;
&lt;h2 id="you-can-run-git-on-object-storage-if-you-re-make-packfiles"&gt;&lt;a href="https://www.tigrisdata.com/blog/objgit-packfiles/" rel="noopener noreferrer"&gt;You can run git on object storage if you re-make packfiles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Xe Iaso is building &lt;code&gt;objgit&lt;/code&gt;, an open-source Git server backed directly by Tigris S3-compatible object storage. A naive first prototype that mapped loose Git objects onto an object-storage filesystem hit a brick wall on real-world repositories. At its core, Git is a content-addressable store of millions of tiny objects—the Linux kernel repository alone contains roughly 11 million objects, so fetching them one by one at 10 ms per &lt;code&gt;GetObject&lt;/code&gt; HTTP call would take over 30 hours. Standard Git solves this with &lt;em&gt;packfiles&lt;/em&gt; (&lt;code&gt;.pack&lt;/code&gt; + &lt;code&gt;.idx&lt;/code&gt;), which bundle objects together and delta-compress them, but the Git packfile format was designed around local disks and &lt;code&gt;mmap&lt;/code&gt;, where random seeks cost nanoseconds rather than a 10 ms network round trip. Worse, standard &lt;code&gt;.idx&lt;/code&gt; files record only each object&amp;rsquo;s byte offset and &lt;em&gt;uncompressed&lt;/em&gt; size—not its compressed byte length in the pack—making it impossible to construct an exact HTTP &lt;code&gt;Range: bytes=start-end&lt;/code&gt; request to fetch a single object out of S3 without reading neighboring headers.&lt;/p&gt;
&lt;p&gt;Drawing inspiration from 1990s CD-ROM &lt;code&gt;.bin&lt;/code&gt;/&lt;code&gt;.cue&lt;/code&gt; rip files, Iaso designed a cloud-native packfile format for &lt;code&gt;objgit&lt;/code&gt;: compressed objects are concatenated into &lt;code&gt;.bin&lt;/code&gt; blobs capped at 128 MiB, while a separate binary &amp;ldquo;cue sheet&amp;rdquo; index stores every object&amp;rsquo;s offset alongside &lt;strong&gt;both&lt;/strong&gt; its compressed and uncompressed sizes—effectively turning a Git repository into a columnar store. With the exact compressed byte span in hand, &lt;code&gt;objgit&lt;/code&gt; can fire precise HTTP &lt;code&gt;Range&lt;/code&gt; requests for individual objects at the tail of a packfile while streaming the full packfile in the background until the sequential download catches up, all compressed with &lt;code&gt;zstd&lt;/code&gt;. Reinventing Git&amp;rsquo;s packfile format sounds like violating Chesterton&amp;rsquo;s Fence, Iaso admits, but because Git itself is distributed and content-addressed, if the server&amp;rsquo;s storage format breaks you can simply &lt;code&gt;git push&lt;/code&gt; again from a local clone. The payoff was dramatic: pushing the &lt;code&gt;Xe/x&lt;/code&gt; repository dropped from &lt;strong&gt;3 minutes 29 seconds down to 14.3 seconds&lt;/strong&gt;, and S3 API calls fell from over 9,000 down to 30. (&lt;code&gt;objgit&lt;/code&gt; still lacks authentication and authorization, so don&amp;rsquo;t expose it to the public internet yet.)&lt;/p&gt;
&lt;h2 id="why-cafebabe"&gt;&lt;a href="https://www.artima.com/insidejvm/whyCAFEBABE.html" rel="noopener noreferrer"&gt;Why CAFEBABE?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in May 1996, while writing his &lt;em&gt;&amp;ldquo;The Class File Lifestyle&amp;rdquo;&lt;/em&gt; column for &lt;em&gt;JavaWorld&lt;/em&gt;, Bill Venners got curious about the famous magic number sitting at the start of every compiled Java &lt;code&gt;.class&lt;/code&gt; file: why must the first four bytes always be &lt;code&gt;0xCAFEBABE&lt;/code&gt;? Venners posted the question to the &lt;code&gt;comp.lang.java&lt;/code&gt; Usenet newsgroup and archived the entire thread on this page. Readers chimed in with clever theories: a 32-bit magic number is fast to check on 32-bit architectures and unlikely to collide with ASCII text; the Java team wanted a coffee-themed hex constant, and since hexadecimal only gives you the letters &lt;code&gt;A&lt;/code&gt; through &lt;code&gt;F&lt;/code&gt; (no &lt;code&gt;J&lt;/code&gt; or &lt;code&gt;V&lt;/code&gt;), combinations using &lt;code&gt;CAFE&lt;/code&gt; beat out alternatives like &lt;code&gt;0xAFABCAFE&lt;/code&gt;, &lt;code&gt;0xCAFEFACE&lt;/code&gt;, or the ominous &lt;code&gt;0xABADCAFE&lt;/code&gt;—while one reader wished they had picked &lt;code&gt;0x00C0FFEE&lt;/code&gt; (reading the leading zeros as the letters &lt;code&gt;&amp;quot;OO&amp;quot;&lt;/code&gt; for &amp;ldquo;Object-Oriented Coffee&amp;rdquo;).&lt;/p&gt;
&lt;p&gt;The Usenet thread also serves as a charming mini-museum of computing folklore around hex magic numbers: the Burroughs B6700 initialized unused memory to &lt;code&gt;0xBADBADBADBAD&lt;/code&gt;; classic IBM systems and AIX RS/6000s filled uninitialized memory with &lt;code&gt;0xDEADBEEF&lt;/code&gt; so pointer bugs jumped right out in a debugger; classic Mac OS placed &lt;code&gt;0x50FFC001&lt;/code&gt; at address &lt;code&gt;0x0&lt;/code&gt; so dereferencing a &lt;code&gt;NULL&lt;/code&gt; code pointer would immediately trap; SGI IRIX started shared arena files with &lt;code&gt;0xDEADBABE&lt;/code&gt;; and debug builds of Solaris overwrote freed heap blocks with &lt;code&gt;0xCAFEFEED&lt;/code&gt;. Another reader pointed out that NeXTSTEP had already used &lt;code&gt;0xCAFEBABE&lt;/code&gt; as the magic number for multi-architecture &amp;ldquo;fat&amp;rdquo; binaries alongside &lt;code&gt;0xFEEDFACE&lt;/code&gt; for Mach-O object files. Finally, Patrick Naughton—one of the original members of Sun&amp;rsquo;s Green Project that created Oak (later renamed Java)—replied with the authoritative answer: he picked &lt;code&gt;0xCAFEBABE&lt;/code&gt; himself years before the name &amp;ldquo;Java&amp;rdquo; even existed! He simply wanted a fun, memorable 32-bit hex constant for the object file format, and &lt;code&gt;0xcafebabe&lt;/code&gt; beat out the runner-up &lt;code&gt;0xdeadbabe&lt;/code&gt;. Any connection to the baristas at Peet&amp;rsquo;s Coffee or the eventual name &amp;ldquo;Java&amp;rdquo; was pure serendipity.&lt;/p&gt;</description></item><item><title>Newsletter #132</title><link>https://miti99.com/en/post/2026/09/10/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #132.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="perfection-is-not-over-engineering"&gt;&lt;a href="https://var0.xyz/posts/perfection-is-not-over-engineering.html" rel="noopener noreferrer"&gt;Perfection is not over-engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The phrase &amp;ldquo;we don&amp;rsquo;t want to aim for perfection&amp;rdquo; comes up in engineering meetings more times than the author can count. He understands the caution—over-engineering has burned out plenty of teams—but argues the industry is conflating two completely different things. Over-engineering is simply &lt;em&gt;solving the wrong problem&lt;/em&gt;, usually with good intentions and a pile of accidental complexity attached. A &amp;ldquo;perfect&amp;rdquo; solution, by contrast, is very real once requirements are clear and all constraints are on the table: tighten the constraints enough and only one design fits, making it perfect precisely because nothing else satisfies the actual problem. Picking Python on serverless to skip a build step might be ideal for one team and completely wrong for a team that doesn&amp;rsquo;t know Python or needs predictable low latency.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, every system is a product: internal libraries, APIs, and CLI tools all have real users with real needs. The clearest tell of over-engineering is asking &amp;ldquo;why did we build it this way?&amp;rdquo; and getting an answer that falls apart under scrutiny. A classic example is a three-person team maintaining five microservices that share the same underlying data: foreign keys once enforced by the database turn into loosely coupled string IDs, and one service deletes records without the others knowing—all to buy &amp;ldquo;independent deployability,&amp;rdquo; a problem the three-person team never actually had. The takeaway: that isn&amp;rsquo;t an excess of perfection, it&amp;rsquo;s a failure of requirements gathering. The enemy was never perfection; it was vague requirements.&lt;/p&gt;
&lt;h2 id="claude-is-not-a-compiler"&gt;&lt;a href="https://blog.exe.dev/claude-is-not-a-compiler" rel="noopener noreferrer"&gt;Claude Is Not a Compiler&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Josh Bleecher Snyder argues that Claude is not a compiler—because it is &lt;em&gt;better&lt;/em&gt; than one. In the idealized textbook view, software is built in neat horizontal layers: vision becomes strategy, product specs become engineering plans, source code becomes binaries, with each layer owned by a different role making thousands of micro-decisions. In reality, layers constantly leak and rub against one another, and working &lt;em&gt;across&lt;/em&gt; layers is where the biggest wins happen—just as the Empire State Building was designed and erected in under a year because the owners, architects, structural engineers, and contractors sat in the same room making cross-cutting trade-offs together. Claude can work vertically across all those layers at once—discussing strategy, architecture, source code, and assembly without needing to schedule a meeting.&lt;/p&gt;
&lt;p&gt;Snyder illustrates this with &lt;code&gt;exe.dev&lt;/code&gt;&amp;rsquo;s distributed DNS server. High-level strategic and architectural decisions were settled human-to-human; for the rest, he spun up multiple parallel agent loops to build full implementations with tests, then had another agent compare the resulting designs. What shocked him was how many consequential design decisions the agents quietly made on their own without asking—and how differently each agent resolved them, such as how to handle a database state rollback. Repeating this multi-agent exploration three times let him distill a concise design document that guided the final agent across every critical decision point. A week later, having barely read the raw code himself, he could answer every question from his teammates, and a month into production the DNS server had zero incidents. He calls this &amp;ldquo;vibe-engineering&amp;rdquo;—and predicts that soon we&amp;rsquo;ll just call it software engineering.&lt;/p&gt;
&lt;h2 id="in-defense-of-not-understanding-your-codebase"&gt;&lt;a href="https://www.seangoedecke.com/in-defense-of-not-understanding-your-codebase/" rel="noopener noreferrer"&gt;In defense of not understanding your codebase&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How thoroughly must an engineer understand their codebase? Sean Goedecke argues the answer depends entirely on the environment. Developers working on small, self-contained codebases like Redis will insist you must understand every line; engineers working on massive systems like Google or GitHub know that is literally impossible. Because the first group dominates online discourse, Goedecke steps up to defend the second: in a sufficiently large system, having only a &lt;em&gt;partial&lt;/em&gt; understanding isn&amp;rsquo;t a moral failing—it is the best anyone can ever achieve. At scale, everyone operates with an incomplete, slightly wrong mental model, so effective engineers must get comfortable making educated guesses.&lt;/p&gt;
&lt;p&gt;He pushes back against Peter Naur&amp;rsquo;s famous essay &lt;em&gt;&amp;ldquo;Programming as Theory Building.&amp;rdquo;&lt;/em&gt; While agreeing that a programmer&amp;rsquo;s most valuable asset is the mental &amp;ldquo;theory&amp;rdquo; of how the program works, Goedecke rejects Naur&amp;rsquo;s conclusion that once the original team leaves, a codebase is dead and ought to be rewritten from scratch. First, large legacy systems encode thousands of hard-won edge cases that a greenfield rewrite won&amp;rsquo;t rediscover until production breaks, and successful rewrites almost always happen incrementally by carving up the existing system. Second, &amp;ldquo;abandoned&amp;rdquo; codebases are successfully revived in industry all the time: you start by tracing one end-to-end flow and expand your mental map from there. Finally, preserving a pristine mental theory is just one business value among many, routinely traded off whenever teams collaborate or patch urgent security vulnerabilities. Being a professional engineer means aligning with your company&amp;rsquo;s trade-offs—even when that means working effectively in code you don&amp;rsquo;t fully understand.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-the-network"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-01-Beyond-Happy-Path-Engineering-the-Network/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: the Network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This opening installment of Gabor Koos&amp;rsquo;s &lt;em&gt;&amp;ldquo;Beyond Happy Path Engineering&amp;rdquo;&lt;/em&gt; series examines the assumptions that local development environments indulge but production mercilessly punishes, starting with the network. A network call looks like a simple function call, but it crosses a boundary into a system you do not control. Using checkout payment authorization as a running example, Koos notes that &amp;ldquo;clean&amp;rdquo; failures like a refused connection are easy to handle compared to a timeout &lt;em&gt;after&lt;/em&gt; the request was sent: the operation may have succeeded, failed, or still be sitting in a queue. The foundational rule of distributed systems is that &lt;em&gt;not receiving a response does not mean the operation didn&amp;rsquo;t happen&lt;/em&gt;. Latency is also a failure mode in disguise: a slow downstream service ties up threads and connection pools, averages hide catastrophic tail latency, and slowness cascades into full outages faster than hard errors.&lt;/p&gt;
&lt;p&gt;Koos outlines the essential defenses: treat timeouts as explicit design decisions derived from per-request latency budgets; retry only when safe, backing mutations with idempotency keys passed on every attempt alongside exponential backoff and jitter to prevent thundering herds; and propagate deadlines and cancellation contexts downstream so abandoned work stops immediately. Circuit breakers and load shedding protect overloaded services, while graceful degradation separates critical path steps (like taking payment) from deferrable side effects (like sending confirmation emails) using explicit order states like &lt;code&gt;&amp;quot;pending&amp;quot;&lt;/code&gt;. GitHub&amp;rsquo;s October 2018 outage—where a network partition lasting under a minute caused over 24 hours of degraded service—vividly illustrates the cost of happy-path network assumptions.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-time"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-19-Beyond-Happy-Path-Engineering-Time/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of the series turns to time—seemingly the simplest dependency of all: grab the current timestamp, compare two values, and make a decision. The running example is a checkout flow that holds inventory for fifteen minutes using &lt;code&gt;if now() &amp;gt; reservation.expiresAt&lt;/code&gt;. If the cleanup worker&amp;rsquo;s clock drifts two minutes ahead of the checkout server&amp;rsquo;s clock, items get released back to inventory while the customer is mid-payment. Wall clocks can jump forward or backward mid-execution via NTP adjustments, turning elapsed durations negative, and timestamps across different machines cannot reliably establish event ordering. Worst of all, time bugs fail silently: services stay up, dashboards stay green, and the system quietly makes wrong business decisions.&lt;/p&gt;
&lt;p&gt;The core lesson is that &amp;ldquo;time&amp;rdquo; actually answers four distinct questions: &lt;em&gt;wall-clock time&lt;/em&gt; records when an event happened in the real world, &lt;em&gt;monotonic time&lt;/em&gt; measures elapsed durations and timeouts on a single machine, &lt;em&gt;logical time&lt;/em&gt; (versions or sequence numbers) orders competing updates, and &lt;em&gt;business time&lt;/em&gt; governs billing periods, cutoff windows, and user time zones. Expiration should be modeled as an explicit &lt;em&gt;state transition&lt;/em&gt; rather than a passive timestamp comparison: use timestamps only to find candidate rows, then execute a conditional write that transitions the row to &lt;code&gt;expired&lt;/code&gt; only if its status is still &lt;code&gt;reserved&lt;/code&gt;, making late or duplicate cleanup runs harmless. When local clocks aren&amp;rsquo;t enough to arbitrate, reconcile against the authoritative external source, such as the payment provider. Cloudflare&amp;rsquo;s New Year&amp;rsquo;s 2017 leap-second DNS outage—when subtracting two &lt;code&gt;time.Now()&lt;/code&gt; readings yielded a negative number and triggered a panic—serves as a classic cautionary tale.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-databases"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-01-Beyond-Happy-Path-Engineering-Databases/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Databases&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part three tackles databases, the layer developers most often treat as an infallible black box. Using an e-commerce checkout flow that works flawlessly on a developer&amp;rsquo;s laptop because there is zero concurrent traffic, Koos shows how production changes everything: checkouts, admin dashboards, background jobs, analytics queries, and schema migrations all compete for the same connections and locks. A single slow query can exhaust the connection pool, causing incoming requests to queue up, users to hit refresh, and &amp;ldquo;checkout to go down&amp;rdquo; even though the database hasn&amp;rsquo;t crashed. Two concurrent requests can both read &lt;code&gt;stock = 1&lt;/code&gt; and both sell the last item; wrapping code in a transaction doesn&amp;rsquo;t magically prevent race conditions unless business invariants are enforced explicitly. On top of that come lagging read replicas, commit timeouts that leave the caller unsure whether the write succeeded, deadlocks, and schema migrations running alongside multiple live application versions.&lt;/p&gt;
&lt;p&gt;Koos recommends starting from the invariant that must never be violated—such as &amp;ldquo;never sell more than available inventory&amp;rdquo;—and enforcing it directly in the atomic write statement (&lt;code&gt;UPDATE ... WHERE stock &amp;gt;= quantity&lt;/code&gt;) backed by database constraints rather than application-level checks alone. Keep transactions short, never make network calls inside a transaction, and retry only transient errors. Make writes idempotent, define explicit data-freshness requirements per endpoint before routing reads to replicas, run schema migrations in backward-compatible expand-and-contract phases, and rehearse backup restores regularly. Atlassian&amp;rsquo;s 2022 outage and GitHub&amp;rsquo;s 2018 incident both prove that recovery speed matters just as much as data durability.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-storage"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-11-Beyond-Happy-Path-Engineering-Storage/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Storage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part four examines object storage, which looks simpler than a relational database but hides a fundamental trap: your database and your object store are two separate systems with no shared transaction coordinator. Consider a document upload flow: write the file to S3, insert a metadata row in the database, and return the URL. If the blob upload succeeds but the database insert fails, you get an invisible orphaned object; flip the order and a failed upload leaves a database row pointing to a missing blob that serves &lt;code&gt;404&lt;/code&gt;s. Abandoned multipart uploads quietly rack up storage bills, presigned URLs remain valid even after the database record is deleted, concurrent uploads to the same key silently overwrite each other, and CDNs keep serving stale cached files. High durability also doesn&amp;rsquo;t equal recoverability, because an accidental &lt;code&gt;DELETE&lt;/code&gt; is replicated just as durably as a valid write.&lt;/p&gt;
&lt;p&gt;Koos advises ordering upload steps so failures fail safe, tracking lifecycle state explicitly in the database (&lt;code&gt;pending&lt;/code&gt;, &lt;code&gt;confirmed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;), and serving only &lt;code&gt;confirmed&lt;/code&gt; records. Object keys should use immutable UUIDs or content hashes rather than user-supplied filenames; large files should upload directly from the client via short-lived presigned URLs; and deletions should soft-delete the database row first before a background job purges the blob, backed by a periodic reconciliation sweeper. The 2014 demise of Code Spaces—which shut down permanently after an attacker gained access to their AWS control panel and wiped both production storage and backups—underscores why backups must live outside the blast radius of production credentials.&lt;/p&gt;
&lt;h2 id="everyone-should-know-simd"&gt;&lt;a href="https://mitchellh.com/writing/everyone-should-know-simd" rel="noopener noreferrer"&gt;Everyone Should Know SIMD&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SIMD has a reputation for being arcane, and Mitchell Hashimoto regularly meets strong engineers who write it off as too hard to learn or useful only in niche high-performance computing. He argues that reputation is undeserved: the vast majority of practical &amp;ldquo;process N items at a time&amp;rdquo; SIMD code follows a single five-step template, and once you internalize that template, writing SIMD is almost as straightforward as writing a standard &lt;code&gt;for&lt;/code&gt; loop. Because SIMD lets the CPU process multiple data elements in a single instruction, any loop scanning bytes, characters, or array elements is a candidate once inputs reach thousands or millions of bytes.&lt;/p&gt;
&lt;p&gt;The five-step template is: broadcast constants into vectors and initialize accumulators if needed; loop over the input in chunks equal to the vector width; perform parallel comparisons or arithmetic across all lanes; reduce or store the vector result; and handle the trailing remainder elements using your original scalar loop. Hashimoto walks through a real example from the Ghostty terminal emulator written in Zig: finding the end of a run of printable ASCII characters by scanning until a byte is &lt;code&gt;&amp;lt;= 0xF&lt;/code&gt;. The scalar loop is a one-liner; the SIMD version adds about 12 lines of code and delivers a theoretical 4x speedup on ARM NEON, 8x on AVX2, and 16x on AVX-512, measuring roughly 5x faster in real benchmarks on an Intel AVX2 machine. While compilers can sometimes auto-vectorize simple loops, whenever a hot path cares about a 5x speedup, Hashimoto prefers explicit, portable SIMD that won&amp;rsquo;t silently regress after a compiler upgrade or minor code tweak.&lt;/p&gt;
&lt;h2 id="htop-explained"&gt;&lt;a href="https://peteris.rocks/blog/htop/" rel="noopener noreferrer"&gt;htop explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pēteris Ņikiforovs admits that for years he used &lt;code&gt;htop&lt;/code&gt; without truly understanding half the numbers on screen—for instance, assuming a load average of &lt;code&gt;1.0&lt;/code&gt; on a dual-core machine meant the CPUs were 50% busy. So he dug into the Linux kernel sources and wrote a comprehensive visual guide breaking down every single bar and column in &lt;code&gt;htop&lt;/code&gt;. What makes the guide stand out is that he traces every metric back to its exact kernel source: uptime comes from &lt;code&gt;/proc/uptime&lt;/code&gt;, load average comes from &lt;code&gt;/proc/loadavg&lt;/code&gt;, and you can verify how &lt;code&gt;htop&lt;/code&gt; gathers them yourself by running it under &lt;code&gt;strace&lt;/code&gt; to see which files it opens.&lt;/p&gt;
&lt;p&gt;Load average isn&amp;rsquo;t CPU percentage at all—it is the exponentially damped moving average of runnable threads plus threads stuck in uninterruptible sleep waiting on disk or network I/O; the 1-minute figure reflects roughly 63% of the past minute&amp;rsquo;s load and 37% of the prior average. The guide then demystifies process states (&lt;code&gt;R&lt;/code&gt; running/runnable, &lt;code&gt;S&lt;/code&gt; interruptible sleep, &lt;code&gt;D&lt;/code&gt; uninterruptible sleep, &lt;code&gt;Z&lt;/code&gt; zombie terminated but not yet reaped by its parent), &lt;code&gt;NI&lt;/code&gt; nice values from &lt;code&gt;-20&lt;/code&gt; to &lt;code&gt;19&lt;/code&gt; and their relation to kernel priority (&lt;code&gt;PR = 20 + NI&lt;/code&gt;), and the memory columns: &lt;code&gt;VIRT&lt;/code&gt; includes unbacked virtual reservations and memory-mapped files so it&amp;rsquo;s rarely actionable, &lt;code&gt;RES&lt;/code&gt; is actual resident RAM (though shared libraries and copy-on-write pages get double-counted across processes), and &lt;code&gt;MEM%&lt;/code&gt; is simply &lt;code&gt;RES&lt;/code&gt; divided by total RAM. He wraps up by auditing every default background process on a fresh Ubuntu Server install to see which ones can be safely stripped out.&lt;/p&gt;
&lt;h2 id="the-productivity-experience-paradox"&gt;&lt;a href="https://annievella.com/posts/the-productivity-experience-paradox/" rel="noopener noreferrer"&gt;The Productivity-Experience Paradox&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the second article from her master&amp;rsquo;s research on how AI coding tools affect software engineers, Annie Vella shares findings from a longitudinal study tracking the exact same cohort of engineers across two waves six months apart (October 2024 to April 2025). On the productivity front, the news is consistently positive: 84% of respondents reported that AI helped them get more done in both waves. Yet developer experience—measured across the DevEx framework dimensions of feedback loops, cognitive load, and flow state—moved in the opposite direction: the share of engineers reporting a net-negative experience nearly doubled from 14% to 27%, and not a single engineer who fell into the negative group in Wave 1 recovered to an all-positive experience by Wave 2.&lt;/p&gt;
&lt;p&gt;The central finding is that productivity and developer experience—long assumed to rise and fall together—are decoupling: tracking the same individuals over time, experience degraded while output held steady, with a near-zero correlation ($r = 0.02$) between changes in flow state and changes in perceived productivity. That decoupling is dangerous because the business case for investing in DevEx has historically been &amp;ldquo;happy developers are productive developers&amp;rdquo;; when output stays high, rising cognitive strain stays invisible until it turns into burnout. Flow suffered the sharpest drop (negative reports rose from 7% to 20%) even as feedback loops sped up, and Vella suspects the two are linked: every fast AI response triggers a micro-context switch from creator to reviewer. Borrowing the term &amp;ldquo;junk flow&amp;rdquo; to describe a slot-machine-like loop of rapid prompting that mimics flow without deep satisfaction, she concludes that while AI boosts extrinsic output, it risks eroding the intrinsic craft and joy of software engineering.&lt;/p&gt;
&lt;h2 id="prefactoring-clear-the-way-for-your-new-feature"&gt;&lt;a href="https://testing.googleblog.com/2026/07/prefactoring-clear-way-for-your-new.html" rel="noopener noreferrer"&gt;Prefactoring: Clear the Way for Your New Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post from Google&amp;rsquo;s &lt;em&gt;&amp;ldquo;Tech on the Toilet&amp;rdquo;&lt;/em&gt; series opens with Kent Beck&amp;rsquo;s famous advice: &lt;em&gt;&amp;ldquo;First make the change easy (warning: this may be hard), then make the easy change.&amp;rdquo;&lt;/em&gt; When you try to bolt a new feature directly onto code that wasn&amp;rsquo;t structured to accommodate it, things get messy fast: tweaking one file forces changes in three others, and soon you&amp;rsquo;re knee-deep in unrelated modules. &lt;em&gt;Prefactoring&lt;/em&gt;—short for preparatory refactoring—is the discipline of restructuring existing code to fit the upcoming requirement &lt;em&gt;before&lt;/em&gt; writing the new feature, rather than promising yourself you&amp;rsquo;ll clean it up afterward.&lt;/p&gt;
&lt;p&gt;The payoffs are immediate: the new feature slots in naturally, code reviews go much faster because structural refactoring and behavioral changes live in separate commits, fewer bugs slip in because cleanup is isolated from new logic, and rollbacks are safer because each change is small and self-contained. In the post&amp;rsquo;s example, the first CL simply extracts a &lt;code&gt;get_display_name(user)&lt;/code&gt; helper to deduplicate name-formatting logic across the profile page and email templates; the second CL adds middle-name support with a one-line edit inside that helper. Even if you only spot the right abstraction mid-implementation, you can still split the cleanup into a preparatory CL—or spin off reviewer-suggested cleanups in parallel while your main CL is under review. Not every cleanup belongs up front, though: if a refactoring doesn&amp;rsquo;t directly unblock your feature, save it for later, or fold it in if it&amp;rsquo;s truly trivial.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #130</title><link>https://miti99.com/en/post/2026/09/08/</link><pubDate>Tue, 08 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #130.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-anthropic-runs-large-scale-code-migrations-with-claude-code"&gt;&lt;a href="https://claude.com/blog/ai-code-migration" rel="noopener noreferrer"&gt;How Anthropic runs large-scale code migrations with Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Migrating a large codebase to another language used to be a multi-year endeavor undertaken only as a last resort. Anthropic shows how that calculus has changed: Bun migrated one million lines of code from Zig to Rust in under two weeks, consuming roughly 5.9 billion input tokens and 690 million output tokens (around $165,000 at standard API pricing). In return, the entire existing test suite passed before merging (19 regressions surfaced afterward and were all fixed), the binary shrank by 19%, runtime performance improved by 2–5%, and one memory benchmark dropped from 6,745 MB to 609 MB. In another example, 165,000 lines of Python were migrated to TypeScript over a single weekend.&lt;/p&gt;
&lt;p&gt;The workflow follows six steps: author a translation rulebook alongside a dependency graph, pilot the rules on a sample batch of files, translate the codebase in parallel using worker agents, run a compilation loop pairing a fixer agent with an adversarial reviewer agent, run fast tests to catch runtime bugs, and finally verify behavioral parity against the original implementation. The core lesson is to fix the generation loop rather than hand-patching generated code: whenever a mistake repeats, update the rulebook and regenerate. Doing so requires an objective &amp;ldquo;oracle&amp;rdquo;—such as a compiler and test suite—up front, plus a resumable work queue. Compute spend should also be tiered deliberately: smaller models like Sonnet handle bulk translation, while larger models like Fable or Opus write the rulebook and perform adversarial reviews.&lt;/p&gt;
&lt;h2 id="the-vfs"&gt;&lt;a href="https://internals-for-interns.com/posts/linux-kernel-vfs/" rel="noopener noreferrer"&gt;The VFS&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Whether you read a file on ext4, a virtual file in &lt;code&gt;/proc&lt;/code&gt; that exists only in kernel memory, or a remote file over NFS, you use the exact same system calls and file descriptor semantics. The layer that makes this possible is the VFS (Virtual File System), sitting between the syscall interface and concrete filesystems. This article explains the VFS as a textbook application of &amp;ldquo;program to an interface, not an implementation&amp;rdquo;—where, in C, an interface is simply a struct of function pointers. Four core objects do the heavy lifting: a &lt;code&gt;superblock&lt;/code&gt; represents a mounted filesystem, an &lt;code&gt;inode&lt;/code&gt; represents an object within it (a file, directory, or link), a &lt;code&gt;dentry&lt;/code&gt; binds a name to an inode (since inodes themselves don&amp;rsquo;t know their own filenames), and a &lt;code&gt;file&lt;/code&gt; represents a specific open handle held by a process with its own read/write offset. The &lt;code&gt;super_operations&lt;/code&gt;, &lt;code&gt;inode_operations&lt;/code&gt;, and &lt;code&gt;file_operations&lt;/code&gt; tables hold filesystem-specific behaviors, falling back to generic VFS implementations whenever a hook is left unimplemented.&lt;/p&gt;
&lt;p&gt;In practice, most work is handled by shared VFS code before ever touching a filesystem driver. When resolving a path like &lt;code&gt;/etc/hostname&lt;/code&gt;, the kernel walks component by component and calls the filesystem&amp;rsquo;s &lt;code&gt;lookup&lt;/code&gt; hook only when the dentry cache (dcache) misses. That cache even remembers nonexistent paths (negative dentries) and is read locklessly via RCU. Reading file contents works similarly: most reads simply copy bytes out of the page cache without touching the disk, and a user-space file descriptor is nothing more than an index into the process&amp;rsquo;s &lt;code&gt;struct file *&lt;/code&gt; array.&lt;/p&gt;
&lt;h2 id="text-editor-data-structures"&gt;&lt;a href="https://cdacamar.github.io/data%20structures/algorithms/benchmarking/text%20editors/c&amp;#43;&amp;#43;/editor-data-structures/" rel="noopener noreferrer"&gt;Text Editor Data Structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When building a text editor from scratch, the first question is how to represent file contents in memory. Cameron DaCamara starts by laying out his requirements: fast insertions and deletions, fast undo/redo, UTF-8 support, and simultaneous multi-cursor editing. From there, he systematically eliminates candidates. A single contiguous string is simple to render, but bogs down on files over 1 MB, reallocations can turn $O(n)$ edits into $O(n^2)$, and snapshotting for undo/redo burns memory. Emacs-style gap buffers are simple but poorly suited to multiple cursors. Ropes give $O(\log n)$ operations, but copy-on-write overhead bloats memory usage. Traditional piece tables, once used in Microsoft Word, hit contiguous-array bottlenecks during long editing sessions. VS Code&amp;rsquo;s piece tree combines the strengths of ropes and piece tables by backing the piece table with a red-black tree.&lt;/p&gt;
&lt;p&gt;DaCamara takes that approach a step further by building an &lt;em&gt;immutable&lt;/em&gt; piece tree called &lt;code&gt;fredbuf&lt;/code&gt;. A purely functional red-black tree needs no parent pointers and allows cheap $O(1)$ snapshots at any point, turning undo and redo into two simple linked lists of tree roots. CRLF line-ending normalization is handled outside the tree, and a &lt;code&gt;TreeWalker&lt;/code&gt; abstraction simplifies character iteration and correctness testing. Two takeaways stand out: analyzing constraints up front saves wasted effort, and investing in debugging tools—like visual tree dumpers—is what gets a complex project across the finish line, especially when implementing notoriously tricky immutable red-black tree deletions. The library is MIT-licensed and requires only C++20.&lt;/p&gt;
&lt;h2 id="scaling-to-1-million-concurrent-sandboxes-in-seconds"&gt;&lt;a href="https://modal.com/blog/scaling-to-1-million-concurrent-sandboxes-in-seconds" rel="noopener noreferrer"&gt;Scaling to 1 million concurrent sandboxes in seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modal rewrote its entire sandbox control plane from the ground up and demonstrated the result with a striking milestone: spinning up one million concurrent sandboxes in under 60 seconds. Their previous architecture, much like Kubernetes, relied on strong consistency across the backend: every placement decision required global coordination, and database writes scaled linearly with sandbox count, making horizontal scaling impossible once demand reached millions of concurrent sandboxes and tens of thousands of creations per second.&lt;/p&gt;
&lt;p&gt;The new architecture embraces decentralization. Instead of a single serialized central scheduler, multiple scheduler servers run in parallel using load-balancing algorithms over in-memory state. Each worker node becomes the source of truth for its own sandboxes, periodically publishing state to Redis rather than writing synchronously to a central datastore, removing Postgres from the sandbox creation hot path entirely. RPC calls that previously scaled per sandbox are coalesced into batches. As a result, creating a sandbox takes just two network hops and a single CPU operation with zero central coordination, achieving a median startup time under 500 ms and scheduling latency of just a few tens of milliseconds. The multi-month effort began with an intense prototyping sprint by four engineers before reimplementing every feature, monitoring pipeline, and container runtime detail—including tracking down and fixing Linux kernel &lt;code&gt;rtnl&lt;/code&gt; lock contention when spinning up containers en masse.&lt;/p&gt;
&lt;h2 id="making-768-servers-look-like-1"&gt;&lt;a href="https://planetscale.com/blog/making-768-servers-look-like-1" rel="noopener noreferrer"&gt;Making 768 servers look like 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When an application has to serve millions of queries per second over petabytes of data, a single database server is no longer enough. PlanetScale outlines three fundamental walls in single-primary scaling: writes always funnel into one machine because the write-ahead log (WAL) is a serialization bottleneck regardless of how many read replicas you add; replicas duplicate the full dataset rather than dividing it; and backing up or restoring a massive monolithic database can take hours or days. The solution is horizontal sharding—splitting both data and queries across many independent primary servers. In the article&amp;rsquo;s example, one petabyte is split across 256 shards of roughly 4 TB each, with one primary and two replicas per shard, totaling 768 servers.&lt;/p&gt;
&lt;p&gt;To shield application developers from that complexity, a routing proxy layer sits between the app and the shards—Vitess for MySQL and Neki for Postgres. Unlike simple connection poolers such as PgBouncer, this router parses SQL queries, understands how data is distributed, plans and scatters queries to the right shards, and merges the results back together. The sharding topology is declared in JSON (a VSchema)—for instance, sharding the &lt;code&gt;user&lt;/code&gt; table by a hash of its &lt;code&gt;id&lt;/code&gt; column. Ultimately, the application connects to a single hostname like &lt;code&gt;mydb.pscale.com&lt;/code&gt;: DNS resolves to network load balancers that distribute connections across stateless query routers, and the application never knows 768 database servers are working behind the scenes.&lt;/p&gt;
&lt;h2 id="branchavoidant-programming"&gt;&lt;a href="https://easylang.online/blog/branchless" rel="noopener noreferrer"&gt;Branch‑Avoidant Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modern CPUs speculate on which way branches will go to keep their instruction pipelines full; when a prediction is wrong, the pipeline must be flushed and refilled at a steep penalty. This article illustrates the cost by filtering numbers smaller than 500 out of a random array—a workload where the branch predictor is essentially guessing a coin flip. The trick is to eliminate the &lt;code&gt;if&lt;/code&gt; statement: unconditionally write the current number into the output slot, and conditionally advance the output index with &lt;code&gt;smlen += (numbers[i] &amp;lt; 500);&lt;/code&gt;. You perform extra writes, but they are far cheaper than branch mispredictions. Filtering 100,000 numbers 1,000 times on an Apple M1 takes 0.345 seconds with an &lt;code&gt;if&lt;/code&gt; branch versus just 0.036 seconds branchless—nearly 10x faster; on an Intel Xeon, it drops from 0.576 to 0.110 seconds. Inspecting the assembly shows why: conditional jump instructions like &lt;code&gt;b.gt&lt;/code&gt; (ARM) or &lt;code&gt;jg&lt;/code&gt; (x86) are replaced by predication instructions like &lt;code&gt;cinc&lt;/code&gt; or &lt;code&gt;setle&lt;/code&gt;, keeping control flow completely straight.&lt;/p&gt;
&lt;p&gt;Compilers don&amp;rsquo;t apply this transformation automatically because they don&amp;rsquo;t know the statistical distribution of your runtime data, nor can they safely assume that a conditional memory write is valid to execute unconditionally (since the destination buffer might only be sized for matching elements or could trigger a data race). Developers therefore have to write branchless loops deliberately when profiling calls for it. The author notes that quicksort partitioning is a prime candidate, as partitioning is fundamentally conditional data movement around a pivot.&lt;/p&gt;
&lt;h2 id="your-redis-leaderboard-is-probably-breaking-ties-wrong"&gt;&lt;a href="https://dev.to/trungdlp/your-redis-leaderboard-is-probably-breaking-ties-wrong-39k4" rel="noopener noreferrer"&gt;Your Redis Leaderboard Is Probably Breaking Ties Wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Building a leaderboard with a Redis sorted set is a classic pattern, but few developers think about what happens when two players have the exact same score. By default, Redis breaks ties lexicographically by member string, meaning the player ID arbitrarily decides who ranks higher—deterministic, but meaningless to players. Common quick fixes have flaws of their own: millisecond timestamps collide under concurrency and suffer from clock skew across servers, while packing both score and timestamp into a single 64-bit IEEE 754 &lt;code&gt;double&lt;/code&gt; eats into the precision and safe range of both numbers.&lt;/p&gt;
&lt;p&gt;Podium, an open-source leaderboard service, implements a clean rule: whoever reaches a tied score first ranks higher. Each leaderboard maintains a monotonic counter initialized to the maximum signed 64-bit integer; whenever a player posts a new score, a Lua script decrements the counter and prepends that 19-digit number to the player&amp;rsquo;s public ID, ensuring earlier arrivals have a lexicographically larger prefix and sort ahead in descending queries. The script atomically updates four keys: the descending sorted set, an ascending sorted set (where counter digits are inverted so earlier arrivals still win ties), a hash mapping public IDs to internal member strings, and the counter itself. If a submitted score equals the player&amp;rsquo;s current score, their existing internal member name is preserved, making retries idempotent. The trade-off is roughly 11–17% higher write latency and 287 bytes per member instead of 99 bytes in local benchmarks—a reasonable price for fair, intuitive tie-breaking.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #129</title><link>https://miti99.com/en/post/2026/09/07/</link><pubDate>Mon, 07 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #129.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hacking-the-method-name"&gt;&lt;a href="https://maxxedev.github.io/2026/08/05/hacking-the-method-name.html" rel="noopener noreferrer"&gt;Hacking the Method Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In Java, when you need a property name as a string—for parsing CSVs, mapping query results, or calling REST APIs—you usually hardcode &lt;code&gt;&amp;quot;title&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;author&amp;quot;&lt;/code&gt; directly into the source, which is prone to typos and invisible to the compiler. This post demonstrates a technique to extract method names directly from method references, such as &lt;code&gt;nameOf(Book::title)&lt;/code&gt;, keeping names refactoring-safe and in sync with your code. The trick relies on &lt;code&gt;SerializedLambda&lt;/code&gt;, introduced in Java 8: the author defines a &lt;code&gt;Getter&amp;lt;T, R&amp;gt;&lt;/code&gt; functional interface that extends both &lt;code&gt;Function&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt;, so when the JVM serializes a method reference of that type, it replaces it with a &lt;code&gt;SerializedLambda&lt;/code&gt; instance containing metadata about the target method. A custom &lt;code&gt;ObjectOutputStream&lt;/code&gt; enables &lt;code&gt;enableReplaceObject(true)&lt;/code&gt;, writes to a no-op stream, overrides &lt;code&gt;replaceObject()&lt;/code&gt; to intercept the replacement object, and reads the method name via &lt;code&gt;getImplMethodName()&lt;/code&gt;. From &lt;code&gt;nameOf()&lt;/code&gt;, it&amp;rsquo;s trivial to build &lt;code&gt;beanNameOf()&lt;/code&gt; to strip the &lt;code&gt;get&lt;/code&gt; prefix.&lt;/p&gt;
&lt;p&gt;The catch is that this stays clean only for zero-argument getters. Supporting multi-parameter methods like &lt;code&gt;save(title, author)&lt;/code&gt; requires manually declaring serializable interfaces like &lt;code&gt;Function2&lt;/code&gt; and &lt;code&gt;Function3&lt;/code&gt; along with corresponding &lt;code&gt;nameOf()&lt;/code&gt; overloads, which gets repetitive fast. To solve that, the author introduces the &lt;code&gt;safety-mirror&lt;/code&gt; library, which handles all the boilerplate out of the box and returns full &lt;code&gt;java.lang.reflect.Method&lt;/code&gt; objects rather than just method name strings.&lt;/p&gt;
&lt;h2 id="control-the-ideas-not-the-code"&gt;&lt;a href="https://antirez.com/news/169" rel="noopener noreferrer"&gt;Control the ideas, not the code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Redis creator antirez argues that in the age of LLMs, programmers should focus on controlling the ideas and design of their software rather than reading every single line of AI-generated code—though that doesn&amp;rsquo;t mean barking &amp;ldquo;build me a product&amp;rdquo; and walking away. He offers three reasons: the sheer volume of code generated daily is too large to review meaningfully (who can earnestly review 5,000 lines a day?); LLMs excel at writing locally optimal code but are weaker at big-picture architecture, so discussing and evaluating design with the model is much higher leverage than inspecting every function; and with only eight hours in a workday, reading code steals time from what matters most—steering the project, conceiving features, finding optimization angles, and testing. His fully AI-written project DwarfStar showed that you still need a deep understanding of how everything works and the taste to pick the right design.&lt;/p&gt;
&lt;p&gt;For Redis, he still reviews AI-generated code out of respect for human maintainers who will edit it by hand, while admitting the ritual feels largely pointless; given free rein, he would spend that time testing and having the LLM maintain a &lt;code&gt;DESIGN.md&lt;/code&gt; file describing the ideas and design of each data structure in plain English. For younger developers who haven&amp;rsquo;t yet built strong mental models, however, he advises writing programs from scratch—such as an interpreter, a small database, or a hash table—by hand.&lt;/p&gt;
&lt;h2 id="good-tools-are-invisible"&gt;&lt;a href="https://www.gingerbill.org/article/2026/07/10/good-tools-are-invisible/" rel="noopener noreferrer"&gt;Good Tools Are Invisible&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Odin creator gingerBill argues that a good tool should be &amp;ldquo;invisible&amp;rdquo;: once mastered, it fades into the background so you only think about the task at hand. He pushes back against the habit of turning a tool&amp;rsquo;s shortcomings into &amp;ldquo;fun puzzles&amp;rdquo; and citing them as proof of the tool&amp;rsquo;s superiority. Take Vim: someone proudly recounts crafting a clever macro for a one-off text edit that gingerBill finished in under a minute using multiple cursors in Sublime Text. Such rationalizations take root when a tool becomes part of someone&amp;rsquo;s personal identity—admitting the tool is flawed feels like admitting a personal flaw. He also distinguishes &lt;em&gt;feeling&lt;/em&gt; productive from &lt;em&gt;being&lt;/em&gt; productive: the honest metric is actual time spent and errors made, not how clever you felt along the way.&lt;/p&gt;
&lt;p&gt;He extends the argument to several perennial debates. If a GUI is hard to navigate by keyboard, that&amp;rsquo;s because its creators didn&amp;rsquo;t implement good keyboard navigation, not because GUIs are inherently mouse-bound; mistaking the current limitations of a tool category for its essence is a common fallacy. Similarly, the culture of endless configuration is part of why desktop Linux hasn&amp;rsquo;t gone mainstream: shipping sensible defaults is the toolmaker&amp;rsquo;s responsibility and a sign of respect for the user&amp;rsquo;s time. A steep learning curve is a cost, not a badge of honor. His takeaway: use whatever tool you like, as long as it disappears from your conscious awareness while you work.&lt;/p&gt;
&lt;h2 id="mysteries-of-telegram-dc"&gt;&lt;a href="https://dev.moe/en/3025" rel="noopener noreferrer"&gt;Mysteries of Telegram DC&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coxxs investigates Telegram&amp;rsquo;s five data centers (DC1–DC5): DC1 and DC3 in Miami, DC2 and DC4 in Amsterdam, and DC5 in Singapore. Every account is assigned to a home DC upon registration based on phone number prefix, never changes with travel or number changes, and cannot be chosen manually. A popular statistics bot once reported zero users in DC2 and DC3, sparking rumors that they were merely auxiliary or slave DCs. Testing all three common DC-detection methods on a fresh DC2 account—calling &lt;code&gt;auth.sendCode&lt;/code&gt; over MTProto to read the &lt;code&gt;PHONE_MIGRATE_2&lt;/code&gt; error, inspecting the &lt;code&gt;dc_id&lt;/code&gt; field in profile photo metadata, and parsing Web CDN domains—reveals the culprit. The third method fails because DC2 and DC3 &amp;ldquo;borrow&amp;rdquo; the Web CDN domains of co-located DC4 and DC1, causing every DC2 user to be misclassified as DC4—the exact bug in that statistics bot.&lt;/p&gt;
&lt;p&gt;The investigation concludes that DC1, DC2, DC4, and DC5 are actively assigned by phone country code at sign-up (for instance, Germany&amp;rsquo;s +49 maps to DC2) and all host large user populations. DC3, by contrast, is alive but practically empty: the author found only two DC3 accounts in the wild, and their older profile photos on DC3 alongside newer ones on DC1 suggest accounts were migrated from DC3 to DC1 around 2020. Probing over 10,000 phone numbers worldwide via the login flow confirmed that DC3 no longer accepts new registrations. The post includes a country-code-to-DC lookup table, while noting that many conclusions remain informed speculation since Telegram&amp;rsquo;s server code is closed-source.&lt;/p&gt;
&lt;h2 id="how-i-use-htmx-with-go"&gt;&lt;a href="https://www.alexedwards.net/blog/how-i-use-htmx-with-go" rel="noopener noreferrer"&gt;How I use HTMX with Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards walks through how he pairs HTMX with Go to add snappy, app-like interactivity with minimal JavaScript while keeping the consistency and safety of server-side HTML rendering via &lt;code&gt;html/template&lt;/code&gt;, illustrated through a small app that filters a user list in real time. The template directory is organized into &lt;code&gt;base.tmpl&lt;/code&gt; for the shared layout, &lt;code&gt;pages/&lt;/code&gt; for individual page content, and &lt;code&gt;partials/&lt;/code&gt; for reusable HTML fragments, all embedded into the binary alongside static assets via &lt;code&gt;//go:embed&lt;/code&gt;. At the heart of the setup is an &lt;code&gt;htmlRenderer&lt;/code&gt; type: it parses the shared templates (base and all partials) once at startup, and its &lt;code&gt;render()&lt;/code&gt; method clones that template set, adds the specific page template, and executes the named template block. By extracting the table rows into a named &lt;code&gt;users:rows&lt;/code&gt; template block, the exact same template file can render either a full HTML page or just the partial fragment for HTMX to swap in.&lt;/p&gt;
&lt;p&gt;The server detects HTMX requests via the &lt;code&gt;HX-Request: true&lt;/code&gt; header and always sets &lt;code&gt;Vary: HX-Request&lt;/code&gt; so intermediate caches don&amp;rsquo;t serve fragments as full pages. To keep the browser&amp;rsquo;s back button working properly, &lt;code&gt;historyRestoreAsHxRequest&lt;/code&gt; must be set to &lt;code&gt;false&lt;/code&gt;; otherwise, navigating back fetches a bare HTML fragment instead of a full page. Redirects can&amp;rsquo;t use standard &lt;code&gt;3xx&lt;/code&gt; responses because &lt;code&gt;fetch()&lt;/code&gt; follows them transparently before HTMX can intervene; instead, the server returns a &lt;code&gt;2xx&lt;/code&gt; status with an &lt;code&gt;HX-Redirect&lt;/code&gt; header for HTMX requests while keeping standard &lt;code&gt;3xx&lt;/code&gt; redirects for normal requests. Finally, configuring &lt;code&gt;responseHandling&lt;/code&gt; lets &lt;code&gt;4xx&lt;/code&gt;/&lt;code&gt;5xx&lt;/code&gt; error pages replace the full document while still allowing &lt;code&gt;422&lt;/code&gt; validation errors to swap into their target form container.&lt;/p&gt;
&lt;h2 id="quadrupling-code-performance-with-a"&gt;&lt;a href="https://purplesyringa.moe/blog/quadrupling-code-performance-with-a-useless-if/" rel="noopener noreferrer"&gt;Quadrupling code performance with a &amp;ldquo;useless&amp;rdquo; if&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;purplesyringa recounts optimizing a specialized string compressor whose hot loop for backtracking the optimal encoding path consisted of a single assignment, &lt;code&gt;j = next_j[i][j]&lt;/code&gt;, compiling down to a single &lt;code&gt;mov&lt;/code&gt; instruction that looked impossible to speed up. The catch is that modern CPUs rely on instruction-level parallelism to execute multiple instructions across loop iterations simultaneously, but they cannot overlap instructions that have data dependencies on one another. Because each iteration needed the &lt;code&gt;j&lt;/code&gt; produced by the previous iteration, execution was bottlenecked by memory latency rather than throughput. Noticing that with small block counts &lt;code&gt;next_j[i][j]&lt;/code&gt; usually equals &lt;code&gt;j&lt;/code&gt; itself, the author exploited branch prediction by wrapping the assignment in &lt;code&gt;if (j != next_j[i][j])&lt;/code&gt;. When the CPU predicts the branch is not taken, the cross-iteration dependency vanishes and speculative execution races ahead; on the rare occasion &lt;code&gt;j&lt;/code&gt; actually changes, branch misprediction recovery flushes the speculative work and resumes with the updated value.&lt;/p&gt;
&lt;p&gt;The hurdle was getting the compiler to emit the branch at all, since &lt;code&gt;if (j != x) j = x;&lt;/code&gt; is a dead-code no-op that optimizers immediately strip out. The author had to cast through a &lt;code&gt;volatile&lt;/code&gt; pointer to make the condition and assignment appear independent to the compiler; readers later pointed out that &lt;code&gt;[[unlikely]]&lt;/code&gt; or &lt;code&gt;__builtin_expect&lt;/code&gt; achieves a similar effect in LLVM, though &lt;code&gt;volatile&lt;/code&gt; produced tighter assembly and worked in GCC as well. The result was a 4x speedup on synthetic benchmarks (dropping from 320 to 80 microseconds) and roughly a 2x speedup in real-world workloads.&lt;/p&gt;
&lt;h2 id="reverse-engineering-chatgpt-web-how-openai-built-for-a-billion-users"&gt;&lt;a href="https://performance.dev/chatgpt" rel="noopener noreferrer"&gt;Reverse Engineering ChatGPT Web: How OpenAI Built for a Billion Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky reverse-engineers the frontend web architecture of ChatGPT, which serves roughly a billion users. What stands out first is how &amp;ldquo;boring&amp;rdquo; the stack is: React 19 with React Router 7, TanStack Query, Tailwind CSS, and Radix UI, with almost no bespoke framework magic. Launched in November 2022 on Next.js, the app migrated to Remix in 2024 and followed Remix&amp;rsquo;s merger into React Router 7. To serve users quickly on every device, the site uses streaming server-side rendering with Suspense boundaries: the logged-out HTML document weighs just 84 KB compressed with a 50–65 ms TTFB, and 556 feature gates, 144 dynamic configs, and 192 experiments are pre-evaluated on the server and embedded straight into the initial payload. It skips custom web fonts in favor of system fonts, splits CSS by feature, and orchestrates its 160 content-hashed startup chunks around a single north-star question: can the user type into the composer yet?—complete with a dedicated &lt;code&gt;deferStartupImportsUntilComposerTTFI&lt;/code&gt; flag.&lt;/p&gt;
&lt;p&gt;The heavy engineering is concentrated where users spend their time: the prompt composer is a ProseMirror editor, code blocks use CodeMirror, and math rendering uses KaTeX paired with a hidden MathML tree for screen readers. Under the hood, Cloudflare proof-of-work challenges and OpenAI&amp;rsquo;s Sentinel anti-abuse system run silently at page load, while logged-out visitors still receive real anonymous identifiers to enforce rate limits without forcing a login wall. Above all, the team instruments time-to-interactive for every user: if you can&amp;rsquo;t measure it, you can&amp;rsquo;t improve it.&lt;/p&gt;
&lt;h2 id="broker-visible-vs-client-local-parallelism"&gt;&lt;a href="https://jack-vanlightly.com/blog/2026/6/3/broker-visible-vs-client-local-parallelism" rel="noopener noreferrer"&gt;Broker-Visible vs Client-Local Parallelism&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a side note to his series on Kafka Share Groups, Jack Vanlightly reminds readers that share groups were designed to bring queue semantics to a log, not primarily to scale out consumption parallelism. The deeper architectural question is where the unit of parallelism lives. If the consumer instance itself is the unit of parallelism, every unit is visible to the broker as protocol interactions, state to track, and one or more TCP connections. If parallelism happens inside the client application—via virtual threads, async tasks, or OS threads—the broker is completely oblivious to it, requiring far fewer consumers, connections, and broker-side state. This trade-off applies across all messaging systems, not just Kafka.&lt;/p&gt;
&lt;p&gt;To size parallelism, Vanlightly uses Little&amp;rsquo;s Law: required concurrency equals message arrival rate multiplied by average processing duration. Processing 60,000 messages per second when each message takes one second requires 60,000 messages in flight at once; if each unit is a single-threaded consumer, you need 60,000 consumers, and if processing takes ten seconds, that balloons to 600,000 consumers and over a million TCP connections. If the workload is mostly I/O-bound and each client instance can process 1,000 messages concurrently on virtual threads, you only need 60 consumers. Managing virtual threads in user space is orders of magnitude cheaper than managing TCP connections and broker metadata per concurrency unit; the trade-off is higher client-side complexity, though modern client libraries increasingly handle that plumbing for you.&lt;/p&gt;
&lt;h2 id="work-loudly"&gt;&lt;a href="https://ben.balter.com/2026/07/14/work-loudly/" rel="noopener noreferrer"&gt;Work Loudly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Balter observes that in a physical office, a baseline level of visibility comes for free: coworkers see you sketching at a whiteboard or helping a teammate debug over coffee. In remote work, that ambient signal drops to zero; your work doesn&amp;rsquo;t become less valuable, just less visible—to the point where even a supportive manager may struggle to articulate what you accomplished come performance review time. Writing a summary after the fact doesn&amp;rsquo;t fix it either, because the most valuable part—your reasoning, trade-offs, and dead ends—has already vanished. The solution is to &amp;ldquo;work loudly&amp;rdquo;: make your work visible while it is happening by opening an issue before writing code, writing PR descriptions that explain the &lt;em&gt;why&lt;/em&gt; behind your approach, sharing 40%-done drafts, and asking questions in public channels rather than DMs. If it only exists in your head or in private messages, it isn&amp;rsquo;t loud enough.&lt;/p&gt;
&lt;p&gt;Balter compares working loudly to wearing a bear bell on a hike: you don&amp;rsquo;t ring it to show off, you ring it so nobody gets startled—because stakeholders who discover a decision only after it ships tend to react defensively. Early visibility also invites teammates to catch bugs early, point out existing solutions, and rally around hard problems; for managers, it enables evaluating people by their actual artifacts rather than performative online presence. The ultimate litmus test: could your manager write your performance review solely from the public trail of artifacts you left behind?&lt;/p&gt;
&lt;h2 id="building-service-topology-at-scale-architecture-challenges-and-lessons-learned"&gt;&lt;a href="https://netflixtechblog.com/building-service-topology-at-scale-architecture-challenges-and-lessons-learned-f4b792f3f0d8" rel="noopener noreferrer"&gt;Building Service Topology at Scale: Architecture, Challenges, and Lessons Learned&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team shares how they built Service Topology, a near-real-time dependency map across Netflix microservices designed to speed up debugging and blast-radius analysis during incidents. They chose stream processing over batch because an hour-old dependency map at 3 a.m. is &amp;ldquo;archaeology,&amp;rdquo; using reactive streams backpressure so that whenever downstream stages slow down, the signal propagates all the way back to the Kafka consumer, buffering data safely in Kafka rather than dropping it. Because raw network flow logs only capture individual hops like App A → Load Balancer → App B, the pipeline runs in three stages: stage one filters and aggregates flows over five-minute windows; stage two repartitions events so hops traversing the same intermediate component land on the same node and stitch together into a direct App A → App B edge; and stage three enriches edges with metadata and writes them to a graph database. Stages communicate over Server-Sent Events instead of CPU-heavy gRPC, using consistent hashing to rebalance automatically as cluster nodes scale.&lt;/p&gt;
&lt;p&gt;The most valuable lessons came from production pain: Kafka consumers falling hours behind, hot nodes receiving 100x the traffic of peers, and garbage collection burning more CPU than business logic—forcing the team to adopt mutable data structures on the hot path against standard Scala idioms. Their takeaway: scale changes everything, fixing one bottleneck immediately exposes the next, and &amp;ldquo;best practices&amp;rdquo; are only a starting point.&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_!lpxK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff9fb99a2-ec71-476d-a9cb-6c1a43339d90_2484x3002.png" alt="MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LZtJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6456348c-5d92-4524-8dd6-d75b4dc7feaf_1280x1547.png" alt="LLM vs RAG vs Agent evals"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ULeT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe81b4572-820e-4790-8861-8efe14f38700_2252x2752.png" alt="How Distributed Tracing Works at the High Level?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6UyI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9f8ea7bf-2170-4466-92f3-edd7eab11de4_3000x3900.png" alt="The Life of a Redis Query"&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 #109</title><link>https://miti99.com/en/post/2026/06/06/</link><pubDate>Sat, 06 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #109.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-history-of-ides-at-google"&gt;&lt;a href="https://laurent.le-brun.eu/blog/a-history-of-ides-at-google" rel="noopener noreferrer"&gt;A History of IDEs at Google&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurent Le Brun, who spent 12 years working on developer tooling at Google, recounts the journey from a fragmented ecosystem of editors to a single IDE used by nearly the entire company. Back in 2011, when someone asked whether Google should standardize on one IDE, the near-unanimous answer was &amp;ldquo;no&amp;rdquo; — Jeff Dean argued that forcing a whole team onto a single editor was a recipe for misery. The price of that freedom was that every useful integration — Bazel, code search, formatters — had to be rebuilt for every editor. Around 2013, Cider launched as a web-based editor initially meant for quick doc edits, but thanks to a backend capable of indexing Google&amp;rsquo;s massive monorepo, it gradually won over Go and then Java developers.&lt;/p&gt;
&lt;p&gt;In 2020, the team decided to replace Cider&amp;rsquo;s custom frontend with the VS Code core while keeping Google&amp;rsquo;s proprietary backend; Cider V opened to 5,000 engineers in 2021 and accounted for roughly 80% of main-repo development by 2023. Once most engineers shared a single platform, teams had strong incentives to build internal extensions — roughly 100 within two years — and AI features like code completion and automated review-comment resolution could be rolled out company-wide far faster. The takeaway: standardizing tooling creates massive leverage, even if the up-front investment is high and not every company can pull it off.&lt;/p&gt;
&lt;h2 id="finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks"&gt;&lt;a href="https://medium.com/pinterest-engineering/finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks-ea4722e552eb" rel="noopener noreferrer"&gt;Finding zombies in our systems: A real-world story of CPU bottlenecks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In early 2025, Pinterest&amp;rsquo;s Ray ML training jobs kept crashing due to flaky network connections, and it took the Kubernetes platform team over three months to track down the culprit. The first clue was that the EC2 ENA network driver reset itself whenever its transmit queue stalled for more than 5 seconds, a classic symptom of CPU starvation; weirdly, the resets only happened in a single availability zone even though cluster configs looked identical, and rebooting nodes only bought about a week of relief. On 96-vCPU GPU instances, aggregate &lt;code&gt;perf&lt;/code&gt; profiles looked completely normal; only per-core, per-second &lt;code&gt;mpstat&lt;/code&gt; monitoring revealed a single CPU core pinned at 100% system time for several seconds right when each reset occurred. The team set up automated 2-minute &lt;code&gt;perf record&lt;/code&gt; captures and used Netflix&amp;rsquo;s Flamescope to scrub to the exact second of the spike.&lt;/p&gt;
&lt;p&gt;The culprit: right before every reset, &lt;code&gt;kubelet&lt;/code&gt; spiked to ~6.5% total CPU (normally under 1%), spending nearly all of that time inside the kernel&amp;rsquo;s &lt;code&gt;mem_cgroup_nr_lru_pages&lt;/code&gt; function. The kernel was tracking nearly 70,000 memory cgroups even though only 240 were actually active — &amp;ldquo;zombie memcgs&amp;rdquo; — and walking that list pinned a single core long enough to starve the network driver thread sharing it. The root cause traced back to the AWS Deep Learning AMI (Ubuntu 20.04) base image, which shipped with the Amazon ECS agent enabled by default; unable to join an ECS cluster, the agent crashed in a tight loop, leaking a zombie cgroup on every restart. The fix was simple: disable the ECS agent systemd unit and reboot the fleet. As for why the &amp;ldquo;healthy&amp;rdquo; availability zone never broke? Another bug there prevented the ECS agent from ever starting in the first place.&lt;/p&gt;
&lt;h2 id="programming-still-sucks"&gt;&lt;a href="https://www.stvn.sh/writing/programming-still-sucks-fqffhyp" rel="noopener noreferrer"&gt;Programming Still Sucks.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steven Langbroek wrote this essay to answer the familiar question &amp;ldquo;Will AI take programmers&amp;rsquo; jobs?&amp;rdquo;, and his answer is no: the real culprit is greed, merely dressed up in a new coat called &amp;ldquo;automation.&amp;rdquo; Starting from a casual question at a birthday party, he paints software engineering as a burning ship: no map, no crew, sails mounted backward, useless navigation instruments, and a predecessor who abandoned ship after leaving behind half-baked &amp;ldquo;initiatives.&amp;rdquo; Layoffs, he argues, are signed off by people who know the consequences full well but bow to spreadsheets and quarterly targets, telling themselves they&amp;rsquo;ll &amp;ldquo;fix it later&amp;rdquo; — a &amp;ldquo;later&amp;rdquo; that never comes.&lt;/p&gt;
&lt;p&gt;The sharpest pain point is what happens to junior developers. A junior&amp;rsquo;s value isn&amp;rsquo;t the code they write today, but the fact that one day they become the senior who understands every dark corner of the system; eliminate apprenticeships to optimize short-term output, and a few years later there is nobody left to take the helm. The emotional heart of the piece is Sara, an older infrastructure specialist who inherited her knowledge from Ben and keeps the company alive via a mysterious cron job nobody else understands. When Sara retires, the company will desperately need a replacement after having dismantled the very pipeline that could have trained one. The disaster, Langbroek concludes, isn&amp;rsquo;t technological — it&amp;rsquo;s organizations actively sabotaging themselves.&lt;/p&gt;
&lt;h2 id="how-container-filesystem-works-building-a-docker-like-container-from-scratch"&gt;&lt;a href="https://labs.iximiuz.com/tutorials/container-filesystem-from-scratch" rel="noopener noreferrer"&gt;How Container Filesystem Works: Building a Docker-like Container From Scratch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ivan Velichko&amp;rsquo;s tutorial on iximiuz Labs builds a container by hand using nothing but standard Linux tools like &lt;code&gt;unshare&lt;/code&gt;, &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;pivot_root&lt;/code&gt; — not to replace Docker, but to give readers a clear mental model of what happens under the hood of &lt;code&gt;docker run&lt;/code&gt;. The foundation is the mount namespace: it isolates the mount table — the list of mounted filesystems visible to a process — rather than the underlying physical filesystem itself, something you can verify with &lt;code&gt;findmnt&lt;/code&gt; across two namespaces. Velichko emphasizes mount propagation across &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;shared&lt;/code&gt;, and &lt;code&gt;slave&lt;/code&gt; modes: if ignored, mounts created inside a container can leak out to the host, and &lt;code&gt;pivot_root&lt;/code&gt; — the safer alternative to &lt;code&gt;chroot&lt;/code&gt; — requires that the parent mount not be marked &lt;code&gt;shared&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough mirrors what &lt;code&gt;runc&lt;/code&gt; actually does: prepare a rootfs directory from an Alpine image; create mount, pid, cgroup, uts, and net namespaces; mount the &lt;code&gt;/proc&lt;/code&gt;, &lt;code&gt;/dev&lt;/code&gt;, and &lt;code&gt;/sys&lt;/code&gt; pseudo-filesystems with appropriate restrictions; bind-mount container-specific &lt;code&gt;/etc/hosts&lt;/code&gt;, &lt;code&gt;/etc/hostname&lt;/code&gt;, and &lt;code&gt;/etc/resolv.conf&lt;/code&gt; files; swap the root filesystem via &lt;code&gt;pivot_root&lt;/code&gt;; and harden the container by remounting sensitive &lt;code&gt;/proc&lt;/code&gt; paths read-only and masking others with &lt;code&gt;tmpfs&lt;/code&gt; or &lt;code&gt;/dev/null&lt;/code&gt;. On the security side, an untrusted rootfs can contain symlinks pointing outside the container, so production runtimes use &lt;code&gt;openat2()&lt;/code&gt; with &lt;code&gt;RESOLVE_NO_SYMLINKS&lt;/code&gt; and operate via file descriptors to prevent TOCTTOU race conditions. Finally, bind mounts are the exact same mechanism powering Docker&amp;rsquo;s &lt;code&gt;-v&lt;/code&gt; flag when sharing host volumes with a container.&lt;/p&gt;
&lt;h2 id="using-ai-to-write-better-code-more-slowly"&gt;&lt;a href="https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/" rel="noopener noreferrer"&gt;Using AI to write better code more slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amid the &amp;ldquo;vibe coding&amp;rdquo; frenzy, Nolan Lawson asks the opposite question: if so many people are using LLMs to crank out sloppy code as fast as possible, can we use the exact same tools to write better code more slowly? His answer is yes. His workflow centers on multi-model code review: having Claude, Codex, and Cursor Bugbot independently review a pull request, rank issues as critical, high, medium, or low, and then manually synthesizing and verifying their findings to filter out false positives. Using distinct models and wiping context between rounds reduces the chance that all of them hallucinate the same nonexistent bug. He then has the agent fix the critical and high issues, repeats the review loop until none remain, weighs whether the minor issues are worth addressing, and throws out the entire pull request if the process exposes a fundamental architectural flaw.&lt;/p&gt;
&lt;p&gt;Interestingly, his overall delivery speed hasn&amp;rsquo;t increased at all: the review process routinely uncovers pre-existing bugs in surrounding code, turning every new feature into a side quest of writing tests and cleaning up legacy debt. For anyone letting agents open hundred-line pull requests they don&amp;rsquo;t fully grasp, Lawson advises slowing down: ask the agent how the code works and where it could break, have it generate documentation with Mermaid diagrams, or use Matt Pocock&amp;rsquo;s &lt;code&gt;/grill-me&lt;/code&gt; skill until you understand every detail. This approach burns more tokens, but pays off in a deep understanding of failure modes and a much healthier codebase.&lt;/p&gt;
&lt;h2 id="how-cockroachdb-built-vector-indexing-at-scale"&gt;&lt;a href="https://blog.bytebytego.com/p/how-cockroachdb-built-vector-indexing" rel="noopener noreferrer"&gt;How CockroachDB Built Vector Indexing at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo breaks down C-SPANN, the vector indexing algorithm CockroachDB designed in-house because no off-the-shelf approach fit a distributed transactional database. Vectors have no natural total ordering, rendering B-trees useless, so every vector index trades exactness for speed via approximate nearest neighbor (ANN) search. CockroachDB set six hard constraints: no central coordinator node, no reliance on massive in-memory structures, minimal network hops, shardable across nodes, no hot spots, and real-time incremental updates — ruling out both traditional HNSW and IVF. C-SPANN instead uses a wide, shallow hierarchical K-means tree: with a branching factor around 100, a million vectors need just three levels and ten billion vectors need five.&lt;/p&gt;
&lt;p&gt;The key architectural decision is storing each partition as ordinary key-value rows inside CockroachDB, allowing the index to automatically inherit range splitting, load balancing, replication, and multi-region placement without a separate infrastructure stack. To cut storage overhead, RaBitQ compresses 1,536-dimensional vectors from ~3 KB down to 200 bytes (a 94% reduction), then uses the full-precision vectors to rerank a small candidate set. For multi-tenancy, prefix columns like &lt;code&gt;(user_id, embedding)&lt;/code&gt; create isolated per-tenant trees, combining with &lt;code&gt;REGIONAL BY ROW&lt;/code&gt; to satisfy data-residency rules. The trade-offs are stated plainly: C-SPANN trails dedicated vector databases on raw tail latency and currently only supports Euclidean distance in preview, but it is a great fit for workloads where vectors need to live alongside transactional data.&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 #58</title><link>https://miti99.com/en/post/2025/10/01/</link><pubDate>Wed, 01 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/01/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Today I tried hooking up &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; to the &lt;code&gt;openai/gpt-oss-120b&lt;/code&gt; model on &lt;a href="https://build.nvidia.com/" rel="noopener noreferrer"&gt;NVIDIA NIM&lt;/a&gt;, but it hit some error and produced no output at all. So we&amp;rsquo;re back to &lt;code&gt;qwen3-coder&lt;/code&gt; running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #58.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-software-engineers-make-productive-decisions-without-slowing-the-team-down"&gt;&lt;a href="https://strategizeyourcareer.com/p/how-software-engineers-make-productive-decisions" rel="noopener noreferrer"&gt;How Software Engineers Make Productive Decisions (without slowing the team down)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many development teams slow down simply because they treat every decision as if it were irreversible. Author Fran Soto proposes clearly distinguishing between two types: &amp;ldquo;two-way door&amp;rdquo; decisions (easy to reverse, such as adding an unused field to an API response, gating a change behind a feature flag, or swapping out an internal library) and &amp;ldquo;one-way door&amp;rdquo; decisions (hard or impossible to reverse, such as data migrations, schema changes, security changes, or customer-visible changes that risk data loss). To classify a decision quickly, the article offers three questions: if you&amp;rsquo;re wrong, is the impact unnoticeable, an annoyance, or a disaster; how hard is it to roll back, for instance can you revert within ten minutes using existing alerting; and can you limit the blast radius with a canary, feature flag, or phased rollout?&lt;/p&gt;
&lt;p&gt;For reversible decisions, the author advises time-boxing research to 30–60 minutes and then acting, backed by guardrails: feature flags defaulting to off, small pull requests, tests covering both states, canary checks, solid alerting, and a ten-minute rollback playbook. Heavy caution should be reserved for decisions that are genuinely hard to undo. The core takeaway: when risk is low and the change is reversible, ship with guardrails—that&amp;rsquo;s how you move fast without being reckless.&lt;/p&gt;
&lt;h2 id="why-are-event-driven-systems-hard"&gt;&lt;a href="https://newsletter.scalablethread.com/p/why-event-driven-systems-are-hard" rel="noopener noreferrer"&gt;Why are Event-Driven Systems Hard?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Event-driven architecture decouples services and makes them easier to scale, but comes with five major challenges. First is event schema evolution: when one service adds or changes a field without coordination, downstream consumers can break; the fix is enforcing backward and forward compatibility rules alongside a schema registry acting as a central dictionary for event formats. Second is observability: because processing flows are split across independent services, seeing the full picture during debugging is difficult; the remedy is distributed tracing with a correlation ID—an identifier attached to the initial event and propagated through every processing step to reconstruct a request&amp;rsquo;s journey.&lt;/p&gt;
&lt;p&gt;Third is failure handling: at-least-once delivery prevents message loss when infrastructure hiccups, while a Dead-Letter Queue (DLQ) captures messages that repeatedly fail after a bounded number of retries, preventing infinite error loops and allowing later inspection. Fourth, at-least-once delivery itself means a service may receive the same message multiple times if it crashes before acknowledging completion, so consumers must be idempotent: recording processed event IDs and skipping duplicates (coordinated atomically with business state updates so there is no gap) to avoid bugs like charging a customer twice. Finally, eventual consistency: because data propagates asynchronously across services, both UI and business logic must tolerate systems being temporarily out of sync.&lt;/p&gt;
&lt;h2 id="dev-culture-is-dying-the-curious-developer-is-gone"&gt;&lt;a href="https://dayvster.com/blog/dev-culture-is-dying-the-curious-developer-is-gone/" rel="noopener noreferrer"&gt;Dev Culture Is Dying: The Curious Developer Is Gone&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that developer culture is shifting in a troubling direction. Foundational tools like VLC, Linux, Git, and Docker were born out of curiosity and a desire to solve problems, not for profit or clout. He recalls the 2000s, when programmers stayed up all night tinkering with new technology purely to learn, expecting neither commercial reward nor recognition. Today, attention has shifted to metrics like MRR, ARR, DAU, MAU, SEO rankings, and conversion rates, and many developers chase new frameworks out of pressure to look current rather than genuine interest. Intrinsic motivation has gradually given way to external validation.&lt;/p&gt;
&lt;p&gt;The post also points to an identity crisis: developers define themselves by their tools, becoming a &amp;ldquo;Next.js developer&amp;rdquo; or &amp;ldquo;Rust developer&amp;rdquo; instead of by the problems they solve. The author compares consumer software&amp;rsquo;s shift toward subscription models with creators losing ownership of their craft to corporations or growth metrics, asking whether developers still care about the software they build or only about revenue. The closing call to action is to go back to building curiosity-driven projects—even things that can&amp;rsquo;t be monetized—building for the joy of it and sharing them to inspire others.&lt;/p&gt;
&lt;h2 id="tool-calls-are-expensive-and-finite"&gt;&lt;a href="https://www.reillywood.com/blog/tool-calls-are-expensive-and-finite/" rel="noopener noreferrer"&gt;Tool Calls Are Expensive And Finite&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giving LLMs access to tools enables powerful agents, but Reilly Wood reminds us that a tool call is orders of magnitude more expensive than a normal function call in code, and the number of calls you can make is practically finite. Under the hood, a tool call is still text generation: the model emits structured text (JSON) specifying the tool name and arguments, the harness parses it, executes the real function, and appends the result into the conversation history as a new message before the model reasons further. Every call therefore burns output tokens to generate the invocation and consumes context window space because the result stays in history.&lt;/p&gt;
&lt;p&gt;The author illustrates this with the task of processing 1,000 user IDs via &lt;code&gt;get_user_info()&lt;/code&gt;: a programmer would simply write a loop, whereas an agent would have to make 1,000 individual tool calls and would likely exhaust its context window before finishing. The post suggests three remedies: design agents for tasks that don&amp;rsquo;t require many tool calls, build more flexible tools so each call accomplishes more work, or let the agent write and execute code itself—provided proper security sandboxing is in place.&lt;/p&gt;
&lt;h2 id="keeping-secrets-out-of-logs"&gt;&lt;a href="https://allan.reyes.sh/posts/keeping-secrets-out-of-logs/" rel="noopener noreferrer"&gt;Keeping Secrets Out of Logs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allan Reyes examines why secrets like passwords and tokens keep leaking into logs, stressing that there is no &amp;ldquo;silver bullet&amp;rdquo; that solves the problem completely—only a combination of &amp;ldquo;lead bullets,&amp;rdquo; imperfect defenses that complement one another. Six common causes are: forgetting to remove debug log statements; logging entire large objects such as config structs or HTTP responses; changing the global log level and exposing previously hidden details; secrets embedded in URLs; error monitoring tools capturing local variables; and users accidentally typing their password into the username field.&lt;/p&gt;
&lt;p&gt;Mitigations include funneling logs through a single pipeline; minimizing, redacting, encrypting, or hashing sensitive data; domain primitives that wrap secrets in dedicated types to prevent accidental logging; read-once objects that lock their value after the first read; log formatters that detect and scrub sensitive patterns; unit tests that fail when sensitive data appears; post-write secret scanners; log preprocessors before storage (such as Vector); static-analysis taint checking; and human training. The broader strategy combines laying a solid foundation, understanding data flows, guarding choke points, layering defenses, and preparing incident response and recovery plans for leaks. The author admits this work is never truly finished because new systems can always bypass existing safeguards.&lt;/p&gt;
&lt;h2 id="things-i-believe"&gt;&lt;a href="https://leerob.com/beliefs" rel="noopener noreferrer"&gt;Things I Believe&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson shares the beliefs that shape how he works. First, shipping fast beats a perfect strategy: speed is a superpower, small teams ship faster, and user adoption matters more than merely pushing code. Careers have no ceiling: persistence beats innate talent, steady daily improvements compound over time, and you should take initiative and be helpful. He values truth-seeking—confronting uncomfortable truths, holding strong opinions loosely, and listening to diverse perspectives.&lt;/p&gt;
&lt;p&gt;In his view, communication is the job: clear writing reflects clear thinking, everyone should hone their writing skills, and leaders must clarify ambiguity to prevent misaligned expectations. Leadership doesn&amp;rsquo;t require a title, because influence matters more than position; great leaders both do hands-on work and empower others. Work can also be a hobby when passion is paired with clear boundaries, rather than chasing a mythical &amp;ldquo;work–life balance.&amp;rdquo; Hiring should be uncompromising—only hire candidates who are a &amp;ldquo;hell yes&amp;rdquo; and prioritize growth potential. Finally, always assume good intent, lead with empathy, take criticism objectively, and remember that a working demo is more persuasive than a long memo.&lt;/p&gt;
&lt;h2 id="how-claude-code-is-built"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built" rel="noopener noreferrer"&gt;How Claude Code is Built&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code started as a prototype built by Boris Cherny in September 2024: using Claude to control a terminal via AppleScript, initially just to check what song was playing. Once the team saw the model exploring the filesystem on its own, they realized its product potential. Anthropic began using it internally in November 2024, and within five days half of its engineers were on board; although they considered keeping it internal as a competitive advantage, they released it publicly to advance AI safety research. The team chose TypeScript, React with the Ink framework, the Yoga layout engine, and Bun because these technologies are &amp;ldquo;on distribution&amp;rdquo;—things Claude is already great at—allowing roughly 90% of Claude Code&amp;rsquo;s codebase to be written by Claude Code itself.&lt;/p&gt;
&lt;p&gt;Architecturally, Claude Code is a thin shell around the model with minimal business logic, running directly on the user&amp;rsquo;s machine without virtualization. The most complex part is the permission system: the tool asks for user approval before irreversible actions, supporting one-time or persistent grants with multi-level configuration across project, user, and enterprise scopes. Prototyping speed is equally striking: when building the to-do list feature, the team tried around 20 different prototypes in just two days. Even as the engineering team doubled in size, completed pull requests per engineer rose by 67%—a metric that usually drops during rapid team growth.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e27232c-d4f1-4f4b-94fa-7318d39f6f3e_2360x2960.png" alt="How Java Works"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9bef6181-7eed-45a9-9c7e-abd6864cc62b_2360x2960.png" alt="How Gitflow Branching Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9ffab5bc-5857-4544-8e25-2dbf795e6f85_3000x3900.png" alt="The Life of a Redis Query"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1c2bd03d-66f2-4eb9-8293-7a1d49b9b9b6_2360x2920.png" alt="Cookies vs Sessions"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/26b55058-17ae-453f-8463-4d4e717e489b_2360x2920.png" alt="Access Control Clearly Explained"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/00912640-ad5f-4ec7-aefa-e5eecf67dab0_3000x3900.png" alt="How Git Reset Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/43b73739-a975-42af-999d-8676b1605ed2_3000x3900.png" alt="Apache Kafka Explained (At the high level)"&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 #57</title><link>https://miti99.com/en/post/2025/09/30/</link><pubDate>Tue, 30 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/30/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was created using &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; with the &lt;code&gt;qwen3-coder&lt;/code&gt; model running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #57.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="agentic-ai-has-changed-my-career"&gt;&lt;a href="https://medium.com/@elliotgraebert/agentic-ai-has-changed-my-career-2c6e3dd29708" rel="noopener noreferrer"&gt;Agentic AI has changed my career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elliot Graebert, a director of engineering at Skydio, confesses that for most of his career he barely wrote code because he moved into management too early. About four months ago, he started &amp;ldquo;vibe coding&amp;rdquo; directly in the multi-million-line monorepo that powers the company&amp;rsquo;s drone fleet, and he is now among its top five contributors, sometimes submitting up to ten pull requests per hour. He distinguishes between two approaches: vibe coding is like pair programming with AI (using tools like Windsurf or Cursor), where the loop is measured in seconds and requires constant attention; agentic AI is like delegating to an eager intern, where the loop is measured in minutes and you only check back once the task is done. His journey went from 0.5x speed (fixing small UI bugs in a single editor), to 1.5x by running three environments in parallel with Gemini, Claude, and GPT to &amp;ldquo;swarm&amp;rdquo; a tough bug, and then to 3x thanks to context files (Windsurf Rules) documenting code conventions and test commands, refined iteratively whenever the AI got stuck.&lt;/p&gt;
&lt;p&gt;The jump to 10x came from Coder Tasks—automated environments that go from prompt to pull request—combined with two MCPs: GitHub to read issues and open pull requests (triggering CI and Vercel previews), and Playwright so the AI can launch a browser, reproduce a bug, fix it, and verify the fix itself. The core lesson is that agentic AI succeeds when it has a feedback loop that does not require a human in the middle; at that point, he can run dozens of tasks at once, such as completing an entire data-filter component migration in a single day. He also stresses that AI does not magically solve everything—you have to invest in tooling—and the most exciting result is that designers, product managers, and even the flight test team can now contribute directly to the product.&lt;/p&gt;
&lt;h2 id="the-evolution-of-garbage-collectors-from-javas-cms-to-zgc-and-a-jvm-vs-go-vs-rust-latency-shootout"&gt;&lt;del&gt;&lt;a href="https://codemia.io/blog/path/The-Evolution-of-Garbage-Collectors-From-Javas-CMS-to-ZGC-and-a-JVM-vs-Go-vs-Rust-Latency-Shootout" rel="noopener noreferrer"&gt;The Evolution Of Garbage Collectors From Javas CMS To ZGC And A JVM Vs Go Vs Rust Latency Shootout&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Memory management is a critical topic in programming, especially in languages like Java, Go, and Rust. This article explores the evolution of garbage collectors (GCs) from Java&amp;rsquo;s traditional Concurrent Mark-Sweep (CMS) to the modern Z Garbage Collector (ZGC).&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;ZGC is a major leap forward in minimizing application pause times, aiming to keep pauses under 10ms regardless of heap size. This makes a dramatic performance difference compared to earlier-generation GCs like CMS.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The article also compares latency performance across platforms:&lt;/del&gt;
&lt;del&gt;- JVM (with ZGC): Significantly reduced pause times thanks to improvements in GC design&lt;/del&gt;
&lt;del&gt;- Go: Efficient low-latency GC powered by a concurrent algorithm and tri-color marking&lt;/del&gt;
&lt;del&gt;- Rust: Avoids GC entirely through its ownership model, delivering predictable performance without GC overhead&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- ZGC keeps application pause times under 10ms&lt;/del&gt;
&lt;del&gt;- Go uses an efficient marking algorithm to keep latency low&lt;/del&gt;
&lt;del&gt;- Rust eliminates the need for GC altogether through its ownership model&lt;/del&gt;
&lt;del&gt;- Language choice significantly impacts performance and user experience&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="new-in-java25-generational-shenandoah-gc-is-no-longer-experimental"&gt;&lt;del&gt;&lt;a href="https://theperfparlor.com/2025/09/14/new-in-java25-generational-shenandoah-gc-is-no-longer-experimental/" rel="noopener noreferrer"&gt;New in Java25: Generational Shenandoah GC is no longer experimental&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Java 25 officially graduates Generational Shenandoah from experimental status, making it ready for production use. Shenandoah is a low-pause-time garbage collector introduced in Java 12 that runs mostly concurrently with the application. Its generational mode, introduced experimentally in Java 24, separates heap memory into young and old generations. Because most objects die young, this separation spares the collector from repeatedly scanning long-lived objects unnecessarily, improving performance and reducing memory footprint.&lt;/p&gt;
&lt;p&gt;In Java 25, the feature has been stabilized with numerous bug fixes, lower garbage collection overhead, more efficient memory region management, and improved tooling and logging. According to the article, these improvements make Generational Shenandoah mature enough for real-world applications, and you no longer need the &lt;code&gt;-XX:+UnlockExperimentalVMOptions&lt;/code&gt; flag to enable it. It marks an important milestone in Java&amp;rsquo;s ongoing garbage collection optimization journey.&lt;/p&gt;
&lt;h2 id="if-all-the-world-were-a-monorepo"&gt;&lt;a href="https://jtibs.substack.com/p/if-all-the-world-were-a-monorepo?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;If all the world were a monorepo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julie Tibshirani shares her experience with CRAN, the central package repository for R. Before accepting an update, CRAN not only checks the submitted package itself, but also runs checks across every package that depends on it. When she released &lt;code&gt;grf&lt;/code&gt; 2.0 with a breaking API change, CRAN blocked publication until the downstream package &lt;code&gt;policytree&lt;/code&gt; was updated. At first she found this unreasonable: why should she be responsible for someone else&amp;rsquo;s code? Over time, however, she realized this isn&amp;rsquo;t merely a different point on the speed-versus-stability trade-off spectrum, but a form of &amp;ldquo;radical empathy&amp;rdquo; in software maintenance: users&amp;rsquo; code is the library author&amp;rsquo;s responsibility too, much like the mindset inside a monorepo.&lt;/p&gt;
&lt;p&gt;She contrasts this with her time working on Elasticsearch, where leaving individual projects to upgrade on their own left thousands of projects stuck on old versions years later. Watching large-scale migrations at Databricks, she saw that when engineering teams took end-to-end ownership—including fixing downstream dependent code—completion rates rose dramatically. Although R packages tolerate less consistent APIs than ecosystems like npm or PyPI, users enjoy nearly painless dependency upgrades, offering a lesson worth pondering for other ecosystems.&lt;/p&gt;
&lt;h2 id="9-software-architecture-patterns-for-distributed-systems"&gt;&lt;a href="https://dev.to/somadevtoo/9-software-architecture-patterns-for-distributed-systems-2o86?=&amp;amp;aid=recZm2jVus1yqUHWw" rel="noopener noreferrer"&gt;9 Software Architecture Patterns for Distributed Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article introduces nine common architectural patterns in distributed systems that are useful both in real-world design and in system design interviews. The communication patterns include: Peer-to-Peer, where nodes exchange data directly without a central coordinator, used in file sharing and blockchains; API Gateway, a unified entry point for backend services that handles security and load balancing in microservices architectures; Pub-Sub, which decouples message senders and receivers through a broker, well suited for real-time messaging, event-driven systems, and IoT; and Request-Response, where a client sends a request and receives a corresponding response from a server, ubiquitous in REST APIs and web applications (though the pattern does not strictly require synchronous execution).&lt;/p&gt;
&lt;p&gt;The data management and processing patterns include: Event Sourcing, which stores state as an immutable sequence of events for easy auditing and replay, commonly seen in financial systems; ETL (extract, transform, load) to consolidate data from multiple sources into a data warehouse for analytics and data migration; Batching, which groups data into batches to process all at once for higher efficiency; Streaming Processing, which processes continuous data streams in real time for finance, IoT, or cybersecurity; and Orchestration, which uses a central coordinator to manage workflows across services. Understanding the strengths and trade-offs of each pattern helps you build reliable, scalable, and maintainable systems as requirements evolve.&lt;/p&gt;
&lt;h2 id="sort-lines-in-source-code"&gt;&lt;a href="https://testing.googleblog.com/2025/09/sort-lines-in-source-code.html?=&amp;amp;aid=recV8wgDMqTb7Hwko" rel="noopener noreferrer"&gt;Sort Lines in Source Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kyle Freeman&amp;rsquo;s post on the Google Testing Blog, adapted from a &amp;ldquo;Tech on the Toilet&amp;rdquo; episode, opens with a familiar scenario: you enable two-player mode on the last line of a config file, but when you run the game, the feature doesn&amp;rsquo;t show up. The culprit is that the &lt;code&gt;enable_two_players&lt;/code&gt; flag was declared twice with different values—easy to miss when lines are in random order. Simply sorting the lines places the duplicates right next to each other, exposing the bug immediately. The main takeaway is that sorted lists and source lines are easier to read, easier to maintain, and help prevent bugs.&lt;/p&gt;
&lt;p&gt;To automate this, the author introduces &lt;code&gt;keep-sorted&lt;/code&gt; (&lt;a href="http://github.com/google/keep-sorted" rel="noopener noreferrer"&gt;github.com/google/keep-sorted&lt;/a&gt;): you wrap the lines to sort with &lt;code&gt;keep-sorted start&lt;/code&gt; and &lt;code&gt;keep-sorted end&lt;/code&gt; comments, run &lt;code&gt;keep-sorted [file1] [file2] ...&lt;/code&gt;, and optionally hook it into pre-commit so it runs automatically on every commit. The tool also supports case-insensitive sorting, numeric sorting, prefix order, and regular expressions (for example, using &lt;code&gt;by_regex&lt;/code&gt; to sort a Go slice by its end-of-line comments). One important caveat: before sorting, make sure the original order doesn&amp;rsquo;t carry semantic meaning, such as dependency load order.&lt;/p&gt;
&lt;h2 id="rating-26-years-of-java-changes"&gt;&lt;a href="https://neilmadden.blog/2025/09/12/rating-26-years-of-java-changes/" rel="noopener noreferrer"&gt;Rating 26 years of Java changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neil Madden looks back on 26 years of working with Java, from Java 1.1.8 in 1999 to Java 25, and gives subjective ratings to language and core library changes (skipping UI, graphics, the JVM, and GC). Top marks go to &lt;code&gt;java.util.concurrent&lt;/code&gt; (10/10), so well designed that people use it in place of the original collection classes; try-with-resources (10/10), which made exception handling far safer; Records (10/10), which he says Java &amp;ldquo;should have had all along&amp;rdquo;; UTF-8 by default (10/10), fixing thousands of character-encoding bugs at a stroke; along with Generics (8/10) and &lt;code&gt;var&lt;/code&gt; type inference (9/10). The Collections Framework gets just 4/10, lambdas 4/10 because of ugly stack traces, and switch expressions 6/10 as a pleasant minor improvement.&lt;/p&gt;
&lt;p&gt;On the flip side, NIO gets 0/10 for its convoluted API, Streams get 1/10 and are called one of modern Java&amp;rsquo;s biggest mistakes due to complexity, overpromised parallelism, and easy resource leaks, while the cryptography APIs get 1/10 for being easy to misuse. Worst of all is Modules at -10/10: massive disruption for very little practical benefit. Virtual threads are deemed promising but not yet battle-tested enough to score. The post also touches on time-based release cadences, pattern matching, and post-quantum cryptography, closing with an invitation for readers to debate his ratings.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/aa5ea98b-c832-429d-8e48-63f25b7feb5a_3000x3900.jpeg" alt="Python vs Java"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4863d93c-ca2a-4b5a-b0b4-fe3621a6c184_2250x2920.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d6d04f12-2adc-4d8e-a9ca-2de16399066f_2250x3376.png" alt="Design Patterns Cheat Sheet"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a370bb6a-82d3-45ad-b6f4-a2a9a4317402_800x1099.jpeg" alt="CI/CD Simplified Visual Guide"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5d9faeeb-3428-44c8-94fd-4b52fc287da3_3000x3900.png" alt="How Apache Kafka Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/45136e24-79ee-4c6d-a53a-89df6afebef6_3000x3900.png" alt="Load Balancers vs API Gateways vs Reverse Proxy"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4Uyj!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1a1213e2-86cb-4fa8-bf72-e37ffe0da44d_2250x2624.heic" alt="Understanding Load Balancers: Traffic Management at Scale"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, the output is concise and I&amp;rsquo;m fairly satisfied—probably around 80% compared to Claude Code with Claude models, and since it&amp;rsquo;s free I&amp;rsquo;m very happy with it :)))&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #53</title><link>https://miti99.com/en/post/2025/09/09/</link><pubDate>Tue, 09 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I experimented with consolidating all my previous coding agent rules into a single &lt;code&gt;AGENTS.md&lt;/code&gt; file, then pointing &lt;code&gt;CLAUDE.md&lt;/code&gt; to read that file.&lt;/del&gt; Enjoy Newsletter #53.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="anti-cheat-secure-boot--tpm"&gt;&lt;a href="https://andrewmoore.ca/blog/post/anticheat-secure-boot-tpm/" rel="noopener noreferrer"&gt;Anti-cheat, Secure Boot &amp;amp; TPM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Moore explains why anti-cheat systems like those in Battlefield 6 or Riot&amp;rsquo;s Vanguard have started requiring players to enable Secure Boot and TPM 2.0, while pushing back against claims that this is a pretext for harvesting player data. Secure Boot relies on a key hierarchy (Platform Key, Key Exchange Key, the DB allowlist of signatures, and the DBX blocklist) to ensure firmware only executes validly signed boot images. Combined with Windows only loading Microsoft-signed kernel drivers, cheat developers have a hard time injecting code into the kernel without an unpatched vulnerability.&lt;/p&gt;
&lt;p&gt;However, an anti-cheat client cannot simply trust the operating system when it reports that Secure Boot is enabled, which is where the TPM becomes the crucial link. The firmware TPM (fTPM) built into modern AMD and Intel CPUs holds a unique Endorsement Key backed by a manufacturer certificate, providing unforgeable hardware identification—meaning a hardware ban forces a cheater to buy a new CPU. In addition, the TPM&amp;rsquo;s PCR registers record a cryptographic hash chain of every event during the boot sequence, and through remote attestation via &lt;code&gt;TPM2_Quote&lt;/code&gt;, the anti-cheat server can verify that the boot environment has not been tampered with. The takeaway: this setup doesn&amp;rsquo;t eliminate cheating completely—especially hardware-based cheats—but it makes ban evasion far more expensive, doesn&amp;rsquo;t compromise user privacy, and forms an important layer of defense in depth.&lt;/p&gt;
&lt;h2 id="left-to-right-programming"&gt;&lt;a href="https://graic.net/p/left-to-right-programming" rel="noopener noreferrer"&gt;Left to Right Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that a program should remain syntactically valid while it is being typed from left to right, so the editor can offer autocomplete and type checking at every step. A classic counterexample is Python&amp;rsquo;s list comprehension: when writing &lt;code&gt;words_on_lines = [line.split() for line in text.splitlines()]&lt;/code&gt;, the variable &lt;code&gt;line&lt;/code&gt; is used before it is declared, so the editor doesn&amp;rsquo;t know its type when you type the dot and cannot suggest methods. By contrast, in Rust (&lt;code&gt;let words_on_lines = text.lines().map(|line| line.split_whitespace());&lt;/code&gt;) or JavaScript, expressions are built from left to right: the source is stated first, and the moment you type a dot, the editor can suggest relevant methods.&lt;/p&gt;
&lt;p&gt;The article connects this to the design principle of &amp;ldquo;progressive disclosure&amp;rdquo;: complexity should only surface when the user actually needs it. In C, because methods cannot be attached to structs, you have to know function names like &lt;code&gt;fread&lt;/code&gt; or &lt;code&gt;fclose&lt;/code&gt; ahead of time rather than discovering them through autocomplete after typing &lt;code&gt;file.&lt;/code&gt;. Python runs into a similar issue with global functions like &lt;code&gt;len&lt;/code&gt; or &lt;code&gt;map&lt;/code&gt;; as logic grows more complex, a single line of Python nesting multiple &lt;code&gt;filter&lt;/code&gt;, &lt;code&gt;lambda&lt;/code&gt;, and comprehension expressions becomes much harder to read than a method chain in JavaScript that reads sequentially from left to right. The closing message for language and library designers is simple: build discoverable APIs.&lt;/p&gt;
&lt;h2 id="big-o-notation"&gt;&lt;a href="https://samwho.dev/big-o/" rel="noopener noreferrer"&gt;Big O Notation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide on samwho.dev introduces Big O notation visually with live in-browser examples. Rather than measuring wall-clock time, Big O describes how execution time grows as input size increases. The author walks through four common complexity classes: summing numbers from 1 to &lt;code&gt;n&lt;/code&gt; with a loop is O(n) (linear), whereas using the formula &lt;code&gt;(n*(n+1))/2&lt;/code&gt; is O(1) (constant)—noting that O(1) does not mean &amp;ldquo;instant,&amp;rdquo; only that runtime does not depend on input size. Bubble sort illustrates O(n²) (quadratic), while guessing a number between 1 and 100 via binary search, halving the search space on each guess, illustrates O(log n) (logarithmic). Big O describes an asymptotic upper bound: O(2n) simplifies to O(n), keeping only the fastest-growing term. You can analyze best, average, or worst cases; the article focuses on the worst case.&lt;/p&gt;
&lt;p&gt;The final section shares practical performance tips: use a hash-table-backed &lt;code&gt;Set&lt;/code&gt; for average O(1) lookups instead of scanning an array (even though building the &lt;code&gt;Set&lt;/code&gt; costs O(n)), avoid calling &lt;code&gt;.indexOf&lt;/code&gt; inside a loop since that quietly turns the whole function into O(n²), and memoize intermediate results—as shown with factorials—to avoid redundant computation at the cost of extra memory. The most important advice: always benchmark before and after changing code, and don&amp;rsquo;t blindly trust performance claims you read online.&lt;/p&gt;
&lt;h2 id="personal-ai-evaluations-august-2025"&gt;&lt;a href="https://darkcoding.net/software/personal-ai-evals-aug-2025/" rel="noopener noreferrer"&gt;Personal AI Evaluations August 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Graham King evaluates large language models (LLMs) against his own day-to-day needs instead of relying on public leaderboards: he selected 12 questions out of 130 prompts from his bash history across four categories (coding, sysadmin, technical explanations, and general knowledge/creative), and ran them against 11 models via OpenRouter—including Claude Sonnet 4, DeepSeek, Gemini 2.5 Flash and Pro, Kimi K2, GPT-OSS-120B, Qwen3, and GLM 4.5. He wrote a custom Rust tool to anonymize the responses for blind grading while recording cost, latency, and throughput for each model.&lt;/p&gt;
&lt;p&gt;His main conclusion is that almost all current models give good answers, making cost and latency the deciding factors. Proprietary models like Gemini 2.5 Pro and Claude Sonnet did not stand out—in fact, they often scored lower than open-weight models while costing dramatically more. Gemini 2.5 Flash was the fastest; Kimi K2, Qwen3, and DeepSeek were among the cheapest; and two DeepSeek models alongside two Qwen3 models achieved the highest average accuracy. Reasoning mode rarely helped outside of a poetry prompt, and the entire evaluation produced only a single hallucination, when GPT-OSS-120B invented a nonexistent movie. Based on these results, the author now queries multiple models in parallel using &lt;code&gt;tmux&lt;/code&gt;: DeepSeek for everyday questions, adding Gemini Flash and Qwen3 when he wants a second opinion, and reserving reasoning models for particularly tough problems.&lt;/p&gt;
&lt;h2 id="how-to-keep-services-running-during-failures"&gt;&lt;a href="https://newsletter.scalablethread.com/p/how-to-keep-services-running-during" rel="noopener noreferrer"&gt;How to Keep Services Running During Failures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post from The Scalable Thread introduces graceful degradation, the design principle of keeping a system&amp;rsquo;s core functionality running when a component fails rather than letting the entire service go down. For example, if a video platform&amp;rsquo;s recommendation service fails, the homepage can fall back to showing trending videos while video playback continues working normally. The first group of strategies focuses on traffic control: rate limiting caps incoming requests during flash sales or DDoS attacks; request coalescing collapses thousands of identical concurrent queries into a single database hit; load shedding proactively drops non-essential requests (such as click tracking) to preserve capacity for checkout transactions; and retries with jitter add random backoff delays to prevent a &amp;ldquo;thundering herd problem&amp;rdquo; when a recovering service comes back online.&lt;/p&gt;
&lt;p&gt;The second group of strategies handles faults and improves observability. A circuit breaker acts like an electrical breaker: when a payment service repeatedly fails, the ordering service trips the breaker and fails fast for a cooldown period (say, 60 seconds) before letting a few probe requests through to check whether the downstream service has recovered. Request timeouts prevent upstream services from exhausting thread pools or connection limits waiting on a slow dependency. Finally, monitoring and alerting on metrics like error rates, latency, and message broker queue depth help engineers catch and contain incidents before they cascade.&lt;/p&gt;
&lt;h2 id="why-was-apache-kafka-created"&gt;&lt;a href="https://bigdata.2minutestreaming.com/p/why-was-apache-kafka-created" rel="noopener noreferrer"&gt;Why Was Apache Kafka Created?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from 2 Minute Streaming explains why Kafka was created in the first place. Around 2012, LinkedIn relied on user activity data to power many core features, but operated two separate data pipelines: an hourly batch system that pushed XML messages through HTTP servers into Oracle and Hadoop data warehouses, and a near-real-time monitoring pipeline built on Zenoss. Both required heavy manual operations, suffered from large backlogs, and consisted of fragile point-to-point connections that couldn&amp;rsquo;t be unified. Specific pain points included parsing hundreds of XML schemas, breaking downstream consumers whenever a schema changed, multi-hour latency, and clean data being locked inside the data warehouse.&lt;/p&gt;
&lt;p&gt;Kafka solved these problems with a distributed, replicated architecture that scales horizontally via partitions, an append-only log structure that supports multiple independent consumers, and disk persistence that decouples producers from consumers. LinkedIn also migrated from XML to Avro (roughly 7x smaller), built a schema versioning service—the precursor to Schema Registry—with backward-compatibility checks, enforced &amp;ldquo;schema on write&amp;rdquo; to validate data before it entered Kafka, and shifted schema ownership to the teams producing the data backed by mandatory review workflows. What surprised the author most is that LinkedIn&amp;rsquo;s original papers emphasized schemas over 13 years ago, whereas he considers the lack of native, built-in schema enforcement to be Kafka&amp;rsquo;s biggest design mistake.&lt;/p&gt;
&lt;h2 id="how-we-vibe-code-at-a-faang"&gt;&lt;a href="https://www.reddit.com/r/vibecoding/comments/1myakhd/how_we_vibe_code_at_a_faang/" rel="noopener noreferrer"&gt;How We Vibe Code at a FAANG&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Reddit user who introduces himself as an AI engineer with over ten years of experience—roughly half of it at FAANG or similar companies—shares how his team integrates AI into a production software development workflow, pushing back against the claim that AI-assisted coding isn&amp;rsquo;t viable for real-world systems. Their process still starts with rigorous technical design docs: a proposal must win stakeholder alignment, followed by a full system design covering architecture and cross-team integrations, and then a design review where senior engineers tear it apart—what the author calls front-loading the pain. Next come subsystem documentation, task breakdowns, and sprint planning with PMs and TPMs.&lt;/p&gt;
&lt;p&gt;Only when it is time to write code does AI become a productivity &amp;ldquo;force multiplier&amp;rdquo;: the team practices Test-Driven Development, having AI agents write the tests first before implementing the feature. Every pull request still requires approval from two human engineers before merging (with AI also starting to assist in code reviews), followed by staging verification before production rollout. According to the poster, end-to-end delivery time from feature proposal to production is about 30% faster. Many commenters pointed out that this isn&amp;rsquo;t really &amp;ldquo;vibe coding&amp;rdquo; at all, but disciplined AI-assisted engineering inside a mature enterprise workflow—a distinction the author himself agreed with.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict on &lt;code&gt;AGENTS.md&lt;/code&gt; effectiveness: Not great yet—it still left quite a lot of English terms untranslated. I&amp;rsquo;ll try to refine it further in upcoming posts. See you next time!&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 #46</title><link>https://miti99.com/en/post/2025/08/05/</link><pubDate>Tue, 05 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/05/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I&amp;rsquo;m going back to Claude Code :D (still my true love—I only jump to other agents when I&amp;rsquo;m worried about burning tokens).&lt;/del&gt; Enjoy Newsletter #46.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-pragmatic-engineer-2025-survey-what"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-pragmatic-engineer-2025-survey" rel="noopener noreferrer"&gt;The Pragmatic Engineer 2025 Survey: What&amp;rsquo;s in your tech stack?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz published the first part of The Pragmatic Engineer&amp;rsquo;s 2025 tech stack survey, based on nearly 3,000 valid responses. The &amp;ldquo;typical respondent&amp;rdquo; is a senior software engineer with 6–10 years of experience working on the backend at companies of all sizes. Up to 85% of participants mentioned at least one AI tool. GitHub Copilot took the top spot, used by one in two respondents; Cursor, despite launching in 2023 and spending nothing on marketing, came in second. Claude narrowed the gap with ChatGPT considerably, and Claude Code received quite a few mentions even though it had only officially launched a few days before the survey closed.&lt;/p&gt;
&lt;p&gt;Among programming languages in this readership sample, TypeScript was mentioned most often; Python stood out, and Swift dominated Objective-C in iOS development, while Ruby on Rails and Elixir were loved far above their usage share, and no language was disliked more than it was liked. JIRA was the most disliked tool—surpassing the next four combined—mainly for being slow and bloated, with Linear frequently cited as the alternative. Git is virtually the default for version control, though GitLab and Bitbucket retain sizable user bases, and GitHub Actions leads in CI/CD. In infrastructure, AWS leads, followed by Azure and Google Cloud, with Vercel standing out as the most prominent provider outside the &amp;ldquo;Big 3.&amp;rdquo; The takeaway: developers are quick to try new tools in fast-moving spaces like AI.&lt;/p&gt;
&lt;h2 id="algorithms-for-making-interesting-organic-simulations"&gt;&lt;a href="https://bleuje.com/physarum-explanation/" rel="noopener noreferrer"&gt;Algorithms for making interesting organic simulations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains techniques for creating organic-looking simulations aimed more at artistic expression than scientific accuracy. The starting point is Jeff Jones&amp;rsquo;s Physarum algorithm (2010): a large number of agents move across a 2D plane, each with a position and heading. On every step, an agent &amp;ldquo;senses&amp;rdquo; three points ahead (straight, slightly left, slightly right), turns toward the strongest trail, moves forward, and deposits a trail onto an image called a trail map; that image is then slightly blurred and multiplied by a decay factor to keep the system stable. With just four parameters (sensor distance, sensor angle, turn angle, and step size), a wide variety of behaviors already emerge.&lt;/p&gt;
&lt;p&gt;The most fascinating part comes from Sage Jenson&amp;rsquo;s &lt;em&gt;36 Points&lt;/em&gt;: instead of keeping parameters fixed, each parameter is computed as a function of the trail value at the agent&amp;rsquo;s current position, plus sampling offsets—bringing the total to roughly 14–20 parameters and producing surprisingly diverse behaviors. The author shares his own implementation (&lt;code&gt;physarum-36p&lt;/code&gt;) using GPU compute shaders via openFrameworks, consisting of four shaders for resetting counters, moving particles, depositing trails, and diffusing, running smoothly with millions of particles. It is a beautiful demonstration of how a few simple rules can give rise to complex behavior.&lt;/p&gt;
&lt;h2 id="ai-coding-tools-are-shifting-to-a-surprising-place-the-terminal"&gt;&lt;a href="https://techcrunch.com/2025/07/15/ai-coding-tools-are-shifting-to-a-surprising-place-the-terminal/" rel="noopener noreferrer"&gt;AI coding tools are shifting to a surprising place: The terminal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to TechCrunch, AI coding tools are shifting from code editors to the terminal. Since February, Anthropic, DeepMind, and OpenAI have each launched their own command-line tools (Claude Code, Gemini CLI, and Codex CLI), and they have quickly become some of these companies&amp;rsquo; most popular products. Mike Merrill, co-creator of the Terminal-Bench benchmark, bets that in the future 95% of interactions between LLMs and computers will happen through terminal-like interfaces. Meanwhile, editor-based tools are showing signs of turbulence: Windsurf was carved up through acquisitions, and a METR study of experienced open-source developers found that when using Cursor Pro, they thought they were about 20% faster when in reality they were about 19% slower.&lt;/p&gt;
&lt;p&gt;The difference lies in the scope of work. The previous generation of tools, measured by SWE-Bench, focused on fixing buggy code from GitHub issues; terminal tools look at the entire execution environment, including DevOps tasks like configuring a Git server, compiling a Linux kernel, or figuring out why a script fails to run. On the leaderboard cited by the article at the time, Warp solved just over half the tasks, showing there is still plenty of room to grow. Even so, Warp&amp;rsquo;s founder believes that tasks like bootstrapping a project, resolving dependencies, and getting it running can now be handed off almost entirely to AI.&lt;/p&gt;
&lt;h2 id="distributed-systems-reliability-glossary"&gt;&lt;a href="https://antithesis.com/resources/reliability_glossary/" rel="noopener noreferrer"&gt;Distributed Systems Reliability Glossary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jepsen and Antithesis jointly compiled a glossary of distributed systems reliability aimed at developers at every career stage. According to the authors, this is the first resource to gather in one place concepts that were previously scattered across multiple disciplines. The glossary is organized into sections covering foundational concepts, consistency models (what a system is allowed to do), availability models, anomalies, fault types (from data loss and clock skew to Byzantine faults), and testing techniques, accompanied by a further reading list. Each entry provides an intuitive definition alongside links to formal academic sources for deeper study.&lt;/p&gt;
&lt;p&gt;What makes it especially valuable is its practical spirit: the authors emphasize that it is a reference guide rather than required cover-to-cover reading, and that every time you write an integration test, you are already testing a distributed system. The testing section explains why distributed systems are hard: they are inherently concurrent and routinely experience partial failures. From there, it introduces techniques such as concurrency testing, fault injection, deterministic simulation testing, property-based testing, and test-case shrinking. A great resource to bookmark when working with databases or multi-node systems.&lt;/p&gt;
&lt;h2 id="test-driven-development-tdd-with-dbt"&gt;&lt;a href="https://xebia.com/blog/test-driven-development-tdd-with-dbt/" rel="noopener noreferrer"&gt;Test-Driven Development (TDD) with dbt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dumky de Wilde (Xebia) discusses applying Test-Driven Development (TDD) to dbt, the popular data transformation tool in analytics engineering. Instead of writing a model and hoping the numbers look right, you first define what &amp;ldquo;good data&amp;rdquo; means, write a test, watch it fail, and then write just enough SQL to make it pass. The author distinguishes several categories of tests: row-level checks on one or more columns (such as &lt;code&gt;not_null&lt;/code&gt; and &lt;code&gt;unique&lt;/code&gt;), aggregate tests across an entire model, unit tests for models (available since dbt 1.8, using mock data instead of production data), unit tests for macros, and model contracts. Contracts validate the output schema at build time so a structurally invalid model fails to build; how strictly the underlying database enforces each constraint depends on the platform and adapter.&lt;/p&gt;
&lt;p&gt;The article walks through writing a row-count limit test for a model that does not yet exist, forcing you to answer business questions like &amp;ldquo;why between 1 and 99 rows?&amp;rdquo; before writing a single line of SQL. In practice, the author recommends always running unit tests and contracts during local development and in CI/CD, running data tests selectively, and skipping unit tests in production. Use tags to group tests, craft small custom fixtures for edge cases, and document why each test exists. The core message is shifting your mindset from &amp;ldquo;build first, test later&amp;rdquo; to &amp;ldquo;define success first, then build.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="rethinking-oop"&gt;&lt;a href="https://max.xz.ax/blog/rethinking-oop/" rel="noopener noreferrer"&gt;Rethinking OOP&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author opens with an example from AP Computer Science A: the textbook definition &amp;ldquo;a class is a blueprint for creating objects, and an object is an instance of a class&amp;rdquo; is virtually meaningless to beginners. According to the author, teaching OOP too early without explaining why leads students to follow templates mechanically rather than considering whether the problem actually calls for them. Drawing inspiration from Professor Matthias Felleisen&amp;rsquo;s &amp;ldquo;design recipe&amp;rdquo; and Ethan McCue&amp;rsquo;s modern approach to teaching Java, the article proposes starting as simply as possible and introducing new language features only when learners hit the limits of their current toolkit.&lt;/p&gt;
&lt;p&gt;Specifically, learners can use JDK 25&amp;rsquo;s compact source files (or JShell) to write sequential statements right away without &lt;code&gt;public static void main&lt;/code&gt;. When they have to copy-paste the same prime-checking block across multiple variables, they naturally see the need for methods; when managing too many loose variables becomes unwieldy, they grasp the value of grouping data into a class. The author acknowledges that this approach lets students write &amp;ldquo;bad&amp;rdquo; code at first, but living with repetitive, clunky code is precisely what makes design choices meaningful. The conclusion is worth pondering: best practices don&amp;rsquo;t need to be memorized from a textbook—they can become intuitive by gradually scaling up program complexity.&lt;/p&gt;
&lt;h2 id="how-i-write-code-that-i-don"&gt;&lt;del&gt;&lt;a href="https://dev.to/resource_bunk_1077cab07da/how-i-write-code-that-i-dont-hate-reading-a-week-later-303b" rel="noopener noreferrer"&gt;How I Write Code That I Don&amp;rsquo;t Hate Reading a Week Later&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;A practical and useful article on writing readable code—an important skill that many developers overlook. The author shares a core philosophy: &amp;ldquo;Write code as if you&amp;rsquo;ll have to debug it at 2 a.m., half-asleep, with a deadline looming.&amp;quot;&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Key principles include giving variables and functions descriptive names (for example, &lt;code&gt;parsed_user_profile_data&lt;/code&gt; instead of just &lt;code&gt;d&lt;/code&gt;), writing comments that explain &amp;ldquo;why&amp;rdquo; rather than &amp;ldquo;what,&amp;rdquo; and prioritizing readability over &amp;ldquo;clever&amp;rdquo; code. Instead of writing dense one-liners to show off technical flair, break them into multiple easier-to-follow lines.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The best point is the principle of writing small, focused functions: each function should do one specific thing with a clear name like &lt;code&gt;handleLoginFormSubmission()&lt;/code&gt;. When code gets tangled, stop and refactor rather than piling on more complexity. The author also mentions helpful tools like Prettier, Black for Python, and even ChatGPT for refactoring. Simple yet highly practical advice for any developer who wants more maintainable code.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="7-habits-that-quietly-made-me-a-10x-developer-no-not-chatgpt"&gt;&lt;a href="https://dev.to/abubakersiddique771/7-habits-that-quietly-made-me-a-10x-developer-no-not-chatgpt-13c4" rel="noopener noreferrer"&gt;7 Habits That Quietly Made Me A 10x Developer (No, Not ChatGPT)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that becoming a &amp;ldquo;10x developer&amp;rdquo; comes not from innate genius or working 20-hour days, but from small habits maintained consistently—without needing an AI assistant. The first habit is writing code that writes code: using scripts, generators, and scaffolding tools to automate boilerplate, CRUD endpoints, test harnesses, or GitHub Actions workflows so you never solve the same problem twice. The second is designing for &amp;ldquo;future you&amp;rdquo; with descriptive commit messages, clear function names, sensible folder structures, and writing the &lt;code&gt;README.md&lt;/code&gt; before starting implementation. The third is keeping a brief &amp;ldquo;debug log&amp;rdquo; stating the problem, hypothesis, and plan before fixing a bug, because writing it down forces clear thinking.&lt;/p&gt;
&lt;p&gt;The remaining habits include building tiny personal tools (a CLI for renaming screenshots, a snippet generator), carving out 90-minute deep-focus blocks free from Slack or social media, studying how other developers structure their workflows rather than just copying their code, and running a Friday retro with three questions: what went well, what slowed me down, and what will I automate or improve next. According to the author, &amp;ldquo;10x&amp;rdquo; effectiveness is the compound result of many small improvements over time.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Claude Code really is my true love :D Fast execution, concise summaries, and getting better all the time. Wonderful!&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 #13</title><link>https://miti99.com/en/post/2025/04/22/</link><pubDate>Tue, 22 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/22/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #13.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="designing-a-distributed-id-generator"&gt;&lt;a href="https://siddharthsabron.in/blog/id-generator/" rel="noopener noreferrer"&gt;Designing a Distributed ID Generator&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through building a 64-bit Snowflake-style distributed ID generator that produces unique IDs across nodes without relying on a centralized coordinator like a database &lt;code&gt;AUTO_INCREMENT&lt;/code&gt; sequence. First, the author explains why random strings (like UUIDv4) make poor primary keys in relational databases: string comparisons are slower than integer comparisons, indexes take up much more memory, and inserting random keys into a B-Tree causes frequent page splits, fragmentation, and poor cache locality. By contrast, time-ordered 64-bit integers keep indexes compact and append new rows cleanly near the right edge of the B-Tree.&lt;/p&gt;
&lt;p&gt;The core design packs three fields into a 64-bit integer: 41 bits for a millisecond timestamp relative to a custom epoch (good for ~69 years), 10 bits for the shard/machine ID (supporting up to 1,024 shards), and 12 bits for a per-millisecond sequence counter (allowing 4,096 IDs per millisecond per shard), combined using bitwise shifts and &lt;code&gt;OR&lt;/code&gt; operations. The author also candidly notes what needs to be hardened before taking the toy code to production, including handling sequence rollovers within the same millisecond, NTP clock drift, and automated shard ID assignment. It is a clear, practical read on why primary-key layout directly impacts database performance.&lt;/p&gt;
&lt;h2 id="3200-cpu-utilization"&gt;&lt;a href="https://josephmate.github.io/2025-02-26-3200p-cpu-util/" rel="noopener noreferrer"&gt;3,200% CPU Utilization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joseph Mate recounts a production war story where a Java server spiked so hard that he could barely SSH into the box: CPU utilization hit 3,200%, pegging all 32 cores at 100%. Pulling a Java 17 thread dump—which includes per-thread CPU time—revealed dozens of threads stuck endlessly inside &lt;code&gt;TreeMap.put()&lt;/code&gt;. The culprit was an unsynchronized &lt;code&gt;TreeMap&lt;/code&gt; being mutated concurrently by multiple threads. Under a race condition during tree rebalancing, the internal red-black tree&amp;rsquo;s pointers became corrupted and formed a cycle, causing subsequent lookups and inserts to spin in an infinite loop. Crucially, the bug stayed hidden until &lt;code&gt;NullPointerException&lt;/code&gt;s thrown during concurrent corruption were silently swallowed by an executor thread pool without an uncaught exception handler (or inside a gRPC request handler), leaving the corrupted map live in memory with zero stack traces in the logs.&lt;/p&gt;
&lt;p&gt;The author reproduces the bug in a standalone test, compares how other languages handle concurrent map mutation, and outlines fixes—the simplest being wrapping the map in &lt;code&gt;Collections.synchronizedMap&lt;/code&gt; or switching to &lt;code&gt;ConcurrentSkipListMap&lt;/code&gt;. Beyond the immediate fix, he advocates defense-in-depth: alerting on unexpected NPEs, monitoring sustained CPU anomalies, always registering an &lt;code&gt;UncaughtExceptionHandler&lt;/code&gt; on thread pools, thorough code review, static analysis, and multithreaded stress tests. It&amp;rsquo;s a vivid reminder that data races don&amp;rsquo;t just corrupt state—they can take down an entire server.&lt;/p&gt;
&lt;h2 id="a-map-metaphor-for-architectural-diagrams"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/maps-metaphor-for-architectural-diagrams.html" rel="noopener noreferrer"&gt;A map metaphor for architectural diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi suggests thinking of software architecture diagrams as maps: the map is not the territory, and every model is &amp;ldquo;wrong&amp;rdquo; because it leaves out detail, yet it becomes useful precisely by highlighting the specific dimension needed for a given task. Just like a topographic map versus a subway map, each architectural diagram should focus on a single slice of concern. If a diagram constantly falls out of sync with the code, it is probably drawn at too low a level of abstraction.&lt;/p&gt;
&lt;p&gt;Sironi shares his experience maintaining a lightweight set of living &amp;ldquo;maps&amp;rdquo; on a digital whiteboard like Miro, using nothing more than boxes, arrows, sticky notes for open decisions, and color-coding for status. These living boards replace sprawling lists of Architectural Decision Records (ADRs)—which become hard to navigate once you have dozens of them—and differ from ADRs by being edited in place as the system evolves. His core set of maps covers system context (inspired by the C4 model), bounded contexts and their ubiquitous language, static module dependencies, testing strategy, observability pipelines, and technology radar choices. Crucially, the whole team owns and updates these maps together rather than treating them as the tech lead&amp;rsquo;s private artifact, consulting them whenever kicking off a new initiative.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/02/28/about-developer-philosophy/" rel="noopener noreferrer"&gt;About &amp;ldquo;Developer philosophy&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea shares his reflections on reading qntm&amp;rsquo;s &amp;ldquo;Developer philosophy&amp;rdquo; essay. He starts by asking whether there is still room for junior developers in the age of AI, empathizing with new grads struggling to land their first role and drawing parallels to the offshoring wave of the 2000s. On the topic of big-bang rewrites, while he agrees with qntm that the rot leading to a rewrite builds up over years, he argues that accumulated gaps can usually still be paid down incrementally. Full rewrites, he warns, are massive projects that inevitably slip their schedules—at which point &amp;ldquo;non-essential&amp;rdquo; requirements get cut to hit the deadline, birthing a brand-new pile of technical debt in the replacement system.&lt;/p&gt;
&lt;p&gt;In the second half, Costea offers pragmatic caveats on qntm&amp;rsquo;s other rules: automating best practices via linters only works once you have buy-in from the influential voices on the team; edge cases often only reveal themselves late in the game following the 80/20 rule; don&amp;rsquo;t expect a V2 rewrite to stay clean and simple for long; and even code that looks modular, testable, and &amp;ldquo;obviously correct&amp;rdquo; can still surprise you in production. It&amp;rsquo;s a grounded, slightly battle-weary counterpoint to the original essay.&lt;/p&gt;
&lt;h2 id="team-learning-session-surviving-legacy-code-by-jb-rainsberger"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/team-learning-session-surviving-legacy.html" rel="noopener noreferrer"&gt;Team learning session: surviving legacy code by J.B. Rainsberger&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi describes how he runs a recurring team learning session built around J.B. Rainsberger&amp;rsquo;s &amp;ldquo;Surviving Legacy Code&amp;rdquo; kata. The fictional premise puts a TypeScript team in charge of maintaining a newly acquired, business-critical PHP codebase with no tests, cryptic logic, and nobody left who knows where the landmines are buried. The exercise targets three learning goals: characterizing and understanding unfamiliar legacy code, writing tests at multiple levels of granularity, and refactoring safely behind a safety net of tests—while also getting comfortable picking up an unfamiliar language and its ecosystem tooling (&lt;code&gt;Composer&lt;/code&gt;, &lt;code&gt;PHPUnit&lt;/code&gt;, &lt;code&gt;PHPStan&lt;/code&gt;, &lt;code&gt;PHP-CS-Fixer&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The team works together in an ensemble (mob programming) format for an hour a week on a single shared screen against a deliberately awful toy repository. Their progression starts with running the code to see what it does, locking down existing behavior with a &lt;strong&gt;Golden Master&lt;/strong&gt; characterization test (controlling the random number generator seed so outputs are deterministic), and only then extracting smaller seams and writing fine-grained unit tests. Because the codebase is fictional and there is no delivery deadline, teammates feel safe saying &amp;ldquo;I don&amp;rsquo;t know&amp;rdquo; and experimenting aloud. Each session wraps up with a quick retrospective to capture takeaways and pick the next thread to pull.&lt;/p&gt;
&lt;h2 id="trimodal-nature-of-tech-compensation-in-the-us-uk-and-india"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/trimodal" rel="noopener noreferrer"&gt;Trimodal Nature of Tech Compensation in the US, UK and India&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, author of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt;, analyzes more than 20,000 compensation data points from Levels.fyi to test his &lt;strong&gt;trimodal compensation model&lt;/strong&gt; across the US, the UK, and India. Under this model, tech employers cluster into three distinct pay bands: &lt;strong&gt;Tier 1&lt;/strong&gt; (local market rate—the vast majority of companies), &lt;strong&gt;Tier 2&lt;/strong&gt; (Big Tech and regional leaders), and &lt;strong&gt;Tier 3&lt;/strong&gt; (top scaleups, elite quant trading firms, and hedge funds). In the US, Tier 2 and Tier 3 typically pay roughly double Tier 1 at both the median and 75th percentile for both entry-level and senior engineers, with significant overlap between Tier 2 and Tier 3 packages.&lt;/p&gt;
&lt;p&gt;The post breaks down top-paying companies in each tier by country and surfaces several striking patterns: hedge funds and quant firms don&amp;rsquo;t grant equity, but pay massive year-end cash bonuses that make them the only group paying higher pure cash compensation than Big Tech; in the UK, hedge funds and financial institutions dominate the very top of the market; and in India, top Tier 3 employers pay over ₹1 crore ($120K+) for senior engineers. Orosz also reminds readers that private &amp;ldquo;paper money&amp;rdquo; equity at pre-IPO scaleups can inflate headline numbers while carrying real liquidity risk. It is an essential read for calibrating your market value and career strategy.&lt;/p&gt;
&lt;h2 id="9-software-architecture-patterns-for-distributed-systems"&gt;&lt;a href="https://dev.to/somadevtoo/9-software-architecture-patterns-for-distributed-systems-2o86" rel="noopener noreferrer"&gt;9 Software Architecture Patterns for Distributed Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Soma provides a visual overview of nine fundamental architectural patterns for managing data flow and communication in distributed systems—topics that also come up constantly in system design interviews. The first five cover communication and state: &lt;strong&gt;Peer-to-Peer&lt;/strong&gt;, where nodes communicate directly without a central coordinator; &lt;strong&gt;API Gateway&lt;/strong&gt;, a single entry point handling authentication, rate limiting, and routing to backend services; &lt;strong&gt;Pub-Sub&lt;/strong&gt;, decoupling producers and consumers asynchronously through topics; &lt;strong&gt;Request-Response&lt;/strong&gt;, the classic synchronous client-server model; and &lt;strong&gt;Event Sourcing&lt;/strong&gt;, persisting every state transition as an immutable append-only log of events.&lt;/p&gt;
&lt;p&gt;The remaining four focus on data processing and workflow coordination: &lt;strong&gt;ETL&lt;/strong&gt; (Extract, Transform, Load) for moving data into analytical stores; &lt;strong&gt;Batching&lt;/strong&gt; for high-throughput periodic processing; &lt;strong&gt;Stream Processing&lt;/strong&gt; for continuous real-time event pipelines; and &lt;strong&gt;Orchestration&lt;/strong&gt;, where a central controller coordinates multi-step workflows across services. Each pattern is paired with a clear diagram and real-world use cases, making the post a handy quick-reference refresher before diving deeper into individual patterns.&lt;/p&gt;
&lt;h2 id="extending-java-apis---add-missing-features-without-the-hassle"&gt;&lt;a href="https://foojay.io/today/extending-java-apis-add-missing-features-without-the-hassle/" rel="noopener noreferrer"&gt;Extending Java APIs - Add Missing Features Without the Hassle&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shai Almog introduces the &lt;strong&gt;extension methods&lt;/strong&gt; feature of the Manifold compiler plugin, which lets you add missing methods to existing Java classes (like &lt;code&gt;String&lt;/code&gt; or &lt;code&gt;Collection&lt;/code&gt;) without waiting years for the JDK to add them. You simply create a class annotated with &lt;code&gt;@Extension&lt;/code&gt; inside a package whose name ends with the fully qualified name of the target class, and write &lt;code&gt;static&lt;/code&gt; methods whose first parameter is annotated with &lt;code&gt;@This&lt;/code&gt;. For example, you can add a &lt;code&gt;.map()&lt;/code&gt; method directly onto &lt;code&gt;Collection&lt;/code&gt; to skip the ceremony of calling &lt;code&gt;.stream().map(...).toList()&lt;/code&gt;. Under the hood, Manifold does not modify the bytecode of the target JDK class—instead, it rewrites call sites into static method calls at compile time with zero runtime wrapper overhead. And if a future JDK release adds a native method with the exact same signature, the real JDK method automatically takes precedence, keeping upgrades smooth.&lt;/p&gt;
&lt;p&gt;Manifold also ships with ready-made extension libraries for collections, &lt;code&gt;String&lt;/code&gt;, I/O, and JSON—bringing Kotlin-style helpers like &lt;code&gt;removePrefix()&lt;/code&gt;, &lt;code&gt;padStart()&lt;/code&gt;, and &lt;code&gt;isEmpty()&lt;/code&gt; on arrays straight to Java. Finally, the post showcases &lt;code&gt;@Structural&lt;/code&gt; interfaces, which bring TypeScript/Go-style structural typing to Java so unrelated classes like &lt;code&gt;String&lt;/code&gt; and &lt;code&gt;Collection&lt;/code&gt; can be treated polymorphically through a shared interface without modifying their class declarations.&lt;/p&gt;
&lt;h2 id="how-spring-boot-reloads-configuration-without-restart"&gt;&lt;a href="https://medium.com/@AlexanderObregon/how-spring-boot-reloads-configuration-without-restart-4d9dc9e8b926" rel="noopener noreferrer"&gt;How Spring Boot Reloads Configuration Without Restart&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon explains how Spring Boot reloads configuration properties dynamically at runtime without restarting the JVM. By default, &lt;code&gt;@Value&lt;/code&gt; and &lt;code&gt;@ConfigurationProperties&lt;/code&gt; bindings are evaluated once at startup. To make them dynamic, applications typically pull configuration from Spring Cloud Config Server, annotate dynamic beans with &lt;code&gt;@RefreshScope&lt;/code&gt;, and trigger a reload by sending a POST request to Spring Boot Actuator&amp;rsquo;s &lt;code&gt;/actuator/refresh&lt;/code&gt; endpoint.&lt;/p&gt;
&lt;p&gt;The article looks under the hood at what happens when &lt;code&gt;/actuator/refresh&lt;/code&gt; is called: Spring publishes a &lt;code&gt;RefreshEvent&lt;/code&gt;; the &lt;code&gt;ConfigurableEnvironment&lt;/code&gt; re-fetches property sources from the external config server and diffs the changes; and any bean marked with &lt;code&gt;@RefreshScope&lt;/code&gt;—which Spring wraps in a CGLIB proxy at startup—has its cached target instance invalidated in the scope cache, forcing Spring to lazily re-instantiate the bean with the fresh property values on the very next method call. Properties injected into regular singleton beans outside &lt;code&gt;@RefreshScope&lt;/code&gt;, the author notes, will not update until a full restart. For multi-instance deployments, pairing Config Server with &lt;strong&gt;Spring Cloud Bus&lt;/strong&gt; over RabbitMQ or Kafka broadcasts the refresh event across every running instance simultaneously via &lt;code&gt;/actuator/bus-refresh&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="building-high-performance-rpc-services-with-grpc-and-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/2025/03/building-high-performance-rpc-services-with-grpc-and-spring-boot.html" rel="noopener noreferrer"&gt;Building High-Performance RPC Services with gRPC and Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eleftheria Drosopoulou walks through integrating gRPC into a Spring Boot application to build high-performance RPC services. Created by Google, gRPC uses HTTP/2 for transport and Protocol Buffers (Protobuf) as its interface definition language and binary serialization format. Thanks to compact binary payloads, HTTP/2 connection multiplexing, native bidirectional streaming, and strongly typed client/server code generation from &lt;code&gt;.proto&lt;/code&gt; schemas, gRPC is a strong fit for internal microservice-to-microservice communication. The article opens with a comparison table pitting gRPC against REST and WebSockets across transport protocol, payload format, performance, streaming support, and browser compatibility.&lt;/p&gt;
&lt;p&gt;The hands-on tutorial steps through adding &lt;code&gt;grpc-spring-boot-starter&lt;/code&gt;, defining a service contract in a &lt;code&gt;.proto&lt;/code&gt; file, configuring the Maven Protobuf plugin to generate Java stubs, implementing the server-side service class, and wiring up the gRPC server port. It wraps up with clear guidance on when to pick each protocol: gRPC for low-latency polyglot microservices and streaming RPCs, REST for public-facing CRUD APIs and direct browser clients, and WebSockets for stateful real-time browser push.&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/39f5b04d-ad39-4bbe-a32f-f47792d4ef62_2250x2682.png" alt="Latency and Partition Tolerance in Distributed Systems"&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;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #12</title><link>https://miti99.com/en/post/2025/04/20/</link><pubDate>Sun, 20 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/20/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #12.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="fundamental-techniques-for-software-architects"&gt;&lt;a href="https://www.workingsoftware.dev/fundamental-techniques-for-software-architects/" rel="noopener noreferrer"&gt;Fundamental Techniques for Software Architects&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Patrick Roos curates roughly 30 foundational techniques every software architect should have in their toolkit, organized by project lifecycle phase. In the &lt;strong&gt;Strategic&lt;/strong&gt; phase, techniques like Impact Mapping and Wardley Mapping connect technical initiatives to business outcomes. Under &lt;strong&gt;Ideation &amp;amp; Alignment&lt;/strong&gt;, he covers Domain Storytelling, Event Storming, Ubiquitous Language, Context Mapping, the Bounded Context Canvas, and quality-attribute workshops like arc42 Q42 and Quality Storming. &lt;strong&gt;Decision-Making&lt;/strong&gt; features Architectural Principles and Architecture Decision Records (ADRs); &lt;strong&gt;Technology Management&lt;/strong&gt; introduces the Tech Stack Canvas and Technology Radar; and &lt;strong&gt;Risk Management&lt;/strong&gt; covers Risk Storming, Technical Debt Records, and Threat Modeling.&lt;/p&gt;
&lt;p&gt;The final groups focus on &lt;strong&gt;Visualization &amp;amp; Documentation&lt;/strong&gt; (the C4 Model, arc42, Documentation as Code) and &lt;strong&gt;Measurement &amp;amp; Improvement&lt;/strong&gt; (DORA Metrics, aim42, Residuality Theory). Each entry includes a concise summary along with reference talks or examples, making the article an excellent reference map: you don&amp;rsquo;t need to apply all 30 on a single project, just reach for the right tool for the problem in front of you—whether that&amp;rsquo;s untangling domain boundaries or aligning stakeholders.&lt;/p&gt;
&lt;h2 id="the-end-of-programming-as-we-know-it"&gt;&lt;a href="https://www.oreilly.com/radar/the-end-of-programming-as-we-know-it/" rel="noopener noreferrer"&gt;The End of Programming as We Know It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tim O&amp;rsquo;Reilly pushes back against the doom-and-gloom narrative that AI will put software developers out of work. Looking back through computing history—from physical plugboards, assembly, and compiled languages to operating systems, the web, and cloud computing—every time a higher-level abstraction &amp;ldquo;ended&amp;rdquo; an older way of programming, the total number of programmers actually grew, because cheaper software unlocked massive pent-up demand. Drawing on economist James Bessen&amp;rsquo;s research on the Industrial Revolution, O&amp;rsquo;Reilly argues that the biggest gains arrive only as workers &amp;ldquo;learn by doing&amp;rdquo; to master new workflows, and that junior developers who embrace AI tools can easily outpace senior engineers who refuse to adapt.&lt;/p&gt;
&lt;p&gt;Quoting practitioners like Sam Schillace, Bret Taylor, and Addy Osmani, the essay argues that we are inventing a brand-new programming paradigm around AI: humans are still essential for supplying domain context, understanding end-to-end business workflows, and hardening prototypes for production, while multi-agent coordination remains in its infancy. His conclusion: when AI multiplies developer productivity, the scope of what is worth automating—and what users expect from software—expands right along with it, marking not the death of programming, but its latest rebirth.&lt;/p&gt;
&lt;h2 id="in-defense-of-simple-architectures"&gt;&lt;a href="https://danluu.com/simple-architectures/" rel="noopener noreferrer"&gt;In defense of simple architectures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Luu shares lessons from his time at Wave, a $1.7 billion fintech company with roughly 70 engineers running on a remarkably simple architecture: a monolithic Python application backed by PostgreSQL. He also points to Stack Overflow as a classic example of scaling a monolithic architecture into one of the top 100 most-visited sites on the web. Wave chose synchronous Python over bug-prone async frameworks, offloaded slow operations to background queues, and candidly acknowledges a few regrets along the way—such as loose database transaction boundaries and friction with RabbitMQ, Celery, and SQLAlchemy. On the flip side, they were very happy with GraphQL and Kubernetes for concrete business reasons, such as spinning up isolated data centers inside individual African countries to meet local regulatory and latency requirements.&lt;/p&gt;
&lt;p&gt;The central takeaway: modern hardware is fast enough that the vast majority of applications—even at very high traffic—can run comfortably on a simple monolithic architecture that is far cheaper to operate and easier to maintain. Keeping application architecture as boring as possible preserves the team&amp;rsquo;s finite &amp;ldquo;complexity budget&amp;rdquo; for the problems that actually differentiate the business, like integrating directly with local telecom providers. Luu also critiques how tech conferences disproportionately spotlight complex microservice architectures from hyperscalers, luring small companies into copying complexity they don&amp;rsquo;t need.&lt;/p&gt;
&lt;h2 id="the-trouble-with"&gt;&lt;a href="https://newsletter.weskao.com/p/the-trouble-with-good-enough" rel="noopener noreferrer"&gt;The trouble with &amp;ldquo;good enough&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao opens with artist Josef Albers&amp;rsquo;s observation that if you say the word &amp;ldquo;red&amp;rdquo; to 50 people, there will be 50 different shades of red in their minds. In the same way, everyone has a different internal definition of &amp;ldquo;good enough.&amp;rdquo; We all know the textbook advice to stop polishing once we hit diminishing returns—but in practice, many people declare victory long before they actually reach that point, often without realizing how low their bar is set.&lt;/p&gt;
&lt;p&gt;Kao illustrates the gap with concrete examples: a product feature is only &amp;ldquo;good enough&amp;rdquo; when it actually solves the customer&amp;rsquo;s problem, not merely when a manager signs off on shipping it; an email is only &amp;ldquo;good enough&amp;rdquo; when it persuades the reader to act, not the moment you hit send. Raising your bar doesn&amp;rsquo;t mean spending 30 hours perfecting every minor task—it means pushing 10–20% further along the quality curve on your highest-leverage work. The post closes with reflection questions to help you spot where you might be calling work &amp;ldquo;good enough&amp;rdquo; prematurely and where raising your standards will pay off most.&lt;/p&gt;
&lt;h2 id="should-managers-still-code"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/should-managers-still-code" rel="noopener noreferrer"&gt;Should managers still code?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier tackles a classic reader question: should engineering managers still write code day-to-day? He starts by drawing a sharp distinction between &lt;strong&gt;being in the code&lt;/strong&gt; and &lt;strong&gt;writing code on the critical path&lt;/strong&gt;. Every engineering manager should stay close to the code: understanding how the system is architected, reviewing pull requests and design docs, helping triage production incidents, pairing with teammates, and owning the team&amp;rsquo;s overall engineering quality. Taking on critical-path feature implementation yourself, however, is much trickier because a manager&amp;rsquo;s fragmented calendar quickly turns them into a bottleneck for the team. Stanier also situates the question in the post-ZIRP era of &amp;ldquo;flattening&amp;rdquo; org charts, where many managers feel renewed pressure to prove their hands-on technical chops.&lt;/p&gt;
&lt;p&gt;For managers who want (or need) to keep coding without blocking their team, he offers practical strategies: blocking out dedicated focus hours on your calendar, pair programming, doing deep code reviews by checking out branches and running them locally, leaning in during early prototyping or incident response, and building small exploratory proofs-of-concept with new technologies to share learnings back with the team.&lt;/p&gt;
&lt;h2 id="what-is-saga-pattern-in-distributed-systems"&gt;&lt;a href="https://newsletter.scalablethread.com/p/what-is-saga-pattern-in-distributed" rel="noopener noreferrer"&gt;What is Saga Pattern in Distributed Systems?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a microservices architecture, a single user action like placing an order often spans multiple services (inventory, payment, shipping), each owning its own isolated database—meaning traditional single-database ACID transactions no longer work. The &lt;strong&gt;Saga Pattern&lt;/strong&gt; solves this by breaking a distributed business transaction into a sequence of local transactions; if any step fails along the way, the saga executes a chain of &lt;strong&gt;compensating transactions&lt;/strong&gt; to semantically undo the steps that already succeeded.&lt;/p&gt;
&lt;p&gt;The post contrasts the two main ways to coordinate a saga. &lt;strong&gt;Orchestration&lt;/strong&gt; uses a central coordinator service that directs each participant step by step, making control flow, monitoring, and error recovery easy to follow at the risk of central coupling. &lt;strong&gt;Choreography&lt;/strong&gt; lets services react to one another asynchronously via domain events without a central orchestrator, keeping services loosely coupled but making end-to-end flow and failure recovery harder to trace as workflows grow. The author wraps up with a summary of the Saga pattern&amp;rsquo;s strengths (eventual data consistency, horizontal scalability, flexibility) and trade-offs (implementation complexity, tricky compensation logic, and added latency).&lt;/p&gt;
&lt;h2 id="what-would-happen-if-we-didn"&gt;&lt;a href="https://github.com/Hawzen/hdp" rel="noopener noreferrer"&gt;What would happen if we didn&amp;rsquo;t use TCP or UDP?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author asks a fun networking question: what actually happens if you send packets over a custom transport-layer protocol instead of TCP, UDP, or ICMP? To find out, he designed a toy protocol called &lt;strong&gt;HDP&lt;/strong&gt;, wrote a client and server in Rust using raw sockets, and tested sending packets over the macOS loopback interface across every possible 8-bit IP &lt;code&gt;Protocol&lt;/code&gt; header number. Most protocol numbers went through fine locally, except &lt;code&gt;1&lt;/code&gt; (ICMP), &lt;code&gt;2&lt;/code&gt; (IGMP), and &lt;code&gt;6&lt;/code&gt; (TCP), which the macOS kernel intercepted before they reached the user-space server, &lt;code&gt;50&lt;/code&gt; and &lt;code&gt;51&lt;/code&gt; (IPSec ESP/AH), which the OS refused to send, and &lt;code&gt;256&lt;/code&gt;, which overflows the 8-bit field. Re-running the exact same test on Linux yielded completely different behavior, showing how differently OS kernels handle raw sockets.&lt;/p&gt;
&lt;p&gt;Testing across the public Internet got even weirder: sending HDP packets to a DigitalOcean droplet let &lt;em&gt;exactly one&lt;/em&gt; packet through before every subsequent packet was silently dropped—likely due to provider firewall rules and NAT gateways that rely on TCP/UDP port numbers to track connection state. Sending from a Mac at home to an AWS EC2 instance also dropped after the first packet, whereas two AWS instances in the same region communicated over HDP without issue at latencies indistinguishable from UDP; a March 1, 2025 update showed that sending over &lt;strong&gt;IPv6&lt;/strong&gt; (bypassing NAT entirely) worked reliably end-to-end too. The verdict: custom IP transport protocols can work in controlled environments or over IPv6, but middleboxes on the public IPv4 Internet are why modern protocols like QUIC are built on top of UDP.&lt;/p&gt;
&lt;h2 id="scoped-values-in-java-24---inside-java-newscast-86"&gt;&lt;a href="https://www.youtube.com/watch?v=7tfUJLUbZiM" rel="noopener noreferrer"&gt;Scoped Values in Java 24 - Inside Java Newscast #86&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Inside Java Newscast #86 introduces &lt;strong&gt;Scoped Values&lt;/strong&gt;, entering its fourth preview in Java 24 (JEP 487), which provides a safe, clean, and efficient way to share immutable data across methods within a thread and its child threads by binding values to a bounded lexical execution scope. The video contrasts Scoped Values with legacy &lt;code&gt;ThreadLocal&lt;/code&gt; variables and shows how child virtual threads forked inside a &lt;code&gt;StructuredTaskScope&lt;/code&gt; automatically inherit parent bindings—eliminating mutable global state and making concurrent code easier to reason about.&lt;/p&gt;
&lt;h2 id="java-24---better-language-better-apis-better-runtime"&gt;&lt;a href="https://www.youtube.com/watch?v=2NTyzL-9Bfo" rel="noopener noreferrer"&gt;Java 24 - Better Language, Better APIs, Better Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This video rounds up the standout improvements landing across Java 22, 23, and 24 along three tracks: language features, standard library APIs, and JVM runtime performance. Highlights include unnamed patterns and variables, single-statement module imports, the finalized Foreign Function &amp;amp; Memory (FFM) API, Stream Gatherers, and under-the-hood runtime optimizations that make modern Java more expressive, ergonomic, and performant.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/f112df94-df52-4140-98ec-873e5b74d988_1280x1601.gif" alt="30 Free APIs for Developers"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c3bf4776-744b-4e87-85f8-6dddd6d85597_1280x1566.gif" alt="The Generative AI Learning Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c1dbb32e-8d1b-4c13-ae48-fe485ad92191_1280x1601.gif" alt="HTTP/1 -&amp;gt; HTTP/2 -&amp;gt; HTTP/3"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d864f35c-537c-4571-8644-ce20d1a0caa5_1280x1427.gif" alt="Structure of URL"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Lis4w4_bBc" rel="noopener noreferrer"&gt;8 Most Important Tips for Designing Fault-Tolerant System&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-resources-from-redisio"&gt;Bonus 3: Interesting resources from &lt;a href="https://redis.io/" rel="noopener noreferrer"&gt;Redis.io&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://redis.io/resources/cache-and-message-broker-for-microservices-solution-brief.pdf" rel="noopener noreferrer"&gt;Cache and Message Broker for Microservices&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://redis.io/wp-content/uploads/2021/12/caching-at-scale-with-redis-updated-2021-12-04.pdf" rel="noopener noreferrer"&gt;Caching at Scale With Redis&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #8</title><link>https://miti99.com/en/post/2025/03/24/</link><pubDate>Mon, 24 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #8.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="let"&gt;&lt;a href="https://info.michael-simons.eu/2025/02/05/lets-deadlock-all-the-things/" rel="noopener noreferrer"&gt;Let&amp;rsquo;s deadlock all the things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael J. Simons recounts a &amp;ldquo;rookie mistake&amp;rdquo; he made while migrating code from legacy &lt;code&gt;HttpURLConnection&lt;/code&gt; to Java&amp;rsquo;s modern &lt;code&gt;HttpClient&lt;/code&gt;. Because &lt;code&gt;HttpClient&lt;/code&gt; does not directly expose an &lt;code&gt;OutputStream&lt;/code&gt; for streaming data into a request body (for instance, when using Jackson to serialize a large JSON payload), he connected a &lt;code&gt;PipedInputStream&lt;/code&gt; and a &lt;code&gt;PipedOutputStream&lt;/code&gt; and ended up performing both the write and the read on the same thread—even though the JavaDoc explicitly warns that doing so can deadlock. Initial unit tests passed because the test payloads were tiny, but as soon as a payload exceeded the default 1,024-byte pipe buffer in production, the thread blocked forever; repeated enough times, it starves the entire thread pool.&lt;/p&gt;
&lt;p&gt;What could have prevented the bug, the author reflects, was a little less overconfidence, a second pair of eyes in code review, and thorough boundary testing. AI assistants might help generate larger test payloads, he notes, but rarely catch subtle API misuses—and even IntelliJ didn&amp;rsquo;t flag a warning. The fix was to create the two streams independently, connect them outside both the reader and writer lambdas, run the write operation on a dedicated virtual thread, and close the output stream inside that thread. It&amp;rsquo;s a great reminder to read the JavaDoc carefully and understand the threading model of the APIs you use.&lt;/p&gt;
&lt;h2 id="engineers-who-won"&gt;&lt;a href="https://www.seangoedecke.com/taking-a-position/" rel="noopener noreferrer"&gt;Engineers who won&amp;rsquo;t commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that sitting on the fence in technical discussions is only acceptable when you are a junior engineer. Once you are the person in the room with the most context, skill, or influence, you have a responsibility to take a position—even when you are only 55–60% confident. Staying silent forces less-informed teammates to guess, creates a vacuum where the loudest, least-competent voice can steer the group into a bad idea, and ultimately punts hard technical decisions onto engineering managers. The author bluntly calls this refusal to commit cowardice, rooted in a fear of being wrong that he himself had to overcome earlier in his career.&lt;/p&gt;
&lt;p&gt;Managers, he notes, are generally quite forgiving when you make a well-reasoned call that turns out to be wrong, as long as you aren&amp;rsquo;t wrong all the time. Refusing to give time estimates is the same failure mode: managers need a rough ballpark to plan around, and answering &amp;ldquo;it depends&amp;rdquo; just forces them to make up a number themselves. The one exception is genuinely toxic workplaces where engineers are punished for missed estimates—there, keeping your head down is understandable. He also adds that when brainstorming with peers who share your level of context, staying open-minded and exploratory is completely fine.&lt;/p&gt;
&lt;h2 id="patterns-for-building-realtime-features"&gt;&lt;a href="https://zknill.io/posts/patterns-for-building-realtime/" rel="noopener noreferrer"&gt;Patterns for building realtime features&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zak Knill surveys four common architectural patterns for building real-time features where a server pushes one user&amp;rsquo;s changes out to other connected clients. The &lt;strong&gt;poke/pull&lt;/strong&gt; pattern is the easiest to bolt onto an existing system: the server sends a lightweight &amp;ldquo;poke&amp;rdquo; notification prompting clients to refetch the latest state via standard HTTP APIs, though this can trigger a thundering herd of simultaneous requests that must be mitigated with caching or client-side jitter. &lt;strong&gt;Push state&lt;/strong&gt; sends the entire updated state payload directly, preventing client drift, but scales poorly as state objects grow and makes it hard for clients to tell exactly what changed. &lt;strong&gt;Push ops&lt;/strong&gt; sends only the delta operation (such as flipping a todo item&amp;rsquo;s &lt;code&gt;completed&lt;/code&gt; field), keeping payloads small, but requires a way to fetch initial state and demands that the server track each client&amp;rsquo;s current state version. &lt;strong&gt;Event sourcing&lt;/strong&gt; broadcasts the domain event itself, requiring every client to reimplement the business logic needed to interpret and fold that event into local state.&lt;/p&gt;
&lt;p&gt;At the transport layer, WebSockets, Server-Sent Events (SSE), and long polling all operate as 1-to-1 HTTP connections between a single client and a single server instance. Once you scale horizontally across multiple server replicas, the instance that processes a write is often not the instance holding open connections to the other clients that need the update. Rather than having every server replica poll the database, the author recommends using a Pub/Sub backbone to fan updates out across instances and manage connection infrastructure.&lt;/p&gt;
&lt;h2 id="optimizing-the-databases-at-quora"&gt;&lt;a href="https://quoraengineering.quora.com/Optimizing-the-databases-at-Quora" rel="noopener noreferrer"&gt;Optimizing the databases at Quora&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Quora engineering team shares how they optimized their database tier as the platform scaled to handle massive data volumes while keeping user-facing latency low. Their first strategy was partitioning data (sharding) by &lt;code&gt;user_id&lt;/code&gt; to distribute load across multiple database servers. Alongside sharding, the team profiled common query patterns, added targeted indexes, and eliminated redundant queries. Quora also built a multi-layered caching architecture—spanning application-level caches for hot objects, database-level query caching, and a distributed Memcached tier—while separating read and write paths so each side could scale independently.&lt;/p&gt;
&lt;p&gt;Beyond those core techniques, Quora invested heavily in comprehensive monitoring and alerting to track database health and catch anomalies early. Key takeaways include treating performance optimization as an ongoing discipline rather than a one-off project, building automation tooling for routine database administration, and constantly balancing raw performance gains against system simplicity.&lt;/p&gt;
&lt;h2 id="failure-mitigation-for-microservices-an-intro-to-aperture"&gt;&lt;a href="https://careersatdoordash.com/blog/failure-mitigation-for-microservices-an-intro-to-aperture/" rel="noopener noreferrer"&gt;Failure Mitigation for Microservices: An Intro to Aperture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cong Ma and Matt Ranney from DoorDash examine common failure modes in microservice architectures: cascading failures rippling across service dependencies, retry storms where aggressive retries pile extra load onto an already degraded service, death spirals where failed nodes shift traffic onto surviving nodes until they collapse too, and metastable failures where a positive feedback loop keeps a system wedged even after the original trigger disappears. Traditional defenses like local load shedding, circuit breakers, and reactive autoscaling only see a single service&amp;rsquo;s local state, require brittle threshold tuning, and cannot coordinate with one another; the authors also advocate predictive autoscaling over reactive scaling that kicks in only after load has already spiked.&lt;/p&gt;
&lt;p&gt;From there, the post evaluates Aperture, an open-source reliability management platform from FluxNinja designed around global visibility and closed-loop control. Aperture collects telemetry from service nodes into Prometheus, uses a standalone controller to monitor deviations from SLOs based on declarative YAML policies, and actuates proportional responses—such as load shedding or distributed rate limiting—at individual nodes. After integrating Aperture into a core service in their staging environment, DoorDash found it worked well as an easy-to-configure load shedder compared to their existing setup, though more advanced capabilities like coordinated multi-service failure mitigation remained to be tested.&lt;/p&gt;
&lt;h2 id="zero-configuration-service-mesh-with-on-demand-cluster-discovery"&gt;&lt;a href="https://netflixtechblog.com/zero-configuration-service-mesh-with-on-demand-cluster-discovery-ac6483b52a51" rel="noopener noreferrer"&gt;Zero Configuration Service Mesh with On-Demand Cluster Discovery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team recounts their journey migrating to a service mesh. Netflix began moving to the cloud in 2008, with the streaming platform running entirely on AWS by 2010. Back when cloud-native tooling barely existed, they built Eureka for service discovery and Ribbon for inter-process communication (IPC). That architecture served them well for a decade, but as internal traffic diversified across REST, GraphQL, and gRPC in multiple programming languages—and teams needed advanced capabilities like adaptive concurrency limits and circuit breaking—maintaining polyglot client libraries became unsustainable. Moving to an Envoy-based service mesh let them centralize IPC logic in an out-of-process proxy.&lt;/p&gt;
&lt;p&gt;The biggest roadblock was that Envoy expects every upstream cluster a service might call to be declared ahead of time, whereas a typical Netflix service talks to dozens of upstream clusters whose owners often don&amp;rsquo;t know the full dependency list—and pushing every cluster in the company to every Envoy proxy was impossible with millions of endpoints. Netflix partnered with Kinvolk and the Envoy community to build &lt;strong&gt;On-Demand Cluster Discovery&lt;/strong&gt;: when an outgoing request targets an unknown cluster, Envoy pauses the request, queries the control plane via CDS (Cluster Discovery Service), fetches its endpoints via EDS backed by Eureka, and resumes the request. This made migration completely zero-configuration for service owners, at the cost of a few extra milliseconds on the very first request to a new cluster—meaning only ultra-latency-sensitive services need to pre-declare clusters or pre-warm connections.&lt;/p&gt;
&lt;h2 id="the-quest-to-understand-metric-movements"&gt;&lt;a href="https://medium.com/pinterest-engineering/the-quest-to-understand-metric-movements-8ab12ae97cda" rel="noopener noreferrer"&gt;The Quest to Understand Metric Movements&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Pinterest engineering team introduces the three pillars behind their automated Root Cause Analysis (RCA) system for investigating sudden spikes or drops in core business metrics—movements that can stem from anything from an OS upgrade to a broken data pipeline. The first approach, &lt;strong&gt;Slice and Dice&lt;/strong&gt;, breaks a metric down across dimensions like country, device type, and Pin format into a hierarchical segment tree (inspired by LinkedIn&amp;rsquo;s ThirdEye) and scores each segment&amp;rsquo;s anomaly contribution; this proved especially effective for video playback metrics. The second approach, &lt;strong&gt;General Similarity&lt;/strong&gt;, searches for other metrics that moved in a similar pattern over the same time window using Pearson correlation, Spearman rank correlation, Euclidean distance, and dynamic time warping—with Pearson and Spearman proving most useful because they provide p-values and capture inverse relationships cleanly (with the standard caveat that correlation does not imply causation).&lt;/p&gt;
&lt;p&gt;The third approach, &lt;strong&gt;Experiment Effects&lt;/strong&gt;, inverts traditional A/B test analysis: given a moving metric, it ranks active experiments that had the strongest statistically significant impact on that metric using Welch&amp;rsquo;s t-test and noise filters, and is now integrated into Pinterest&amp;rsquo;s experimentation platform covering nearly 2,000 metrics. Analysts can chain all three techniques iteratively to narrow down root causes. Looking ahead, Pinterest plans to incorporate user feedback loops, explore causal discovery to map cause-and-effect graphs across metrics, and embed RCA directly into their data discovery and visualization tools.&lt;/p&gt;
&lt;h2 id="meta"&gt;&lt;a href="https://cacm.acm.org/research/metas-hyperscale-infrastructure-overview-and-insights/" rel="noopener noreferrer"&gt;Meta&amp;rsquo;s Hyperscale Infrastructure: Overview and Insights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chunqiang Tang provides a sweeping overview of Meta&amp;rsquo;s hyperscale infrastructure and the lessons learned along the way, arguing that while few engineers directly build infrastructure at this scale, many mainstream industry technologies originate there. Meta&amp;rsquo;s engineering culture revolves around four pillars: moving fast with continuous deployment, technological openness via a unified monorepo and major open-source projects like PyTorch, Llama, and Presto, conducting systems research directly on production infrastructure rather than in an isolated research lab, and standardizing on shared infrastructure building blocks (for instance, converging product teams onto ZippyDB as a common key-value store). To maximize developer productivity, Meta pushes continuous deployment to extreme scale—executing over 100,000 configuration changes per day with 97% of services deploying completely automatically, while roughly 50% more engineers write serverless functions than traditional long-running services.&lt;/p&gt;
&lt;p&gt;To drive down hardware costs, Meta treats its global fleet of data centers as a single planet-scale computer, automatically placing and migrating workloads across regions, co-designing hardware and software to compensate for commodity hardware failure rates, and tiering storage across hot, warm, and cold media. On the AI front, Meta co-designs the entire stack—from PyTorch, custom AI accelerators, and datacenter fabrics up to foundation models like Llama—and projects that before the end of the decade, more than half of its datacenter power capacity will be dedicated to AI workloads.&lt;/p&gt;
&lt;h2 id="incremental-platforms-monolithic-modular-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-platforms-monolithic" rel="noopener noreferrer"&gt;Incremental Platforms: Monolithic Modular Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kicking off a series on incremental architecture for SaaS products, Marcos F. Lobo introduces the &lt;strong&gt;Modular Monolith&lt;/strong&gt;: packaging and deploying the entire application as a single artifact while structuring the internal codebase into well-defined modules with clear responsibilities that communicate strictly through explicit interfaces and contracts. This approach retains the operational simplicity of a monolith while capturing the modularity benefits of decoupled design. To pull it off, the author advises defining strict module boundaries and using patterns like Facade to hide internal implementation details, enforcing high cohesion and low coupling within each module, aligning package structure with module boundaries so modules can be extracted later if needed, pairing use-case testing with CI/CD, and wiring dependencies via dependency injection or in-process messaging and events.&lt;/p&gt;
&lt;p&gt;The benefits include simple single-artifact deployment and operations, easier refactoring and local development, fast in-memory calls between modules instead of network RPCs, straightforward transactional consistency, and natural alignment with Domain-Driven Design when modules map to bounded contexts. According to the author, a modular monolith is an ideal starting point for early-stage products, small teams, and systems that prioritize strong consistency, while serving as a clean stepping stone toward microservices if and when business scale demands it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos-from-bytebytego"&gt;Bonus: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Kqal7QaCCM" rel="noopener noreferrer"&gt;How the Garbage Collector Works in Java, Python, and Go!&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus 2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c3beec9e-cd04-4748-ae7e-3299b42883f6_2360x2824.png" alt="How to Build Idempotent APIs"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2f632296-4214-4ec8-a1d2-280e9b7f2696_1280x1532.gif" alt="12 Algorithms for System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/65a92a81-f2c5-4aed-9faa-35a66124cffe_1283x1536.gif" alt="How Kubernetes Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a6903386-4b5f-450e-b64d-839c6fdf8238_1280x1601.gif" alt="PostgreSQL 101: The Everything Database"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/06c5ad46-faaf-479b-bde3-b5de8033b4e9_1280x1664.gif" alt="Top 12 Tips for API Security"&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-images-from-designgurus"&gt;Bonus 3: Interesting images from &lt;a href="https://designgurus.io/" rel="noopener noreferrer"&gt;DesignGurus&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://www.designgurus.io/_next/image?url=https%3A%2F%2Fstorage.googleapis.com%2Fdownload%2Fstorage%2Fv1%2Fb%2Fdesigngurus-prod.appspot.com%2Fo%2Fee5726e8e29469477b999c100%3Fgeneration%3D1726724098184989%26alt%3Dmedia&amp;amp;w=3840&amp;amp;q=75&amp;amp;dpl=dpl_3Rx6M949Pc1cQKT3QTdj87FcKNdg" alt="System Design Master Template"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>