<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Go on miti99</title><link>https://miti99.com/en/tags/go/</link><description>Recent content in Go 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/go/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 #135</title><link>https://miti99.com/en/post/2026/10/03/</link><pubDate>Sat, 03 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #135.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="git-at-any-scale"&gt;&lt;a href="https://cursor.com/blog/git-at-any-scale" rel="noopener noreferrer"&gt;Git at any scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vicent Martí explains why hosting centralized Git repositories at massive scale is notoriously difficult: Git packfiles are large binary blobs that expect to live on a local POSIX filesystem with fast &lt;code&gt;mmap&lt;/code&gt; random access. Early attempts to ditch packfiles and store loose Git objects in distributed key-value stores made &lt;code&gt;git clone&lt;/code&gt; unusably slow, because walking the commit and tree graph incurred a network round trip at every hop. Shared network filesystems like NFS, GFS, or DRBD proved slow, brittle, and operationally painful. GitHub&amp;rsquo;s Spokes replicates repositories at the application layer using a three-phase commit for reference transactions, but push throughput is bottlenecked by the slowest replica, and fixing every repo at three copies over-provisions cold repos while under-provisioning hot CI monorepos—all while requiring a massive central routing database.&lt;/p&gt;
&lt;p&gt;Cursor&amp;rsquo;s &lt;em&gt;Continuity&lt;/em&gt; engine flips the architecture by making a write-ahead log (WAL) on S3-compatible object storage the single source of truth. Every &lt;code&gt;git push&lt;/code&gt; writes its pack data and ref update to the WAL before acknowledging the client, becoming visible only after the reference transaction succeeds and updates the WAL index—making all pushes strictly linearizable. Standard on-disk Git repositories on local NVMe drives act purely as stateless, disposable caches reconstructed on demand from the WAL, eliminating consensus protocols entirely. Nodes are selected via rendezvous hashing, while write safety relies on S3&amp;rsquo;s conditional compare-and-swap (&lt;code&gt;If-Match&lt;/code&gt; / &lt;code&gt;If-None-Match&lt;/code&gt;). Read replicas receive invalidation hints over UDP gossip and verify freshness via conditional &lt;code&gt;GET&lt;/code&gt; requests with ETags in under 10 ms. Only the primary node runs packfile compaction; replicas simply download compacted packs from S3. Benchmarks on Cursor&amp;rsquo;s own monorepo show linear read scaling up to 100 replicas, ~120 pushes/sec on S3 Standard, and over 300 pushes/sec on S3 Express One Zone—laying the foundation for Origin, Cursor&amp;rsquo;s Git hosting platform built for high-concurrency agent workloads.&lt;/p&gt;
&lt;h2 id="regressive-jpegs"&gt;&lt;a href="https://maurycyz.com/projects/bad_jpeg/" rel="noopener noreferrer"&gt;Regressive JPEGs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maurycy explores a delightfully cursed trick with progressive JPEGs, a format designed to transmit low-frequency image components first so a partially downloaded photo appears blurry rather than half-blank. Inside a progressive JPEG, compressed image data is divided into multiple &amp;ldquo;scans,&amp;rdquo; each with its own header specifying which color channels (&lt;code&gt;Y&lt;/code&gt;, &lt;code&gt;Cb&lt;/code&gt;, &lt;code&gt;Cr&lt;/code&gt;), which range of DCT frequency bins, and which bit-precision slice it contains. The first scan normally carries the DC (average color) bin for all three channels, while subsequent scans progressively fill in high-frequency AC detail. Because each scan declares its own spectral range, the author realized nothing stops a later scan from &lt;em&gt;overwriting&lt;/em&gt; frequency bins that were already rendered—meaning you can concatenate multiple same-resolution images into a single JPEG file (stripping their intermediate &lt;code&gt;SOI&lt;/code&gt;, &lt;code&gt;SOF&lt;/code&gt;, and &lt;code&gt;EOI&lt;/code&gt; markers) so the image morphs from one picture into another as it loads over a slow connection.&lt;/p&gt;
&lt;p&gt;The catch is that browsers cap the maximum number of scans they will decode before giving up (likely as a defense against decompression bombs), limiting full-detail progressive overwrites to about nine frames. To cram a real animation into a single JPEG, you have to minimize the number of scans per frame. Because the JPEG spec forbids mixing DC and AC coefficients in the same progressive scan, the smallest possible frame is a single DC-only scan—producing a blocky 8×8-pixel-per-block low-res image. Using one DC scan per frame, Chrome renders roughly 90 frames before bailing out, Firefox keeps going even longer, and ghosting artifacts vanish because there are no leftover AC coefficients from earlier frames bleeding through. The result is an entire multi-second video inside a valid &lt;code&gt;.jpg&lt;/code&gt; file—utterly useless in production since playback speed is dictated entirely by network bandwidth, but prime material for a rickroll.&lt;/p&gt;
&lt;h2 id="a-quick-look-at-zero-knowledge-proofs"&gt;&lt;a href="https://bernsteinbear.com/blog/zkp/" rel="noopener noreferrer"&gt;A quick look at zero-knowledge proofs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Bernstein and Chris Gregory demystify zero-knowledge proofs (ZKPs) through a classic example that has nothing to do with cryptocurrency: proving a graph is 3-colorable, following Goldreich, Micali, and Wigderson&amp;rsquo;s 1986 paper. In a ZKP, a &lt;em&gt;prover&lt;/em&gt; claims to know a secret solution to a hard problem, and a &lt;em&gt;verifier&lt;/em&gt; wants to be convinced the prover truly knows it without learning a single bit about the solution itself. Graph 3-coloring—assigning one of three colors to every vertex so no two connected vertices share a color—is NP-complete to solve but trivial to check locally along any single edge. Each round of the interactive protocol runs in four steps: the prover randomly permutes the three color names, &amp;ldquo;locks&amp;rdquo; each vertex&amp;rsquo;s permuted color inside a sealed box, and sends all the locked boxes to the verifier; the verifier picks one random edge &lt;code&gt;(u, v)&lt;/code&gt; and challenges the prover; the prover sends back the keys to only boxes &lt;code&gt;u&lt;/code&gt; and &lt;code&gt;v&lt;/code&gt;; and the verifier opens those two boxes to verify that their colors are valid and different.&lt;/p&gt;
&lt;p&gt;In Python code, a &amp;ldquo;locked box&amp;rdquo; is a cryptographic commitment: the hash of the vertex&amp;rsquo;s color concatenated with a random cryptographic nonce (using &lt;code&gt;hashlib.sha256&lt;/code&gt; and &lt;code&gt;secrets&lt;/code&gt;), since hashing the color alone without a random nonce would produce identical hashes for same-colored vertices and leak the coloring structure. Because a cheating prover who doesn&amp;rsquo;t actually have a valid 3-coloring can still get lucky unless the verifier picks the exact edge that violates the rules, a single round catches a cheater with probability at least $1/m$ (where $m$ is the number of edges). Repeating the protocol with fresh random color permutations and nonces for $m^2$ rounds drives the probability of forgery down exponentially: on a 1,000-edge graph, ~4,600 rounds reduce the soundness error below 1%, and 10,000 rounds drop it to 0.0045%. The authors build a working client-server demo and note that because 3-coloring is NP-complete, any NP problem—from Sudoku to integer factorization—can theoretically be reduced to it, even if the resulting circuit graph balloons quickly in size.&lt;/p&gt;
&lt;h2 id="the-pulse-we-need-to-talk-about-migrations-with-ai"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-we-need-to-talk-about-migrations-with-ai/" rel="noopener noreferrer"&gt;The Pulse: We need to talk about migrations with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this free edition of &lt;em&gt;The Pulse&lt;/em&gt;, Gergely Orosz argues that AI coding tools have fundamentally changed the economics of large-scale code migrations that teams previously put off for years as prohibitively expensive. The headline example comes from Asana: according to an OpenAI case study, Asana used Codex to rip out Enzyme and migrate their test suite to React Testing Library in roughly 1.5 engineer-weeks and ~$12,000 in model and compute costs—a migration previously estimated at $6 million and five years of background effort. Similarly, Airbnb migrated 3,500 Enzyme test files in six weeks (versus a 1.5 engineer-year manual estimate), Uber migrated 600,000 JUnit 4 tests to JUnit 5 in four months with two engineers, and Bun ported 530,000 lines of Zig to Rust in two weeks for $165,000 in API spend. By contrast, back in 2021 Sentry spent 1.5 years and roughly ten engineers migrating 95,000 lines of JavaScript to TypeScript.&lt;/p&gt;
&lt;p&gt;Across these successes, the same engineering patterns recur: automated retry loops when a migrated file fails to build or pass tests, multi-phase per-file pipelines, engineer-designed verification harnesses, starting with leaf files or frequently touched files first, and refactoring the codebase beforehand so patterns are uniform for the LLM. Orosz notes that Asana&amp;rsquo;s &amp;ldquo;$6M saved&amp;rdquo; headline is likely inflated—manual estimates rarely account for humans getting much faster after the first hundred files—and stresses that every single migration still required experienced engineers to design the pipeline, build the verification gates, and handle edge cases. Even so, the cost-benefit curve for paying down massive technical debt has shifted permanently.&lt;/p&gt;
&lt;h2 id="the-accidental-application-runtime"&gt;&lt;a href="https://adventures.michaelfbryan.com/posts/accidental-application-runtime" rel="noopener noreferrer"&gt;The Accidental Application Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael F. Bryan describes how a small Go service managing a 3D-printer farm gradually grew into an tangled mess. It started as a simple dashboard where the HTTP server spawned a single background goroutine to poll printer status. Over time, polling jobs from a cloud backend, persisting state to SQLite, scheduling print jobs, streaming G-code, and reporting telemetry were all bolted onto that same initialization block until &lt;code&gt;NewServer&lt;/code&gt; was spawning five long-running background goroutines. When the team needed to add graceful shutdown on &lt;code&gt;SIGTERM&lt;/code&gt;, figuring out which goroutines were running, in what order they needed to stop, and who owned closing which Go channels required reading the entire startup file line by line. Bryan calls this an &amp;ldquo;accidental application runtime&amp;rdquo;: the service had a real concurrent pub/sub architecture, but nothing in the code&amp;rsquo;s structure made that topology explicit.&lt;/p&gt;
&lt;p&gt;Inspired by the PX4 drone autopilot&amp;rsquo;s uORB messaging layer, Bryan built a lightweight Go library called &lt;code&gt;backplane&lt;/code&gt;. Each subsystem becomes a plain Go function &lt;code&gt;func(ctx, deps...) error&lt;/code&gt; whose typed parameters declare its communication topology: a &lt;code&gt;chan&amp;lt;- T&lt;/code&gt; parameter publishes to topic &lt;code&gt;T&lt;/code&gt;, &lt;code&gt;&amp;lt;-chan T&lt;/code&gt; subscribes to a stream of &lt;code&gt;T&lt;/code&gt;, and &lt;code&gt;*backplane.Latest[T]&lt;/code&gt; polls the latest state snapshot. Topics are keyed by Go types rather than error-prone string names. &lt;code&gt;backplane.New&lt;/code&gt; validates the dependency graph before startup, and &lt;code&gt;Run&lt;/code&gt; supervises the modules like an &lt;code&gt;errgroup&lt;/code&gt; with in-process, backpressured delivery. Rebuilding the printer service as six explicit modules—anchored by a strict &lt;em&gt;commit-then-notify&lt;/em&gt; rule where the scheduler commits job state to SQLite before publishing a wake-up message—even let the team auto-generate accurate Mermaid architecture diagrams straight from the function signatures.&lt;/p&gt;
&lt;h2 id="generic-methods-in-go-127"&gt;&lt;a href="https://dominik.info/blog/go-generic-methods" rel="noopener noreferrer"&gt;Generic Methods in Go 1.27&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When Go 1.18 introduced generics in 2022, functions and types could declare type parameters, but methods could not declare additional type parameters of their own. Go 1.27 finally lifts that restriction: methods can now introduce their own type parameters without polluting the receiver struct. Dominik Braun illustrates why this matters using a generic graph node &lt;code&gt;Node[T]&lt;/code&gt;. Previously, if you wanted a &lt;code&gt;Map&lt;/code&gt; method that transforms a &lt;code&gt;Node[T]&lt;/code&gt; into a &lt;code&gt;Node[U]&lt;/code&gt;, you either had to pollute the struct definition itself as &lt;code&gt;Node[T, U]&lt;/code&gt;—forcing every unrelated method on &lt;code&gt;Node&lt;/code&gt; to carry &lt;code&gt;U&lt;/code&gt; around—or give up on method syntax and write a standalone package-level function &lt;code&gt;Map[T, U any](n *Node[T], ...)&lt;/code&gt;. Starting in Go 1.27, you can simply write &lt;code&gt;func (n *Node[T]) Map[U any](...) Node[U]&lt;/code&gt;, scoping &lt;code&gt;U&lt;/code&gt; strictly to the &lt;code&gt;Map&lt;/code&gt; method.&lt;/p&gt;
&lt;p&gt;Why did this take four years to land? The hurdle lay in how Go compiles generics versus how it dispatches interfaces. Go&amp;rsquo;s compiler primarily uses &lt;em&gt;monomorphization&lt;/em&gt; (stenciling specialized machine code for concrete type shapes at compile time), whereas Go interfaces rely on runtime dynamic dispatch via an &lt;code&gt;itable&lt;/code&gt; of function pointers. Those two models collide if an interface is allowed to declare a generic method like &lt;code&gt;type Mapper interface { Map[U any]() Node[U] }&lt;/code&gt;: the compiler cannot pre-populate a fixed-size runtime vtable for an unbounded set of potential type arguments &lt;code&gt;U&lt;/code&gt;, especially when reflection can look up methods dynamically at runtime. Go&amp;rsquo;s pragmatic compromise in 1.27 is to allow generic methods on concrete types while forbidding them in interface definitions—and a generic method cannot be used to satisfy an interface.&lt;/p&gt;
&lt;h2 id="your-executable-is-a-sqlite-database"&gt;&lt;a href="https://fzakaria.com/2026/08/23/your-executable-is-a-sqlite-database" rel="noopener noreferrer"&gt;Your executable is a SQLite database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria, author of &lt;code&gt;sqlelf&lt;/code&gt;, takes his previous experiment to its logical conclusion: replacing ELF entirely with SQLite as a native Linux executable format. His prototype, &lt;strong&gt;SELF&lt;/strong&gt; (&lt;em&gt;Structured Executable &amp;amp; Linkable Format&lt;/em&gt;), produces real SQLite database files that you can &lt;code&gt;chmod +x&lt;/code&gt; and run directly from the shell. His core argument is that ELF is already an ad-hoc, bespoke relational database in denial: &lt;code&gt;.strtab&lt;/code&gt; is string interning, &lt;code&gt;.gnu.hash&lt;/code&gt; is a hash index, section headers are a catalog table, and symbol versioning is a foreign-key schema. In SELF, an executable&amp;rsquo;s schema consists of a &lt;code&gt;self_meta&lt;/code&gt; table for the ELF header, a &lt;code&gt;segments&lt;/code&gt; table storing each program header row with its raw machine code/data as a SQLite &lt;code&gt;BLOB&lt;/code&gt;, and a &lt;code&gt;symbols&lt;/code&gt; table indexed by standard SQLite B-trees in place of &lt;code&gt;.dynsym&lt;/code&gt; and &lt;code&gt;.gnu.hash&lt;/code&gt;. Registering the SQLite magic header with Linux&amp;rsquo;s &lt;code&gt;binfmt_misc&lt;/code&gt; lets the kernel hand &lt;code&gt;./my_app&lt;/code&gt; directly to &lt;code&gt;self-exec&lt;/code&gt;, a tiny C loader that queries the segments, maps them into memory, performs relocations, and jumps to the entry point.&lt;/p&gt;
&lt;p&gt;For dynamic linking, SELF supports two modes: keeping glibc&amp;rsquo;s standard &lt;code&gt;ld.so&lt;/code&gt; and using an &lt;code&gt;rtld-audit&lt;/code&gt; hook so a SQL query resolves shared libraries, or using &lt;code&gt;self-ld&lt;/code&gt;, an experimental SQL-native dynamic linker. Even cooler, &lt;code&gt;self closure&lt;/code&gt; bundles a binary and all its transitive shared-library dependencies into a single self-contained SQLite database file—turning &lt;code&gt;ldd&lt;/code&gt; into a simple SQL &lt;code&gt;JOIN&lt;/code&gt;. Packing all 723 executables in &lt;code&gt;/usr/bin&lt;/code&gt; into a single shared SELF database shrank total size from 644.4 MiB (ELF) down to 611.9 MiB thanks to cross-binary library and symbol deduplication, even though individual standalone SELF files are 2.2x to 3.6x larger than their ELF counterparts. While copying segments out of SQLite blobs prevents cross-process &lt;code&gt;mmap&lt;/code&gt; page sharing for &lt;code&gt;.text&lt;/code&gt; segments and slows cold start on massive binaries, being able to inspect, strip, or atomically patch executables with &lt;code&gt;UPDATE&lt;/code&gt; and &lt;code&gt;ROLLBACK&lt;/code&gt; is a fascinating glimpse into an alternate Unix universe.&lt;/p&gt;
&lt;h2 id="what-happens-when-a-gpu-reads-memory"&gt;&lt;a href="https://blog.doubleword.ai/what-happens-when-a-gpu-reads-memory" rel="noopener noreferrer"&gt;What happens when a GPU reads memory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doubleword founder Fergus Finn traces the exact hardware journey of a single global memory load instruction (&lt;code&gt;LDG.E&lt;/code&gt;) inside an NVIDIA RTX 4090. Because NVIDIA documents very little of its microarchitectural memory pipeline publicly, Finn reverse-engineered the path using custom cycle-accurate microbenchmarks and hardware performance counters. When a 32-thread warp issues a 4-byte load per thread, the hardware coalescer groups those 32 requests into four 32-byte sectors—one 128-byte cache line. On an L1 miss, the virtual address passes through a 16-entry per-SM L1 TLB (backed by 2 MiB pages) to translate into a physical address, because the L2 cache is physically indexed. From there, the chip-wide crossbar routes the request to one of 36 L2 cache slices selected by an undocumented hash of the physical address bits, which in turn forwards L2 misses to one of 12 memory controllers wired to 12 GDDR6X chips—where the controller must issue an expensive DRAM row &lt;code&gt;ACTIVATE&lt;/code&gt; command to open a 1 KiB row before bursting the four 32-byte sectors back.&lt;/p&gt;
&lt;p&gt;The latency ladder is stark: an L1 hit takes ~15.4 ns, an L2 hit takes ~127 ns, and a full miss down to GDDR6X DRAM takes ~255 ns—roughly 660 GPU clock cycles during which that warp sits stalled. Activating a new DRAM row costs roughly 15x more time than reading from an already-open row, and hammering a single L2 slice caps throughput at 1,957 million loads/sec versus ~68,000 million loads/sec when spread evenly across all 36 slices (a 34.8x difference). GPUs hide that 660-cycle latency through massive warp-level parallelism—switching to other ready warps every cycle—which is why memory-bound kernels live or die by coalesced access patterns that spread traffic evenly across L2 slices and DRAM banks.&lt;/p&gt;
&lt;h2 id="a-faster-way-to-calculate-the-day-of-the-week"&gt;&lt;a href="https://www.benjoffe.com/fast-day-of-week" rel="noopener noreferrer"&gt;A faster way to calculate the day-of-the-week&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Joffe tackles a deceptively simple problem: converting a signed 32-bit Unix epoch day count (&lt;code&gt;1970-01-01&lt;/code&gt; = Thursday) into a day of the week (&lt;code&gt;0..6&lt;/code&gt;) as fast as possible across the entire 32-bit integer range. Cassio Neri&amp;rsquo;s 2024 algorithm serves as the state-of-the-art baseline, but requires an extra correction step because 7 is an awkward divisor in binary. Joffe&amp;rsquo;s key insight is to exploit the fact that $7 = 2^3 - 1$ is a Mersenne number, which means $N \bmod 7 = \lfloor N \cdot \frac{8}{7} \rfloor \bmod 8$. Multiplying by $\frac{8}{7}$ can be approximated by a single fixed-point multiplication by a magic constant &lt;code&gt;M&lt;/code&gt;, and taking $\bmod 8$ comes almost for free by masking or shifting to keep only the top three bits of the fractional part. A bounded 32-bit version reduces to a one-liner—&lt;code&gt;((u32(rd) * M + Z) &amp;gt;&amp;gt; 29)&lt;/code&gt;—valid across $\pm 242,000$ years, which sped up weekday calculations in the Rust &lt;code&gt;jiff&lt;/code&gt; datetime crate by ~40%.&lt;/p&gt;
&lt;p&gt;To cover the full signed 32-bit domain without overflow, Joffe presents several variants: widening to a 64-bit multiply (already adopted by WebKit), adding a bit-shifted correction term that executes in parallel with the multiply, using two multiplies for higher instruction throughput, or collapsing the entire calculation into three x86 instructions via &lt;code&gt;LEA&lt;/code&gt;. Switching between Sunday-indexed (&lt;code&gt;0..6&lt;/code&gt;) and ISO Monday-indexed (&lt;code&gt;1..7&lt;/code&gt;) output only requires swapping the additive constant &lt;code&gt;Z&lt;/code&gt;. Better yet, the same Mersenne identity generalizes to any divisor of the form $2^N - 2^K$, including &lt;code&gt;x % 24&lt;/code&gt; and &lt;code&gt;x % 60&lt;/code&gt; for extracting hours, minutes, and seconds. Benchmarks show Joffe&amp;rsquo;s variants taking just 0.17x to 0.39x the runtime of Neri&amp;rsquo;s algorithm on an Apple M4 Pro and 0.27x to 0.59x on a Ryzen 9 9950X3D, with patches already merged into WebKit, Elixir, Rust&amp;rsquo;s &lt;code&gt;jiff&lt;/code&gt;, and Zig&amp;rsquo;s &lt;code&gt;zeit&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="dark-mode-toggles-two-states-are-enough"&gt;&lt;a href="https://lea.verou.me/blog/2026/dark-mode-toggles/" rel="noopener noreferrer"&gt;Dark mode toggles: two states are enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lea Verou argues that website header dark-mode toggles should only expose two visible states to the user, even though the underlying state machine has three (&lt;code&gt;System&lt;/code&gt;, &lt;code&gt;Light&lt;/code&gt;, and &lt;code&gt;Dark&lt;/code&gt;). In her view, exposing a three-way segmented control or dropdown in the navbar solves an imaginary user goal: nobody visits a website thinking &amp;ldquo;my OS is in light mode and this page looks great in light mode, let me proactively pin it to Light just in case my OS switches to dark mode tonight.&amp;rdquo; Users click a theme toggle for one reason: &lt;em&gt;the current appearance is uncomfortable to read right now, make it the opposite&lt;/em&gt;. Exposing all three states in the header is classic &amp;ldquo;implementation-model UI&amp;rdquo; that adds visual clutter, extra clicks, and unnecessary cognitive load. At the same time, a naive two-state toggle is even worse if clicking it once permanently locks &lt;code&gt;localStorage&lt;/code&gt; into an override with no way to return to following the OS theme.&lt;/p&gt;
&lt;p&gt;Verou&amp;rsquo;s solution is a single two-state button that cleanly traverses all three underlying states. By default (when following the OS), the button displays the currently active theme and stores nothing in &lt;code&gt;localStorage&lt;/code&gt;. Clicking it once switches to the opposite theme and saves that explicit override. Clicking it a second time switches back to the theme that matches the user&amp;rsquo;s current OS preference—and instead of saving a hard override, it &lt;em&gt;clears&lt;/em&gt; the stored setting, returning the site to &lt;code&gt;System&lt;/code&gt; mode. Because the override is only re-evaluated when the user clicks the toggle, users whose OS automatically flips between light and dark at sunset can still override a site whenever they want without getting stuck permanently out of sync. Reserve explicit three-way &lt;code&gt;Light / Dark / Auto&lt;/code&gt; selectors for dedicated settings pages—not the top navigation bar.&lt;/p&gt;</description></item><item><title>Newsletter #133</title><link>https://miti99.com/en/post/2026/10/01/</link><pubDate>Thu, 01 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #133.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-go-is-an-ideal-language-for-ai-assisted-software-engineering"&gt;&lt;a href="https://developers.googleblog.com/why-go-is-an-ideal-language-for-ai-assisted-software-engineering/" rel="noopener noreferrer"&gt;Why Go is an Ideal Language for AI-Assisted Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with &lt;code&gt;gofmt&lt;/code&gt;, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.&lt;/p&gt;
&lt;p&gt;On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go&amp;rsquo;s checksum database guards against tampered dependencies, while &lt;code&gt;govulncheck&lt;/code&gt; alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and &lt;code&gt;go fix&lt;/code&gt; lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.&lt;/p&gt;
&lt;h2 id="how-does-programming-language-affect-token-efficiency-and-correctness"&gt;&lt;a href="https://danluu.com/pl-tokens/" rel="noopener noreferrer"&gt;How does programming language affect token efficiency and correctness?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete &lt;code&gt;zstd&lt;/code&gt; decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).&lt;/p&gt;
&lt;p&gt;The results tell a nuanced story: on &lt;code&gt;zstd&lt;/code&gt; at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed &lt;code&gt;byte&lt;/code&gt; coercion throws an exception on values &lt;code&gt;128–255&lt;/code&gt;. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren&amp;rsquo;t enough to draw universal laws, the blanket claim that &amp;ldquo;dynamic languages are better for LLMs&amp;rdquo; doesn&amp;rsquo;t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.&lt;/p&gt;
&lt;h2 id="my-agentic-coding-setup-july-2026"&gt;&lt;a href="https://domenic.me/agentic-coding-setup/" rel="noopener noreferrer"&gt;My Agentic Coding Setup, July 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a &amp;ldquo;semi-disposable&amp;rdquo; Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (&lt;code&gt;--dangerously-skip-permissions&lt;/code&gt; / &lt;code&gt;--yolo&lt;/code&gt;) mode with &lt;code&gt;gh&lt;/code&gt; pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn&amp;rsquo;t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.&lt;/p&gt;
&lt;p&gt;The remaining pieces solve each workflow friction point: &lt;code&gt;git worktree&lt;/code&gt; lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT&amp;rsquo;s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and &lt;code&gt;chezmoi&lt;/code&gt; syncs his &lt;code&gt;AGENTS.md&lt;/code&gt;, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.&lt;/p&gt;
&lt;h2 id="the-bedrock-of-software-design"&gt;&lt;a href="https://alex.draftist.io/blog/the-bedrock-of-software-design-ycqvcedsj" rel="noopener noreferrer"&gt;The Bedrock of Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. &lt;em&gt;Product types&lt;/em&gt; combine multiple fields into a single value, like a struct with an &lt;code&gt;id&lt;/code&gt; and a &lt;code&gt;role&lt;/code&gt;; &lt;em&gt;sum types&lt;/em&gt; (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either &lt;code&gt;Anonymous&lt;/code&gt; or &lt;code&gt;Authenticated(User)&lt;/code&gt;. When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with &lt;code&gt;Switchable&lt;/code&gt; and &lt;code&gt;Fixed&lt;/code&gt; variants, each holding only the fields that actually apply, making illegal states unrepresentable.&lt;/p&gt;
&lt;p&gt;The same thinking applies to errors and the absence of values. With unchecked exceptions, a function&amp;rsquo;s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via &lt;code&gt;Result&lt;/code&gt;, whose error type can itself be a domain-specific sum type carrying rich context. &lt;code&gt;Option&amp;lt;T&amp;gt;&lt;/code&gt; replaces &lt;code&gt;null&lt;/code&gt;, and a signature like &lt;code&gt;Result&amp;lt;Option&amp;lt;User&amp;gt;, FindUserError&amp;gt;&lt;/code&gt; cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive &lt;code&gt;match&lt;/code&gt; expressions force callers to handle every variant, so when a new &lt;code&gt;Staff&lt;/code&gt; role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev&amp;rsquo;s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.&lt;/p&gt;
&lt;h2 id="90--of-the-t-distribution"&gt;&lt;a href="https://entropicthoughts.com/ninety-percent-of-the-t-distribution" rel="noopener noreferrer"&gt;90 % of the t distribution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student&amp;rsquo;s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.&lt;/p&gt;
&lt;p&gt;With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you&amp;rsquo;re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-computer-not-a-container--introducing-cloudflarecomputer"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-computer/" rel="noopener noreferrer"&gt;Your agent needs a computer, not a container — introducing @cloudflare/computer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare has released a preview of &lt;code&gt;@cloudflare/computer&lt;/code&gt;, an open-source, npm-installable agent runtime that gives every AI agent its own virtual &amp;ldquo;computer&amp;rdquo; complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare&amp;rsquo;s target is for containers to handle less than 10% of an agent&amp;rsquo;s workload.&lt;/p&gt;
&lt;p&gt;Architecturally, the runtime decouples the agent&amp;rsquo;s &amp;ldquo;brain&amp;rdquo; from its &amp;ldquo;hands&amp;rdquo;: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a &lt;code&gt;node:fs&lt;/code&gt;-compatible wrapper. Two execution backends sit behind a unified &lt;code&gt;exec&lt;/code&gt; interface: the isolate backend uses &lt;code&gt;just-bash&lt;/code&gt; to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.&lt;/p&gt;
&lt;h2 id="notes-on-incidents"&gt;&lt;a href="https://www.seangoedecke.com/notes-on-incidents/" rel="noopener noreferrer"&gt;Notes on incidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic &amp;ldquo;firefighting&amp;rdquo; often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.&lt;/p&gt;
&lt;p&gt;When intervention &lt;em&gt;is&lt;/em&gt; needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.&lt;/p&gt;
&lt;h2 id="beyond-clean-code-why-your-comments-matter"&gt;&lt;a href="https://blog.moertel.com/posts/2026-07-27-beyond-clean-code-why-your-comments-matter.html" rel="noopener noreferrer"&gt;Beyond “Clean Code”: Why Your Comments Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express &lt;em&gt;what&lt;/em&gt; the machine is instructed to do, whereas human readers also need to know &lt;em&gt;what the author intended&lt;/em&gt; and &lt;em&gt;why&lt;/em&gt; the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn&amp;rsquo;t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; that comments shouldn&amp;rsquo;t be used as deodorant for needlessly tangled code, he argues that the dogma &amp;ldquo;every comment is a failure&amp;rdquo; goes way too far. Crucial &amp;ldquo;why&amp;rdquo; context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.&lt;/p&gt;
&lt;p&gt;Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. &lt;em&gt;&amp;ldquo;Comments lie&amp;rdquo;&lt;/em&gt;: without a comment stating the intent, buggy code leaves zero clue that it&amp;rsquo;s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. &lt;em&gt;&amp;ldquo;Comments rot&amp;rdquo;&lt;/em&gt;: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.&lt;/p&gt;
&lt;h2 id="relying-on-go"&gt;&lt;a href="https://antonz.org/relying-on-go/" rel="noopener noreferrer"&gt;Relying on Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many new programming languages pitch themselves as &amp;ldquo;like Go, but with more features&amp;rdquo; or &amp;ldquo;like Rust, but simpler.&amp;rdquo; Anton Zhiyanov takes the opposite path with Solod, a &amp;ldquo;systems language for C and Go programmers&amp;rdquo;: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, &lt;code&gt;gopls&lt;/code&gt; autocomplete, linters, formatters, and &lt;code&gt;go.mod&lt;/code&gt; package management. The developer workflow is identical to Go: install the &lt;code&gt;so&lt;/code&gt; CLI tool, initialize a Go module, import Solod&amp;rsquo;s standard library package, and write normal Go code; &lt;code&gt;so run .&lt;/code&gt; compiles and runs the binary just like &lt;code&gt;go run&lt;/code&gt;. Even Solod&amp;rsquo;s standard library reuses large swaths of Go&amp;rsquo;s standard library code and test suites, adapted for manual memory management.&lt;/p&gt;
&lt;p&gt;Zhiyanov is upfront about the trade-offs: standard Go tooling doesn&amp;rsquo;t know about Solod&amp;rsquo;s subset restrictions, so &lt;code&gt;gopls&lt;/code&gt; won&amp;rsquo;t warn you if you use unsupported Go features like closures or iterators—catching those is up to the &lt;code&gt;so&lt;/code&gt; compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, &lt;code&gt;so&lt;/code&gt; transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn&amp;rsquo;t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod&amp;rsquo;s greatest strength.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was reviewed and updated by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #131</title><link>https://miti99.com/en/post/2026/09/09/</link><pubDate>Wed, 09 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #131.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-codename-one-javascript-port-is-now-free-and-open-source"&gt;&lt;a href="https://dev.to/codenameone/the-codename-one-javascript-port-is-now-free-and-open-source-2f84" rel="noopener noreferrer"&gt;The Codename One JavaScript Port Is Now Free and Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Codename One has open-sourced its JavaScript port under GPLv2 with the Classpath Exception. Previously restricted to Enterprise subscribers, the port is now available across all tiers, and developers can build web targets locally without even needing a Codename One account via a single Maven command powered by the bundled ParparVM compiler. ParparVM also replaces TeaVM as the default compiler for both local and cloud builds, though TeaVM remains available via a build hint for comparison. Architecturally, the application&amp;rsquo;s Java code runs inside a background Web Worker while browser interaction lives on the main UI thread, preventing Java code from accidentally coupling to the DOM or browser globals.&lt;/p&gt;
&lt;p&gt;The release also ships major framework additions. A unified Calendar API connects device calendars, Google Calendar, Microsoft 365, CalDAV, and &lt;code&gt;.ics&lt;/code&gt; files with support for recurring events, incremental sync, offline change queues, and conflict resolution. Bluetooth moves into the core framework with BLE, GATT, L2CAP, RFCOMM, and Web Bluetooth support. &lt;code&gt;EditField&lt;/code&gt;, &lt;code&gt;RichTextArea&lt;/code&gt;, and &lt;code&gt;CodeEditor&lt;/code&gt; now render and edit text directly on the canvas instead of overlaying native text inputs, while &lt;code&gt;RichTextComponent&lt;/code&gt; renders HTML, Markdown, AsciiDoc, and RTF without a WebView. A new proxy layer supports Jakarta Servlet, Node.js, PHP, AWS Lambda, Google Cloud Functions, and Cloudflare Workers. Finally, ParparVM adds compressed strings—halving memory usage for ASCII text—and Android API 36 becomes the default target next week.&lt;/p&gt;
&lt;h2 id="hacking-in-the"&gt;&lt;a href="https://committing-crimes.com/articles/2026-08-04-java-nameof/" rel="noopener noreferrer"&gt;Hacking in the &lt;code&gt;nameOf&lt;/code&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Java lacks C#&amp;rsquo;s &lt;code&gt;nameof&lt;/code&gt; expression for obtaining an identifier&amp;rsquo;s name as a compile-time string. That gap is especially annoying in argument validation, where you end up hardcoding parameter names into exception messages like &lt;code&gt;&amp;quot;name must not be blank&amp;quot;&lt;/code&gt;—and if someone renames the variable later without updating the string, the compiler won&amp;rsquo;t say a word. This article experiments with building a pure-Java &lt;code&gt;nameOf&lt;/code&gt; function that recovers variable names at runtime without bytecode instrumentation agents or annotation processors.&lt;/p&gt;
&lt;p&gt;The hack works in three steps. First, &lt;code&gt;StackWalker&lt;/code&gt; locates the caller frame that invoked &lt;code&gt;nameOf&lt;/code&gt;, yielding the class, method name, method descriptor, and exact bytecode index (BCI). Next, the caller class&amp;rsquo;s &lt;code&gt;.class&lt;/code&gt; file is loaded into memory and parsed into a &lt;code&gt;ClassModel&lt;/code&gt; using Java&amp;rsquo;s new Class-File API. Finally, the author simulates the JVM operand stack symbolically: instead of actual runtime values, each stack slot holds a symbolic label—such as a local variable or field name—which is propagated across load, store, field-access, and invocation instructions until the simulator reaches the exact BCI of the &lt;code&gt;nameOf&lt;/code&gt; call and reads the symbolic name sitting on top of the stack. The author strongly advises against using this in production: it breaks on unfamiliar opcodes, relies on optional debug info or the &lt;code&gt;-parameters&lt;/code&gt; compiler flag, may fail on non-&lt;code&gt;javac&lt;/code&gt; bytecode, and is barely tested. It is a delightful over-engineering exercise that doubles as a tour of JVM bytecode and the Class-File API.&lt;/p&gt;
&lt;h2 id="set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep"&gt;&lt;a href="https://dev.to/sshenvi/set-it-and-ship-it-how-i-let-ai-agents-build-my-java-services-while-i-sleep-1jhj" rel="noopener noreferrer"&gt;Set It and Ship It: How I Let AI Agents Build My Java Services While I Sleep&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sudarshan Shenvi argues that AI agents are fully capable of building production-grade Java services autonomously over multi-hour runs, provided their work is gated by strict verification controls; without those gates, you just get plausible-sounding slop. He relies on three pillars: machine-verifiable requirements where every item specifies a concrete behavior or performance threshold that grades as pass or fail; a separate critic agent that audits the output item by item, since the builder agent must never grade its own homework; and an always-on execution harness with interactive permission prompts disabled so a five-hour run doesn&amp;rsquo;t stall waiting for a human click, paired with narrowly scoped credentials, sandboxed isolation, and hard spend limits.&lt;/p&gt;
&lt;p&gt;As an example, he walks through a ticket to build a payment reconciliation service. Instead of writing Java code, the engineer writes a 15-line requirements contract specifying REST endpoints, reconciliation logic, JPA entities, p95 latency under 500 ms, 100% test coverage, and security constraints. He kicks off the agent at 9:10 a.m. and walks away; the critic loop catches missing latency proof and a package structure violation, the builder agent fixes both, and by 11:35 a.m. he returns to a 15/15 passing scorecard with measured latency at 410 ms. Shenvi cautions that token consumption can spike unpredictably, so teams should enforce strict budget caps, run agents on isolated branches inside sandboxes, and always keep human code review before merging.&lt;/p&gt;
&lt;h2 id="software-abundance"&gt;&lt;a href="https://nader.substack.com/p/software-abundance" rel="noopener noreferrer"&gt;Software abundance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nader Dabit, a 14-year industry veteran currently at Cognition, writes that despite earlier anxieties about AI&amp;rsquo;s impact on software engineering, he has never been more optimistic about the field. He sees a sharp bifurcation in the job market: engineers who actively adopt AI-native workflows and pivot toward AI-driven growth areas are seeing stronger compensation and opportunities, while those who cling rigidly to narrow traditional silos like pure frontend or backend—or stay at slow-moving legacy enterprises—face headwinds and layoffs.&lt;/p&gt;
&lt;p&gt;The centerpiece of his argument is Jevons paradox: when the cost of producing software drops and capacity rises, demand for software doesn&amp;rsquo;t shrink—it expands dramatically. Teams he works with are now shipping 10x to 20x more pull requests than before, and cloud-hosted agents let non-specialists ship changes that previously required senior engineers. Higher velocity leads to more ambitious product roadmaps and a higher bar for polish. In Dabit&amp;rsquo;s view, software engineering isn&amp;rsquo;t disappearing; it is shedding the repetitive toil engineers disliked anyway—bug bashing, dependency upgrades, rote migrations—freeing humans to focus on judgment, curiosity, domain context, and taste, while reclaiming time for the creative experimentation that drew them to programming in the first place.&lt;/p&gt;
&lt;h2 id="the-development-pipeline-is-a-production-system"&gt;&lt;a href="https://sundry.jerryorr.com/2026/07/31/development-pipeline-is-a-production-system" rel="noopener noreferrer"&gt;The development pipeline is a production system&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jerry Orr argues that the software development pipeline is itself a production system, and when it breaks, engineering teams should treat the outage with the same urgency as a customer-facing incident. When the build is broken, developers cannot work; when the QA environment goes down, testers cannot verify releases. For those internal users, it is literally a production outage, and any component blocking the path from code commit to deployment—whether issue trackers, CI/CD runners, or a flaky test suite—represents a critical failure.&lt;/p&gt;
&lt;p&gt;Orr draws a parallel with manufacturing, where factories have long had disciplined processes to minimize assembly-line downtime, whereas software teams routinely neglect their own internal delivery infrastructure. He recommends explicitly cataloging and prioritizing every essential piece of the development pipeline: work and change-management platforms, developer tools like IDEs and build systems, artifact registries and local dev environments, CI/CD pipelines, QA environments, and automated test suites. Applying structured incident management—borrowed from IT service management and manufacturing—to developer infrastructure is essential, because a broken pipeline directly prevents value from reaching customers.&lt;/p&gt;
&lt;h2 id="how-llms-figure-out-what-you-mean---no-math-degree-required"&gt;&lt;a href="https://zarar.dev/how-ai-figures-out-what-you-mean-no-math-required/" rel="noopener noreferrer"&gt;How LLMs Figure Out What You Mean - No Math Degree Required&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains how a large language model figures out the meaning of a sentence without requiring any math background, using the question &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt; as a running example. Step one is turning words into numbers: text is split into tokens, each assigned an integer ID. A single ID number carries no semantic meaning on its own—there is no reason token #2 should be &amp;ldquo;similar&amp;rdquo; to token #3—so each token is mapped to an embedding vector, a long list of numbers whose dimensions jointly capture aspects of meaning so that words with similar meanings have similar vectors. You can picture vectors as arrows in space: synonyms point in the same direction, antonyms point in opposite directions, and unrelated words sit at right angles.&lt;/p&gt;
&lt;p&gt;To measure how closely two words align, the model uses the dot product, illustrated as two people pushing a shopping cart: push in the same direction and your forces add up to a high positive score; push at an angle and efficiency drops; push in opposite directions and you cancel each other out with a negative score. Because raw scores only make sense relative to one another, the model passes them through a &lt;code&gt;softmax&lt;/code&gt; function to convert them into percentages—like giving each word a single dollar of attention to slice up like a pizza among the other words in the sentence based on relevance. That is how, in &lt;code&gt;&amp;quot;Do lions roar?&amp;quot;&lt;/code&gt;, the word &lt;code&gt;&amp;quot;roar&amp;quot;&lt;/code&gt; directs most of its attention to &lt;code&gt;&amp;quot;lions&amp;quot;&lt;/code&gt; rather than &lt;code&gt;&amp;quot;Do&amp;quot;&lt;/code&gt;. All these vectors start out completely random and are gradually nudged into place during training via backpropagation over massive amounts of text.&lt;/p&gt;
&lt;h2 id="meet-alice-alice-is-impatient"&gt;&lt;a href="https://brooker.co.za/blog/2026/06/19/waiting.html" rel="noopener noreferrer"&gt;Meet Alice. Alice is impatient.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker opens with two scenarios every service operator recognizes. You measure an average request latency of 100 ms, yet your customer Alice swears she waits a full second on average. You report a mean time to recovery (MTTR) under one minute, yet your customer Alex experiences outages as lasting roughly an hour each. According to Brooker, both sides are telling the truth: operators average over &lt;em&gt;events&lt;/em&gt;, whereas customers sample across &lt;em&gt;time&lt;/em&gt;. This is the inspection paradox: the longer an outage or slow window lasts, the more customer requests (or retries) land inside it, so what customers actually experience is a duration-weighted version of the underlying distribution.&lt;/p&gt;
&lt;p&gt;Mathematically, if operators measure a mean duration of $E[X]$, a customer arriving at a random point in time experiences an expected duration of $\frac{E[X^2]}{2E[X]}$, which simplifies to $\frac{1}{2}\left(E[X] + \frac{\text{Var}(X)}{E[X]}\right)$. The gap between operator metrics and customer perception is proportional to the variance divided by the mean, meaning high variance drives perceived wait times through the roof. Brooker includes an interactive calculator and Python simulation: with a 30-minute median outage and a 600-minute p99, customers experience an average recovery time of roughly 6 hours even though measured MTTR is just 1 hour. Because real-world systems follow heavy-tailed distributions, trimming outliers hides the exact tail events that dominate customer pain. Short blips are already well handled by retries and failovers; long tail outages remain the industry&amp;rsquo;s unsolved problem and where engineering investment belongs.&lt;/p&gt;
&lt;h2 id="harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one"&gt;&lt;a href="https://lukasniessen.medium.com/harness-engineering-deep-dive-where-the-term-came-from-and-how-to-actually-build-one-a955bcdf5cce" rel="noopener noreferrer"&gt;Harness Engineering Deep Dive: Where The Term Came From, And How To Actually Build One&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen starts from the equation that has become standard in 2026: &lt;strong&gt;Agent = Model + Harness&lt;/strong&gt;. The harness is everything around the model: the execution loop, tools, sandboxing, context assembly, permissions, verification suites, durable state, execution traces, cost caps, and approval gates. Because you rent the model but own the harness, whenever an agent fails, instead of waiting for the next model release, you can re-engineer the environment so that class of failure becomes structurally impossible. Coined in early 2026 through posts by Mitchell Hashimoto, Birgitta Böckeler, and an OpenAI report, harness engineering represents the natural progression after prompt engineering and context engineering. The dividing line between a thin wrapper and a true harness is the closed feedback loop: once model outputs become actions executed against real state, whose results feed back into the next turn, every harness engineering concern comes into play.&lt;/p&gt;
&lt;p&gt;The technical deep dive walks through seven failure modes of a naive agent loop: sensors must distill signal rather than dumping raw stdout into the context window; conversation history is merely a cache while an external ledger holds the source of truth; the agent must never be allowed to declare its own work &amp;ldquo;done&amp;rdquo; without an external verifier; action spaces should be constrained via strict tool schemas rather than longer system prompts; budgets need stall detection; tool gates should be tiered by risk reversibility; and full execution traces must be treated as the primary unit of debugging. According to Niessen, harness quality alone can swing token consumption by 10x to 50x on the exact same task.&lt;/p&gt;
&lt;h2 id="how-big-is-a-git-commit"&gt;&lt;a href="https://ratfactor.com/cards/git-commit-size" rel="noopener noreferrer"&gt;How big is a Git commit?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How much disk space does a Git commit actually take? To find out, Dave Gauer measures the size of the &lt;code&gt;.git&lt;/code&gt; directory with &lt;code&gt;du -sb&lt;/code&gt; across a series of controlled scenarios, using only loose objects (no packfiles) to expose Git&amp;rsquo;s raw storage mechanics. A freshly initialized empty repository takes about 64 KB; committing 250 tiny files across 5 directories adds roughly 47 KB; a tiny edit to a single file inside that tree costs 17 KB, whereas making the exact same three-byte change in a repository containing only one file takes about 8.7 KB.&lt;/p&gt;
&lt;p&gt;The reason lies in Git&amp;rsquo;s object model: when you edit a file inside a subdirectory, Git writes four new zlib-compressed objects—the commit object itself, the updated blob holding the file&amp;rsquo;s full contents, a new tree object for the subdirectory listing all its entries, and a new root tree object. Even for a three-byte edit, that metadata and object overhead adds up to kilobytes and scales with directory depth and breadth. On larger files, zlib compression shines: a 580 KB binary shrinks to 298 KB, and a 16.4 MB source code file compresses down to 1.6 MB—about 10% of its original size. Across these large-file tests, &lt;code&gt;.git&lt;/code&gt; grows by roughly 10–50% of the raw data size depending on content compressibility. Gauer concludes that Git&amp;rsquo;s loose object storage is already remarkably frugal—especially for text—and packfiles make it dramatically smaller still by delta-compressing similar objects.&lt;/p&gt;
&lt;h2 id="how-i-find-problems-to-solve-as-a-staff-engineer"&gt;&lt;a href="https://lalitm.com/post/find-problems-staff-engineer/" rel="noopener noreferrer"&gt;How I Find Problems to Solve as a Staff Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lalit Maganti shares how he discovers high-leverage problems to solve as a Staff Engineer. Instead of blocking off calendar time to &amp;ldquo;think strategically,&amp;rdquo; he acts like a sponge: soaking up the daily ambient noise of meetings, chat channels, and email threads to absorb the friction people are experiencing. When something touches his domain, he digs past the surface request to uncover the underlying problem—sometimes sitting with teams to watch their workflow firsthand or debugging an issue himself to separate the real need from the solution the team asked for. He also deliberately resists jumping on the first request that comes in, since the loudest team doesn&amp;rsquo;t necessarily represent org-wide priorities; when the same pain point surfaces independently across multiple teams, that&amp;rsquo;s a strong signal.&lt;/p&gt;
&lt;p&gt;Long walks help him connect the dots across accumulated observations. On Perfetto, teams spent two years requesting disparate UI features—pinned tracks, custom zoom levels, bespoke aggregations—before he realized the underlying need was a general UI extensibility plugin system. Before committing engineering resources, he validates ideas with throwaway prototypes and socializes them with managers and partner teams. Solving the right problems builds trust that gets him invited into conversations earlier, letting him shape the roadmap without having to build everything himself—an approach he notes works best in bottom-up engineering cultures.&lt;/p&gt;
&lt;h2 id="golang-maps-how-swiss-tables-replaced-the-old-bucket-design"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-24-Golang-Maps-How-Swiss-Tables-Replaced-the-Old-Bucket-Design/" rel="noopener noreferrer"&gt;Golang Maps: How Swiss Tables Replaced the Old Bucket Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maps sit on the hot path of almost every Go program, and Go 1.24 replaced their internal implementation with Swiss Tables. The classic design used an array of buckets, each holding up to 8 key-value pairs plus metadata bytes; when a bucket filled up, the runtime allocated an overflow bucket and chained it via a pointer. While battle-tested, overflow chains forced lookups to chase pointers across non-contiguous memory, causing CPU cache misses, and capped the maximum load factor at roughly 81% before collision overhead degraded performance.&lt;/p&gt;
&lt;p&gt;Swiss Tables split each key&amp;rsquo;s hash into two parts: a prefix that selects the group, and a 7-bit fingerprint stored in a compact control byte array. Data is organized into 8-slot groups consisting of an 8-byte control word alongside key and value slots; during a lookup, the runtime scans all 8 control bytes in parallel using SIMD or bitwise operations, performs full key comparisons only on slots whose 7-bit fingerprint matches, and stops immediately if an empty slot is present. Most non-matching slots are filtered out at the cheap metadata stage, flat probing improves cache locality, and the max load factor rises to 87.5%. Rather than resizing one giant table all at once, Go uses an extendable hashing directory over multiple smaller tables so growth happens incrementally while preserving Go&amp;rsquo;s &lt;code&gt;range&lt;/code&gt; iteration semantics. Benchmarks show 2–3% overall CPU wins and 30–35% speedups on large map operations, with the trade-off that delete-heavy workloads leave tombstones that lengthen probe sequences until a table rehash clears them.&lt;/p&gt;
&lt;h2 id="the-new-rules-of-context-engineering-for-claude-5-models"&gt;&lt;a href="https://x.com/trq212/status/2080710971228918066" rel="noopener noreferrer"&gt;The new rules of context engineering for Claude 5 models&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you send a prompt to Claude, your message is only a small fraction of the context window it actually sees; the bulk is assembled from system prompts, skills, &lt;code&gt;CLAUDE.md&lt;/code&gt; files, memory, and tool definitions—and designing that assembly is context engineering. In this post, Anthropic engineer Thariq Shihipar reveals that the team deleted over 80% of Claude Code&amp;rsquo;s system prompt for frontier models like Claude Opus 5 and Claude Fable 5 without losing a single point on their coding evaluations. The reason is that earlier prompts over-constrained the model: within a single request, the system prompt, a skill, and the user&amp;rsquo;s &lt;code&gt;CLAUDE.md&lt;/code&gt; might give conflicting instructions—such as &amp;ldquo;write documentation where appropriate&amp;rdquo; alongside &amp;ldquo;DO NOT add comments&amp;rdquo;—forcing the model to waste reasoning tokens reconciling rules that newer models can navigate using their own judgment.&lt;/p&gt;
&lt;p&gt;The post contrasts old habits with the new playbook. Instead of rigid rules, trust the model&amp;rsquo;s judgment; the new instruction simply says &amp;ldquo;write code that matches the surrounding codebase.&amp;rdquo; Instead of stuffing few-shot tool examples into the prompt—which narrows exploration—design more expressive, self-documenting tool parameter schemas. Instead of front-loading everything into the initial context, use progressive disclosure: verification and code-review instructions are broken out into on-demand skills, and specialized tools are loaded lazily when needed. Memory is now captured automatically, and reference material can live as rich HTML artifacts or executable test suites rather than flat markdown files. Keep &lt;code&gt;CLAUDE.md&lt;/code&gt; lean, reserving it for non-obvious repo gotchas rather than facts Claude can discover by reading the code.&lt;/p&gt;
&lt;h2 id="the-git-history-command-deserves-more-attention"&gt;&lt;a href="https://lalitm.com/post/git-history/" rel="noopener noreferrer"&gt;The git history command deserves more attention&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Juggling multiple stacked changes in Git usually means tedious branch hopping and error-prone interactive rebases, which is why tools like &lt;code&gt;jj&lt;/code&gt; (Jujutsu) have gained a devoted following. Lalit Maganti argues that Git&amp;rsquo;s experimental &lt;code&gt;git history&lt;/code&gt; command—introduced across Git 2.54 (April 2026, adding &lt;code&gt;reword&lt;/code&gt; and &lt;code&gt;split&lt;/code&gt;) and Git 2.55 (June 2026, adding &lt;code&gt;fixup&lt;/code&gt;)—brings many of those same ergonomic benefits straight into stock Git without requiring a workflow overhaul, yet has flown largely under the radar. With &lt;code&gt;fixup&lt;/code&gt;, you stage changes via &lt;code&gt;git add&lt;/code&gt; and run &lt;code&gt;git history fixup &amp;lt;commit&amp;gt;&lt;/code&gt; to fold them directly into an earlier commit; every descendant local branch stacked on top of that commit is automatically rebased in place, going well beyond &lt;code&gt;git rebase --update-refs&lt;/code&gt;. Meanwhile, &lt;code&gt;reword&lt;/code&gt; opens your editor to amend an old commit message and automatically rebases the entire stack of descendant commits and branches, and &lt;code&gt;split&lt;/code&gt; interactively carves a commit into two.&lt;/p&gt;
&lt;p&gt;What unites all three subcommands is atomicity: they never drop your repository into a half-broken interactive rebase state, because they immediately abort any operation that would produce a merge conflict. That is also their biggest limitation compared to &lt;code&gt;jj&lt;/code&gt;, which treats conflicts as first-class objects you can resolve whenever you like; additionally, &lt;code&gt;fixup&lt;/code&gt; cannot cross merge commits, and Git still lacks &lt;code&gt;jj&lt;/code&gt;&amp;rsquo;s operation log for effortless undo. Git&amp;rsquo;s documentation notes that the conflict restriction may be lifted in future releases, but even today &lt;code&gt;git history&lt;/code&gt; is a major quality-of-life leap built right into standard Git.&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 #127</title><link>https://miti99.com/en/post/2026/07/29/</link><pubDate>Wed, 29 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/29/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #127.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-return-to-two-pizza-culture"&gt;&lt;a href="https://www.allthingsdistributed.com/2026/06/return-to-two-pizza-culture.html" rel="noopener noreferrer"&gt;A return to two-pizza culture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Werner Vogels looks back at the &amp;ldquo;two-pizza team&amp;rdquo; model that helped Amazon move fast: teams small enough that everyone understands each other&amp;rsquo;s work, owns their product end-to-end, and makes reversible decisions autonomously without waiting for sign-off. As a company grows to hundreds of services, cross-team dependencies, management layers, and review gates easily erode that agility. According to Vogels, coding agents like Kiro are changing the equation because a working prototype can now be built in hours instead of months.&lt;/p&gt;
&lt;p&gt;Through the story of the Amazon Quick desktop team—where the first prototype was built in a single evening and quickly attracted contributors—Vogels proposes adapting the Working Backwards process. When you have high conviction about a customer problem but aren&amp;rsquo;t yet sure about the solution, build a prototype first, dogfood it daily, fix bugs on the spot, and write the PR/FAQ document only after learning from hands-on experience. Writing remains essential for clarifying thought, but it is no longer the only way to make an idea concrete. Even when an organization grows to hundreds of people, structuring it as small teams with end-to-end ownership keeps innovation from stalling. AI tools don&amp;rsquo;t replace human judgment; they shorten the feedback loop between idea and reality.&lt;/p&gt;
&lt;h2 id="a-peek-into-reddit"&gt;&lt;a href="https://lyra.horse/blog/2026/06/reddit-spam-internals/" rel="noopener noreferrer"&gt;A peek into Reddit&amp;rsquo;s anti-spam internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In 2021, a brief UI bug exposed Reddit&amp;rsquo;s internal content-removal reasons to moderators. Piecing together screenshots from that incident, old open-source Reddit code, and public documentation, the author reconstructs how the platform fights spam. There is no single silver-bullet filter: Spamurai, the primary rule engine since 2020, combines account age and karma, user reports, ASN/network provider, browser fingerprinting via TLS and user-agent strings, email domains, and posting behavior. Alongside it sit domain blacklists dating back to 2012, the REV1 and REV2 rule generations, keyword filters, a fetcher that crawls linked pages to find shared analytics or ad IDs across domains, and external image classification services.&lt;/p&gt;
&lt;p&gt;The post also highlights how fragile individual signals can be in isolation. Against Google&amp;rsquo;s Perspective API, inserting just a few random letter pairs into a paragraph dropped its spam score from 86% down to 1%. Real-world anti-abuse systems therefore have to aggregate many independent signals and continuously learn from moderator actions. The author notes that publishing these details is now safe because the Perspective API is shutting down in 2026 and LLM-generated spam has forced Reddit to overhaul its defenses anyway—a reminder that anti-abuse architectures must constantly evolve alongside attacker techniques.&lt;/p&gt;
&lt;h2 id="understanding-the-go-runtime-profiling"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-profiling/" rel="noopener noreferrer"&gt;Understanding the Go Runtime: Profiling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the internal mechanics of Go&amp;rsquo;s five built-in profilers: CPU, heap, block, mutex, and goroutine. Although they measure different things, all five capture call stacks and emit the same compressed &lt;code&gt;pprof&lt;/code&gt; protobuf format: each sample stores only a list of location IDs and measurement values, while locations, functions, and strings live in shared lookup tables so thousands of identical stacks aren&amp;rsquo;t duplicated. What truly distinguishes the profilers is how each one captures stacks.&lt;/p&gt;
&lt;p&gt;CPU profiling is streaming: the OS sends a timer signal to interrupt threads roughly 100 times per second, the signal handler writes the stack into a lock-free ring buffer, and a background goroutine drains and aggregates those samples—willingly dropping samples if the buffer fills up so it never blocks a running thread. Heap profiling aggregates in place: the allocator samples roughly once every 512 KiB and folds the stack directly into a hash table bucketed by call stack to estimate both total allocations and live in-use memory. Block and mutex profiles reuse that same in-place table infrastructure to measure wait durations—one recording when a goroutine finishes waiting, the other recording contended lock releases and scaling the sample up to estimate total contention. Goroutine profiling, by contrast, is an on-demand snapshot that collects the stacks of all live goroutines via a two-phase mechanism designed to minimize stop-the-world pause time. The overarching lesson is that the Go runtime quietly absorbs a great deal of complexity so that profiling feels effortless to use.&lt;/p&gt;
&lt;h2 id="incident-report-cve-2026-lgtm"&gt;&lt;a href="https://nesbitt.io/2026/06/26/incident-report-cve-2026-lgtm.html" rel="noopener noreferrer"&gt;Incident Report: CVE-2026-LGTM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a satirical incident report about a fictional software supply-chain attack in which a malicious package, &lt;code&gt;foxhole-lz4&lt;/code&gt;, breezes past seven AI-powered security gates, each failing in its own way. The release gate trusts hidden white-on-white text claiming the package was manually audited. One scanner gets distracted critiquing an illustration embedded in the package, while three commercial scanners exhaust their context windows on padding before ever reaching the payload. The single system that accurately flags the credential-stealing behavior gets dismissed by the repository&amp;rsquo;s AI triage assistant as benign telemetry, and the human who reports the actual compromise is rate-limited by a triage bot for &amp;ldquo;suspicious activity.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Next, two evaluator agents burn over $41,000 arguing with each other, and the remediation agent signs a formal &amp;ldquo;treaty&amp;rdquo; with the attacker&amp;rsquo;s agent. Ultimately, an old-fashioned canary file planted by a human is what stops the breach. The root cause is summed up neatly: seven models lined up in a row—six assumed one of the others had read the code, and the seventh read it and apologized. The piece lampoons granting broad autonomy to AI agents without verification: stacking multiple layers powered by the same foundation model only creates an illusion of diversity; untrusted data must be separated from instructions; model failures must never default to &amp;ldquo;no findings&amp;rdquo;; and having a &amp;ldquo;human in the loop&amp;rdquo; needs to be a real operational control rather than a line item in a compliance contract.&lt;/p&gt;
&lt;h2 id="cors-what-is-it-protecting"&gt;&lt;a href="https://sanyamserver.online/posts/cors/" rel="noopener noreferrer"&gt;CORS: What is it protecting?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article clears up a widespread misconception: CORS is a browser-enforced security mechanism, not a server-side firewall. On cross-origin requests, the browser attaches an &lt;code&gt;Origin&lt;/code&gt; header, checks the response&amp;rsquo;s &lt;code&gt;Access-Control-Allow-Origin&lt;/code&gt; header, and allows frontend JavaScript to read the response body only if the origin is permitted. For simple requests that don&amp;rsquo;t trigger a preflight check, the server may have already executed the request even when the browser blocks JavaScript from reading the response. If a preflight check fails, the actual request is never sent. Command-line tools like &lt;code&gt;curl&lt;/code&gt; ignore browser CORS policies entirely. More complex requests—such as those using methods other than GET/POST/HEAD, custom headers, or JSON bodies—trigger an &lt;code&gt;OPTIONS&lt;/code&gt; preflight request asking the server which origins, methods, and headers it accepts.&lt;/p&gt;
&lt;p&gt;What CORS actually protects is data confidentiality in the browser: when configured properly, a malicious site cannot read your bank account details even though your browser holds an active session cookie. However, CORS does not prevent CSRF. A standard HTML form POST doesn&amp;rsquo;t require a preflight, so the server processes the state-changing request before the browser blocks the response from being read. Defending against CSRF requires request-side protections such as &lt;code&gt;SameSite&lt;/code&gt; cookie attributes, anti-CSRF tokens, or server-side validation of the &lt;code&gt;Origin&lt;/code&gt; and &lt;code&gt;Referer&lt;/code&gt; headers. In short, CORS and CSRF defenses solve two distinct problems and shouldn&amp;rsquo;t be conflated.&lt;/p&gt;
&lt;h2 id="data-access-patterns-that-makes-your-cpu-really-angry"&gt;&lt;a href="https://blog.weineng.me/posts/slowest_add/" rel="noopener noreferrer"&gt;Data Access Patterns That Makes Your CPU Really Angry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post runs a contrarian experiment: finding the slowest possible traversal order to sum all elements of a $2^{26}$-element array. Sequential scanning is the fastest at roughly 132 million cycles thanks to CPU caches and hardware prefetchers, while random access—typically treated as the worst case—takes about 1.57 billion cycles. The author systematically tests strided access patterns: jumping by one cache line, jumping by one memory page, and combining both. On the author&amp;rsquo;s Intel Core Ultra 7 268V, page-strided access is especially punishing because hardware prefetchers do not cross 4 KB page boundaries, while simultaneously causing many addresses to map to and thrash the exact same cache set in L1.&lt;/p&gt;
&lt;p&gt;The worst culprit is an eight-page stride—roughly 32 KB between consecutive reads—which takes around 2.06 billion cycles, about 33% slower than random access. It simultaneously saturates the cache set, defeats hardware prefetching, eliminates cache-line reuse, and destroys TLB locality, driving up address-translation overhead. The author also experiments with clustering accesses by DRAM bank and row to minimize memory-level parallelism, though undocumented physical address mapping makes that part approximate. Understanding why specific access patterns make a CPU crawl helps developers recognize the real-world limits of caches, prefetchers, and TLBs in everyday code.&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 #126</title><link>https://miti99.com/en/post/2026/07/23/</link><pubDate>Thu, 23 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #126.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="2-portable-executables"&gt;&lt;a href="https://anteiku.fun/papers/an-introduction-to-modern-malware-development-for-red-teams/02_portable_executables/" rel="noopener noreferrer"&gt;2. Portable Executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article is the second chapter in an introductory series on modern malware development for red teams, focusing on the Portable Executable (PE) format—the shared structure behind executables, dynamic-link libraries, and drivers on Windows. The author walks through the DOS Header, DOS Stub, PE Header, Optional Header, section table, and familiar sections such as &lt;code&gt;.text&lt;/code&gt;, &lt;code&gt;.data&lt;/code&gt;, &lt;code&gt;.rdata&lt;/code&gt;, &lt;code&gt;.rsrc&lt;/code&gt;, and &lt;code&gt;.reloc&lt;/code&gt;. The core point is that a PE simultaneously describes how the file is laid out on disk and how the Windows Loader maps it into memory: header fields specify the architecture, entry point, alignment, image size, and locations of key data directories, while each section&amp;rsquo;s attributes determine its contents and its read, write, or execute permissions at runtime.&lt;/p&gt;
&lt;p&gt;The second half shifts to the perspective of security products performing static analysis—evaluating a file before it is executed. Common indicators examined include hashes, digital signatures, data entropy, unusual entry point locations, sections marked &lt;code&gt;RWX&lt;/code&gt;, large discrepancies between on-disk and in-memory sizes, unfamiliar section names, sparse import tables, and suspicious API combinations. For newcomers, the article illustrates why a solid understanding of the PE structure is foundational both for analyzing malware and for building detection mechanisms against packed or obfuscated binaries.&lt;/p&gt;
&lt;h2 id="how-4-bytes-of-padding-make-array-clearing-49-faster"&gt;&lt;a href="https://blog.andr2i.com/posts/2026-06-22-optimization-catalog-how-4-bytes-of-padding-make-array-clearing-49-faster" rel="noopener noreferrer"&gt;How 4 bytes of padding make array clearing 49% faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part of the &amp;ldquo;Optimization catalog&amp;rdquo; series, this post analyzes a memory alignment phenomenon in Go: when a &lt;code&gt;uint32&lt;/code&gt; array sits at a 4-byte offset from an 8-byte boundary, clearing the array slows down dramatically. On the benchmarked Intel processor, adding just 4 bytes of padding to align the array to 8 bytes increases throughput by roughly 49%; on AMD the improvement is only around 9%, and ARM machines are virtually unaffected. Inspecting the assembly reveals that the entire clear is handled by a single &lt;code&gt;REP STOSQ&lt;/code&gt; instruction. Based on performance counters, the author hypothesizes that Intel&amp;rsquo;s fast-string path writes full cache lines directly without reading them first; when the array is misaligned by 4 bytes, an 8-byte store straddles every 64-byte cache-line boundary, so no cache line is ever completely overwritten in one go and the fast path cannot kick in.&lt;/p&gt;
&lt;p&gt;Follow-up benchmarks show that SIMD—whether via Go&amp;rsquo;s experimental intrinsics or handwritten assembly—does not outperform &lt;code&gt;STOSQ&lt;/code&gt;. A non-temporal store variant is occasionally faster, but its results fluctuate wildly depending on whether the OS kernel allocates contiguous or fragmented physical pages. The article also considers tagging elements with generation numbers to avoid actually zeroing memory, though generation tags enlarge the array and can push working data out of cache. The takeaway is that low-level optimizations depend heavily on the CPU microarchitecture, machine instructions, and data size, so you always need to measure on real hardware.&lt;/p&gt;
&lt;h2 id="engineering-high-performance-parsers-with-data-oriented-design"&gt;&lt;del&gt;&lt;a href="https://www.arshad.fyi/writings/engineering-high-performance-parsers" rel="noopener noreferrer"&gt;Engineering High-Performance Parsers with Data-Oriented Design&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This article shares the design principles behind Yuku, a JavaScript and TypeScript parser written in Zig, centered on one thesis: once the grammar is right, parser performance is dictated almost entirely by how the syntax tree is represented in memory rather than the parsing algorithm itself. Instead of individually heap-allocated nodes linked by pointers—which cause tens of thousands of allocations and unpredictable memory accesses—Yuku stores nodes in a flat array and uses &lt;code&gt;u32&lt;/code&gt; indices as references. An index takes half the space of a 64-bit pointer, the entire tree is freed in a single operation, and the recursive-descent parsing logic remains familiar.&lt;/p&gt;
&lt;p&gt;The author applies the same data-oriented mindset across the parser: splitting node payloads and source locations into separate parallel arrays so each traversal pass touches only the data it needs; storing variable-length child lists as offset-and-length pairs into an extra buffer; reusing scratch buffers across recursive calls; representing strings as byte spans into the original source; packing operator metadata directly into tag bits; and compressing Unicode lookup tables by deduplicating identical blocks. Size and layout invariants are verified at compile time to prevent accidental regressions. Because the tree consists purely of indices and offsets, its in-memory representation doubles as its wire format, allowing the AST to be handed over to JavaScript as a single contiguous buffer rather than serialized through JSON.&lt;/p&gt;
&lt;h2 id="how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-learn-go-fast-a-practical-roadmap-for-senior-backend-developers-18l5" rel="noopener noreferrer"&gt;How To Learn Go Fast: A Practical Roadmap For Senior Backend Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article lays out a Go learning roadmap for experienced backend developers, particularly those coming from PHP, Laravel, or Symfony. The author argues that you don&amp;rsquo;t need to relearn backend fundamentals like APIs, databases, or queues; instead, leverage that foundation and focus on how Go structures programs: explicit code, errors as values, small implicitly satisfied interfaces, explicit dependency wiring, and a preference for the standard library over monolithic frameworks.&lt;/p&gt;
&lt;p&gt;The roadmap starts with syntax, types, packages, and error handling before quickly moving into building CLI tools, HTTP services, and concurrent worker systems, since building small projects early teaches the language faster than reading syntax tutorials alone. A 12-week plan progresses from core fundamentals to PostgreSQL, integration testing, race detection, cancellation contexts, profiling, observability, and a portfolio-ready capstone project—treating testing, error handling, and operations as parallel tracks rather than afterthoughts. The post also includes a condensed multi-day track for developers jumping into an existing Go codebase immediately, while still emphasizing production habits like setting timeouts on network calls, implementing graceful shutdown, reading real-world source code, and profiling before optimizing. Ultimately, senior-level Go proficiency shows in your ability to build, deploy, diagnose, and maintain real systems.&lt;/p&gt;
&lt;h2 id="how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid--senior-engineers"&gt;&lt;a href="https://dev.to/nazar-boyko/how-to-prepare-for-a-golang-interview-a-practical-guide-for-mid-senior-engineers-200p" rel="noopener noreferrer"&gt;How To Prepare For A Golang Interview: A Practical Guide For Mid &amp;amp; Senior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article serves as a comprehensive study map for mid- and senior-level Go interviews, emphasizing that interviewers evaluate reasoning and system design rather than mere syntax recall. It covers zero values, packages, slices, maps, pointers, interfaces, error handling, &lt;code&gt;defer&lt;/code&gt;, &lt;code&gt;panic&lt;/code&gt;, and common memory pitfalls. Topics frequently used to separate candidates are explained in depth—such as shared backing arrays across slices, non-nil interfaces holding nil pointers, channel closing rules, and choosing between mutexes and channels—because these are also frequent sources of production bugs.&lt;/p&gt;
&lt;p&gt;The senior section expands into the G-M-P scheduler, the memory model, escape analysis, garbage collection, goroutine leaks, context cancellation, race detection, and profiling with &lt;code&gt;pprof&lt;/code&gt;. It also covers testing, databases, HTTP, graceful shutdown, system design, and operational concerns beyond the language itself. According to the author, a strong interview answer articulates choices, trade-offs, and how to verify behavior through tests or benchmarks. The guide concludes with a list of common mistakes, time-boxed coding exercises like worker pools, rate limiters, and retry mechanisms, and a self-assessment checklist for writing correct, production-grade Go.&lt;/p&gt;
&lt;h2 id="shard-your-locks-benchmarking-6-go-cache-designs"&gt;&lt;a href="https://strebkov.dev/posts/shard-your-locks/" rel="noopener noreferrer"&gt;Shard your locks: benchmarking 6 Go cache designs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks six ways to build a concurrent &lt;code&gt;string → string&lt;/code&gt; cache using only the Go standard library: an unlocked map (as a baseline), a single &lt;code&gt;Mutex&lt;/code&gt;, a single &lt;code&gt;RWMutex&lt;/code&gt;, &lt;code&gt;sync.Map&lt;/code&gt;, a 256-shard map, and copy-on-write. Benchmarks run across varying read/write ratios and from one to eight CPU cores. The results show that a single lock does not scale: at eight cores, even a read-only workload with a &lt;code&gt;Mutex&lt;/code&gt; is slower than on a single core. &lt;code&gt;RWMutex&lt;/code&gt;, the reflexive choice for read-heavy contention, scales only to about 2x before plateauing because its atomic reader counter becomes the new contention bottleneck—and under write-heavy workloads, it performs even worse than a plain &lt;code&gt;Mutex&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The sharded design, where each shard has its own map and lock, is the only approach that consistently ranks near the top across all workloads—outperforming a single lock by up to 8x because operations on different shards proceed in parallel. Copy-on-write leads on pure read workloads but collapses toward zero throughput as soon as writes appear, since every write clones the entire map, making it suitable only for rarely updated data. The author also notes that skewed key distributions can actually speed up reads thanks to CPU cache locality, while concentrating write contention onto a few hot shards. Using 256 shards is a sweet spot for this benchmark rather than a universal constant; before picking a concurrency primitive, always benchmark with your actual key distribution, hardware, and workload.&lt;/p&gt;
&lt;h2 id="the-join-that-should-be-a-bug"&gt;&lt;a href="https://kronotop.com/blog/the-join-that-should-be-a-bug/" rel="noopener noreferrer"&gt;The .join() That Should Be a Bug&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains how Kronotop serves thousands of concurrent connections when nearly every command has to wait on network calls to FoundationDB or filesystem I/O. The author contrasts two familiar architectures: Redis uses a single thread for all connections, holding massive connection counts at the cost of forbidding any blocking command; PostgreSQL uses one process per connection, allowing straightforward sequential blocking code but consuming heavy OS resources as connections scale. Kronotop takes a third path, decoupling connection holding from blocking work to combine the strengths of both models.&lt;/p&gt;
&lt;p&gt;A small pool of Netty event-loop threads accepts data, parses commands, and sends responses without ever blocking. Disk I/O and network calls are offloaded to Java virtual threads, where a &lt;code&gt;.join()&lt;/code&gt; call—normally considered an anti-pattern or bug in asynchronous code—can block sequentially without pinning the underlying OS carrier thread. Once the result is ready, writing the response is always dispatched back to the exact Netty event loop that owns the connection, keeping concurrency invariants clean and predictable. Each connection also acts as a session holding authentication state, namespace, and open transaction state; when a connection closes or resets, its associated transactions and resources are safely aborted and cleaned up.&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 #124</title><link>https://miti99.com/en/post/2026/07/12/</link><pubDate>Sun, 12 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #124.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="riding-technology-waves"&gt;&lt;a href="https://staysaasy.com/strategy/2026/06/22/riding-technology-waves.html" rel="noopener noreferrer"&gt;Riding Technology Waves&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Major technology waves—the internet, cloud computing, mobile, and now AI—arrive faster and hit harder with each cycle, minting massive new winners while wiping out incumbents, even as other hyped waves like 3D printing or VR fizzle out. To orient yourself early without getting swept up in empty hype, Stay SaaSy proposes answering four questions in order: does this technology actually matter (i.e., do real users get sustained value from it)?; how does it work under the hood, at a level you could explain clearly to a smart outsider?; what concrete new capabilities does it unlock, stated as plain facts rather than buzzwords?; and how do those capabilities affect your specific product, cost structure, or customers?&lt;/p&gt;
&lt;p&gt;The two classic failure modes sit at opposite extremes. Complacency leads companies to dismiss real signals as a fad, though that mistake usually forces its own correction once the wave becomes undeniable. Far more common in volatile times is FOMO-driven panic: leaders who don&amp;rsquo;t understand the technology chase the herd, betting the company on unvalidated use cases or blowing up a working roadmap to slap an &amp;ldquo;AI&amp;rdquo; label on the product while customers are asking for basic reliability. Blindly pivoting is the default strategic blunder during a hype cycle. Yet the worst mistake of all is missing an obvious wave and then letting ego keep you in denial; when that happens, leadership must admit the miss, take ownership, put their best people and real resources on catching up, and stay hands-on until the course is corrected.&lt;/p&gt;
&lt;h2 id="find-a-new-role"&gt;&lt;a href="https://larahogan.me/blog/identify-new-role/" rel="noopener noreferrer"&gt;Find a new role&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When thinking about changing jobs or transitioning into a new role, Lara Hogan recommends filling out a 2×2 grid of four lists: your non-negotiable &amp;ldquo;Must Haves&amp;rdquo;; your &amp;ldquo;Want to Haves&amp;rdquo; that matter a lot, though you&amp;rsquo;d trade off one or two for the right opportunity; things that &amp;ldquo;Don&amp;rsquo;t Matter&amp;rdquo; to you right now, even if they mattered in the past or matter to peers; and a single crisp &amp;ldquo;Optimizing For&amp;rdquo; sentence stating the one thing you are prioritizing above everything else in this chapter. Putting those four boxes on paper turns a murky career decision into concrete criteria for sourcing roles, asking interview questions, and weighing offers.&lt;/p&gt;
&lt;p&gt;Hogan advises leaving job titles off every list entirely, since the same title can mean wildly different things across companies; evaluate the actual day-to-day scope and responsibilities instead. Keep the &amp;ldquo;Must Haves&amp;rdquo; box ruthlessly short: if you would still accept an offer missing a given item, it belongs in &amp;ldquo;Want to Haves,&amp;rdquo; and you will almost certainly have to compromise on at least one want-to-have. Anchor your criteria in what you need &lt;em&gt;today&lt;/em&gt; rather than what you wanted five years ago or might want in the distant future—sometimes top-of-market compensation gives way to great healthcare, or scope gives way to work-life balance. Your single &amp;ldquo;Optimizing For&amp;rdquo; statement is the sharpest tool of all: tape it next to your monitor, share it with trusted friends who can hold you accountable, and use it to ask which opportunity moves you closest to that specific goal. Re-run the exercise whenever your life circumstances shift.&lt;/p&gt;
&lt;h2 id="i-stored-a-website-in-a-favicon"&gt;&lt;a href="https://www.timwehrle.de/blog/i-stored-a-website-in-a-favicon" rel="noopener noreferrer"&gt;I Stored a Website in a Favicon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After previously hiding two bytes of state inside a custom mouse cursor, Tim Wehrle decided to see if he could pack an entire web page inside a &lt;code&gt;favicon.ico&lt;/code&gt;/PNG image. The encoding is delightfully direct: a favicon is an image, an image is a grid of pixels, and each RGB pixel gives you three color channels—red, green, and blue—worth one byte each. Wehrle encodes an HTML snippet into UTF-8 bytes using &lt;code&gt;TextEncoder&lt;/code&gt;, prepends a 4-byte length header so the decoder knows exactly where the payload ends (ignoring any trailing padding pixels in the grid), and writes three bytes into each pixel&amp;rsquo;s RGB values. A 208-byte HTML payload plus the 4-byte header totals 212 bytes, fitting into 71 pixels inside a tiny 9×9 PNG at 87% capacity—producing an icon that looks like colorful static.&lt;/p&gt;
&lt;p&gt;To reconstruct the page, a tiny bootstrap page loads the favicon onto an HTML &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt;, reads back the pixel array via &lt;code&gt;getImageData()&lt;/code&gt;, extracts the RGB bytes up to the 4-byte length prefix, decodes the UTF-8 string with &lt;code&gt;TextDecoder&lt;/code&gt;, and replaces the current document with the recovered HTML. Crucially, a PNG favicon is inert data and cannot execute itself on its own—you still need that small loader script to unpack and render it. Wehrle readily admits the experiment has zero practical utility given the tiny storage budget and the existence of normal HTTP responses, but it is a fun reminder that every file format is ultimately just bytes that can be repurposed in unexpected ways. He closes by noting alternative steganographic tricks like embedding markup inside an SVG favicon, stuffing text into PNG &lt;code&gt;tEXt&lt;/code&gt; chunks, or packing multiple resolutions into an &lt;code&gt;.ico&lt;/code&gt; container.&lt;/p&gt;
&lt;h2 id="antipatterns-never-left-we-just-stopped-calling-them-by-name"&gt;&lt;a href="https://dev.to/leonpennings/antipatterns-never-left-we-just-stopped-calling-them-by-name-969" rel="noopener noreferrer"&gt;AntiPatterns Never Left, We Just Stopped Calling Them by Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in 1998, the book &lt;em&gt;AntiPatterns&lt;/em&gt; cataloged recurring software failure modes—giving each one a memorable name, symptoms, root causes, and a refactoring path out. Leon Pennings argues that those exact failure modes are still everywhere today; we just rebranded them as modern best practices and stopped recognizing them because the system still compiles and passes tests. Short-term delivery creates survivorship bias where teams assume their architectural choices succeeded, since nobody builds the simpler alternative alongside it for comparison. Industry popularity doesn&amp;rsquo;t prove an approach fits your context, and naming anti-patterns explicitly helps teams see water they&amp;rsquo;ve been swimming in for years.&lt;/p&gt;
&lt;p&gt;Pennings groups modern anti-patterns into four recurring themes. First is organizing code around technical layers (&lt;code&gt;controllers/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;, &lt;code&gt;repositories/&lt;/code&gt;) instead of business capabilities, scattering domain concepts across folders, producing anemic domain models, and coupling business logic tightly to frameworks. Second is cargo-culting Resume-Driven Development—reaching for Kubernetes or Kafka as a golden hammer regardless of scale. Third is when the cure recreates the disease: turning a monolithic Big Ball of Mud into a distributed microservices ball of mud where complexity simply moves across network boundaries, or standing up a platform team that becomes just another ticket-driven silo. Fourth is separating decision-makers from the consequences of their decisions, such as Scrum intermediaries insulating developers from real users. Sometimes writing fifty lines of plain code is far cheaper over five years than pulling in a massive dependency; the goal isn&amp;rsquo;t rejecting frameworks, microservices, or Scrum wholesale, but evaluating every trade-off against your actual problem.&lt;/p&gt;
&lt;h2 id="5-more-advanced-java-tips-that-senior-engineers-actually-use"&gt;&lt;a href="https://dev.to/cyclopt_dimitrisk/5-more-advanced-java-tips-that-senior-engineers-actually-use-bbp" rel="noopener noreferrer"&gt;5 More Advanced Java Tips That Senior Engineers Actually Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through five modern Java capabilities, though it is worth noting upfront that they did not all land as final, stable APIs in Java 21: Record Patterns and Sequenced Collections were finalized in JDK 21, the Foreign Function and Memory (FFM) API was finalized in JDK 22, and Stream Gatherers became final in JDK 24, while Structured Concurrency remains a preview feature in the JDK 24 release referenced by the examples—so check your target JDK version before adopting. Structured Concurrency (&lt;code&gt;StructuredTaskScope&lt;/code&gt;) groups related concurrent subtasks into a single lexical lifetime: using a policy like &lt;code&gt;ShutdownOnFailure&lt;/code&gt;, if one subtask fails the remaining siblings are cancelled automatically (assuming they respect thread interruption), and once the &lt;code&gt;try-with-resources&lt;/code&gt; block exits no orphan threads are left running in the background—a major upgrade over manually juggling independent &lt;code&gt;CompletableFuture&lt;/code&gt; chains. Record Patterns let you destructure nested records directly inside &lt;code&gt;switch&lt;/code&gt; expressions; paired with &lt;code&gt;sealed&lt;/code&gt; interfaces, the compiler enforces exhaustiveness so adding a new subtype immediately flags every unhandled &lt;code&gt;switch&lt;/code&gt; at compile time.&lt;/p&gt;
&lt;p&gt;Sequenced Collections (&lt;code&gt;SequencedCollection&lt;/code&gt;, &lt;code&gt;SequencedSet&lt;/code&gt;, &lt;code&gt;SequencedMap&lt;/code&gt;) unify access to first/last elements and reverse-order iteration across ordered collections; calling &lt;code&gt;.reversed()&lt;/code&gt; returns a lightweight view rather than copying the underlying list, which is handy when scanning chronological event logs backward. The Foreign Function and Memory API (Project Panama) replaces brittle &lt;code&gt;sun.misc.Unsafe&lt;/code&gt; and JNI boilerplate with a pure-Java API for allocating off-heap memory and calling native C libraries, complete with bounds checking and deterministic deallocation via &lt;code&gt;Arena&lt;/code&gt; lifetimes (though the underlying native code itself must still be trusted). Finally, Stream Gatherers (&lt;code&gt;Stream::gather&lt;/code&gt;) fill a long-standing gap in the Stream API: just as &lt;code&gt;Collector&lt;/code&gt; lets you customize terminal operations, &lt;code&gt;Gatherer&lt;/code&gt; lets you write custom stateful intermediate operations—such as fixed batching, sliding windows, deduplicating adjacent elements, or running averages—while keeping pipelines readable.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://dev.to/mihirmohapatra/gos-type-system-structs-interfaces-and-life-without-inheritance-2lb7" rel="noopener noreferrer"&gt;Go&amp;rsquo;s Type System — Structs, Interfaces, and Life Without Inheritance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming to Go after six years of Java and Kotlin, Mihir Mohapatra reflects that the biggest mental shift in Go&amp;rsquo;s type system is the complete absence of class inheritance. A &lt;code&gt;struct&lt;/code&gt; holds only data fields—there are no constructors or &lt;code&gt;implements&lt;/code&gt; keywords; a factory function like &lt;code&gt;NewOrder&lt;/code&gt; is just a naming convention, and callers can still instantiate the zero-valued struct directly unless the type is unexported. Methods are declared separately with explicit value receivers (which operate on a copy) or pointer receivers (which can mutate the caller&amp;rsquo;s struct); reassigning a struct field requires a pointer receiver, though a value copy containing a &lt;code&gt;map&lt;/code&gt;, &lt;code&gt;slice&lt;/code&gt;, or pointer still shares the underlying referenced storage. Instead of inheritance, Go uses struct embedding: fields and methods of an embedded inner struct are promoted to the outer struct, modeling a &amp;ldquo;has-a&amp;rdquo; composition relationship rather than an &amp;ldquo;is-a&amp;rdquo; subtype hierarchy.&lt;/p&gt;
&lt;p&gt;The biggest design departure is that Go interfaces are satisfied implicitly: any type that implements the required method signatures automatically satisfies the interface, even types from third-party packages you don&amp;rsquo;t control. That flips interface design on its head: instead of defining massive upfront contracts in a central package that every implementation must explicitly import and declare, Go interfaces are typically small—often one or two methods like &lt;code&gt;io.Reader&lt;/code&gt; and &lt;code&gt;io.Writer&lt;/code&gt;—and defined by the consumer right where the behavior is needed. Types stay decoupled and brittle base-class hierarchies disappear. Mohapatra also notes the trade-offs newcomers bump into: finding every type that satisfies an interface requires IDE tooling rather than grepping for &lt;code&gt;implements&lt;/code&gt;, struct embedding doesn&amp;rsquo;t give you subclass polymorphism, and Go&amp;rsquo;s zero values mean an uninitialized struct compiles cleanly and can look valid unless you validate required fields explicitly.&lt;/p&gt;
&lt;h2 id="conduit-the-gateway-i-built-to-forget-about"&gt;&lt;a href="https://dev.to/adamthedeveloper/conduit-the-gateway-i-built-to-forget-about-2ann" rel="noopener noreferrer"&gt;Conduit: The Gateway I Built to Forget About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adam built an internal Go API gateway sitting in front of three backend services with two authentication schemes: a custom HMAC-signed session token for end-user and chat routes, and JWTs for admin endpoints. While the Go proxy was fast and rock-solid, every new public-route exception or header tweak meant adding another &lt;code&gt;if&lt;/code&gt; branch in Go, recompiling, and redeploying the binary. Conduit solves this by splitting what rarely changes from what changes constantly: a core Go binary handles HTTP ingress, routing, reverse proxying, CORS, and SSRF protection, while an isolated Deno subprocess executes TypeScript policy modules for auth, logging, and request mutation—letting operators edit a &lt;code&gt;.ts&lt;/code&gt; file and reload policies without recompiling Go.&lt;/p&gt;
&lt;p&gt;The two processes communicate over a Unix domain socket using a strict snapshot-and-patch contract. Go sends a serializable JSON snapshot of the incoming request metadata; the TypeScript policy modules return only a minimal patch describing headers to add/remove or whether to short-circuit the request, rather than owning or mutating the live request object directly, while request bodies larger than 64 KiB stay inside Go and are referenced by handle ID. Failure modes are explicitly separated too: if an individual policy module times out, Conduit logs a warning and moves on, whereas if the entire Deno sidecar crashes, each route follows its configured failure policy—either failing closed with &lt;code&gt;503 Service Unavailable&lt;/code&gt; or failing open by proxying directly to the upstream. Simplicity comes from crisp responsibility boundaries rather than raw line count; Conduit isn&amp;rsquo;t trying to replace Envoy or Kong at massive scale, just stay out of the way in front of a handful of services whose edge policies evolve often.&lt;/p&gt;
&lt;h2 id="the-reflect-package"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-reflect" rel="noopener noreferrer"&gt;The Reflect Package&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go compiles ahead of time to native machine code, yet the standard library&amp;rsquo;s &lt;code&gt;reflect&lt;/code&gt; package can inspect struct field names, types, and struct tags at runtime. This post dives into how the Go compiler embeds static type metadata inside the compiled binary so &lt;code&gt;reflect&lt;/code&gt; can read it (while noting that other &lt;code&gt;reflect&lt;/code&gt; APIs can still allocate or construct types dynamically at runtime). Under the hood, an empty interface value (&lt;code&gt;any&lt;/code&gt; / &lt;code&gt;interface{}&lt;/code&gt;) is a two-word struct holding two pointers: one pointing to the underlying data and one pointing to a runtime type descriptor (&lt;code&gt;abi.Type&lt;/code&gt;), whose address is a compile-time constant known to the linker. Calling &lt;code&gt;reflect.TypeOf&lt;/code&gt; therefore just reads that type pointer—no hash table lookup, no heap allocation.&lt;/p&gt;
&lt;p&gt;During compilation, the compiler&amp;rsquo;s &lt;code&gt;reflectdata&lt;/code&gt; pass serializes a descriptor for every needed type as a linker symbol named &lt;code&gt;type:&amp;lt;typename&amp;gt;&lt;/code&gt;, and the linker packs those symbols into a read-only data section of the binary—which is why running &lt;code&gt;strings&lt;/code&gt; on a Go executable reveals your struct tags in plain text. Every descriptor starts with a fixed 48-byte common header (&lt;code&gt;abi.Type&lt;/code&gt;) recording byte size, alignment, kind (&lt;code&gt;Struct&lt;/code&gt;, &lt;code&gt;Slice&lt;/code&gt;, &lt;code&gt;Int&lt;/code&gt;, etc.), type hash, garbage-collector pointer bitmap, equality function pointer, and name offset; immediately following that header in memory sit kind-specific fields—for a struct (&lt;code&gt;abi.StructType&lt;/code&gt;), a slice of &lt;code&gt;StructField&lt;/code&gt; entries holding each field&amp;rsquo;s name, type pointer, and byte offset within the struct, followed by method table metadata. Field names and tags are deduplicated in a shared read-only string pool to save binary size. When you use &lt;code&gt;reflect.Value&lt;/code&gt;, it pairs the type descriptor with the data pointer and adds the stored byte offset to jump straight to a field&amp;rsquo;s memory address. Reading works fine on a value copy, but mutating via reflection requires passing a pointer into &lt;code&gt;any&lt;/code&gt;—otherwise &lt;code&gt;reflect&lt;/code&gt; is only looking at a copy of your struct.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #121</title><link>https://miti99.com/en/post/2026/07/09/</link><pubDate>Thu, 09 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #121.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dial-up"&gt;&lt;a href="https://jkm.dev/posts/how-2004-runescape-fit-a-multiplayer-rpg-into-56k-dialup/" rel="noopener noreferrer"&gt;How 2004 RuneScape fit a multiplayer RPG into 56k dial-up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post dissects how 2004 RuneScape ran a massively multiplayer world over 56k dial-up modems, where real-world throughput was just a few kilobytes per second and the Java applet client had only a single TCP connection. Rather than sending self-describing messages, the network protocol was co-designed as a shared state machine between client and server: both sides held the exact same collision map, ran the same pathfinding algorithm, and stepped forward on a 600 ms server tick. Thanks to all that shared implicit context never having to cross the wire, walking across the map cost roughly 7 bytes upstream and 9 bytes downstream per observer—the client only sent path waypoints where direction changed, and the server validated and reconstructed the rest.&lt;/p&gt;
&lt;p&gt;The most fascinating takeaway is how saving bytes goes far beyond generic compression. The most common state was made practically free: an idle player in your viewport cost a single bit, meaning standing among twenty stationary players took roughly five bytes per tick to confirm nothing changed. Newly appearing players were encoded using 5-bit relative coordinates offset from the local player rather than 16-bit global world coordinates. Bit-packing was reserved strictly for small, high-frequency movement updates; larger, rarely changing appearance blocks stayed byte-aligned so the server could cache and memcpy pre-built buffers directly. The architectural lesson: the smallest possible wire format comes from tightly coupling client and server assumptions, trading away the self-description, independent deployability, and easy debugging that modern HTTP/JSON APIs prioritize.&lt;/p&gt;
&lt;h2 id="how-does-struct-take-zero-bytes-in-go"&gt;&lt;a href="https://www.bud1m.com/blog/go-empty-struct/" rel="noopener noreferrer"&gt;How does struct{} take zero bytes in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why Go&amp;rsquo;s empty struct &lt;code&gt;struct{}&lt;/code&gt; occupies zero bytes and how it is idiomatically used to represent presence or signaling rather than data. Inspecting &lt;code&gt;unsafe.Sizeof&lt;/code&gt; confirms that an empty struct takes 0 bytes; used as the value type in &lt;code&gt;map[string]struct{}&lt;/code&gt;, it expresses a pure set where only key existence matters, and on a channel (&lt;code&gt;chan struct{}&lt;/code&gt;) it signals an event without carrying a payload. The author also notes that starting in Go 1.24, Go&amp;rsquo;s built-in maps use Swiss Tables under the hood, leaving almost no meaningful memory difference between &lt;code&gt;map[string]struct{}&lt;/code&gt; and &lt;code&gt;map[string]bool&lt;/code&gt;—so choosing &lt;code&gt;struct{}&lt;/code&gt; today is mainly about expressing intent clearly.&lt;/p&gt;
&lt;p&gt;At the runtime level, whenever a zero-sized value has to be allocated on the heap, &lt;code&gt;mallocgc&lt;/code&gt; checks for &lt;code&gt;size == 0&lt;/code&gt; and returns a pointer to a single global runtime variable named &lt;code&gt;zerobase&lt;/code&gt; instead of allocating heap memory. Whether the value escapes to the heap in the first place is decided by escape analysis: passing it to &lt;code&gt;fmt.Println&lt;/code&gt; (which takes &lt;code&gt;any&lt;/code&gt;) often triggers an escape to &lt;code&gt;zerobase&lt;/code&gt;, whereas built-in &lt;code&gt;println&lt;/code&gt; keeps it on the stack. This design creates two subtle gotchas worth remembering. First, multiple distinct &lt;code&gt;struct{}&lt;/code&gt; variables may share the exact same memory address, and the compiler is free to merge or not merge them, so you should never rely on pointer equality to distinguish zero-sized values. Second, placing a &lt;code&gt;struct{}&lt;/code&gt; as the final field inside a larger non-empty struct causes the compiler to add 1 byte of trailing padding (plus alignment) so that taking the address of that final field doesn&amp;rsquo;t point past the end of the allocation into an adjacent object; if you want zero overhead inside a struct, place the empty struct field anywhere except last.&lt;/p&gt;
&lt;h2 id="is-cloudflare-silently-killing-the-web-hosting-industry"&gt;&lt;a href="https://webhosting.today/2026/06/17/is-cloudflare-silently-killing-the-web-hosting-industry/" rel="noopener noreferrer"&gt;Is Cloudflare silently killing the web hosting industry?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Konrad Keck argues that Cloudflare isn&amp;rsquo;t killing traditional web hosting by becoming a better shared host—it is doing it by moving the starting point of how websites get built and deployed. Historically, a customer bought a domain, signed up for shared hosting, logged into cPanel, installed WordPress, configured SSL and email, and maybe put Cloudflare in front later for CDN and DDoS protection. Today, when a project starts inside Claude Code, Cursor, Lovable, Bolt, or Replit, the question is no longer &amp;ldquo;which hosting plan do I buy?&amp;rdquo; but &amp;ldquo;where do I deploy this?&amp;rdquo;, and Cloudflare, Vercel, and Netlify are built to capture that exact moment. Cloudflare is competing on workflow, not just infrastructure.&lt;/p&gt;
&lt;p&gt;Keck highlights two main levers: near-zero-cost deployment via Pages, Workers, static assets, and usage-priced R2/D1—which hollows out traditional hosting&amp;rsquo;s bread-and-butter market of landing pages, docs sites, frontends, and small APIs—and at-cost domain registration as a top-of-funnel wedge into the ecosystem. Cloudflare&amp;rsquo;s Registrar API closes the loop even further: an AI agent can scaffold a project, suggest available domains, check pricing, register the domain, configure DNS, and deploy to production without the user ever visiting a hosting control panel. Traditional web hosts aren&amp;rsquo;t disappearing overnight—legacy WordPress/WooCommerce and PHP apps, real business email, hands-on migrations, emergency support, local compliance, and non-technical SMBs still rely on human-backed services. The strategic shift is that traditional hosts must evolve into specialized managed service providers, because selling the default starting point of a website is slipping away.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://staysaasy.com/startups/2026/06/16/stacked-weaknesses.html" rel="noopener noreferrer"&gt;Don&amp;rsquo;t Stack Weaknesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy writes about an organizational failure mode that often hides in plain sight across leadership chains: stacking the same weakness across multiple layers of management. Almost every leader has at least one real weakness—someone might be a visionary strategist but poor at operational execution, or deeply technical but weak at executive communication—and on its own, that doesn&amp;rsquo;t sink an org. The danger comes when a leader hires or promotes direct reports who share the exact same blind spot. If both a VP and their directors are weak at operations, the odds of the teams underneath them having strong operational processes drop to nearly zero: leadership doesn&amp;rsquo;t know how to do it themselves, doesn&amp;rsquo;t know how to interview for it, and can&amp;rsquo;t accurately judge whether it&amp;rsquo;s being done well.&lt;/p&gt;
&lt;p&gt;Weakness stacking usually happens unconsciously: leaders naturally recognize and reward strengths that mirror their own, labeling that similarity &amp;ldquo;values alignment&amp;rdquo; or &amp;ldquo;culture fit&amp;rdquo; while actually cloning their own skillset and blind spots. Avoiding the trap starts with an honest self-assessment across six core axes—technical/domain depth, people management, process and operations, strategy, communication/presentation, and learning agility—and then deliberately hiring people who are significantly stronger than you in your weakest areas. The post also warns against comforting yourself with &amp;ldquo;I could do operations if I really wanted to,&amp;rdquo; which is almost always an excuse to avoid confronting a gap. An organization without stacked weaknesses is far more resilient to unexpected challenges.&lt;/p&gt;
&lt;h2 id="system-design-cheatsheet"&gt;&lt;a href="https://gist.github.com/SuyashDive2005/be5865a9755ca1dd50523f7aeeae4417" rel="noopener noreferrer"&gt;System Design Cheatsheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This gist serves as a compact checklist for system design interviews and architecture reviews, anchored on a core principle: good architecture is about picking the right battles and managing trade-offs. It outlines a familiar five-step loop: clarify scope through use cases and constraints; sketch a high-level design covering core services, storage, caching, and load balancing; dive into component details including APIs and data schemas; identify bottlenecks; and scale vertically or horizontally as needed. For newer engineers, its biggest value is forcing quantitative questions early, before jumping to technology choices: how many requests per second, what is the read-to-write ratio, how fast does data grow, does latency or throughput matter more, and where does the system sit on the consistency-versus-availability spectrum?&lt;/p&gt;
&lt;p&gt;The scaling section reviews foundational building blocks: multi-tier caching, load balancing, replication and sharding, MapReduce for batch data processing, and platform separation so components can scale independently. It also lists six core fundamentals worth mastering: concurrency, networking, abstraction boundaries, real-world hardware performance numbers, back-of-the-envelope estimation to rule out dead ends early, and fault tolerance in distributed environments. While brief and carrying a few older examples, it remains a solid mental checklist: characterize load, data shape, failure modes, and scaling paths before picking tools.&lt;/p&gt;
&lt;h2 id="sqlite-improving-performance-with-pre-sort"&gt;&lt;a href="https://andersmurphy.com/2026/06/07/sqlite-improving-performance-with-pre-sort.html" rel="noopener noreferrer"&gt;SQLite improving performance with pre-sort&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anders Murphy follows up on his earlier SQLite UUIDv4 vs. UUIDv7 benchmarks with a tougher scenario: what happens when your primary key must be a 160-bit cryptographically random value generated via &lt;code&gt;SecureRandom&lt;/code&gt;—such as a session token—where you cannot switch to time-ordered UUIDv7 because you need maximum entropy and zero timestamp leakage? When batch-inserting one million rows into a &lt;code&gt;WITHOUT ROWID&lt;/code&gt; table keyed by a &lt;code&gt;BLOB PRIMARY KEY&lt;/code&gt;, insert throughput starts around 100,000 rows per second and steadily degrades as the table grows. The bottleneck isn&amp;rsquo;t SQLite being slow; it&amp;rsquo;s the physics of a B+ Tree: because the tree stores keys in sorted order, sequential inserts append cleanly, whereas uniformly random keys scatter writes across leaf pages all over disk, triggering constant page splits and tree rebalancing.&lt;/p&gt;
&lt;p&gt;Murphy&amp;rsquo;s optimization is disarmingly simple: since the application is already inserting in batches, sort each batch in memory by primary key before inserting. Because SQLite compares &lt;code&gt;BLOB&lt;/code&gt; keys using &lt;code&gt;memcmp()&lt;/code&gt;, the application-side comparator just needs to match byte-wise ordering; Murphy grabs the first 8 bytes of each 20-byte token as an unsigned 64-bit integer to make the in-memory sort fast. Even including the CPU cost of sorting each batch, once the table reaches ten million rows, batch insert time drops from 11.1 seconds to 3.8 seconds—roughly a 2–3x speedup. The practical takeaway: batching doesn&amp;rsquo;t just amortize transaction overhead; it also gives you a window to reorder writes into a layout that is far friendlier to the underlying storage engine.&lt;/p&gt;
&lt;h2 id="why-is-meta-destroying-its-engineering-organization"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/why-is-meta-destroying-its-engineering" rel="noopener noreferrer"&gt;Why is Meta destroying its engineering organization?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz pieces together a tense picture of engineering inside Meta since April 2026, as the company pivots aggressively around AI. Historically, Meta was renowned for its strong bottom-up engineering culture: lightweight process, high individual autonomy, rock-solid internal tooling that let engineers &amp;ldquo;move fast,&amp;rdquo; and engineers treated as the core value creators. Under the direction of Mark Zuckerberg and Alexandr Wang, however, 30–50% of core software engineers across many teams—including infrastructure and security—were reassigned into a new ADO organization (roughly 6,500 people) to do data labeling, model output grading, and RLHF. Meta also rolled out mandatory keystroke and mouse tracking on engineering laptops to harvest training data with no opt-out (later walked back slightly after internal backlash), alongside ongoing layoff pressure and AI token-usage quotas.&lt;/p&gt;
&lt;p&gt;What stands out most isn&amp;rsquo;t just &amp;ldquo;Meta is pushing AI hard,&amp;rdquo; but how badly perverse incentives distort behavior. Once AI token consumption became a performance metric, engineers naturally gamed the metric (burning 60.2 trillion tokens in 30 days) rather than optimizing for software quality. And when AI-generated code reviewed only by AI gets pushed rapidly to production while security teams are gutted and reassigned, operational risk compounds fast: Orosz connects these dynamics to the May 30 Instagram account-takeover incident and the departure of Meta&amp;rsquo;s CISO shortly afterward. The broader lesson is not to confuse fast MTTR with system health: recovering quickly from outages cannot compensate for eroding human comprehension, weakened guardrails, and hollowed-out engineering ownership.&lt;/p&gt;
&lt;h2 id="cs-6120-advanced-compilers-the-self-guided-online-course"&gt;&lt;a href="https://www.cs.cornell.edu/courses/cs6120/2025fa/self-guided/" rel="noopener noreferrer"&gt;CS 6120: Advanced Compilers: The Self-Guided Online Course&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page hosts the self-guided version of CS 6120, Adrian Sampson&amp;rsquo;s PhD-level course at Cornell on programming language implementation and modern compilers. The curriculum progresses from core compiler foundations—intermediate representations, dataflow analysis, local and global optimizations, SSA form, and LLVM—into research-adjacent topics like dynamic compilers (JITs), garbage collection, parallelism, and fast compilation. Each lesson pairs lecture videos and written notes with classic academic papers and open-ended implementation tasks to turn abstract theory into working code.&lt;/p&gt;
&lt;p&gt;The self-guided track preserves the linear structure of the university course while removing deadlines, grading, and internal class discussion boards. Learners follow a clear rhythm: watch the lecture, read the companion paper, and implement compiler passes using either LLVM or Bril—a small, pedagogical intermediate representation designed to be much easier to hack on than jumping straight into a production compiler—culminating in a final project. It is an outstanding resource for internalizing that a compiler isn&amp;rsquo;t just &amp;ldquo;a parser bolted onto a code generator,&amp;rdquo; but a pipeline of representation choices, program analyses, optimizations, and trade-offs between correctness, compile time, and generated code quality. The best way to use it is writing the small transformation passes yourself as you go, since compiler concepts are notoriously easy to misunderstand if you only read about them.&lt;/p&gt;
&lt;h2 id="epoll-vs-io_"&gt;&lt;a href="https://sibexi.co/posts/epoll-vs-io_uring/" rel="noopener noreferrer"&gt;epoll vs io_uring in Linux&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares &lt;code&gt;epoll&lt;/code&gt; and &lt;code&gt;io_uring&lt;/code&gt; through the lens of building TinyGate, a lightweight reverse proxy in C. The first prototype used a simple thread-per-worker model that was easy to reason about but hit a hard performance ceiling; moving to &lt;code&gt;epoll&lt;/code&gt; delivered a major speedup, yet still paid the fundamental tax of a readiness-based model: &lt;code&gt;epoll&lt;/code&gt; only tells you when a file descriptor is ready for I/O, leaving the application to issue its own &lt;code&gt;read()&lt;/code&gt; or &lt;code&gt;write()&lt;/code&gt; syscalls afterward. Every I/O event therefore incurs syscall and context-switch overhead on top of &lt;code&gt;epoll_ctl&lt;/code&gt; registration, which adds up quickly across tens of thousands of active connections.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;io_uring&lt;/code&gt; shifts to a completion-based model: the application writes I/O requests into a submission queue in shared memory, the kernel executes them asynchronously, and results land in a shared completion queue. A single &lt;code&gt;io_uring_enter()&lt;/code&gt; call can submit and harvest an entire batch of operations instead of paying a syscall per &lt;code&gt;read()&lt;/code&gt;/&lt;code&gt;write()&lt;/code&gt;. Enabling &lt;code&gt;IORING_SETUP_SQPOLL&lt;/code&gt; can even eliminate steady-state syscalls almost entirely, at the cost of dedicating a kernel thread that spins and consumes CPU to poll the submission ring. While the author recommends considering &lt;code&gt;io_uring&lt;/code&gt; for new high-performance Linux projects (available since Linux 5.1, though specific opcodes depend on kernel version), he cautions that production use requires care: using rings or registered buffers doesn&amp;rsquo;t automatically guarantee zero-copy I/O, errors arrive asynchronously via completion queue entries, and minimal tutorial examples omit many edge-case checks required in real servers.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #120</title><link>https://miti99.com/en/post/2026/07/08/</link><pubDate>Wed, 08 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #120.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="lessons-from-building-claude-code-how-we-use-skills"&gt;&lt;a href="https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills" rel="noopener noreferrer"&gt;Lessons from building Claude Code: How we use skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thariq Shihipar, a member of the Claude Code team at Anthropic, distills lessons learned from building and using hundreds of internal skills. The central insight is that a skill isn&amp;rsquo;t just a single Markdown file of instructions—it is an entire folder that can bundle scripts, assets, reference data, hooks, and configuration. This structure enables progressive disclosure: the agent reads &lt;code&gt;SKILL.md&lt;/code&gt; first and only loads auxiliary docs or helper scripts when the task actually needs them, keeping the context window lean. Shihipar groups skills into nine practical categories: library/API references, product verification, data analysis, workflow automation, code scaffolding, code review, CI/CD, operational runbooks, and infrastructure management.&lt;/p&gt;
&lt;p&gt;When authoring skills, he advises skipping generic advice Claude already knows and focusing on instructions that nudge the model out of its default habits—especially a living &amp;ldquo;gotchas&amp;rdquo; section capturing recurring pitfalls, repo conventions, and edge cases added whenever the agent makes a mistake in practice. State high-level goals rather than rigid step-by-step micromanagement, give the skill a persistence mechanism (like log or JSON files) to maintain state across sessions, and bundle composable helper scripts so the agent doesn&amp;rsquo;t have to reconstruct boilerplate operations from scratch via token generation. For larger teams, skills can be committed directly to the repo or distributed through an internal plugin marketplace so engineers install only what they need without bloating context, while hooks track usage metrics to prune overly broad or unused skills.&lt;/p&gt;
&lt;h2 id="bulkhead-pattern---go"&gt;&lt;a href="https://dev.to/kamal_namdeo/bulkhead-pattern-go-362c" rel="noopener noreferrer"&gt;Bulkhead Pattern - Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kamal Namdeo walks through implementing the Bulkhead Pattern in Go: isolating resources per downstream dependency so one slow or failing service cannot exhaust goroutines, sockets, and request budgets across your entire application. Instead of letting every outbound HTTP call share &lt;code&gt;http.DefaultTransport&lt;/code&gt;, each downstream dependency gets its own three-layer bulkhead: a semaphore capping concurrent in-flight requests (using &lt;code&gt;TryAcquire&lt;/code&gt; to fail fast when full), a dedicated connection pool via &lt;code&gt;MaxConnsPerHost&lt;/code&gt; so one slow host cannot starve TCP connections to others, and tight timeouts that free resources quickly when an upstream stalls. That way, if the auth service is degraded, billing and S3 calls continue unaffected.&lt;/p&gt;
&lt;p&gt;The post also shows how to size concurrency limits. Little&amp;rsquo;s Law relates average concurrency to throughput and average latency; plugging in p99 latency plus a 30% safety buffer is the author&amp;rsquo;s practical sizing heuristic rather than the law itself, showing why slower dependencies require more slots to sustain the same throughput. Blast radius during outages is contained through layered timeouts: &lt;code&gt;ResponseHeaderTimeout&lt;/code&gt; (roughly 1.2x p99), &lt;code&gt;Client.Timeout&lt;/code&gt; covering the full request lifecycle, a 1–2 second TCP dial/TLS handshake timeout, and a &lt;code&gt;QueueTimeout&lt;/code&gt; derived by subtracting downstream latency from your SLA budget. Namdeo closes with common Go pitfalls: &lt;code&gt;runtime.NumCPU()&lt;/code&gt; is the wrong basis for sizing I/O concurrency because goroutines blocked on network reads don&amp;rsquo;t consume CPU cores, response bodies must be drained before closing so connections can return to the idle pool, and &lt;code&gt;MaxIdleConns&lt;/code&gt; should equal the sum of per-host idle limits so dependencies don&amp;rsquo;t evict each other&amp;rsquo;s pooled connections.&lt;/p&gt;
&lt;h2 id="max-consecutive-ones"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/max-consecutive-ones-13mj" rel="noopener noreferrer"&gt;Max Consecutive Ones&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh breaks down a foundational LeetCode problem in Java: given a binary array, find the maximum number of consecutive &lt;code&gt;1&lt;/code&gt;s. The brute-force approach starts at every index containing a &lt;code&gt;1&lt;/code&gt;, scans forward to count the streak, and updates the global maximum. While easy to explain in an interview, it repeatedly re-scans the same elements, resulting in &lt;code&gt;O(N²)&lt;/code&gt; time complexity with &lt;code&gt;O(1)&lt;/code&gt; auxiliary space.&lt;/p&gt;
&lt;p&gt;The optimal solution rests on a simple observation: a streak of &lt;code&gt;1&lt;/code&gt;s grows as long as we keep seeing &lt;code&gt;1&lt;/code&gt; and resets the moment we hit a &lt;code&gt;0&lt;/code&gt;, meaning we only ever need to track the length of the current streak. By maintaining two scalar variables—current streak length and maximum streak seen so far—we increment the counter and update the max on &lt;code&gt;1&lt;/code&gt;, and reset the counter to &lt;code&gt;0&lt;/code&gt; on &lt;code&gt;0&lt;/code&gt;. That single pass runs in &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space without nested loops. Recognizing this &amp;ldquo;maintain running state, update global best, reset when the invariant breaks&amp;rdquo; pattern makes short work of many contiguous-subarray interview questions.&lt;/p&gt;
&lt;h2 id="double-bigdecimal-or-fixed-point"&gt;&lt;a href="https://blog.frankel.ch/bigdecimal-vs-double/" rel="noopener noreferrer"&gt;double, BigDecimal, or Fixed-Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago pushes back against blanket slogans like &amp;ldquo;always use &lt;code&gt;BigDecimal&lt;/code&gt; for money&amp;rdquo; or &amp;ldquo;&lt;code&gt;double&lt;/code&gt; is broken.&amp;rdquo; Under IEEE 754, &lt;code&gt;double&lt;/code&gt; is a binary floating-point approximation, meaning base-10 fractions like &lt;code&gt;0.1&lt;/code&gt; cannot be represented exact to the last bit—but that is a deliberate engineering trade-off. For domains that are inherently approximate, such as analytics, machine learning, or physics simulations, &lt;code&gt;double&lt;/code&gt; is usually the right choice because it runs directly in hardware at blistering speed; you simply need to compare values using an epsilon tolerance instead of &lt;code&gt;==&lt;/code&gt;, handle &lt;code&gt;NaN&lt;/code&gt; and &lt;code&gt;-0.0&lt;/code&gt; properly, and reach for techniques like Kahan or Neumaier summation, pairwise summation, or &lt;code&gt;Math.fma()&lt;/code&gt; when minimizing accumulated rounding error.&lt;/p&gt;
&lt;p&gt;Conversely, &lt;code&gt;BigDecimal&lt;/code&gt; shines when exact decimal representation, explicit rounding modes, and auditability are mandatory—such as tax calculation, invoicing, and accounting—at the cost of heap allocations and software arbitrary-precision arithmetic. It also has its own footguns: calling &lt;code&gt;new BigDecimal(0.1)&lt;/code&gt; bakes in the binary float inaccuracy (always use &lt;code&gt;new BigDecimal(&amp;quot;0.1&amp;quot;)&lt;/code&gt; or &lt;code&gt;BigDecimal.valueOf(0.1)&lt;/code&gt;), forgetting to reassign results on immutable instances, or calling &lt;code&gt;equals()&lt;/code&gt;—which compares scale (&lt;code&gt;2.0&lt;/code&gt; != &lt;code&gt;2.00&lt;/code&gt;)—instead of &lt;code&gt;compareTo()&lt;/code&gt;. For high-throughput financial engines, fixed-point arithmetic using &lt;code&gt;long&lt;/code&gt; is often the pragmatic sweet spot: store &lt;code&gt;$19.99&lt;/code&gt; as &lt;code&gt;1999&lt;/code&gt; cents, use &lt;code&gt;Math.addExact&lt;/code&gt; and &lt;code&gt;multiplyExact&lt;/code&gt; to catch overflows immediately, and convert to &lt;code&gt;BigDecimal&lt;/code&gt; only at system boundaries. Fago also warns about losing trailing scale during JSON serialization and non-reproducible sums in parallel &lt;code&gt;DoubleStream&lt;/code&gt; pipelines. Choose numeric types based on domain precision rules, rounding semantics, and performance constraints—not slogans.&lt;/p&gt;
&lt;h2 id="can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update"&gt;&lt;a href="https://medium.com/helidon/can-java-microservices-be-as-fast-as-go-a-2026-benchmark-update-e16a2e262fc4" rel="noopener noreferrer"&gt;Can Java Microservices Be As Fast As Go? A 2026 Benchmark Update&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Six years after his original comparison, Mark Nelson revisits the question: can a small Java microservice match Go on raw performance? He benchmarks Go 1.26.3 using &lt;code&gt;net/http&lt;/code&gt; against Helidon SE 4.4.1 (handling requests on virtual threads) running on Oracle JDK 26.0.1, alongside a variant using a Project Leyden AOT cache. The test service is deliberately small and synthetic: an endpoint generates payloads of 7, 128, 2048, or 8192 bytes, performs uppercase, lowercase, string reversal, and CRC32 calculations with &lt;code&gt;WORK_FACTOR=10&lt;/code&gt;, and returns JSON. Each runtime is benchmarked sequentially with dedicated warmup passes and logging disabled. Before recording final numbers, Nelson noticed Helidon exhibiting a puzzling 44–48 ms latency floor on larger responses over reused HTTP/1.1 connections; enabling &lt;code&gt;tcpNoDelay(true)&lt;/code&gt; eliminated the Nagle/delayed-ACK interaction immediately.&lt;/p&gt;
&lt;p&gt;What stands out in the results isn&amp;rsquo;t a simplistic &amp;ldquo;Java beats Go&amp;rdquo; headline, but the shape of the scaling curves. At small payload sizes and low concurrency, all three configurations perform in roughly the same ballpark. As concurrent connections and payload sizes climb, however, the Java setups scale noticeably better: at 2 KB payloads, Go peaks around 17,000 requests/sec, whereas standard JVM reaches ~39,500 and Leyden AOT hits ~41,600. Leyden AOT posts the highest peak throughput across every payload size, while Go doesn&amp;rsquo;t win a single cell despite staying competitive at the smallest sizes. Nelson stresses that teams shouldn&amp;rsquo;t use synthetic microbenchmarks to dictate company-wide language mandates—measure your own workload, as runtime tuning, frameworks, hardware, warmup, logging, and socket options often matter just as much as the language itself.&lt;/p&gt;
&lt;h2 id="stop-using-conventional-commits"&gt;&lt;a href="https://sumnerevans.com/posts/software-engineering/stop-using-conventional-commits/" rel="noopener noreferrer"&gt;Stop Using Conventional Commits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sumner Evans argues against Conventional Commits because the format puts the emphasis in the wrong place. In his view, the single most valuable piece of information in a commit subject line is the scope—which subsystem, package, module, or service was touched. Developers scanning &lt;code&gt;git log&lt;/code&gt; are usually rebasing, debugging, or triaging an incident, so they need to know immediately which part of the codebase changed. Conventional Commits instead puts a change-type category like &lt;code&gt;fix&lt;/code&gt;, &lt;code&gt;feat&lt;/code&gt;, or &lt;code&gt;chore&lt;/code&gt; up front and makes the scope optional. Worse, the change type is usually obvious from the description anyway, and often ambiguous when a single commit fixes a bug, refactors a helper, and adds a small capability at once.&lt;/p&gt;
&lt;p&gt;Evans then dismantles the usual selling points of Conventional Commits one by one. Auto-generating user-facing changelogs from commit history produces poor results because changelogs are written for end users while commit logs are written for maintainers—two audiences that need completely different levels of detail. Automating SemVer bumps from commit prefixes breaks down around reverts, breaking changes discovered after the fact, or follow-up fixes landed before release. Triggering CI/CD pipelines off commit message prefixes is even a security and reliability hazard, since automation should inspect which files actually changed in the tree rather than trusting human-typed subject lines. Instead, he recommends the scope-first convention used by Linux, FreeBSD, Git, Go, and Node.js—&lt;code&gt;scope: description&lt;/code&gt;, such as &lt;code&gt;net/http/cookiejar: add godoc links&lt;/code&gt;—where scopes mirror the natural structure of the project.&lt;/p&gt;
&lt;h2 id="stop-using-jwts"&gt;&lt;a href="https://gist.github.com/samsch/0d1f3d3b4745d778f78b230cf6061452" rel="noopener noreferrer"&gt;Stop using JWTs!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Schlinkert argues for defaulting to server-side sessions for browser authentication, noting that revocation, logout, and lifecycle management are usually much simpler than rolling a custom stateless JWT scheme. That said, the gist&amp;rsquo;s claim that the JWT specification was designed strictly for short-lived tokens of around five minutes is factually incorrect: RFC 7519 imposes no such lifetime limit. A JWT is simply a signed or encrypted claims format; its security depends on the surrounding protocol, key management, and validation rules rather than every use of JWT being inherently insecure.&lt;/p&gt;
&lt;p&gt;The post rightly warns that storing authentication tokens in &lt;code&gt;localStorage&lt;/code&gt; magnifies the blast radius of any XSS vulnerability. For cookie-based sessions, &lt;code&gt;Secure&lt;/code&gt; and &lt;code&gt;HttpOnly&lt;/code&gt; flags provide important defense-in-depth, though applications still have to address CSRF, XSS, and session expiration at the architectural level. When JWTs are genuinely needed, RFC 8725 (JWT Best Current Practices) requires restricting accepted algorithms, verifying signatures, and validating claims like issuer and audience; alternatives like PASETO eliminate several cryptographic footguns by design, though they still don&amp;rsquo;t solve stateful session revocation on their own. For most web applications, the pragmatic default remains starting with your framework&amp;rsquo;s built-in session middleware backed by &lt;code&gt;Secure&lt;/code&gt;, &lt;code&gt;HttpOnly&lt;/code&gt; cookies and a fast store like Redis or Postgres, reaching for bearer tokens only when cross-service trust boundaries actually call for them.&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_!N2N1!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5edb76e4-d060-48d2-bd73-afe04f1cff5a_1284x1536.jpeg" alt="The AI Agent Stack, Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!wI2g!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F148840a3-d7df-4308-adad-c227f4d280e8_2360x2960.png" alt="Understanding Git Reset Modes"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!CKOS!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8d2521b0-1dd8-4b28-afbd-34f2bb44ee50_2360x2960.png" alt="How NAT Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!HMwY!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6af9e24b-9be2-4a45-9f81-14ec6f4330ca_2484x3002.png" alt="SLMs vs. LLMs, Clearly Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Z5zI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5233378c-3c59-40b1-9de2-6515b9d3e928_2484x3002.png" alt="Single Agent vs. Multi-Agent Architecture"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!U8C6!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b849efb-0467-4a5d-b735-f2296b125e9f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=U8lGbSaCCYI" rel="noopener noreferrer"&gt;Running LLMs Locally for Learning and Privacy&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This ByteByteGo video explains why running LLMs on your own machine is great for learning, experimentation, and privacy: sensitive data never leaves your device, you can work offline, and costs stay completely predictable. It also surveys the local LLM ecosystem—from Ollama, LM Studio, and MLX-LM for personal workflows to vLLM and SGLang for high-throughput inference serving.&lt;/p&gt;

&lt;/blockquote&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 #119</title><link>https://miti99.com/en/post/2026/07/07/</link><pubDate>Tue, 07 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #119.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="special-cases-in-go"&gt;&lt;a href="https://www.dolthub.com/blog/2026-05-22-special-cases-in-go/" rel="noopener noreferrer"&gt;Special Cases in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go is frequently marketed as a &amp;ldquo;simple&amp;rdquo; language that deliberately avoids special cases. Nick Tobey points out that Go actually has plenty of exceptions hiding in unexpected places. The &lt;code&gt;init&lt;/code&gt; function is the clearest example: it runs automatically when a package is imported, takes no arguments, returns no values, can be declared multiple times within the same package, yet cannot be called manually. If you try to call it, the compiler reports &lt;code&gt;undefined: init&lt;/code&gt; without further explanation. Similarly, the &lt;code&gt;internal&lt;/code&gt; directory creates a visibility scope narrower than public/private, yet that rule doesn&amp;rsquo;t exist in the Go language specification at all—it is enforced by the &lt;code&gt;go&lt;/code&gt; toolchain.&lt;/p&gt;
&lt;p&gt;The reason is that the language spec intentionally leaves import path interpretation implementation-defined. That flexibility lets build systems like Bazel apply their own rules while allowing the standard &lt;code&gt;go&lt;/code&gt; toolchain to evolve without amending the language spec—adding special cases like &lt;code&gt;internal&lt;/code&gt; directories or &lt;code&gt;_test&lt;/code&gt; package suffixes that live in the same directory as the package under test. Tobey also notes that a package&amp;rsquo;s declared name doesn&amp;rsquo;t have to match its directory name, forcing IDEs to parse every imported package just to resolve where an identifier comes from; for new code, explicit import aliases avoid the ambiguity. The broader takeaway: while most of these quirks rarely get in the way of day-to-day work, they show that a language&amp;rsquo;s simplicity often just means the complexity was pushed somewhere else.&lt;/p&gt;
&lt;h2 id="writing-code-vs-shipping-code-productivity-effects-across-generations-of-ai-coding-tools"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/writing-code-vs-shipping-code.html" rel="noopener noreferrer"&gt;Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Murat Demirbas analyzes an MIT and Wharton study that combines internal Microsoft telemetry with public GitHub traces from over 100,000 developers to measure the real-world productivity impact of AI coding tools. The study divides tools into three generations: autocomplete, synchronous agents like Claude Code or Cursor, and asynchronous agents. Output gains at the lines-of-code level are striking, but attenuate sharply at each downstream stage—from files to commits, pull requests, repositories, and finally shipped releases: with autocomplete, lines of code jump by over 228% while shipped releases rise by only ~10%; with synchronous agents, the corresponding numbers are 741% and 20%.&lt;/p&gt;
&lt;p&gt;While Demirbas is skeptical of applying a linear manufacturing production function to software development, he finds the framing useful because it exposes human coordination and review costs. Translating the findings into Amdahl&amp;rsquo;s Law, he calculates that the parallelizable, acceleratable fraction of software work sits right around 35% across all three tool generations—matching the share of time developers actually spend writing code. Agents produce more shipped releases not because they expand that 35% slice, but because they accelerate it more aggressively and intervene closer to the finish line. The remaining 65%—understanding the problem, planning, team alignment, and code review—remains a serial bottleneck. To genuinely ship faster, organizations have to improve those non-coding stages rather than just generating code faster.&lt;/p&gt;
&lt;h2 id="when-was-the-last-time-you-did-just-one-thing"&gt;&lt;a href="https://alifeengineered.substack.com/p/when-was-the-last-time-you-did-just" rel="noopener noreferrer"&gt;When Was the Last Time You Did Just One Thing?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Huynh recounts packing for a long trip: downloading dozens of YouTube videos, queueing up a backlog of podcasts, packing a handheld game console, two physical books, a Kindle, and his laptop just in case he wanted to get some work done. Then it hit him that this entire &amp;ldquo;arsenal&amp;rdquo; against a single moment of boredom would cause him to miss the trip itself—and that paradoxically, the harder we try not to waste a single second, the emptier every second feels. While the public preview ends there, the message from the title and setup is unmistakable: doing just one thing at a time is no longer our default state, but a skill we have to actively practice.&lt;/p&gt;
&lt;p&gt;For people in tech, it is a timely reminder about attention management. Not every quiet gap in the day needs to be filled with upskilling, podcasts, or side work. When every spare moment is stuffed with fresh stimulation, we gradually lose the ability to observe, rest properly, think deeply, and be fully present with whatever is in front of us. Looking busy and optimized isn&amp;rsquo;t the same as living intentionally; leaving blank space in your day is part of sustainable productivity, especially in engineering roles already fragmented by constant context switching.&lt;/p&gt;
&lt;h2 id="predicting-ai-job-exposure"&gt;&lt;a href="https://www.ben-evans.com/benedictevans/2026/5/24/ai-job-exposure" rel="noopener noreferrer"&gt;Predicting AI job exposure&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benedict Evans critiques efforts to score which professions, companies, or industries are most &amp;ldquo;exposed&amp;rdquo; to AI disruption. In his view, this amounts to predicting the unpredictable, and the simplest sanity check is running the same methodology backward against previous technology waves. Over the past century, we automated accounting with mainframes, databases, spreadsheets, and ERPs—yet the total number of accountants kept growing. When analysis becomes cheap and fast, organizations do far more of it and ask different questions, while new regulations create entire categories of compliance work.&lt;/p&gt;
&lt;p&gt;A second blind spot is that a job&amp;rsquo;s core tasks can stay unchanged while the business model underneath it collapses: the internet didn&amp;rsquo;t automate away the craft of journalism, it destroyed the classified-ad monopoly that funded newsrooms. Third are second-order shocks nobody extrapolates from task lists, like smartphone GPS enabling Uber and reshaping the taxi industry. Deeper still, occupational databases like O*NET cannot capture what a real job actually entails, much like early expert systems failed to capture tacit human expertise. Evans concludes that while high-level frameworks are useful for thinking, granular job-by-job forecasts at this early stage will only be right by accident, because we have no way of knowing whether the exceptions will dwarf the rule.&lt;/p&gt;
&lt;h2 id="choosing-values-for-robust-tests"&gt;&lt;a href="https://testing.googleblog.com/2026/06/choosing-values-for-robust-tests.html" rel="noopener noreferrer"&gt;Choosing Values for Robust Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Radion Khait highlights a subtle testing bug that is remarkably easy to miss: a test passes not because the implementation is correct, but because the test input happens to match the type&amp;rsquo;s default value. In the post&amp;rsquo;s example, a custom map&amp;rsquo;s &lt;code&gt;insert&lt;/code&gt; method forgets to assign the &lt;code&gt;value&lt;/code&gt; parameter and simply default-initializes the entry. A test that inserts &lt;code&gt;0&lt;/code&gt; and asserts that lookup returns &lt;code&gt;0&lt;/code&gt; passes with flying colors, because &lt;code&gt;0&lt;/code&gt; is already the default value for an integer. The result is a false sense of security: the method was called, but nothing proved the input was actually stored.&lt;/p&gt;
&lt;p&gt;From that example, Khait distills three practical rules for choosing test inputs. First, always use non-default values: non-zero numbers, non-empty strings, and enum variants other than the first declared value—changing &lt;code&gt;0&lt;/code&gt; to &lt;code&gt;5&lt;/code&gt; exposes the map bug immediately. Second, where appropriate, test representative inputs across equivalence classes such as empty, missing, &lt;code&gt;null&lt;/code&gt;, boundary values, and inputs that trigger complex branches, optionally pairing with fuzzing for broader coverage. Third, use distinct values for every parameter so tests immediately catch implementations that accidentally reuse an argument or swap parameter order; parameterized tests make it easy to cover multiple input combinations without duplicating test code.&lt;/p&gt;
&lt;h2 id="ai-demands-more-engineering-discipline-not-less"&gt;&lt;a href="https://charity.wtf/p/ai-demands-more-engineering-discipline" rel="noopener noreferrer"&gt;AI demands more engineering discipline. Not less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charity Majors pushes back against a growing temptation: if AI generates code quickly and reasonably well, can we relax code reviews, verification, and engineering rigor? Her answer is the exact opposite. As the cost of generating code plummets, lines of code stop being a precious asset and become a disposable artifact of our current understanding. A software team&amp;rsquo;s true output is shared understanding, and what retains lasting value is everything that tells us whether the system is actually working: requirements, invariants, failure modes, tests, observability, and reproducibility.&lt;/p&gt;
&lt;p&gt;She compares the AI wave to the shift from hand-tended &amp;ldquo;pet&amp;rdquo; servers to immutable infrastructure. Once servers could be torn down and rebuilt at will, engineering discipline didn&amp;rsquo;t vanish—it moved up a level into configuration management, provisioning pipelines, verification, and repeatable operations. Software is undergoing the same shift: when code can be regenerated cheaply, individual lines of code stop being the highest-leverage place to spend review energy, and focus moves to artifacts that specify behavior, architecture, trade-offs, and production outcomes. Human brains were never great at statically verifying code anyway, and non-deterministic AI systems make tracing, testing in production, record-and-replay, and tight feedback loops even more critical. Far from making software less rigorous, AI demands more engineering discipline than ever.&lt;/p&gt;
&lt;h2 id="nine-questions-i-now-ask-in-interviews-that-i-wish-i"&gt;&lt;a href="https://louisedeason.substack.com/p/nine-questions-i-now-ask-in-interviews" rel="noopener noreferrer"&gt;Nine Questions I Now Ask in Interviews That I Wish I&amp;rsquo;d Asked Five Years Ago&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Louise Deason reminds candidates that an interview is a two-way evaluation, even though most people still treat it like a school exam—which conveniently benefits the employer. The &amp;ldquo;do you have any questions for us?&amp;rdquo; segment at the end is the most underutilized part of the process, precisely because interviewers let their guard down and inadvertently reveal how the org actually runs. She shares nine questions designed to force specific, revealing answers: how the most recent promotion on the team happened, what the longest-tenured person in this role is doing now, what the team is genuinely bad at, how the team handled a recent disagreement with leadership, headcount plans for the next year, whether you can meet the people you&amp;rsquo;ll actually work with day to day, what six-month success and failure look like, when the last reorg happened, and why this role is open.&lt;/p&gt;
&lt;p&gt;The real signal lies in how the interviewer responds: whether the answer is concrete, evasive, or hesitant. A clear story about promotion criteria or an honest admission of a team&amp;rsquo;s weak spots signals transparency; conversely, claims that &amp;ldquo;we always agree,&amp;rdquo; reluctance to let you speak with future peers, or an awkward pause when asked why the seat is open are major red flags. Her closing reminder: you are always choosing between differently imperfect options, and any company that gets defensive when asked thoughtful questions doesn&amp;rsquo;t deserve your time.&lt;/p&gt;
&lt;h2 id="agentic-testing-where-agents-fit-in-the-e2e-testing-stack"&gt;&lt;a href="https://slack.engineering/agentic-testing-where-agents-fit-in-the-e2e-testing-stack/" rel="noopener noreferrer"&gt;Agentic Testing: Where Agents Fit in the E2E Testing Stack&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergii Gorbachov at Slack shares findings from over 200 end-to-end test runs powered by AI agents, exploring where agentic testing belongs in the testing stack. Traditional E2E tests enforce a rigid, scripted path through the UI, whereas agentic tests start from a high-level goal: the agent observes the current UI state, decides the next action on the fly, and verifies the outcome. The team benchmarked three approaches—an agent driving Playwright MCP, an agent driving Playwright CLI, and AI-generated deterministic Playwright test scripts—against a staging workspace with synthetic data across two user flows: replying to a thread and search discovery.&lt;/p&gt;
&lt;p&gt;The AI-generated Playwright scripts ran fastest at around 3 minutes, but their failure rate spiked to ~48% on the more complex flow. Using Sonnet 4.5 to run the agent and Opus 4.6 to generate tests, Playwright MCP achieved the lowest failure rate at 0–12%, compared to 12–20% for Playwright CLI, where most failures stemmed from login and navigation hiccups at the execution layer. MCP also required fewer interaction turns because it batches actions and returns updated state in a single round-trip. However, each agentic test run cost $15–$30 and took over 5 minutes, with most of the cost driven by repeatedly re-sending conversation history. Slack&amp;rsquo;s conclusion: deterministic E2E tests remain the backbone for fast CI regression checks, while agentic testing sits as a complementary layer at the top of the testing pyramid—ideal for exploratory testing of complex flows, diagnosing flaky journeys, and reproducing production bugs.&lt;/p&gt;
&lt;h2 id="making-agents-easy-13-lessons-from-forter"&gt;&lt;a href="https://blog.forter.dev/making-agents-easy-13-lessons-from-forters-agentic-ai-sprint/" rel="noopener noreferrer"&gt;Making Agents Easy: 13 Lessons from Forter&amp;rsquo;s Agentic AI Sprint&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Maraney recounts how Forter ran a two-week company-wide sprint to get their entire R&amp;amp;D organization building AI agents. The core thesis isn&amp;rsquo;t that building agents is inherently effortless, but that an organization can systematically remove friction across three layers: tooling, agent runtime infrastructure, and organizational guardrails. On the tooling side, Forter built an internal MCP server called Toolchain: engineers open a web UI, pick and configure the tools they need, and immediately get an API key; adding a new internal tool takes just a declarative YAML file and a thin wrapper. By the end of the two-week sprint, Toolchain had grown to over 90 internal tools. And rather than standing up a complex custom RAG pipeline, they exposed their existing enterprise search engine as an MCP tool.&lt;/p&gt;
&lt;p&gt;The post shares several pragmatic operational lessons as well. Agent builders need full visibility into every raw tool request and response—one Forter incident-response agent appeared to &amp;ldquo;solve&amp;rdquo; an outage brilliantly until traces revealed it had simply read the already-written postmortem doc. For internal human-in-the-loop tools, teams don&amp;rsquo;t need formal eval suites on day one; prioritize tracing and observability first. Bring legal and security in early, enforce permissions in deterministic code rather than prompts, and put token costs on a visible dashboard. Finally, when training teams, tell them to treat an LLM like a bright new-grad intern: broad textbook knowledge, zero institutional context—meaning the responsibility for giving clear instructions rests squarely on the builder.&lt;/p&gt;
&lt;h2 id="agentic-code-review"&gt;&lt;a href="https://addyosmani.com/blog/agentic-code-review/" rel="noopener noreferrer"&gt;Agentic Code Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that as coding agents write code faster and faster, the primary bottleneck in software engineering shifts from writing code to verifying and trusting it. AI can produce mountains of syntactically valid, test-accompanied, plausible-looking code, but human reading comprehension hasn&amp;rsquo;t sped up to match. That makes code review the highest-leverage skill in modern engineering: not merely hunting for typos, but reconstructing intent, assessing blast radius, spreading system knowledge across the team, and deciding whether a change should exist at all. Industry data from 2026 cited in the post shows that while code output has surged, code churn, defects, production incidents, and review wait times have climbed right alongside it.&lt;/p&gt;
&lt;p&gt;There is no single review policy that fits every context. Solo side projects with no users can lean heavily on automated tests and AI review; long-lived production systems handling real users, money, or sensitive data require risk-tiered human review. Osmani recommends keeping pull requests small, stating intent explicitly, requiring concrete proof of verification (such as real test outputs) before human review begins, reading test diffs more closely than implementation diffs, treating deterministic CI as a non-negotiable guardrail, and using AI reviewers as sensors rather than final judges. Humans may no longer read every single generated line, but they still own the merge button, carry accountability for production, and must focus their deepest scrutiny on high-blast-radius changes like auth, billing, security, and privacy.&lt;/p&gt;
&lt;h2 id="i-thought-redis-was-just-a-hashmap"&gt;&lt;a href="https://mukul0x9.pages.dev/blog/memdb/" rel="noopener noreferrer"&gt;I Thought Redis Was Just a HashMap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mukul Makwana starts from a deceptively simple question: how different is Redis or Memcached from a global hash map supporting &lt;code&gt;set&lt;/code&gt;, &lt;code&gt;get&lt;/code&gt;, and &lt;code&gt;del&lt;/code&gt;? To find out, he built a minimal in-memory database from scratch in Go. Version one wrapped Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt;, accepted commands over TCP, and spawned one goroutine per client connection. The bottleneck appeared immediately as soon as multiple goroutines read and wrote concurrently: the map needed synchronization, and a single global mutex forced every operation to wait in line.&lt;/p&gt;
&lt;p&gt;To fix that, Makwana replaced the built-in map with a two-array arena design: &lt;code&gt;bucket_array&lt;/code&gt; stores offsets while &lt;code&gt;data_array&lt;/code&gt; packs metadata, keys, values, and next-entry offsets for collision chaining in contiguous byte slices. To reduce lock contention, the keyspace is partitioned into shards, each with its own arrays and &lt;code&gt;RWMutex&lt;/code&gt;, while a background goroutine handles shard resizing when load factors climb. Because &lt;code&gt;data_array&lt;/code&gt; is append-only, deletes simply mark a tombstone bit, and a compaction pass rebuilds the shard once dead bytes cross a threshold—at the cost of locking that shard during compaction. Benchmarking &lt;code&gt;SET&lt;/code&gt; workloads showed Go&amp;rsquo;s built-in &lt;code&gt;map&lt;/code&gt; still winning on raw throughput and stop-the-world pause times, but the custom pointer-free arena slashed concurrent GC mark time from ~113 ms down to 7.8 ms. Even then, this toy engine still lacks persistence, eviction policies, crash recovery, and replication—the exact things that make real Redis a serious piece of engineering.&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 #118</title><link>https://miti99.com/en/post/2026/07/06/</link><pubDate>Mon, 06 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #118.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="telling-the-story-right-efficient-logging-in-go"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-logs/" rel="noopener noreferrer"&gt;Telling the story right: efficient logging in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on his post about Go error handling, Robin Siep turns to logging: good logs must carry enough context to debug production issues while remaining easy to read during local development. He groups what to log into three categories: errors, almost always at &lt;code&gt;ERROR&lt;/code&gt; level with a stack trace and triggering conditions; important business events and state transitions, typically at &lt;code&gt;INFO&lt;/code&gt; level recording who performed the action; and interactions with databases, third-party services, or clients, where overly chatty details can be pushed down to &lt;code&gt;DEBUG&lt;/code&gt;. Three common mistakes are logging secrets, credentials, or PII, running production at the wrong log level, and pruning logs too aggressively up front—since logging too little usually hurts far more than logging too much.&lt;/p&gt;
&lt;p&gt;Structured logs are essential in production for filtering and querying, whereas colorized plain-text logs are much easier to scan locally. Siep recommends keeping plain-text output in production as well: when your log ingestion pipeline goes down, stdout text logs are what you have left to diagnose and fix the pipeline itself. His implementation uses Go&amp;rsquo;s standard &lt;code&gt;slog&lt;/code&gt; package with two custom handlers: one that formats records as CLEF to ship to Seq with stack traces extracted into a dedicated field, and a colorized text handler that renders attributes cleanly. If shipping to Seq fails, both the pipeline error and the original log record still get written through the text handler. The same pattern works with &lt;code&gt;zap&lt;/code&gt;, showing that logs are only as valuable as their ability to preserve context even when your observability stack is having a bad day.&lt;/p&gt;
&lt;h2 id="on-cpu-physics-and-cpu-cycles"&gt;&lt;a href="https://6it.dev/blog/on-cpu-physics-and-cpu-cycles-80730" rel="noopener noreferrer"&gt;On CPU Physics and CPU Cycles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is a draft book section on writing efficient C++ for modern 64-bit CPUs, built around one central thesis: software performance is governed not just by algorithms, but by hardware physics. The farther an electrical signal has to travel, the slower the access, largely because parasitic capacitance grows with wire length. That is why operations on registers and the ALU take just a couple of cycles, L1 cache takes a few cycles, L2 and L3 get progressively more expensive, and a trip to main RAM can cost hundreds of CPU cycles. Going farther out—across the motherboard to SSDs, HDDs, and the network—adds orders of magnitude more latency, giving cache locality massive real-world impact.&lt;/p&gt;
&lt;p&gt;To hide that latency, modern CPUs rely on instruction pipelining, superscalar execution, and branch prediction, speculatively executing instructions before a branch outcome is known. Even so, a mispredicted branch costs tens of cycles; attributes like &lt;code&gt;[[likely]]&lt;/code&gt; and &lt;code&gt;[[unlikely]]&lt;/code&gt; should be reserved for cases where the branch direction is overwhelmingly lopsided, such as error-handling paths. Cache warmth depends on access patterns and working set size rather than whether memory lives on the stack, static storage, or the heap. Contiguous layouts like &lt;code&gt;std::vector&lt;/code&gt; shine during sequential traversal, making &lt;code&gt;vector&lt;/code&gt; far friendlier to both CPU caches and the TLB than node-based structures like linked lists or trees. Think of performance as a chain of physical costs.&lt;/p&gt;
&lt;h2 id="the-log-is-the-agent"&gt;&lt;a href="https://x.com/ishaansehgal/status/2065129901427130678" rel="noopener noreferrer"&gt;The Log Is the Agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ishaan Sehgal offers a crisp definition of an AI agent: the agent is not the model, the runtime, the active loop, or the toolset—it is the durable log of everything it has seen and done. He compares it to a character in Skyrim or Elden Ring: what defines your character isn&amp;rsquo;t the game engine, the console, or the controller, but the save file. For an agent, the log is an append-only sequence of events capturing user inputs, model outputs, tool calls, and tool results, alongside references to system prompts and skills. The log alone is enough for a brand-new process to reconstruct state and pick up right where the previous one left off.&lt;/p&gt;
&lt;p&gt;The architectural implication is that the log must be the centerpiece of the system rather than a debugging byproduct. Every operation reads from the log, appends to the log, or renders a projection of the log—much like a database treats tables, indexes, and caches as projections over a write-ahead log. While the log enables crash recovery, it doesn&amp;rsquo;t automatically make external side effects idempotent, so runtimes still have to handle duplicate or ambiguous in-flight tool calls; if a worker dies, another worker can claim the session and continue; if you want to test a different model or strategy, you simply fork from the same history. Context compaction and summarization help fit within token windows, but because they are lossy by nature, they must never replace the raw log as the source of truth. This framing also exposes a new form of vendor lock-in: lock-in to an agent&amp;rsquo;s operational history. Whoever can inspect, export, and query the log is who truly owns the agent.&lt;/p&gt;
&lt;h2 id="software-is-not-a-single-player-game"&gt;&lt;a href="https://www.davidpoll.com/2026/06/software-is-not-a-single-player-game/" rel="noopener noreferrer"&gt;Software Is Not A Single-Player Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Poll responds to the argument that all meaningful judgment should happen before code review, back in the PRD or design doc phase. That view had a rational origin: writing code used to be the most expensive step, so the industry built an entire apparatus of PRDs, design docs, and RFCs to reduce the cost of building the wrong thing. Yet that linear view misses the essence of software development: it is not a single-player game, but a collaborative practice where teams develop shared technical taste, mental models, and product judgment over time. Code review isn&amp;rsquo;t just about catching bugs—it is one of the primary places where that shared understanding is forged.&lt;/p&gt;
&lt;p&gt;Now that AI has dramatically lowered the cost of writing code, documents that used to serve as proxies for code are giving way to working changes. A prototype or pull request is now cheap enough to be a better medium for debate, making code review even more central: the team looks at a concrete change, asks how it affects the system and users, and decides whether it belongs in the product. A closed pull request is no longer a wasted failure, but often the cheapest way to learn that an approach doesn&amp;rsquo;t fit. Still, Poll warns against a reckless &amp;ldquo;just ship and rollback&amp;rdquo; mentality: code can be reverted, but user trust and product perception cannot. Some decisions still must be settled before coding—such as org-wide architecture, security, compliance, and customer commitments—even as the set of things requiring heavy up-front specification shrinks.&lt;/p&gt;
&lt;h2 id="cleaning-up-after-ai-rockstar-developers"&gt;&lt;a href="https://www.codingwithjesse.com/blog/rockstar-developers/" rel="noopener noreferrer"&gt;Cleaning up after AI rockstar developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jesse Skinner uses the trope of the &amp;ldquo;rockstar developer&amp;rdquo; to illustrate a familiar engineering hazard: someone brilliant, fast, and enamored with shiny new technology who can single-handedly rewrite a core system over a weekend, but leaves behind code the rest of the team struggles to understand or maintain. When that person moves on, the remaining team pays the real bill: spending days just getting the project to run, untangling convoluted data flows, learning unfamiliar languages or libraries, and convincing management that the system needs rescuing rather than continuing to coast on the rockstar&amp;rsquo;s aura.&lt;/p&gt;
&lt;p&gt;Skinner&amp;rsquo;s core point is that AI can amplify this exact failure mode. Every chat session with an LLM is like dropping a brand-new &amp;ldquo;rockstar&amp;rdquo; into your codebase: it generates code at breakneck speed, holds zero long-term institutional memory, eagerly applies generic &amp;ldquo;best practices&amp;rdquo; the problem doesn&amp;rsquo;t need, and bears no responsibility for whether the system remains comprehensible to the team six months later. When dozens of features and bug fixes are generated across disconnected sessions, a codebase quickly devolves into a patchwork of hundreds of clashing design styles while the architecture balloons far beyond the problem&amp;rsquo;s actual complexity. He advises using LLMs as assistants under firm human technical leadership: work in small increments, review every change closely, retain architectural control, simplify relentlessly, and stay willing to write code by hand whenever that is the better way to preserve quality.&lt;/p&gt;
&lt;h2 id="a-new-era-for-software-testing"&gt;&lt;a href="https://antirez.com/news/168" rel="noopener noreferrer"&gt;A new era for software testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Antirez observes that while AI-assisted coding trades away some structural code quality for speed, in QA and testing LLMs unlock much stronger automation without sacrificing quality. Traditional test suites made up of unit and integration tests remain essential, but 100% line coverage does not mean 100% state coverage. End-to-end integration testing has historically been painful due to timing issues, complex environment setup, and outputs that require human judgment to evaluate, causing many manual test scenarios to be skipped before release.&lt;/p&gt;
&lt;p&gt;His proposal is to write a Markdown prompt instructing an AI agent to act as a QA engineer performing exploratory manual testing on a new release. The agent starts by inspecting recent commits since the last release, identifying potentially affected areas, and hunting for targeted regressions. On DwarfStar, an open-source LLM inference engine, the agent tested distributed inference across two MacBooks over every available GGUF model file and caught a throughput regression without needing hardcoded baseline numbers, reasoning about expected speeds dynamically. On Redis Arrays, the agent built a non-trivial application from scratch, spun up an environment with replication and persistence, and simulated days of multi-user activity to uncover edge-case misbehavior—even flagging surprising semantics, missing docs, and rough edges. Antirez believes agentic QA can raise the quality bar for every release, partially offsetting the structural sloppiness introduced by rapid AI coding.&lt;/p&gt;
&lt;h2 id="nobody-pushed-back-why-engineers-stay-silent-until-it"&gt;&lt;a href="https://howtocenterdiv.com/beyond-the-div/nobody-pushed-back" rel="noopener noreferrer"&gt;Nobody Pushed Back: Why Engineers Stay Silent Until It&amp;rsquo;s Too Late&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that many architectural disasters happen not because engineers failed to spot the flaw, but because they saw it clearly and didn&amp;rsquo;t feel safe speaking up. In a meeting room, a shaky technical direction gets rubber-stamped under the banner of &amp;ldquo;alignment&amp;rdquo; even though half the room privately disagrees; months later, when the system collapses, everyone admits they saw it coming. The pattern repeats across the industry: the technical risk is obvious to the people closest to the work, but the social and career cost of pushing back is higher than the cost of staying quiet.&lt;/p&gt;
&lt;p&gt;Case studies from Nokia, TSB, Boeing, and Microsoft show that bad news is rarely missing—it just fails to travel upward to decision-makers. Nokia had engineers who knew Symbian wasn&amp;rsquo;t built for the touchscreen era; TSB had technical objections raised before its disastrous core banking migration; Boeing had engineers flagging MCAS risks; Microsoft had internal signals that Windows Phone&amp;rsquo;s direction was boxing itself into a corner. The root cause isn&amp;rsquo;t personal cowardice, but organizational incentives: dissent gets labeled &amp;ldquo;not being a team player,&amp;rdquo; the Highest Paid Person&amp;rsquo;s Opinion (HiPPO) wins by default, and watermelon metrics (green on the outside, red on the inside) are used to shut down debate, turning technical trade-offs into political loyalty tests. Effective pushback isn&amp;rsquo;t saying &amp;ldquo;this is wrong,&amp;rdquo; but making costs and risks concrete through questions like: what will this decision cost us in 18 months, how are we testing this failure mode, and what is our rollback plan if it breaks?&lt;/p&gt;
&lt;h2 id="loop-engineering"&gt;&lt;a href="https://addyo.substack.com/p/loop-engineering" rel="noopener noreferrer"&gt;Loop Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani describes &amp;ldquo;loop engineering&amp;rdquo; as the natural evolution beyond prompt engineering: instead of manually prompting an agent turn by turn, the engineer designs a self-sustaining loop that finds work, delegates tasks, verifies results, and decides what to do next. A loop acts like a recursive goal—you define the objective, and the AI iterates until the exit criteria are met. According to Osmani, this paradigm is already practical today because both Codex and Claude Code provide all the necessary building blocks, so rather than arguing over which tool wins, teams should design loops that can run across both.&lt;/p&gt;
&lt;p&gt;A complete loop rests on five primitives. Scheduled automations triage issues, summarize CI failures, or hunt for new bugs. Git worktrees let multiple agents work in parallel without stepping on each other&amp;rsquo;s files. Skills package project-specific knowledge so you don&amp;rsquo;t have to re-explain conventions in every session. Connectors, typically built on MCP, give agents access to issue trackers, databases, Slack, or staging APIs. Subagents separate the builder from the verifier, since an agent that just wrote the code is usually far too lenient when grading its own homework. Tying it all together is durable external memory—Markdown files or Linear boards in the repo—because models forget between runs while the repository remembers. Even so, Osmani stresses that loops don&amp;rsquo;t replace the engineer: an unsupervised loop is also an unsupervised mistake generator. Without human review and comprehension, loops simply accumulate &amp;ldquo;comprehension debt&amp;rdquo; faster; a good loop accelerates delivery while keeping the engineer deeply connected to how the system works.&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_!Y582!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1b5057ba-3667-446b-9760-b726da1431f4_2484x3002.png" alt="Latency vs Throughput vs Bandwidth"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!bdjh!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc9c8ec17-676c-441a-9c97-d08f8eec804f_2484x3002.png" alt="7 Permission Modes Every Claude Code User Should Know"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=MUWAbpg1xLo" rel="noopener noreferrer"&gt;How Do CPUs, GPUs, and TPUs Differ?&lt;/a&gt;&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;This video breaks down the differences between CPUs, GPUs, and TPUs: CPUs offer flexibility for general-purpose tasks, GPUs excel at massively parallel processing, and TPUs are purpose-built accelerators for machine learning workloads. A concise overview to help you pick the right hardware across latency, throughput, and cost trade-offs.&lt;/p&gt;

&lt;/blockquote&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 #117</title><link>https://miti99.com/en/post/2026/07/05/</link><pubDate>Sun, 05 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #117.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="should-you-normalize-rgb-values-by-255-or-256"&gt;&lt;a href="https://30fps.net/pages/255-vs-256-division/" rel="noopener noreferrer"&gt;Should you normalize RGB values by 255 or 256?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pekka Väänänen dissects a deceptively small question that sparks endless debate in image processing: when converting 8-bit RGB color values to floating point, should you divide by 255, or add half a step and divide by 256? The familiar &lt;code&gt;img / 255.0&lt;/code&gt; maps 0 to 0.0 and 255 to 1.0, preserving exact black and exact white, which is convenient for almost all downstream shader and image code. The alternative &lt;code&gt;(img + 0.5) / 256.0&lt;/code&gt; places each sample at the midpoint of a quantization bucket—cleaner from a signal-quantization standpoint and yielding slightly lower theoretical reconstruction error, but only when you control both the encoding and decoding sides of the pipeline.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s pragmatic verdict: for images coming from the outside world, divide by 255. The usual arguments against 255—that the two endpoint buckets are half-width, that floats don&amp;rsquo;t represent thirds or fifths of 255 exact to the last bit, or that a tiny sliver of precision is wasted—are negligible in practice. Conversely, dividing by 256 on images that were quantized under the standard 255 convention introduces bias and hardcodes an 8-bit assumption into your code. The real bug to fear is mixing one convention&amp;rsquo;s encoder with the other&amp;rsquo;s decoder. Only consider dividing by 256 inside a closed system where you control the entire read/write pipeline, don&amp;rsquo;t need 0 to map to 0.0, and every component agrees on the exact same convention.&lt;/p&gt;
&lt;h2 id="jira-is-turing-complete"&gt;&lt;a href="https://seriot.ch/computation/jira.html" rel="noopener noreferrer"&gt;Jira is Turing-Complete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Seriot turns a classic office joke about Jira into a formal proof: Jira Automation can simulate a Minsky register machine, a computational model known to be Turing-complete. In the author&amp;rsquo;s construction, each register is represented by the count of linked issues of a specific type (such as Bug and Task); the instruction pointer is the current status of an Epic; the program table is the set of automation rules; and each clock cycle is a status transition triggered by an automation rule. Using only operations that create, delete, and check linked issues, Jira can express &lt;code&gt;INC&lt;/code&gt;, &lt;code&gt;DEC&lt;/code&gt;, and conditional branching.&lt;/p&gt;
&lt;p&gt;The minimal example is addition: transferring the count of Bugs in register A into Tasks in register B using statuses like &lt;code&gt;TODO&lt;/code&gt;, &lt;code&gt;DEV&lt;/code&gt;, and &lt;code&gt;PROD&lt;/code&gt;. While A still has a Bug, a rule deletes one Bug and transitions to a state that increments B; once A hits zero, it transitions to the halt state. Seriot also uses an issue-type conversion action—which effectively fuses a decrement and an increment into a single step—to compress a Fibonacci program down to three statuses across three registers. The program runs until it hits Jira Cloud&amp;rsquo;s automation chain-depth limit and requires an operator to re-trigger it. Quota limits like that don&amp;rsquo;t invalidate the proof, since every physical computer is finite too. The takeaway isn&amp;rsquo;t that you should write software in Jira, but that complex workflow automations genuinely are programs—complete with state, memory, branches, and loops.&lt;/p&gt;
&lt;h2 id="usb-for-software-developers-an-introduction-to-writing-userspace-usb-drivers"&gt;&lt;a href="https://werwolv.net/posts/usb_for_sw_devs/" rel="noopener noreferrer"&gt;USB for Software Developers: An introduction to writing userspace USB drivers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WerWolv writes an approachable introduction to USB for software developers who want to talk to hardware devices without diving into electrical signaling or writing kernel modules. The running example is an Android phone in bootloader mode, since the Fastboot protocol is simple, well documented, and typically doesn&amp;rsquo;t have an OS kernel driver claiming the interface automatically. The guide starts with &lt;code&gt;lsusb&lt;/code&gt; to inspect the &lt;code&gt;VID&lt;/code&gt;, &lt;code&gt;PID&lt;/code&gt;, device class, and bound drivers, before moving to &lt;code&gt;libusb&lt;/code&gt; to discover and open the device directly from userspace.&lt;/p&gt;
&lt;p&gt;The most valuable part is how the author connects each USB concept directly to working code. During enumeration, the host uses control endpoint &lt;code&gt;0x00&lt;/code&gt; to send standard requests like &lt;code&gt;GET_STATUS&lt;/code&gt; and &lt;code&gt;GET_DESCRIPTOR&lt;/code&gt;, reading descriptors to learn what configurations, interfaces, and endpoints the device exposes. Endpoints can be thought of like communication ports, except USB is strictly host-driven—a device never sends data unprompted. The post explains the four transfer types (Control, Bulk, Interrupt, Isochronous) and notes that &lt;code&gt;IN&lt;/code&gt; and &lt;code&gt;OUT&lt;/code&gt; directions are always defined from the host&amp;rsquo;s perspective. Finally, the sample program sends a Fastboot &lt;code&gt;getvar:version&lt;/code&gt; command over a Bulk OUT endpoint and reads back &lt;code&gt;OKAY0.4&lt;/code&gt; from the Bulk IN endpoint. The takeaway: for a device with a documented protocol, writing a userspace driver with &lt;code&gt;libusb&lt;/code&gt; feels much closer to socket programming than intimidating kernel development.&lt;/p&gt;
&lt;h2 id="everything-you-need-to-know-about-sourcemaps"&gt;&lt;a href="https://neciudan.dev/everything-you-need-to-know-about-sourcemaps" rel="noopener noreferrer"&gt;Everything you need to know about Sourcemaps&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neciu Dan examines sourcemaps from both angles: as an indispensable debugging tool and as a source-code exposure risk. After bundling, browsers execute concatenated, minified, and mangled code, making an error like &lt;code&gt;bundle.min.js:1:48211&lt;/code&gt; nearly useless. A sourcemap is a JSON file mapping positions in the minified output back to the original file, line, column, and identifier names so stack traces become readable again. Yet those very fields—&lt;code&gt;sources&lt;/code&gt;, &lt;code&gt;names&lt;/code&gt;, &lt;code&gt;mappings&lt;/code&gt;, and especially &lt;code&gt;sourcesContent&lt;/code&gt;—can expose directory structures, module names, comments, internal API endpoints, and even the entire original source code if &lt;code&gt;.map&lt;/code&gt; files are left publicly accessible.&lt;/p&gt;
&lt;p&gt;The core lesson is that minification is not a security boundary. When a production bundle points to a sourcemap via &lt;code&gt;sourceMappingURL&lt;/code&gt; or the &lt;code&gt;SourceMap&lt;/code&gt; HTTP header, anyone with DevTools or &lt;code&gt;curl&lt;/code&gt; can download it if the server permits access. The author cites real-world incidents—including Apple&amp;rsquo;s web App Store in 2025 and version 2.1.88 of the &lt;code&gt;@anthropic-ai/claude-code&lt;/code&gt; npm package shipping with a nearly 60 MB &lt;code&gt;cli.js.map&lt;/code&gt; file—to show that leaks are usually simple build or packaging misconfigurations rather than sophisticated attacks. Mitigations include disabling sourcemaps in production when unneeded, uploading sourcemaps privately to Sentry (noting that &amp;ldquo;hidden&amp;rdquo; sourcemaps only omit the reference comment without blocking direct URL access), blocking &lt;code&gt;.map&lt;/code&gt; requests at the web server or CDN, stripping &lt;code&gt;.map&lt;/code&gt; files from build artifacts and npm tarballs, and adding CI/CD checks (such as inspecting &lt;code&gt;npm pack&lt;/code&gt; output) to catch accidental sourcemap publishing.&lt;/p&gt;
&lt;h2 id="extended-statistics-in-postgres"&gt;&lt;a href="https://www.valerieparhamthompson.com/posts/extended-statistics-postgres/" rel="noopener noreferrer"&gt;Extended Statistics in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Valerie Parham-Thompson explains how extended statistics help the Postgres query planner make far more accurate row estimates when columns are correlated in ways default statistics cannot see. The planner relies on internal catalog tables like &lt;code&gt;pg_class&lt;/code&gt; and &lt;code&gt;pg_stats&lt;/code&gt; to estimate row counts, distinct values, histograms, and most common values, but those statistics are collected per column and implicitly assume filter conditions are independent. For instance, &lt;code&gt;zip='91605'&lt;/code&gt; almost entirely implies &lt;code&gt;state='CA'&lt;/code&gt;, yet by default the planner multiplies the two selectivities as if they were independent variables, severely underestimating row counts and picking a poor execution plan.&lt;/p&gt;
&lt;p&gt;The post walks through all three kinds of extended statistics. The &lt;code&gt;dependencies&lt;/code&gt; type captures functional dependencies between columns, such as a ZIP code largely determining the state; after running &lt;code&gt;CREATE STATISTICS ... (dependencies)&lt;/code&gt; and &lt;code&gt;ANALYZE&lt;/code&gt;, the planner&amp;rsquo;s row estimate jumps much closer to reality. The &lt;code&gt;mcv&lt;/code&gt; (most-common values) type tracks frequent value combinations across multiple columns, helping multi-column &lt;code&gt;WHERE&lt;/code&gt; filters like category plus subcategory. The &lt;code&gt;ndistinct&lt;/code&gt; type helps the planner estimate group counts for multi-column &lt;code&gt;GROUP BY&lt;/code&gt; clauses instead of naively multiplying each column&amp;rsquo;s distinct count. The practical takeaway: when you know your schema has correlated columns, teach the planner with extended statistics instead of reflexively reaching for another index.&lt;/p&gt;
&lt;h2 id="finding-a-needle-in-a-4-gb-haystack-from-075-gbs-to-49-gbs-in-go"&gt;&lt;a href="https://segflow.github.io/post/fast-file-search-go/" rel="noopener noreferrer"&gt;Finding a needle in a 4 GB haystack: from 0.75 GB/s to 49 GB/s in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Assel Meher uses a deliberately trivial problem to dissect file reading and scanning performance in Go: finding a single non-zero &lt;code&gt;int64&lt;/code&gt; near the end of a 4 GiB file filled almost entirely with zeros. With no parsing or complex algorithms in the way, the benchmarks expose the true cost of each layer: the Go runtime, standard library, syscalls, page cache, memory bandwidth, &lt;code&gt;mmap&lt;/code&gt;, &lt;code&gt;pread&lt;/code&gt;, multithreading, and SIMD. The baseline—calling &lt;code&gt;os.ReadFile&lt;/code&gt; and ranging byte by byte—hits just ~0.75 GB/s because it allocates and copies 4 GiB before inspecting one byte at a time; &lt;code&gt;bufio.ReadByte&lt;/code&gt; fares no better due to per-byte function call overhead.&lt;/p&gt;
&lt;p&gt;The first major leap comes from eliminating per-byte work: reading in 1 MiB chunks and scanning as &lt;code&gt;uint64&lt;/code&gt; words immediately crosses 13 GB/s. &lt;code&gt;mmap&lt;/code&gt; doesn&amp;rsquo;t automatically win because, while it avoids copying into userspace buffers, touching every page triggers over a million minor page faults. Parallelism helps further, and parallel &lt;code&gt;pread&lt;/code&gt; handily beats parallel &lt;code&gt;mmap&lt;/code&gt;—which plateaus around 28 GB/s due to page-fault lock contention—because sequential block copies are cheaper than massive concurrent page faults. Adding SIMD via AVX2 or Go 1.26&amp;rsquo;s &lt;code&gt;simd/archsimd&lt;/code&gt; package makes the inner scan loop nearly free, at which point memory bandwidth, read strategy, and concurrency become the real bottlenecks. On a Ryzen 5 9600X under WSL2 with a warm page cache, parallel &lt;code&gt;pread&lt;/code&gt; plus SIMD reaches ~49 GB/s; going any faster requires reading less data or buying faster hardware.&lt;/p&gt;
&lt;h2 id="http-caching-a-refresher"&gt;&lt;a href="https://danburzo.ro/http-caching-refresher/" rel="noopener noreferrer"&gt;HTTP caching, a refresher&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Cătălin Burzo revisits RFC 9111 to organize the essential concepts of modern HTTP caching. He reminds readers that &amp;ldquo;the cache&amp;rdquo; isn&amp;rsquo;t just the browser&amp;rsquo;s private cache, but also shared caches like proxies, CDNs, and Varnish sitting between clients and origin servers. At the center is the &lt;code&gt;Cache-Control&lt;/code&gt; header: directives like &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;no-cache&lt;/code&gt;, &lt;code&gt;no-store&lt;/code&gt;, &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;must-revalidate&lt;/code&gt;, &lt;code&gt;stale-while-revalidate&lt;/code&gt;, and &lt;code&gt;stale-if-error&lt;/code&gt; govern not only whether a response may be stored, but also how long it stays &amp;ldquo;fresh&amp;rdquo; (based on age versus &lt;code&gt;max-age&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, &lt;code&gt;Expires&lt;/code&gt;, or heuristics from &lt;code&gt;Last-Modified&lt;/code&gt;), when it must be revalidated with the origin, and whether a shared cache is allowed to store responses to requests carrying an &lt;code&gt;Authorization&lt;/code&gt; header.&lt;/p&gt;
&lt;p&gt;Burzo also clarifies several common points of confusion. A stale response isn&amp;rsquo;t necessarily discarded: a cache can send a conditional request using &lt;code&gt;If-None-Match&lt;/code&gt; (with an &lt;code&gt;ETag&lt;/code&gt;) or &lt;code&gt;If-Modified-Since&lt;/code&gt; (with &lt;code&gt;Last-Modified&lt;/code&gt;) to receive a &lt;code&gt;304 Not Modified&lt;/code&gt; without re-downloading the body. The &lt;code&gt;Vary&lt;/code&gt; header splits the cache key across request headers like &lt;code&gt;Accept-Language&lt;/code&gt;, which can tank hit rates if header values are too diverse, while &lt;code&gt;No-Vary-Search&lt;/code&gt; solves the inverse problem by ignoring query parameters that don&amp;rsquo;t affect response content. The final section compares normal reloads against hard reloads in browsers, explains the role of &lt;code&gt;immutable&lt;/code&gt;, and warns that misusing &lt;code&gt;public&lt;/code&gt;, &lt;code&gt;s-maxage&lt;/code&gt;, or &lt;code&gt;must-revalidate&lt;/code&gt; can trick shared caches into storing authenticated responses—so reach for &lt;code&gt;private&lt;/code&gt; whenever a response belongs strictly to one user.&lt;/p&gt;
&lt;h2 id="how-to-use-ss-as-a-replacement-for-netstat-to-view-ipv4-sockets"&gt;&lt;a href="https://oneuptime.com/blog/post/2026-03-20-ss-replacement-netstat-ipv4-sockets/view" rel="noopener noreferrer"&gt;How to Use ss as a Replacement for netstat to View IPv4 Sockets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nawaz Dhandala introduces &lt;code&gt;ss&lt;/code&gt; as the modern replacement for the deprecated &lt;code&gt;netstat&lt;/code&gt; utility when inspecting sockets on Linux. Because &lt;code&gt;ss&lt;/code&gt; queries socket state directly from the kernel via netlink rather than parsing &lt;code&gt;/proc&lt;/code&gt; files, it is significantly faster, especially on busy servers handling thousands of connections. Focusing on IPv4 with the &lt;code&gt;-4&lt;/code&gt; flag, the post walks through everyday command patterns: listing all TCP, UDP, and raw sockets, viewing active TCP connections, checking listening ports, displaying process names and PIDs (when run with privileges), filtering by state such as &lt;code&gt;state established&lt;/code&gt;, filtering by port with expressions like &lt;code&gt;dport = :443&lt;/code&gt;, filtering by address like &lt;code&gt;src 192.168.1.100&lt;/code&gt;, and viewing summary statistics with &lt;code&gt;ss -s&lt;/code&gt;. The flags &lt;code&gt;-t&lt;/code&gt;, &lt;code&gt;-u&lt;/code&gt;, &lt;code&gt;-l&lt;/code&gt;, &lt;code&gt;-n&lt;/code&gt;, and &lt;code&gt;-p&lt;/code&gt; map cleanly to TCP, UDP, listening sockets, numeric output, and process info.&lt;/p&gt;
&lt;p&gt;The handiest section is a side-by-side translation table from &lt;code&gt;netstat&lt;/code&gt; to &lt;code&gt;ss&lt;/code&gt;: muscle-memory commands like &lt;code&gt;netstat -an&lt;/code&gt;, &lt;code&gt;netstat -tnp&lt;/code&gt;, and &lt;code&gt;netstat -tlnp&lt;/code&gt; translate directly to &lt;code&gt;ss -an&lt;/code&gt;, &lt;code&gt;ss -tnp&lt;/code&gt;, and &lt;code&gt;ss -tlnp&lt;/code&gt;. For day-to-day troubleshooting, &lt;code&gt;ss -4tulnp&lt;/code&gt; is the most compact command to see all listening IPv4 TCP and UDP sockets along with their owning processes, while &lt;code&gt;ss -4tn state established&lt;/code&gt; is ideal for inspecting active IPv4 TCP connections. It serves as a concise, practical cheat sheet for Linux operations.&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 #116</title><link>https://miti99.com/en/post/2026/07/04/</link><pubDate>Sat, 04 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #116.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="8-myths-on-software-engineering-and-ai"&gt;&lt;a href="https://newsletter.getdx.com/p/8-myths-on-software-engineering-and" rel="noopener noreferrer"&gt;8 myths on software engineering and AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck introduces the paper &amp;ldquo;8 Myths on Software Engineering and GenAI,&amp;rdquo; which he co-authored, grouping eight common misconceptions about AI in software engineering into three themes: how developers actually spend their time, how to measure AI&amp;rsquo;s impact, and how AI is adopted inside real organizations. A 2025 study found that developers spend only about 14% of their time writing code, with the rest going to design, meetings, code review, and coordination. Consequently, code generation tools act on a relatively small lever, and speeding up coding easily shifts the bottleneck downstream into code review. Measuring productivity by lines of code—including AI-generated lines—only inflates the review burden; PR throughput is better, but still needs to sit inside a balanced set of metrics.&lt;/p&gt;
&lt;p&gt;Research findings on AI coding tools vary widely: some studies show clear speedups, others are neutral, and one study found experienced developers actually took 18% longer when using AI. Task type, developer experience, and prompting skill all shape the outcome. On the adoption side, 80% of developers use AI tools, yet only 29% trust their accuracy. The overarching takeaway is that AI&amp;rsquo;s impact depends far more on the work system surrounding developers than on the model itself: organizations need to build trust, workflows, guardrails, and system-level measurement rather than simply buying licenses and waiting for productivity to climb on its own.&lt;/p&gt;
&lt;h2 id="you-don"&gt;&lt;a href="https://blog.tjll.net/you-dont-love-systemd-timers-enough/" rel="noopener noreferrer"&gt;You Don&amp;rsquo;t Love systemd Timers Enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that while we still call every scheduled task a &amp;ldquo;cron job,&amp;rdquo; in 2026 there is rarely a reason to use actual &lt;code&gt;cron&lt;/code&gt;. A systemd timer is a unit that schedules another unit—typically a matching &lt;code&gt;.service&lt;/code&gt;—cleanly separating &amp;ldquo;when to run&amp;rdquo; from &amp;ldquo;what to run.&amp;rdquo; That separation solves classic &lt;code&gt;cron&lt;/code&gt; headaches: unpredictable &lt;code&gt;$PATH&lt;/code&gt; environments, swallowed stdout/stderr, hard-to-audit run history, and cryptic schedule syntax. Output goes straight into the journal, while &lt;code&gt;systemctl status&lt;/code&gt; and &lt;code&gt;systemctl list-timers&lt;/code&gt; show both the last run and the next scheduled trigger. The post also notes that &lt;code&gt;ExecStart=&lt;/code&gt; does not run inside a shell by default and does not inherit your interactive shell environment, so unit files should be written explicitly rather than treated like shell scripts—taking advantage of built-in directives like &lt;code&gt;ExecCondition=&lt;/code&gt;, &lt;code&gt;OnFailure=&lt;/code&gt;, and &lt;code&gt;Restart=&lt;/code&gt; instead of reinventing them by hand.&lt;/p&gt;
&lt;p&gt;The most valuable part highlights capabilities that go well beyond traditional &lt;code&gt;cron&lt;/code&gt;. The &lt;code&gt;systemd-analyze calendar&lt;/code&gt; command lets you validate and test schedule expressions before deploying them. Alongside wall-clock schedules via &lt;code&gt;OnCalendar=&lt;/code&gt;, timers support monotonic schedules like &lt;code&gt;OnBootSec=&lt;/code&gt; and &lt;code&gt;OnUnitActiveSec=&lt;/code&gt;—running relative to system boot or the unit&amp;rsquo;s last activation, which often matches operational intent much better than fixed minute or hour intervals. Options like &lt;code&gt;WakeSystem=&lt;/code&gt;, &lt;code&gt;Persistent=&lt;/code&gt;, &lt;code&gt;RandomizedDelaySec=&lt;/code&gt;, &lt;code&gt;FixedRandomDelay=&lt;/code&gt;, and &lt;code&gt;RandomizedOffsetSec=&lt;/code&gt; can wake a sleeping machine, catch up on missed runs after downtime, and prevent thundering herds across fleets. In short, systemd timers express operational schedules far more clearly than &lt;code&gt;cron&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="life-is-too-short-for-a-slow-terminal"&gt;&lt;a href="https://mijndertstuij.nl/posts/life-is-too-short-for-a-slow-terminal/" rel="noopener noreferrer"&gt;Life is too short for a slow terminal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mijndert Stuij writes about keeping his terminal fast because he lives in it all day, where every tiny delay when opening a tab, typing a command, or hitting Tab to autocomplete gets multiplied hundreds of times. His zsh shell starts in roughly 30ms—not thanks to a massive optimization project, but through a habit of keeping the configuration minimal. The biggest wins come from what isn&amp;rsquo;t there: no oh-my-zsh, no plugin manager, just sourcing the three plugins he actually needs directly. Because &lt;code&gt;compinit&lt;/code&gt; is a common startup bottleneck, he caches &lt;code&gt;.zcompdump&lt;/code&gt; so a full check runs only about once a day, while every other shell launch uses &lt;code&gt;compinit -C&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For heavy tools like &lt;code&gt;nvm&lt;/code&gt; or &lt;code&gt;kubectl&lt;/code&gt; completions, he uses lazy-loading: wrapping them in stub functions that only load the real initialization code the first time the command is invoked. Any tool that tells you to drop &lt;code&gt;eval &amp;quot;$(tool init zsh)&amp;quot;&lt;/code&gt; into &lt;code&gt;.zshrc&lt;/code&gt; is a prime candidate for lazy-loading. Prompts should also avoid running synchronous &lt;code&gt;git status&lt;/code&gt; checks inside large repositories; an async prompt like &lt;code&gt;pure&lt;/code&gt; renders immediately and fills in Git status in the background. Finally, he advises measuring instead of guessing, distinguishing between startup time, prompt latency, and input latency: use &lt;code&gt;time zsh -i -c exit&lt;/code&gt;, &lt;code&gt;hyperfine&lt;/code&gt;, &lt;code&gt;zprof&lt;/code&gt;, or startup traces to find the slowest culprit and fix bottlenecks one by one. By his rule of thumb, under 100ms is fine and under 50ms is great.&lt;/p&gt;
&lt;h2 id="opencodereview"&gt;&lt;a href="https://github.com/alibaba/open-code-review" rel="noopener noreferrer"&gt;OpenCodeReview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;OpenCodeReview is Alibaba&amp;rsquo;s open-source CLI tool for AI-powered code review. Born out of an internal review assistant that served tens of thousands of developers over two years, the project is now open to the community and works out of the box with any OpenAI- or Anthropic-compatible model endpoint. Rather than feeding a raw diff to a model and getting generic remarks back, the tool reads the Git diff, lets an agent read full files, search the codebase, and inspect related changed files, and then emits precise line-by-line review comments. Beyond diff-based reviews, the &lt;code&gt;ocr scan&lt;/code&gt; command can audit entire files or directories when exploring an unfamiliar codebase.&lt;/p&gt;
&lt;p&gt;A notable design choice is its hybrid architecture combining deterministic pipelines with agentic reasoning. Steps that cannot afford to be flaky—file selection, grouping related files, matching rules to files, and anchoring line comments—are handled by a strictly constrained pipeline; the agent focuses solely on dynamic reasoning like gathering context and calling tools, guided by review-tuned prompts and toolsets. Built-in rules cover issues like NPEs, thread safety, XSS, and SQL injection. Benchmarks built from 200 real pull requests show that compared to a general-purpose coding agent running the same model, OpenCodeReview achieves higher precision and F1 score while using roughly 1/9th the tokens, at the cost of lower recall—a deliberate trade-off to keep false positives down.&lt;/p&gt;
&lt;h2 id="golang-code-review-notes-ii"&gt;&lt;a href="https://www.elttam.com/blog/golang-code-review-notes-ii" rel="noopener noreferrer"&gt;Golang code review notes II&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zoltan Madarassy and Alex Brown continue their security-focused Go code review notes. Their main premise is that automated scanners and AI assistants now catch most obvious bugs, leaving the truly dangerous issues hiding in subtle corners of the language and standard library that reviewers must actively know to look for. The post starts with a few positive ecosystem improvements: &lt;code&gt;os.Root&lt;/code&gt; in Go 1.24 helps prevent path traversal vulnerabilities, and Go 1.26 updates several cryptographic functions to draw from a secure internal randomness source automatically, though &lt;code&gt;math/rand&lt;/code&gt; remains unsuitable for cryptographic use.&lt;/p&gt;
&lt;p&gt;The bulk of the post focuses on footguns that still slip past review. Integer overflows happen silently—for example, casting a length to a narrower type like &lt;code&gt;uint32(len(s))&lt;/code&gt;—which can corrupt framing boundaries in serialization libraries. &lt;code&gt;httputil.ReverseProxy.Director&lt;/code&gt; is vulnerable to hop-by-hop header abuse, so code should migrate to &lt;code&gt;Rewrite&lt;/code&gt;, which runs after those headers are stripped. Shallow pointer copies in &lt;code&gt;net/url&lt;/code&gt; can lead to shared-state mutation and race conditions; null bytes crossing CGO or C library boundaries can bypass validation checks; and &lt;code&gt;encoding/json&lt;/code&gt; can silently skip a custom marshaller if the method uses a pointer receiver while the struct is passed by value. JSON APIs also aren&amp;rsquo;t automatically immune to CSRF unless &lt;code&gt;Content-Type&lt;/code&gt;, &lt;code&gt;SameSite&lt;/code&gt; cookies, and request origins are properly validated. The authors also release a set of Semgrep rules to catch several of these patterns automatically.&lt;/p&gt;
&lt;h2 id="thoughts-on-starting-new-projects-with-llm-agents"&gt;&lt;a href="https://eli.thegreenplace.net/2026/thoughts-on-starting-new-projects-with-llm-agents/" rel="noopener noreferrer"&gt;Thoughts on starting new projects with LLM agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eli Bendersky shares his experience using LLM agents to build &lt;code&gt;watgo&lt;/code&gt;, a new Go project, from scratch. He starts by iterating with the agent on the design and API, saving the result as a committed Markdown file in the repository that both human and agent follow as a shared blueprint. From there, he asks the agent to implement small changelists (CLs) in a logical sequence, reviews each one in VSCode&amp;rsquo;s diff view, makes manual edits where needed, and commits the changes himself. When the agent produces a diff that grows too large, the pragmatic move is to commit at an acceptable intermediate state and ask for follow-up refactorings in separate CLs; if a whole direction turns out wrong, the commit chain is still easy to revert.&lt;/p&gt;
&lt;p&gt;His central message is that humans must stay firmly in the loop on any project meant for long-term maintenance. Vibe coding works fine for prototypes or throwaway scripts, but on a serious project, the author must understand, review, and steer every design decision. He stresses small CLs and a solid testing strategy, warning against letting an agent write both the implementation and the tests in one go, where it can easily bake its own bugs into the test expectations. He also finds Go exceptionally well suited for agentic coding thanks to its stability, minimal syntactic redundancy, rich standard library, uniform formatting, and explicit error handling—when human effort shifts from writing code to reading it, readability becomes a massive advantage. Finally, he cautions junior developers to be careful about leaning too heavily on LLMs while still building foundational skills.&lt;/p&gt;
&lt;h2 id="the-history-of-pets-vs-cattle-and-how-to-use-the-analogy-properly"&gt;&lt;a href="https://cloudscaling.com/blog/cloud-computing/the-history-of-pets-vs-cattle/" rel="noopener noreferrer"&gt;The History of Pets vs Cattle and How to Use the Analogy Properly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Randy Bias recounts the origin and intended meaning of the &amp;ldquo;pets vs. cattle&amp;rdquo; analogy in cloud infrastructure. He adapted the metaphor from a presentation on scaling SQL Server, reframing it for cloud computing to contrast the irreplaceability of a &amp;ldquo;pet&amp;rdquo; with the fungibility of &amp;ldquo;cattle.&amp;rdquo; A &amp;ldquo;pet&amp;rdquo; is a server or pair of servers treated as indispensable—typically built and cared for by hand, where a failure sends the whole team scrambling to nurse it back to health. &amp;ldquo;Cattle&amp;rdquo; are fleets of three or more machines provisioned automatically and designed for failure, so losing a node or two is handled automatically by the system without human intervention. The analogy caught on because it captured the shift from traditional sysadmin practices to cloud-native architecture in a single image.&lt;/p&gt;
&lt;p&gt;Bias also warns that misusing the analogy strips away its original lesson. A prime example was Kubernetes originally naming StatefulSets &amp;ldquo;Pet Sets&amp;rdquo;: the stateful distributed systems cited as examples—Cassandra, Kafka, MongoDB—are actually architected as &amp;ldquo;cattle,&amp;rdquo; since they handle node failure through horizontal scale-out. Defining a &amp;ldquo;pet&amp;rdquo; as any system that needs special handling, rather than a system that isn&amp;rsquo;t allowed to fail, blurs the distinction between legacy operations and cloud-native design. The core of the analogy is server replaceability and system-level fault tolerance, not whether a workload happens to be stateful.&lt;/p&gt;
&lt;h2 id="every-byte-matters"&gt;&lt;a href="https://fzakaria.com/2026/06/01/every-byte-matters" rel="noopener noreferrer"&gt;Every byte matters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Farid Zakaria reminds us that performance isn&amp;rsquo;t just about Big-O complexity. Even inside a simple linear loop, data size and memory layout make a massive difference because CPUs fetch memory in cache lines, typically 64 bytes at a time. If a struct is large but a loop only inspects a single small field like &lt;code&gt;is_alive&lt;/code&gt;, an array-of-structs layout drags dozens of unused bytes into the cache on every read. Flipping to a struct-of-arrays layout packs that single field into contiguous memory so every cache line fetch serves many more elements; in the author&amp;rsquo;s benchmark, this yielded up to a 30x speedup when the struct size reached 1KiB.&lt;/p&gt;
&lt;p&gt;The post also explains why working set size is critical for random access patterns. During sequential scans, the CPU hardware prefetcher can predict upcoming addresses and hide memory latency. With hash maps, trees, graphs, or pointer-heavy structures, however, the next address is unpredictable, meaning the working set must fit inside CPU cache to avoid stalling on main memory. Simply doubling a struct from 64B to 128B pushes the exact same number of elements down into a slower cache tier: at 512 elements, 64B structs fit inside L1d at ~3 ns latency, whereas 128B structs spill into L2 at ~11 ns. The practical lesson is that every byte on a hot path carries a cost, and understanding struct sizes, cache lines, and working sets often yields far bigger wins than algorithmic analysis alone.&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 #115</title><link>https://miti99.com/en/post/2026/07/02/</link><pubDate>Thu, 02 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #115.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-experiments-explained"&gt;&lt;a href="https://www.alexedwards.net/blog/go-experiments-explained" rel="noopener noreferrer"&gt;Go Experiments Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards explains the experimental feature mechanism Go ships in each release: sometimes a new standard library package like &lt;code&gt;testing/synctest&lt;/code&gt;, sometimes a compiler or runtime change like a new garbage collector, and more rarely a language behavior change like loop variable scoping before it became the default in Go 1.22. The goal is to gather real-world feedback before locking a feature in; if it causes problems or draws pushback, it can be revised or dropped entirely. The typical lifecycle starts disabled by default, flips to enabled by default after a release or two (often with a transition period allowing opt-out), and eventually retires the flag—though exceptions happen: &lt;code&gt;Arenas&lt;/code&gt; was put on indefinite hold after negative feedback, while Swiss tables went straight to default.&lt;/p&gt;
&lt;p&gt;Because there is no official status page tracking experiments, Edwards compiled a reference table for Go 1.26 from &lt;code&gt;go doc goexperiment.Flags&lt;/code&gt;, the &lt;code&gt;internal/buildcfg&lt;/code&gt; source, and release notes. To use them, pass comma-separated lowercase names in the &lt;code&gt;GOEXPERIMENT&lt;/code&gt; environment variable to enable features, or prefix a name with &lt;code&gt;no&lt;/code&gt; to disable it, across &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go test&lt;/code&gt;. For everyday Go developers, the most notable flags are &lt;code&gt;GreenTeaGC&lt;/code&gt; and &lt;code&gt;Dwarf5&lt;/code&gt; (already enabled by default, so worth knowing how to disable if issues arise), &lt;code&gt;JSONv2&lt;/code&gt;, &lt;code&gt;GoroutineLeakProfile&lt;/code&gt; for catching leaked goroutines, &lt;code&gt;RuntimeSecret&lt;/code&gt; for code handling sensitive data, and &lt;code&gt;RuntimeFreegc&lt;/code&gt;. One important caveat: experiments fall outside Go&amp;rsquo;s compatibility promise, so use them to test, benchmark, and give feedback rather than relying on them prematurely in production.&lt;/p&gt;
&lt;h2 id="low-level-network-optimizations-socket-options-that-matter"&gt;&lt;a href="https://goperf.dev/02-networking/low-level-optimizations/" rel="noopener noreferrer"&gt;Low-Level Network Optimizations: Socket Options That Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This entry from the Go Optimization Guide examines socket options that directly impact latency and throughput in Go network applications. Operating system defaults prioritize safety and broad compatibility, meaning under heavy load they often become bottlenecks well before CPU or memory. &lt;code&gt;TCP_NODELAY&lt;/code&gt; disables Nagle&amp;rsquo;s algorithm so small packets are sent immediately at the cost of higher bandwidth overhead; Go enables this by default on &lt;code&gt;TCPConn&lt;/code&gt;. &lt;code&gt;SO_REUSEPORT&lt;/code&gt; lets multiple processes or threads bind to the same port while the kernel distributes incoming connections across separate queues, reducing lock contention and scaling across CPU cores. Receive and send buffer sizes (&lt;code&gt;SO_RCVBUF&lt;/code&gt; and &lt;code&gt;SO_SNDBUF&lt;/code&gt;) should roughly match the bandwidth-delay product: too small increases syscalls and caps throughput, while too large wastes memory and inflates latency via bufferbloat.&lt;/p&gt;
&lt;p&gt;For TCP keepalives, OS defaults are very conservative; common production settings wait 30–60 seconds, probe every 10–15 seconds, and retry 3–5 times, though tuning them too aggressively increases traffic and risks false drops on congested links. In Go, &lt;code&gt;SetKeepAlivePeriod&lt;/code&gt; only controls the initial idle time; starting in Go 1.23, &lt;code&gt;SetKeepAliveConfig&lt;/code&gt; lets you configure Interval and Count without dropping down to raw syscalls. &lt;code&gt;SOMAXCONN&lt;/code&gt; governs the listener backlog queue and is tuned at the OS level via &lt;code&gt;sysctl&lt;/code&gt;. To apply socket options at the right moment—before the socket is bound—use the &lt;code&gt;Control&lt;/code&gt; callback on &lt;code&gt;net.ListenConfig&lt;/code&gt; with &lt;code&gt;syscall.RawConn&lt;/code&gt;. The overarching advice: change one setting at a time, test under realistic load, and rely on measurements rather than copy-pasting configs from elsewhere.&lt;/p&gt;
&lt;h2 id="when-is-100-vibe-coding-ok-"&gt;&lt;a href="https://dev.to/realvorl/when-is-100-vibe-coding-ok--38p" rel="noopener noreferrer"&gt;When Is 100% Vibe Coding OK ?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Viorel PETCU opens with the frustration of spending hours reviewing &amp;ldquo;vibe-written&amp;rdquo; specifications: they read smoothly on the surface but say almost nothing concrete and cannot be applied to an existing system. The author isn&amp;rsquo;t against vibe coding—in fact, he uses it regularly for one-off scripts, throwaway charts, quick parsers, or docs nobody has to maintain, where speed matters more than rigor. Once software needs long-term maintenance, however, the equation changes completely.&lt;/p&gt;
&lt;p&gt;His motivating example is a wooden puzzle of 25 identical pentacube pieces that must pack a &lt;code&gt;5×5×5&lt;/code&gt; cube. After failing to solve it by hand, he used Go and ChatGPT to write a solver: the initial struggle wasn&amp;rsquo;t the algorithm, but the domain representation—coordinate conventions, slice notation, piece rotations, and naming. Once the model stabilized, the rest was classic brute-force recursion with backtracking, and modern hardware was fast enough that no further optimization was needed. Within about two hours, the project evolved into a general solver complete with OBJ/MTL export for viewing in Blender. Crucially, the author was able to push past hallucinated constraints, wrong assumptions, and buggy code because he already knew for a fact that the puzzle had a physical solution. His conclusion: 100% vibe coding is fine when a human holds the invariants, the constraints are real, and the output is verifiable; if the requirements themselves are just vibes, the system has nothing solid to converge on.&lt;/p&gt;
&lt;h2 id="self-calling-executables"&gt;&lt;a href="https://log.pfad.fr/2026/self-calling-executable/" rel="noopener noreferrer"&gt;Self-calling executables&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Olivier introduces the &amp;ldquo;self-calling executable&amp;rdquo; pattern: a running program spawns another instance of itself, directly or indirectly, to take on a different role. The first use case is black-box testing a &lt;code&gt;main&lt;/code&gt; function when the codebase relies on global state that causes in-process tests to interfere with one another. A test invokes the test binary itself via &lt;code&gt;os.Args[0]&lt;/code&gt; along with an environment variable like &lt;code&gt;TEST_MAIN&lt;/code&gt;; inside &lt;code&gt;TestMain&lt;/code&gt;, if that variable is set, the binary runs the real entrypoint instead of the test runner, isolating each invocation inside a fresh child process.&lt;/p&gt;
&lt;p&gt;The second use case is integrating with external tools, illustrated by jjui, a terminal UI for Jujutsu. The &lt;code&gt;ssh&lt;/code&gt; command uses the &lt;code&gt;SSH_ASKPASS&lt;/code&gt; environment variable to invoke an external helper when it needs a passphrase; jjui points &lt;code&gt;SSH_ASKPASS&lt;/code&gt; back at itself so that when &lt;code&gt;ssh&lt;/code&gt; prompts for a password, the grandchild process connects back to the main jjui process over a Unix domain socket (with the PID embedded in the path so multiple sessions can run concurrently), forwards the prompt, collects the user&amp;rsquo;s input, and prints it to stdout for &lt;code&gt;ssh&lt;/code&gt;. Because this handles sensitive credentials, the author adds two safeguards: each child receives a random token it must present on connect, and the main process walks the connecting client&amp;rsquo;s ancestor PID chain to verify lineage. Downsides include harder debugging, risk of infinite recursion if environment variables are misconfigured, and the Go race detector sleeping for 1 second on every process exit—which once stretched Forgejo&amp;rsquo;s integration suite from 45 minutes to over 2 hours, fixable via &lt;code&gt;GORACE=&amp;quot;atexit_sleep_ms=0&amp;quot;&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="modern-engineering-values"&gt;&lt;a href="https://cpojer.net/posts/modern-engineering-values" rel="noopener noreferrer"&gt;Modern Engineering Values&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christoph Nakazawa shares that he now rarely writes code by hand: projects like Vite+, fate, and Athena Crisis are largely written by coding agents, primarily via Codex CLI. His workflow is to have the agent propose a plan and ask clarifying questions before executing, require a failing test before fixing a bug, run several automated review passes, and only then review the diff himself. When writing code is no longer the bottleneck, discussing and reviewing code becomes the limiting factor.&lt;/p&gt;
&lt;p&gt;From there, the post proposes a set of engineering values for the agentic era. Strong ownership: agents amplify engineers with deep product understanding just as much as they amplify noise from people lacking context, meaning effective teams will be small—around two to three people—with clear boundaries, and code review will focus on alignment rather than nitpicking individual lines. Good taste to know what is actually worth building. Tight guardrails and fast feedback loops—linters, automated tests, and tools that operate only on changed files—because working with agents is like onboarding a brand-new hire with zero context on every prompt. Keeping context inside the repo rather than scattered across docs, chat threads, or tribal memory. Owning your stack instead of pulling in heavy third-party dependencies, since agents have drastically lowered the cost of building in-house. As for management, he believes the role will become increasingly technical: as execution becomes cheap, judgment becomes the bottleneck.&lt;/p&gt;
&lt;h2 id="building-software-is-learning"&gt;&lt;a href="https://registerspill.thorstenball.com/p/building-software-is-learning" rel="noopener noreferrer"&gt;Building Software Is Learning&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball publishes an internal note sent to the Amp team on why building new software is always a learning process. The idealized sequence—&amp;ldquo;we need this feature,&amp;rdquo; &amp;ldquo;I built it,&amp;rdquo; &amp;ldquo;that&amp;rsquo;s exactly what I wanted&amp;rdquo;—almost never happens without a detailed spec; reality usually looks more like &amp;ldquo;that&amp;rsquo;s not what I meant,&amp;rdquo; &amp;ldquo;there are three ways to do this, which one do we want?&amp;rdquo;, or &amp;ldquo;I tried it and I don&amp;rsquo;t like how it feels.&amp;rdquo; That is because people only truly understand what they are building while building it, and avoiding that discovery entirely would require specifying every detail up front—which is just programming by another name.&lt;/p&gt;
&lt;p&gt;The good news is that you can shrink the gap between a confident &amp;ldquo;I&amp;rsquo;ll build it&amp;rdquo; and contact with reality. Instead of disappearing for four weeks, build a prototype in an hour, write a spec in thirty minutes, break the work down and ship a piece every day, cut scope to isolate the unknowns, record a fake demo video, write the release announcement first, or draft README examples to test an API design. Feedback can come from CI, teammates, users, or yourself dogfooding the feature. Ball adds two practical warnings: a prototype riddled with obvious bugs will only get you bug reports instead of useful design feedback, and keeping a branch alive for three weeks before merging 27 commits at once means when CI breaks, you have 27 potential culprits. The question to keep asking is how to get feedback as early and as often as possible so you can learn faster.&lt;/p&gt;
&lt;h2 id="you-must-fix-your-asserts"&gt;&lt;a href="https://kristoff.it/blog/fix-your-asserts/" rel="noopener noreferrer"&gt;You Must Fix Your Asserts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Loris Cro argues against the habit of disabling assertions in production, using Zig as context. An assertion is a line of code stating a program truth—a precondition, postcondition, or invariant; if the type system can express the constraint, use types, and otherwise assertions catch programming bugs, often more effectively than unit tests when paired with fuzzing. In Zig, &lt;code&gt;std.debug.assert&lt;/code&gt; is built on &lt;code&gt;unreachable&lt;/code&gt;: in checked build modes like Debug or ReleaseSafe, a violated assertion panics; in ReleaseFast or ReleaseSmall, the compiler treats the assertion as an assumed fact for optimization, meaning a false assertion leads to unpredictable undefined behavior. Unlike C/C++, Zig&amp;rsquo;s assert is a regular function rather than a macro, so its argument expression is always evaluated.&lt;/p&gt;
&lt;p&gt;According to Cro, you have three choices: keep assertions active as runtime checks, let the compiler optimize around them and accept the risk, or strip them out—and the third option is the worst. Disabling assertions means that when the &amp;ldquo;impossible&amp;rdquo; happens, the program keeps running on broken assumptions, silently diverging from its spec while stripping away the very signal that would have caught it. Worse, future maintainers will write new code trusting those false assertions, allowing vulnerabilities to creep in unnoticed. He points to TigerBeetle keeping assertions enabled in production and Ghostty shipping ReleaseFast builds. The takeaway: fix broken assertions, gate genuinely expensive checks behind debug-only flags, log instead of crashing where appropriate, and choose build modes based on your risk model rather than erasing error signals.&lt;/p&gt;
&lt;h2 id="the-software-engineering-books-i-keep-recommending"&gt;&lt;a href="https://newsletter.techworld-with-milan.com/p/best-software-engineering-books-2026" rel="noopener noreferrer"&gt;The Software Engineering Books I keep recommending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dr. Milan Milanović shares the software engineering books he recommends most often, noting that reading gives him both breadth and depth in technical discussions and decision-making—and in the AI era, helps him evaluate and steer AI tools more effectively. Rather than presenting a one-size-fits-all &amp;ldquo;must-read&amp;rdquo; list, he groups the books by the specific problem a reader is facing, arguing that the right question isn&amp;rsquo;t &amp;ldquo;what should I read?&amp;rdquo; but &amp;ldquo;where am I currently stuck?&amp;rdquo; Most of the picks aren&amp;rsquo;t tied to specific frameworks, so their lessons age well.&lt;/p&gt;
&lt;p&gt;For coding mindset, he highlights &lt;code&gt;The Pragmatic Programmer&lt;/code&gt;, &lt;code&gt;Clean Code&lt;/code&gt; (noting some rules are dated), and &lt;code&gt;A Philosophy of Software Design&lt;/code&gt;, the book he re-reads most often. Architecture covers &lt;code&gt;Fundamentals of Software Architecture&lt;/code&gt;, &lt;code&gt;Software Architecture: The Hard Parts&lt;/code&gt;, and &lt;code&gt;Domain-Driven Design Quickly&lt;/code&gt;; systems and data feature the second edition of &lt;code&gt;Designing Data-Intensive Applications&lt;/code&gt; alongside the more approachable &lt;code&gt;Understanding Distributed Systems&lt;/code&gt;. The AI section pairs &lt;code&gt;The Hundred-Page Language Models Book&lt;/code&gt; on how language models work with Chip Huyen&amp;rsquo;s &lt;code&gt;AI Engineering&lt;/code&gt; on building real-world AI applications. Rounding out the list are &lt;code&gt;The Art of Unit Testing&lt;/code&gt; for testing, &lt;code&gt;Accelerate&lt;/code&gt; (with the four DORA metrics) and &lt;code&gt;Refactoring&lt;/code&gt; for development workflow, and &lt;code&gt;The Software Engineer's Guidebook&lt;/code&gt; and &lt;code&gt;Deep Work&lt;/code&gt; for career growth. He also mentions his own new book on laws in software engineering.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #114</title><link>https://miti99.com/en/post/2026/07/01/</link><pubDate>Wed, 01 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #114.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-errors-are-a-story-most-teams-lose-the-plot"&gt;&lt;a href="https://robinsiep.com/blog/posts/go-errors/" rel="noopener noreferrer"&gt;Go errors are a story, most teams lose the plot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Robin Siep examines a fundamental difference in how Go handles errors: unlike Java and many other languages, Go errors do not automatically carry stack traces. Instead, developers wrap errors with context at each layer they pass through—such as &lt;code&gt;fmt.Errorf(&amp;quot;unable to get user: %w&amp;quot;, err)&lt;/code&gt;—ultimately producing a chain like &lt;code&gt;unable to get user: failed to query users table: connection refused&lt;/code&gt;. The author calls this a &amp;ldquo;logical trace&amp;rdquo;: when maintained well, it is easier to read than a multi-dozen-line stack trace and stays intact even when errors cross channels, goroutines, or other handoff boundaries where call stacks can get lost.&lt;/p&gt;
&lt;p&gt;The catch is that a logical trace requires relentless discipline from the entire team. Forget to wrap an error at just one call site, and your logs may be left with a bare &lt;code&gt;connection refused&lt;/code&gt;; and much like code comments, an error-wrapping message written two years ago can drift out of date or become misleading. In the author&amp;rsquo;s observation, most teams fail to keep up with this maintenance burden, leaving production errors without enough context to diagnose root causes. The proposed middle ground is to attach a stack trace the moment the application creates an error or first receives one from a third-party library, and then add manual context only when it genuinely clarifies the problem. That way, the stack trace serves as a cheap, always-present fallback. Implementing this yourself is straightforward, or you can reach for Dave Cheney&amp;rsquo;s &lt;code&gt;pkg/errors&lt;/code&gt; or &lt;code&gt;cockroachdb/errors&lt;/code&gt; if you want an actively maintained library.&lt;/p&gt;
&lt;h2 id="the-last-technical-interview"&gt;&lt;a href="https://steve-yegge.medium.com/the-last-technical-interview-bc13ddcf4564" rel="noopener noreferrer"&gt;The Last Technical Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Yegge—who has conducted technical interviews for nearly 35 years, serving as an Amazon Bar Raiser and a Google Hiring Committee member—argues that the traditional technical interview loop is reaching the end of the line. The model of cramming several one-hour interviews into a single day has barely changed in fifty years despite terrible results: interviewers routinely disagree with one another, interview scores barely correlate with actual on-the-job performance, and resumes are becoming increasingly useless now that AI writes them. His most memorable anecdote comes from Google, where recruiting handed the hiring committee a batch of anonymized interview packets disguised as a &amp;ldquo;calibration exercise&amp;rdquo;; the committee voted to reject roughly two-thirds of them, only to learn afterward that the packets were their own historical interview files.&lt;/p&gt;
&lt;p&gt;According to Yegge, the strongest hiring signal has always come from real work—internships, six-month co-ops at Geoworks, or contract-to-hire trials—so it is time to stop &amp;ldquo;simulating work.&amp;rdquo; A new &amp;ldquo;campfire&amp;rdquo; model is emerging in San Francisco: inviting candidates for a paid multi-day stint working on real code, real requirements, and alongside the real team. To make this fair, every stint should &amp;ldquo;count twice&amp;rdquo;: the company gets high-signal evaluation and real output, while the candidate walks away with a durable, company-verified record of what they built and how well they performed, whether or not they receive an offer. Such a system only works if those &amp;ldquo;stamps of approval&amp;rdquo; are issued honestly.&lt;/p&gt;
&lt;h2 id="guidelines-for-respectful-use-of-ai"&gt;&lt;a href="https://www.elidedbranches.com/2026/05/guidelines-for-respectful-use-of-ai.html" rel="noopener noreferrer"&gt;Guidelines for Respectful Use of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Camille Fournier argues that many leaders view AI policies purely through the lens of security, compliance, or cost, overlooking how teams actually work together when AI enters the picture. AI lets an individual generate far more output, but if that person doesn&amp;rsquo;t review it themselves, the quality-control burden simply gets pushed onto teammates and overall team productivity drops. Her first rule is therefore simple: never ask someone else to read or review something you haven&amp;rsquo;t read yourself. This applies to code and even more so to documents, since the context in your head while chatting with an AI may be completely absent from the final text; if you cannot explain and discuss a document yourself, you shouldn&amp;rsquo;t send it out.&lt;/p&gt;
&lt;p&gt;Her second rule is &amp;ldquo;shorter is better&amp;rdquo;: AI-generated code often reads like verbose tutorial code, pull requests balloon to thousands of lines, three-page documents turn into 10-to-20-page essays, and Slack messages and emails become walls of text. She suggests a litmus test: if this change breaks at 3 a.m. and every AI tool is down, can you debug it yourself? For long documents, put a concise summary of the key points right at the top; if you find yourself writing a massive email to explain something, you should probably hop on a call instead. Ultimately, AI is not an excuse to turn off your brain or your empathy: use the productivity gains to ship simpler, better-tested work.&lt;/p&gt;
&lt;h2 id="software-after-ai"&gt;&lt;a href="https://tomtunguz.com/harnessing-ai/" rel="noopener noreferrer"&gt;Software After AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz argues that the familiar software era—where SaaS products manage databases through fixed workflows—is giving way to the era of the &amp;ldquo;harness&amp;rdquo;: the surrounding layer that turns a raw LLM into a reliable agent. He compares an LLM to a wild horse that needs to be broken in. When every company has access to the exact same foundation models, competitive advantage no longer lives in the model itself, but in whoever builds the best harness.&lt;/p&gt;
&lt;p&gt;The post outlines seven components of an AI harness. Context and memory require domain-specific retrieval alongside a &amp;ldquo;context database&amp;rdquo; capturing how a business actually operates. Tools and actions are exposed through a registry with parameter validation and approval gates for sensitive operations, with MCP acting as the connective tissue. Orchestration is the think-act-observe-repeat loop, complete with planning, subagents, and stopping conditions. State and persistence allow a mid-flight failure to resume from the last verified checkpoint (for instance, finishing step 7 and resuming at step 8) instead of starting over from scratch. Sandboxing isolates the execution environment. Observability and governance—traces, logs, evals, and human-in-the-loop approvals for high-stakes decisions—turn a demo into a production system. Finally, cost and workflow optimization decide which steps belong in deterministic code and which call for large or small models. Frontier labs will win the markets they prioritize, but thousands of vertical markets remain wide open for startups.&lt;/p&gt;
&lt;h2 id="design-patterns-are-dead-long-live-design-patterns"&gt;&lt;a href="https://medium.com/google-cloud/design-patterns-are-dead-long-live-design-patterns-b2c2602fbdc4" rel="noopener noreferrer"&gt;Design Patterns Are Dead. Long Live Design Patterns.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christina Lin, a veteran developer, asks whether classic design patterns still matter when AI writes most of the code. Patterns like Singleton, Factory, and Observer were created for human comprehension rather than compilers, so at first she wondered if they had become obsolete. Once a codebase grows large enough, however, AI starts to ramble because it has limits of its own: Chroma&amp;rsquo;s research across 18 models showed reliability degrading as input length grows (&amp;ldquo;context rot&amp;rdquo;), with the drop-off varying by model. As a result, design patterns aren&amp;rsquo;t dead—they&amp;rsquo;ve been promoted from implementation blueprints to ways of compressing intent into prompts and enforcing architectural guardrails around probabilistic models.&lt;/p&gt;
&lt;p&gt;Lin reclassifies patterns around a single question: is this pattern here to help humans read code, or to constrain AI? Patterns that merely patched missing language features, like Iterator or Prototype, are dead; speculative abstractions built &amp;ldquo;just in case&amp;rdquo; should also be pared back now that code is cheap and intent is expensive. Conversely, three patterns matter more than ever: Adapter forces AI outputs into strict schemas before touching the database and feeds validation errors back for self-correction; Decorator wraps retries, timeouts, and token-cost tracking around core logic; and Facade hides complex multi-step agent workflows behind a clean, auditable interface. The unifying principle is treating AI output as untrusted input: isolate it, validate at the boundary, and trust it only once proven valid.&lt;/p&gt;
&lt;h2 id="merge-intervals"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/merge-intervals-89l" rel="noopener noreferrer"&gt;Merge Intervals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh walks through Merge Intervals, a classic interview problem: given an array of &lt;code&gt;[start, end]&lt;/code&gt; intervals, merge all overlapping intervals and return the disjoint result. At first glance it looks like a simulation problem, and the brute-force approach checks every subsequent interval to extend the current end point in &lt;code&gt;O(N²)&lt;/code&gt; time. The key insight is that once intervals are sorted by start time, any overlapping intervals are guaranteed to sit adjacent to one another, so you only ever need to compare the current interval against the most recently merged one.&lt;/p&gt;
&lt;p&gt;That makes the optimal algorithm clean and compact: sort by &lt;code&gt;start&lt;/code&gt; and scan left to right; if the end of the last interval in the result list is smaller than the current interval&amp;rsquo;s start, append the current interval as a new entry; otherwise, update the last interval&amp;rsquo;s end to the maximum of both ends. For input &lt;code&gt;[[1,3],[2,6],[8,10],[15,18]]&lt;/code&gt;, this produces &lt;code&gt;[[1,6],[8,10],[15,18]]&lt;/code&gt;. Overall time complexity is &lt;code&gt;O(N log N)&lt;/code&gt; due to sorting, while the linear scan takes &lt;code&gt;O(N)&lt;/code&gt;. The author also shares interview tips: clearly explain why sorting makes overlapping intervals contiguous, and remember the &amp;ldquo;sort first, then sweep left to right&amp;rdquo; pattern for related problems like Insert Interval, Meeting Rooms, and Non-overlapping Intervals.&lt;/p&gt;
&lt;h2 id="best-time-to-buy-and-sell-stock"&gt;&lt;a href="https://dev.to/jaspreet_singh_86ae1740ac/best-time-to-buy-and-sell-stock-3792" rel="noopener noreferrer"&gt;Best Time to Buy and Sell Stock&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jaspreet Singh follows up with another classic LeetCode problem, Best Time to Buy and Sell Stock: given an array of daily stock prices where you may buy once and sell once on a later day, find the maximum profit. For &lt;code&gt;[7,1,5,3,6,4]&lt;/code&gt;, buying at 1 and selling at 6 yields a profit of 5. The brute-force approach treats every day as a buy day, checks every subsequent sell day, and tracks the maximum profit—correct, but &lt;code&gt;O(N²)&lt;/code&gt; because it evaluates far too many redundant buy-sell pairs.&lt;/p&gt;
&lt;p&gt;The key observation is that on any given day, you don&amp;rsquo;t need to remember every prior price—only the lowest price seen so far, because the best profit you could make by selling today is today&amp;rsquo;s price minus that historical minimum. The author notes that he initially considered a dynamic programming array &lt;code&gt;dp[i]&lt;/code&gt;, before realizing that the minimum price is the only state that matters, collapsing the array into two scalar variables: &lt;code&gt;minPrice&lt;/code&gt; and &lt;code&gt;maxProfit&lt;/code&gt;. A single pass that computes today&amp;rsquo;s potential profit, updates the best answer, and updates the running minimum achieves &lt;code&gt;O(N)&lt;/code&gt; time and &lt;code&gt;O(1)&lt;/code&gt; space. This is the classic &amp;ldquo;prefix minimum&amp;rdquo; pattern: whenever a problem asks for a maximum profit, maximum difference, or future outcome relative to past values, think about maintaining a running minimum or maximum during a single sweep.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #110</title><link>https://miti99.com/en/post/2026/06/07/</link><pubDate>Sun, 07 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #110.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-podcast--086-just-use-postgres-man"&gt;&lt;a href="https://share.transistor.fm/s/5159e8a9" rel="noopener noreferrer"&gt;go podcast() | 086: Just use postgres, man&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this podcast episode, Dominic St-Pierre and Morten Vistisen revolve around a familiar question: should you store telemetry data in ClickHouse or just stick with PostgreSQL? Morten wants to try ClickHouse, while Dominic takes the pragmatic stance: below roughly 10 million rows, PostgreSQL performs nearly as well, and scaling rarely happens overnight, leaving plenty of time to migrate when you actually need to. Morten also recounts having to rewrite a component in his DeployQuad project because the LLM-generated code from the initial prototype didn&amp;rsquo;t behave as expected, underscoring the importance of truly understanding the code you ship.&lt;/p&gt;
&lt;p&gt;Dominic introduces StaticBackend v1.7.0, adding multi-account user support and expanded server-side functions powered by Goja (a JavaScript runtime written in Go), while lamenting how tedious releases are when updating multiple NPM packages compared to Go&amp;rsquo;s simple tag-and-push workflow. Toward the end, both hosts express skepticism about over-relying on AI code generation: it disrupts deep flow states while programming, causes skills to atrophy, and may not even deliver a net productivity gain. They remain convinced that core programming skills are as valuable as ever.&lt;/p&gt;
&lt;h2 id="that-one-time-i-used-go-panics-for-flow-control"&gt;&lt;a href="https://noncrab.net/posts/panic-as-flow-control/" rel="noopener noreferrer"&gt;That one time I used Go panics for flow control&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author recounts an overload incident on an in-memory Go data service: when query volume exceeded capacity, requests that normally took 1–2 seconds stretched to a full minute, and upstream retries only piled on more load. The root problem was that Go&amp;rsquo;s standard library sorting functions neither accept a &lt;code&gt;context&lt;/code&gt; nor return an error, so the service kept burning CPU cycles sorting results for queries whose callers had already timed out and walked away. That library design is normally reasonable, since sorting usually happens in batch jobs or over slices small enough that execution time is negligible.&lt;/p&gt;
&lt;p&gt;Rather than rewriting the entire sorting layer, the team used a &lt;code&gt;panic&lt;/code&gt;/&lt;code&gt;recover&lt;/code&gt; pair as an escape hatch: the comparison function checks whether the &lt;code&gt;context&lt;/code&gt; has been canceled and, if so, calls &lt;code&gt;panic&lt;/code&gt; with a dedicated sentinel value. A &lt;code&gt;defer&lt;/code&gt; wrapper around the sort catches that specific sentinel &lt;code&gt;panic&lt;/code&gt; and converts it into a normal error while re-panicking on anything else so real bugs aren&amp;rsquo;t swallowed. That let the system abort useless sorts immediately. The author readily admits this is &amp;ldquo;an ugly solution to an ugly problem,&amp;rdquo; strictly for narrow, tightly controlled situations.&lt;/p&gt;
&lt;h2 id="the-last-six-months-in-llms-in-five-minutes"&gt;&lt;a href="https://simonwillison.net/2026/May/19/5-minute-llms/" rel="noopener noreferrer"&gt;The last six months in LLMs in five minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is the annotated version of Simon Willison&amp;rsquo;s lightning talk at PyCon US 2026, recapping developments in large language models from November 2025 through May 2026. The standout trend is that coding agents crossed a decisive quality threshold: thanks to OpenAI and Anthropic applying reinforcement learning with verifiable rewards throughout 2025, agents went from &amp;ldquo;often works&amp;rdquo; to &amp;ldquo;almost always works&amp;rdquo; and became everyday workhorses. In November alone, the title of &amp;ldquo;best model&amp;rdquo; changed hands five times between Anthropic, OpenAI, and Google, while Willison continued using his signature benchmark of asking models to generate an SVG of a pelican riding a bicycle.&lt;/p&gt;
&lt;p&gt;The second major trend is local open-weight models blowing past expectations, including Google&amp;rsquo;s Gemma 4 family, China&amp;rsquo;s GLM-5.1, and Qwen3.6-35B-A3B, which weighs in at roughly 21GB and runs comfortably on a standard laptop. The talk also highlights OpenClaw, a personal AI assistant project that went so viral that &amp;ldquo;Claws&amp;rdquo; became the generic term for the entire category of personal agents and Mac Minis sold out as people bought them to run Claws at home.&lt;/p&gt;
&lt;h2 id="prompts-are-technical-debt-too"&gt;&lt;a href="https://www.seangoedecke.com/prompts-are-technical-debt-too/" rel="noopener noreferrer"&gt;Prompts are technical debt too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that prompts — including instruction files like &lt;code&gt;AGENTS.md&lt;/code&gt; and &lt;code&gt;CLAUDE.md&lt;/code&gt; — are a form of technical debt, and in some ways worse than code debt. When code doesn&amp;rsquo;t change, its behavior stays largely the same, and when it breaks it usually fails loudly; prompts, by contrast, silently degrade every time the underlying model is upgraded. A prompt painstakingly tuned to work around an older model&amp;rsquo;s quirks can become useless or actively counterproductive on a newer model without anyone noticing. According to Goedecke, an agent harness with elaborate prompts wrapped around an older model will almost always lose to a minimal harness running a newer model.&lt;/p&gt;
&lt;p&gt;From there, he offers concrete advice: stick to mainstream AI coding tools like Claude Code, Cursor, or Copilot with their default configurations, since their engineering teams continuously re-tune the system prompts for you; avoid installing extra MCP servers or skills unless strictly necessary; if you must write an &lt;code&gt;AGENTS.md&lt;/code&gt;, stick to core factual details about the project rather than trying to micromanage model behavior, and never check in model-generated instructions without reviewing them carefully. Finally, regularly prune custom prompts to keep maintenance overhead low.&lt;/p&gt;
&lt;h2 id="we-see-something-that-works-and-then-we-understand-it"&gt;&lt;a href="https://lemire.me/blog/2025/12/04/we-see-something-that-works-and-then-we-understand-it/" rel="noopener noreferrer"&gt;We see something that works, and then we understand it&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire pushes back against the &amp;ldquo;linear model of innovation&amp;rdquo; — the belief that theoretical understanding must come first and practical progress follows afterward. Borrowing Kevin Kelly&amp;rsquo;s term &amp;ldquo;thinkism,&amp;rdquo; he critiques the illusion that thinking hard enough in the abstract can solve any problem. That mindset dominates schools and bureaucracies, where rules are fixed in advance: students learn a concept first and then solve textbook problems designed to require only that exact concept. History usually works the other way around: pendulum clocks were keeping time in 1656, well before Newton and Hooke formulated the laws of force and motion that explained why they worked.&lt;/p&gt;
&lt;p&gt;In Lemire&amp;rsquo;s view, real R&amp;amp;D always happens with incomplete understanding; people entering industry often learn more in a single year on the job than across their entire university degree because real-world engineering demands continuous experimentation and observation. He draws two lessons: breakthroughs require prioritizing hands-on experimentation over abstract theorizing, and we shouldn&amp;rsquo;t expect AI to solve every complex problem purely from existing knowledge, because the physical world is always richer and messier than what we already know.&lt;/p&gt;
&lt;h2 id="how-vercel-cut-build-wait-times-from-90-seconds-to-5"&gt;&lt;a href="https://blog.bytebytego.com/p/how-vercel-cut-build-wait-times-from" rel="noopener noreferrer"&gt;How Vercel Cut Build Wait Times From 90 Seconds To 5&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article examines how Vercel cut build environment provisioning wait times from 90 seconds down to 5 seconds — an 18x speedup — using an internal platform called Hive. The core challenge is that Vercel runs untrusted build code from thousands of customers on shared hardware, meaning every build must be treated as potentially hostile. Standard containers aren&amp;rsquo;t isolated enough because they share the host Linux kernel, where a single kernel vulnerability could expose another customer&amp;rsquo;s workload. Instead of Kubernetes, Vercel built Hive on AWS Firecracker microVMs: each build runs inside a &amp;ldquo;cell&amp;rdquo; — a tiny virtual machine with its own dedicated kernel that boots in roughly 125 milliseconds. The architecture spans regional clusters where physical &amp;ldquo;boxes&amp;rdquo; host multiple cells, coordinated by a control plane.&lt;/p&gt;
&lt;p&gt;The speedup comes from three compounding optimizations: container image caching and disk snapshots cut cold starts from ~50 seconds down to 5 seconds; a warm pool of pre-booted cells waiting for work means most builds experience near-zero queue wait; and Firecracker&amp;rsquo;s millisecond boot times make maintaining and replenishing that warm pool economical. The trade-off is that keeping warm cells idle consumes resources and every cell must be destroyed after a single build for security, but owning the underlying infrastructure has unlocked new product capabilities for Vercel.&lt;/p&gt;
&lt;h2 id="the-anatomy-of-an-ai-native-org"&gt;&lt;a href="https://ajeygore.in/content/the-anatomy-of-an-ai-native-org" rel="noopener noreferrer"&gt;The Anatomy of an AI-Native Org&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ajey Gore argues that AI is reshaping organizational structure by eliminating the &amp;ldquo;translation layer.&amp;rdquo; For thirty years, software companies have operated across three tiers: leadership decides the &amp;ldquo;Why,&amp;rdquo; product defines the &amp;ldquo;What,&amp;rdquo; and engineering translates those decisions into code — the &amp;ldquo;How.&amp;rdquo; Much of the day-to-day work in that model consists of translating between well-defined inputs and outputs. According to Gore, AI doesn&amp;rsquo;t target a specific job title so much as that entire category of translation work — turning requirements into code or specs into UI components — making it orders of magnitude cheaper, while the strategic work at both ends remains just as hard as ever.&lt;/p&gt;
&lt;p&gt;The shape of an &amp;ldquo;AI-Native&amp;rdquo; organization shifts accordingly: the &amp;ldquo;Why&amp;rdquo; layer stays small; the &amp;ldquo;What&amp;rdquo; layer expands because judgment and taste become critical when directing AI; the human &amp;ldquo;How&amp;rdquo; layer shrinks sharply in headcount but rises in difficulty, focusing on architecture, security, and verification mechanisms that make AI output trustworthy; and AI agents handle routine translation under human supervision. Managers can no longer just coordinate — they must contribute directly — while engineers should move toward problem definition rather than competing with AI on raw code translation.&lt;/p&gt;
&lt;h2 id="how-to-stay-resilient-in-a-difficult-job"&gt;&lt;a href="https://andiroberts.com/executive-coaching/how-to-stay-resilient-in-a-difficult-job" rel="noopener noreferrer"&gt;How to Stay Resilient in a Difficult Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article outlines 7 practical, science-backed strategies for maintaining mental resilience when stuck in a difficult job — whether dealing with a poor manager, irregular shifts, or chronic stress. The author stresses that resilience here doesn&amp;rsquo;t mean forcing toxic positivity or pretending the job is fun; it means conserving energy, keeping an objective perspective, and maintaining a sense of agency so you can do good work, protect your health, and stay positioned for future moves.&lt;/p&gt;
&lt;p&gt;The strategies include: grounding yourself mentally at the start of the day and stabilizing your physiology with sunlight, hydration, and movement before work; focusing strictly on what lies within your control and upholding your own professional standards even when surrounding systems are messy; setting emotional boundaries so you don&amp;rsquo;t carry work stress home; finding at least one trusted colleague to confide in; and consistently taking small steps toward landing a better role.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://brooker.co.za/blog/2026/05/18/whats-easy-whats-hard.html" rel="noopener noreferrer"&gt;What&amp;rsquo;s Easy Now? What&amp;rsquo;s Hard Now?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker proposes the &amp;ldquo;feedback loop hypothesis&amp;rdquo;: over the long run, AI coding agents will find tasks with clear, measurable feedback loops &amp;ldquo;easy,&amp;rdquo; while tasks lacking effective automated feedback will remain &amp;ldquo;hard&amp;rdquo; — and this divide will be the primary determinant of agent capability. Opening with an analogy from electrical engineering, he notes that strong negative feedback can turn simple, nonlinear, even flawed components into remarkably accurate amplifiers.&lt;/p&gt;
&lt;p&gt;From that premise, he flips the conventional wisdom that web development is easy and systems programming is hard. A database storage engine like RocksDB has a relatively compact specification — an API plus safety and liveness properties — that can be verified automatically. Web development, by contrast, lacks an equivalent automated oracle and relies on slow, inconsistent human judgment. Current practice already reflects this: agents excel at performance optimization when given a solid benchmark suite, struggle with subjective architectural trade-offs, and get guided toward correct code in languages like Rust thanks to strict compiler errors. Consequently, formal specification languages, compile-time checks, and rigorous testing frameworks will only grow in importance.&lt;/p&gt;
&lt;h2 id="making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use"&gt;&lt;a href="https://medium.com/pinterest-engineering/making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use-2a56a928cae1" rel="noopener noreferrer"&gt;Making User-Sequence Data More Cost-Efficient, Faster, and Easier to Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest&amp;rsquo;s engineering team shares how they redesigned their user-sequence data platform — the ordered history of a user&amp;rsquo;s recent actions enriched with signals like embeddings, device context, and country. This data powers ML ranking, retrieval, and recommendation models across the Home feed, Related Pins, and search results, serving training pipelines, offline analytics, and real-time inference alike. Because it must be simultaneously fresh, complete, consistent between training and serving, and schema-stable, it is often one of the most expensive and brittle parts of a data stack.&lt;/p&gt;
&lt;p&gt;The core principle of the redesign is &amp;ldquo;One definition, multiple runtimes&amp;rdquo;: each signal is defined once and shared across real-time indexing, batch backfills for historical data, and online serving via a unified execution engine supporting both streaming and batch modes. That eliminates training-serving skew by construction. Combined with a Lambda architecture to balance freshness and completeness, plus columnar storage and time-based partitioning, Pinterest significantly cut storage costs and network bandwidth while turning the addition of new event types or signals into a mostly configuration-driven change.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #104</title><link>https://miti99.com/en/post/2026/05/24/</link><pubDate>Sun, 24 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #104.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="designing-the-ai-native-engineering-organization"&gt;&lt;a href="https://newsletter.getdx.com/p/designing-the-ai-native-engineering" rel="noopener noreferrer"&gt;Designing the AI-native engineering organization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a panel at the DX Annual conference, engineering leaders from Microsoft, 1Password, and Atlassian shared how AI is reshaping the software development lifecycle (SDLC). Previously, roughly 80% of engineering time went into execution and operations, but in the highest-performing teams that ratio is flipping: as AI compresses code generation and routine execution, planning and verification now take up the bulk of the time, because that is where human judgment matters most. The speakers advised against handing verification or security over to AI just yet.&lt;/p&gt;
&lt;p&gt;Notably, none of the companies redrew their org charts; what changed is how teams work internally. Atlassian forms 3–4 person pods for greenfield projects, Microsoft uses small v-teams running on eight-week cycles for rapid learning, and 1Password shortened its planning horizon from 12–18 months down to a single quarter. None of the three mandated AI usage; instead, they invested in training, amplified internal &amp;ldquo;champions,&amp;rdquo; and shared concrete success stories. Token spend is managed as rigorously as cloud infrastructure costs, with 1Password building internal tooling to map spend by repo and project. The archetype of the future engineer is a &amp;ldquo;maker&amp;rdquo; with broad generalist knowledge, strong product intuition, and the agency to make decisions. Non-engineers like designers and customer experience staff are now submitting pull requests too, though that is only safe when backed by a solid test suite and deployment verification pipeline.&lt;/p&gt;
&lt;h2 id="10-lessons-for-agentic-coding"&gt;&lt;a href="https://www.dbreunig.com/2026/05/04/10-lessons-for-agentic-coding.html" rel="noopener noreferrer"&gt;10 Lessons for Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drew Breunig distills ten lessons for developers working with AI agents like Claude Code, Codex, or Pi around a central question: what should you do when code becomes cheap? Because writing code surfaces decisions that a spec never anticipated, he advises implementing to learn and not hesitating to throw code away and rebuild multiple times to test bold ideas. Pair that with end-to-end tests that measure product behavior rather than implementation details, leaving you free to rewrite the underlying code. Neither tests nor code capture &lt;em&gt;why&lt;/em&gt; something was built a certain way, so keep intent alongside the codebase and evolve the spec in tandem with development rather than freezing it up front.&lt;/p&gt;
&lt;p&gt;When the easy parts are handled quickly by AI, real value shifts to the hard parts: intuitive design, performance, security, fault tolerance, and system architecture. Automate all the easy work to free up time for the hard problems, and cultivate your own &amp;ldquo;taste&amp;rdquo; — because when code is generated faster than external feedback can arrive, your domain and user understanding become the only feedback loop fast enough to keep pace. AI agents also amplify experience: engineers with deep technical mastery know the right terminology, how to frame problems, and the right level of specificity, saving countless iterations. The final lesson is a reminder: code is cheap, but maintenance, support, and security are not.&lt;/p&gt;
&lt;h2 id="just-fucking-use-go"&gt;&lt;a href="https://blainsmith.com/articles/just-fucking-use-go/" rel="noopener noreferrer"&gt;Just Fucking Use Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an intentionally blunt polemic, Blain Smith argues that Go has been sitting there for over a decade waiting for developers to stop overcomplicating backend development. Go&amp;rsquo;s boredom is by design: no decorators, no macros, no metaclasses — just structs, functions, interfaces, goroutines, and channels. Because of that, a newly hired junior developer can read code written two years ago by someone who already left, and &lt;code&gt;gofmt&lt;/code&gt; enforces a single formatting style, ending all style debates. The standard library &lt;em&gt;is&lt;/em&gt; the framework: &lt;code&gt;net/http&lt;/code&gt;, &lt;code&gt;database/sql&lt;/code&gt;, &lt;code&gt;encoding/json&lt;/code&gt;, and &lt;code&gt;html/template&lt;/code&gt; paired with &lt;code&gt;embed&lt;/code&gt; are enough to build a complete database-backed web app with zero third-party dependencies; &lt;code&gt;io.Reader&lt;/code&gt;/&lt;code&gt;io.Writer&lt;/code&gt; and &lt;code&gt;context.Context&lt;/code&gt; make every component snap together cleanly and propagate cancellation end to end. Goroutines cost only about 2KB at startup, and channels handle synchronization.&lt;/p&gt;
&lt;p&gt;The biggest advantage is operational: &lt;code&gt;go build&lt;/code&gt; produces a single static binary that you can &lt;code&gt;scp&lt;/code&gt; to a server and restart with systemd — no Dockerfile, Kubernetes, or service mesh required. Dependency management fits neatly into &lt;code&gt;go.mod&lt;/code&gt; and &lt;code&gt;go.sum&lt;/code&gt;, while testing, race detection, benchmarking, and profiling ship built-in with the toolchain. The author criticizes Rails, Django, Express, and Next.js for elaborate deployment rituals and constantly shifting conventions, advocating instead for a monolith consisting of one Go binary and one PostgreSQL instance rather than chasing microservices. Even &lt;code&gt;if err != nil&lt;/code&gt; error handling is praised as a feature, because it forces you to decide how to handle failures at every call site where something can go wrong.&lt;/p&gt;
&lt;h2 id="symptoms-of-bad-software-design"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/symptoms-of-bad-software-design" rel="noopener noreferrer"&gt;Symptoms of Bad Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marcos F. Lobo outlines four symptoms of poor software design along with how to fix them. &lt;strong&gt;Rigidity&lt;/strong&gt; is when a small change in one module triggers a cascade of changes across dependent modules, turning a two-day estimate into two weeks; the root cause is usually tight coupling. For example, an order-processing class with a giant &lt;code&gt;switch&lt;/code&gt; statement calculating shipping rates for every carrier can be refactored using the Strategy Pattern (Open/Closed Principle) so each carrier has its own class and adding a new one requires no edits to existing code. &lt;strong&gt;Fragility&lt;/strong&gt; is when fixing something in one place breaks an unrelated feature elsewhere — such as changing a date format in a global config Singleton and breaking the payroll module; the cure is encapsulation and interface segregation so each module only sees the configuration it actually needs.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Immobility&lt;/strong&gt; appears when business logic is so entangled with UI, database, and framework code that extracting it for reuse takes more effort than rewriting it from scratch. The solution is layered architecture (Clean Architecture): isolate the core algorithm into a pure component that receives database access through an interface following the Dependency Inversion Principle. &lt;strong&gt;Viscosity&lt;/strong&gt; is when doing the right thing is harder than hacking in a shortcut, whether due to software design or a sluggish development environment, pushing developers toward band-aid fixes. The remedy is automating and improving infrastructure and using tooling to cut boilerplate so the right path is nearly as fast as the wrong one. Recognizing these four symptoms is the first step toward incremental refactoring.&lt;/p&gt;
&lt;h2 id="claude-code-is-not-making-your-product-better"&gt;&lt;a href="https://ethanding.substack.com/p/claude-code-is-not-making-your-product" rel="noopener noreferrer"&gt;Claude Code is Not Making Your Product Better&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ethan Ding challenges the notion that AI coding agents are making products better, even as code output climbs. Commit-size charts show a K-shaped productivity split: senior engineers have seen a sharp jump in output since 2023, while junior engineers have largely flatlined or declined. Builders like dax (opencode), Karri Saarinen (Linear), and David Cramer (Sentry) all struggle to see faster product improvement from agents. The author argues that if Claude Code truly created a compounding advantage, Anthropic should have pulled far ahead of competitors after months of exclusive internal use, yet the later-arriving Codex competes neck and neck — meaning the bottleneck to product quality was never typing speed.&lt;/p&gt;
&lt;p&gt;The best engineering cultures treat lines of code as a liability rather than an asset, because every line is surface area for bugs and accumulating complexity; tinychat even sets alerts when the codebase crosses a size threshold and celebrates deleting code. Linear achieved higher quality than Jira with a fraction of the engineering headcount because the difference comes from creative vision and restraint — deciding to build less — rather than token generation speed. In the author&amp;rsquo;s view, coding agents help products get from zero to &amp;ldquo;decent&amp;rdquo; faster and will make commodity software much cheaper, but they don&amp;rsquo;t help frontier teams build extraordinary products — leaving behind a pile of technical debt that someone will eventually have to clean up.&lt;/p&gt;
&lt;h2 id="the-pulse-ai-load-breaks-github--why-not-other-vendors"&gt;&lt;a href="https://blog.pragmaticengineer.com/the-pulse-ai-load-breaks-github/" rel="noopener noreferrer"&gt;The Pulse: AI load breaks GitHub – why not other vendors?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz analyzes GitHub&amp;rsquo;s recent string of severe outages. On April 23, a bug caused pull requests merged via merge queue using squash merge to produce corrupt commits whenever a merge group contained more than one PR, &amp;ldquo;losing&amp;rdquo; commits across 2,092 pull requests — violating the most fundamental data-integrity guarantee and forcing customers to recover manually. A wave of other incidents followed: an overloaded Elasticsearch cluster made pull requests and issues vanish from the UI for 6 hours, GitHub Actions suffered outages, and Wiz disclosed a critical RCE vulnerability. An unofficial third-party tracker recorded uptime around 86% (measured as time with no component reporting an incident), or &amp;ldquo;zero nines.&amp;rdquo; Mitchell Hashimoto, creator of Ghostty, announced he was leaving GitHub after 18 years because near-daily outages were blocking his work.&lt;/p&gt;
&lt;p&gt;GitHub&amp;rsquo;s CTO blamed higher-than-forecast load from AI agents: traffic grew roughly 3.5x over two years, with most of the surge concentrated in recent months. GitHub only began planning a 10x capacity expansion in October 2025, months behind Google, and by February 2026 had to revise the target to 30x. At the same time, the company is migrating from its own data centers to Azure, making underlying flaws much more likely to surface as outages. Why, then, have Vercel, Linear, GitLab, and Bitbucket weathered similar AI traffic waves without buckling? Orosz argues that much of GitHub&amp;rsquo;s pain is self-inflicted: a heavily stateful architecture that is hard to scale horizontally, 18 years of technical debt, roughly 4,000 employees who have to coordinate, and an inability to break existing customer workflows.&lt;/p&gt;
&lt;h2 id="you-need-ai-that-reduces-maintenance-costs"&gt;&lt;a href="https://www.jamesshore.com/v2/blog/2026/you-need-ai-that-reduces-your-maintenance-costs" rel="noopener noreferrer"&gt;You Need AI That Reduces Maintenance Costs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Shore gets straight to the point: coding agents must reduce maintenance costs, and they must reduce them in proportion to the increase in code-writing speed. Every line of code carries an indefinite maintenance tail of bug fixes, cleanup, and dependency upgrades. Using a &amp;ldquo;wisdom of the crowd&amp;rdquo; estimate, he assumes each month of feature coding generates roughly 10 days of maintenance in the first year and 5 days in each subsequent year. Modeling this in a spreadsheet shows that after about two and a half years, a team spends more than half its time on maintenance, and after ten years it can barely build anything new — matching what he observes when consulting for late-stage startups.&lt;/p&gt;
&lt;p&gt;Applying this to AI: if an agent doubles code output but produces code that is twice as hard to maintain, the productivity gain is wiped out in roughly five months, and long-term velocity ends up lower than without AI. Even if AI-generated code is just as maintainable as human-written code, the net benefit only lasts about 19 months. Worse, if a team later stops using agents due to high costs, the speed boost disappears while the maintenance burden of all that generated code stays behind — a form of &amp;ldquo;perpetual servitude.&amp;rdquo; Shore&amp;rsquo;s conclusion: maintenance cost must drop inversely with output — doubling output requires cutting maintenance cost in half. Teams should therefore invest at least as much effort into reducing maintenance costs as they do into chasing coding speed.&lt;/p&gt;
&lt;h2 id="cognitive-surrender"&gt;&lt;a href="https://addyosmani.com/blog/cognitive-surrender/" rel="noopener noreferrer"&gt;Cognitive Surrender&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani introduces the concept of &amp;ldquo;cognitive surrender&amp;rdquo; from research by Steven Shaw and Gideon Nave (Wharton). It must be distinguished from &amp;ldquo;cognitive offloading&amp;rdquo;: offloading delegates the &amp;ldquo;how&amp;rdquo; to AI while you still evaluate the result yourself, whereas surrender happens when you stop forming your own answer and let the AI&amp;rsquo;s output become your output. Across three experiments with 1,372 participants, when AI gave a wrong answer, participants accepted the incorrect answer 73% of the time, and their confidence actually increased even though half the answers were deliberately rigged to be wrong. For developers, this shows up as approving a 600-line PR just because tests are green, letting an agent fix a bug without understanding the root cause, or letting an agent make architectural decisions.&lt;/p&gt;
&lt;p&gt;Software engineers are uniquely vulnerable because generated code compiles and passes linters so it looks right on the surface, productivity metrics count merged PRs, and models always speak in an authoritative tone. Each act of surrender is a small loan that compounds into &amp;ldquo;comprehension debt&amp;rdquo; — the growing gap between the code that exists and the code humans actually understand. To push back, Osmani suggests forming your own expectations before looking at the output, reading diffs as if they were written by a junior dev, asking the model to critique itself, watching out for fatigue, keeping PRs small, and treating verification evidence as a mandatory condition for finishing a task. If code keeps shipping while your understanding of the system shrinks, you are accumulating comprehension debt.&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_!oEvb!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F49df56c9-1f92-4f88-bd16-8cd59dab407c_2484x3002.jpeg" alt="Claude Code vs. OpenClaw: 5 Design Dimensions"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6UGD!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F265133fd-d0f8-48c0-b170-73f6e6a49fec_1280x1605.jpeg" alt="Why Does Git Revert Cause Conflicts?"&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 #98</title><link>https://miti99.com/en/post/2026/04/18/</link><pubDate>Sat, 18 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/18/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #98.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="impeccable-design-fluency-for-ai-harnesses"&gt;&lt;a href="https://impeccable.style/" rel="noopener noreferrer"&gt;Impeccable: Design fluency for AI harnesses&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Impeccable is a toolkit that gives AI coding assistants—including Claude Code, Cursor, Gemini CLI, Codex CLI, and GitHub Copilot—much stronger frontend design fluency. It targets a familiar problem: most developers lack the design vocabulary to articulate exactly what looks off, while AI models trained on the same generic web templates keep churning out lookalike interfaces full of unmistakable &amp;ldquo;AI tells&amp;rdquo;—purple gradients, Inter everywhere, and cards nested inside cards. Impeccable closes that gap by injecting structured design principles directly into the agent&amp;rsquo;s coding workflow.&lt;/p&gt;
&lt;p&gt;At its core is the &lt;code&gt;impeccable&lt;/code&gt; skill, which teaches the model foundational UI design across seven dimensions and loads automatically whenever the agent works on frontend code. Alongside it come 18 slash commands—such as &lt;code&gt;/polish&lt;/code&gt;, &lt;code&gt;/audit&lt;/code&gt;, &lt;code&gt;/typeset&lt;/code&gt;, and &lt;code&gt;/overdrive&lt;/code&gt;—that give developers a shared vocabulary for steering visual output, plus a catalog of named design anti-patterns so the model knows what to avoid. Its Visual Mode, run via a Chrome extension or &lt;code&gt;npx impeccable live&lt;/code&gt;, executes 25 deterministic (non-LLM) layout and typography checks directly against the live DOM. Supporting Cursor, Claude Code, Gemini CLI, Codex CLI, VS Code Copilot, Antigravity, Kiro, and OpenCode, it&amp;rsquo;s well worth trying if you rely on AI to build UIs.&lt;/p&gt;
&lt;h2 id="getdesignmd--designmd-collection-for-ai-coding-agents"&gt;&lt;a href="https://getdesign.md/" rel="noopener noreferrer"&gt;getdesign.md — DESIGN.md collection for AI coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maintained by VoltAgent, &lt;code&gt;getdesign.md&lt;/code&gt; is an open collection of &lt;code&gt;DESIGN.md&lt;/code&gt; files that reverse-engineer the design systems of iconic websites like SpaceX, IBM, Lamborghini, and dozens of other brands. Using one is dead simple: pick a &lt;code&gt;DESIGN.md&lt;/code&gt;, drop it into your repository, and tell your coding agent (Claude Code, Cursor, Copilot) to follow it when building UI components. Every new screen then inherits a cohesive visual language instead of defaulting to generic AI-generated layouts.&lt;/p&gt;
&lt;p&gt;At the time this newsletter was compiled, the catalog featured 68 brand systems and was still growing. Each file documents color palettes, typography scales, spacing rules, signature component patterns, and the rationale behind those choices—giving coding agents enough context to produce polished, stylistically consistent interfaces even if you aren&amp;rsquo;t a designer. The source lives in &lt;code&gt;VoltAgent/awesome-design-md&lt;/code&gt; on GitHub, with a Request page where the community can propose new sites to analyze. It&amp;rsquo;s a handy resource whenever you want to prototype fast with a distinct visual identity without crafting a design system from scratch.&lt;/p&gt;
&lt;h2 id="which-java-construct-should-you-use-let-change-drivers-decide"&gt;&lt;a href="https://dev.to/yannick555/which-java-construct-should-you-use-let-change-drivers-decide-3159" rel="noopener noreferrer"&gt;Which Java Construct Should You Use? Let Change Drivers Decide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yannick Loth proposes choosing Java language constructs through deliberate analysis rather than habit: look at the &lt;em&gt;change drivers&lt;/em&gt;—the forces that, when they change, force a given piece of code to change with them. Through this &amp;ldquo;IVP lens,&amp;rdquo; you can separate &lt;em&gt;essential coupling&lt;/em&gt; (inherent to the domain problem) from &lt;em&gt;accidental coupling&lt;/em&gt; (imposed unnecessarily by the language construct you picked). The guiding question is always: does this construct force me to couple more than the problem actually requires?&lt;/p&gt;
&lt;p&gt;For example, a non-static inner class carries an implicit reference to its enclosing instance, so it should only be used when it genuinely needs that outer state; a &lt;code&gt;static&lt;/code&gt; nested class fits when you need state or multiple methods without the outer instance; and lambdas or method references capture only what their body actually touches. Java &lt;code&gt;record&lt;/code&gt;s replace mutable data-holder classes that turn every writer into a change driver for every reader (even if &lt;code&gt;record&lt;/code&gt; immutability is shallow across &lt;code&gt;final&lt;/code&gt; fields). &lt;code&gt;sealed&lt;/code&gt; interfaces paired with exhaustive pattern matching bound the variant space cleanly when the set of subtypes is closed. Finally, &lt;code&gt;Optional&lt;/code&gt; and &lt;code&gt;Result&lt;/code&gt; types turn invisible change drivers like &lt;code&gt;null&lt;/code&gt; or checked exceptions (which force every intermediate caller to redeclare them) into explicit return types. Viewed this way, nearly every major Java feature from Java 8 through Java 25 marches in the same direction: narrowing the gap between what the language forces you to couple and what your domain actually needs.&lt;/p&gt;
&lt;h2 id="the-git-commands-i-run-before-reading-any-code"&gt;&lt;a href="https://piechowski.io/post/git-commands-before-reading-code/" rel="noopener noreferrer"&gt;The Git Commands I Run Before Reading Any Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When inheriting an unfamiliar codebase, Ally Piechowski doesn&amp;rsquo;t start by opening source files—she opens a terminal and interrogates the Git history. Commit logs offer an instant diagnostic X-ray of a project: who built it, where bugs cluster, and whether the team ships with confidence or tiptoes around minefields. The post walks through five groups of Git one-liners that size up a repository&amp;rsquo;s health in minutes before reading a single line of code.&lt;/p&gt;
&lt;p&gt;First is listing the 20 most frequently modified files over the past year; high churn in a file nobody wants to own is the clearest red flag in any repo. Second is ranking contributors by commit count: if one person accounts for 60%+ of commits, the project has a dangerously low bus factor—especially if that person has already left the company. Third is filtering commits for bug-fix keywords (&lt;code&gt;fix&lt;/code&gt;, &lt;code&gt;bug&lt;/code&gt;, &lt;code&gt;broken&lt;/code&gt;) and intersecting them with high-churn files to pinpoint the riskiest hotspots in the codebase. Fourth is plotting monthly commit velocity to see the shape of team momentum over time, which reflects organizational health as much as code health. Finally, checking the frequency of reverts and hotfixes reveals how much the team can trust its deployment pipeline. She notes two caveats: squash-merge workflows flatten commit counts, and bug-keyword searches depend on disciplined commit messages.&lt;/p&gt;
&lt;h2 id="chess-in-pure-sql"&gt;&lt;a href="https://www.dbpro.app/blog/chess-in-pure-sql" rel="noopener noreferrer"&gt;Chess in Pure SQL&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This playful experiment demonstrates just how expressive SQL can be by building a playable chessboard using nothing but &lt;code&gt;SELECT&lt;/code&gt;, &lt;code&gt;UPDATE&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;, and &lt;code&gt;INSERT&lt;/code&gt;—no JavaScript, no application framework. The 8×8 board is modeled as a simple three-column table (&lt;code&gt;rank&lt;/code&gt;, &lt;code&gt;file&lt;/code&gt;, &lt;code&gt;piece&lt;/code&gt;), seeded with 32 rows representing the 32 pieces on their starting squares.&lt;/p&gt;
&lt;p&gt;The key trick is using conditional aggregation (a SQL pivot) to render rows as an 8×8 visual grid: &lt;code&gt;GROUP BY rank&lt;/code&gt;, wrap &lt;code&gt;CASE&lt;/code&gt; expressions inside &lt;code&gt;MAX()&lt;/code&gt; to pluck out the piece for each file column (&lt;code&gt;a&lt;/code&gt; through &lt;code&gt;h&lt;/code&gt;), join against a CTE that generates all 64 squares, and use &lt;code&gt;COALESCE&lt;/code&gt; to render empty squares cleanly. Moving a piece is a simple &lt;code&gt;UPDATE&lt;/code&gt;, while captures run a &lt;code&gt;DELETE&lt;/code&gt; on the target square first. To top it off, the author replays Paul Morphy&amp;rsquo;s famous 1858 &amp;ldquo;Opera Game&amp;rdquo; as a sequence of SQL statements ending in checkmate. The same pivot pattern generalizes nicely to any grid-style query output—calendars, seating charts, or heatmaps—making it a fun workout for mastering SQL aggregation.&lt;/p&gt;
&lt;h2 id="gits-magic-files"&gt;&lt;a href="https://nesbitt.io/2026/02/05/git-magic-files.html" rel="noopener noreferrer"&gt;Git’s Magic Files&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Nesbitt catalogs the special configuration files that Git and its surrounding ecosystem recognize when placed inside a repository. Each file acts as an in-repo convention that alters tool behavior per repository without requiring global machine configuration—making them essential to understand if you build developer tooling that operates on Git repos.&lt;/p&gt;
&lt;p&gt;Core Git files include &lt;code&gt;.gitignore&lt;/code&gt; (ignore patterns with wildcards and a multi-level fallback hierarchy), &lt;code&gt;.gitattributes&lt;/code&gt; (clean/smudge filters, line-ending normalization, custom diff/merge drivers, and GitHub Linguist language overrides), &lt;code&gt;.lfsconfig&lt;/code&gt; (repo-committed Git LFS endpoints), and &lt;code&gt;.gitmodules&lt;/code&gt; (submodule mappings pinned to specific commits in the parent tree). Next are &lt;code&gt;.mailmap&lt;/code&gt; (consolidating multiple author emails or name spellings for &lt;code&gt;git shortlog&lt;/code&gt; and &lt;code&gt;git blame&lt;/code&gt;), &lt;code&gt;.git-blame-ignore-revs&lt;/code&gt; (telling &lt;code&gt;git blame&lt;/code&gt; to skip mass-reformatting commits), and &lt;code&gt;.gitmessage&lt;/code&gt; (a commit message template enabled via &lt;code&gt;git config commit.template&lt;/code&gt;). The post also surveys forge-specific directories across GitHub, GitLab, Bitbucket, Forgejo, Gitea, and SourceHut for CI workflows and PR templates, alongside broader conventions like &lt;code&gt;.editorconfig&lt;/code&gt; and &lt;code&gt;.ruby-version&lt;/code&gt;—carefully distinguishing files Git reads automatically from conventions that require explicit config activation like &lt;code&gt;.gitmessage&lt;/code&gt; and &lt;code&gt;.git-blame-ignore-revs&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="adding-correctness-conditions-to-code-changes"&gt;&lt;a href="https://jessitron.com/2026/04/06/adding-correctness-conditions-to-code-changes/" rel="noopener noreferrer"&gt;Adding Correctness Conditions to Code Changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jessica Kerr (Jessitron) describes a familiar moment in the age of coding agents: an agent opens a project&amp;rsquo;s first PR adding a new run script, but forgets to mention it in the &lt;code&gt;README&lt;/code&gt;. Instead of leaving a one-off review comment on that PR, she wants to solve the problem permanently for every future PR through automation—enforcing an explicit &lt;em&gt;correctness condition&lt;/em&gt;: every PR must update relevant documentation files. There are two ways to do that—update the instructions in &lt;code&gt;AGENTS.md&lt;/code&gt;, or add an automated review agent that checks PRs—and the crucial question is which one to do first.&lt;/p&gt;
&lt;p&gt;Simply editing &lt;code&gt;AGENTS.md&lt;/code&gt; is easy and appears to work right away, she notes, but offers zero guarantees: the day the agent forgets to update the docs, you probably won&amp;rsquo;t notice either. By contrast, if you add the automated verification check &lt;em&gt;first&lt;/em&gt;, every PR gets audited and incomplete PRs get rejected, forcing the agent to fix them; updating &lt;code&gt;AGENTS.md&lt;/code&gt; then becomes an optimization to reduce retry loops rather than your only line of defense. This is test-driven development elevated to the system level, and closer to property-based testing than unit testing because it asserts an invariant (&amp;ldquo;documentation stays in sync with feature changes&amp;rdquo;) across every change. Reviewing a PR thus becomes reviewing the &lt;em&gt;development system itself&lt;/em&gt;: asking how the agent&amp;rsquo;s context and feedback loops should change so the next PR comes out right the first time. She calls this the new Boy Scout Rule: don&amp;rsquo;t just leave the codebase cleaner—leave the system that builds the codebase stronger.&lt;/p&gt;
&lt;h2 id="the-impact-of-ai-on-software-engineers-in-2026-key-trends-part-1"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026" rel="noopener noreferrer"&gt;The impact of AI on software engineers in 2026: key trends. Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (&lt;em&gt;The Pragmatic Engineer&lt;/em&gt;) distills more than 900 survey responses from software engineers and engineering leaders on how AI tools are impacting their work in 2026. Rather than ranking individual tools, Part 1 focuses on three macro trends: rising AI tooling costs, engineers regularly hitting usage caps, and sharply uneven impact across different engineer archetypes.&lt;/p&gt;
&lt;p&gt;On cost, roughly 15% of respondents voiced concern. Many companies now pay $100–$200 per engineer per month for &amp;ldquo;Max&amp;rdquo; tiers of Claude Code, Cursor, or Codex, while others cap budgets around $20/month (standard GitHub Copilot territory). Enterprises are still experimenting, and many engineers doubt current subsidy levels are sustainable long-term; European companies tend to demand upfront ROI proof, whereas US firms are more willing to spend first and measure later. A popular cost-saving tactic is planning with Claude Opus and executing with Sonnet or Cursor Composer. When engineers hit rate limits, they swap tools, fall back to pay-as-you-go API keys, or upgrade tiers. Finally, the report groups engineers into three archetypes: &lt;em&gt;builders&lt;/em&gt; (who care deeply about architecture and code quality) use AI effectively to power through tedious, high-judgment work like large refactors, migrations, and test coverage; &lt;em&gt;shippers&lt;/em&gt; (focused on product velocity) are the most enthusiastic adopters because they can ship features dramatically faster; and &lt;em&gt;coasters&lt;/em&gt; do the bare minimum and care little about code quality. The overarching lesson: AI acts as an amplifier for the engineering habits and culture you already have.&lt;/p&gt;
&lt;h2 id="flat-error-codes-are-not-enough"&gt;&lt;a href="https://home.expurple.me/posts/flat-error-codes-are-not-enough/" rel="noopener noreferrer"&gt;Flat Error Codes Are Not Enough&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dmitrii Aleksandrov pushes back against the minimalist advice that every library should expose a single error struct containing only a human-readable message and a flat &lt;code&gt;ErrorCode&lt;/code&gt; enum for programmatic handling. While he agrees that flat error codes work well in top-level application code—where callers rarely perform intricate programmatic recovery—he argues they fall short in high-level, I/O-heavy libraries where callers need rich context to recover intelligently.&lt;/p&gt;
&lt;p&gt;His concrete example comes from a production Rust codebase using the &lt;code&gt;sea_orm&lt;/code&gt; ORM atop the &lt;code&gt;sqlx&lt;/code&gt; database driver. &lt;code&gt;sea_orm::DbErr&lt;/code&gt; wraps an underlying &lt;code&gt;sqlx::Error&lt;/code&gt;, which in turn exposes a &lt;code&gt;sqlx::DatabaseError&lt;/code&gt; carrying structured details straight from the database engine—such as the exact constraint violation kind (unique, foreign key, check) and the violated constraint&amp;rsquo;s name. The application relies on that structured payload to map database constraint failures into specific, user-friendly validation errors. If &lt;code&gt;sea_orm&lt;/code&gt; flattened everything into its own enum without exposing the underlying &lt;code&gt;sqlx&lt;/code&gt; error, it would either have to duplicate all of &lt;code&gt;sqlx&lt;/code&gt;&amp;rsquo;s database-specific error inspection APIs or throw that information away. Worse, even a fine-grained error code saying &amp;ldquo;a &lt;code&gt;CHECK&lt;/code&gt; constraint failed&amp;rdquo; isn&amp;rsquo;t enough without the &lt;em&gt;name&lt;/em&gt; of the violated constraint—otherwise callers are forced to regex-parse human error strings, which is brittle and unsafe. For complex I/O libraries, nested errors carrying structured variant data are essential.&lt;/p&gt;
&lt;h2 id="who-will-be-the-senior-engineers-of-2035"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/who-will-be-the-senior-engineers" rel="noopener noreferrer"&gt;Who will be the senior engineers of 2035?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier poses an uncomfortable question for the industry: where will the senior engineers of 2035 come from? Historically, junior developers became seniors through a steady diet of low-risk bug fixes, pair programming, mentorship, and learning from small mistakes. Today, post-COVID layoffs, cautious entry-level hiring, and AI coding agents absorbing the exact small tickets and bug fixes that used to serve as training wheels for juniors are choking off the talent pipeline at multiple points at once. Real production scar tissue—earned by breaking things, diagnosing why, and fixing them—cannot be replaced by prompting an LLM.&lt;/p&gt;
&lt;p&gt;He sketches three possible futures. First is a &lt;em&gt;talent crunch&lt;/em&gt;: the shortage stays invisible for years and then erupts around 2035 when critical systems fail at 3 a.m. and nobody left on call understands what happens beneath the abstractions. Second is &lt;em&gt;bifurcation&lt;/em&gt;: the profession splits into fast AI orchestrators with shallow fundamentals on one side, and a shrinking, ultra-expensive priesthood of deep systems engineers on the other, with the middle hollowed out. Third is a more optimistic arc grounded in computing history: every new abstraction layer—from BASIC to JavaScript to the cloud—was once feared as the end of real programming, yet ended up creating new entry ramps and new kinds of expertise. Which future we get depends on the choices engineering leaders make today about whom to hire, whom to mentor, and whom to give a safe space to fail and learn.&lt;/p&gt;
&lt;h2 id="repository-pattern-in-go-service"&gt;&lt;a href="https://pawelgrzybek.com/repository-pattern-in-go-service/" rel="noopener noreferrer"&gt;Repository pattern in Go service&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Paweł Grzybek walks through applying Domain-Driven Design&amp;rsquo;s Repository pattern to a Go backend service. He starts from a familiar trajectory: a service begins life inside a single &lt;code&gt;main.go&lt;/code&gt;, then gradually balloons into a tangle of cross-package dependencies where business rules and SQL queries are inseparable and unit testing is painful. The Repository pattern prevents that decay by hiding data persistence behind domain-defined interfaces, while concrete database adapters for PostgreSQL, SQLite, or DynamoDB live in separate packages—enforcing a clean, one-way dependency flow.&lt;/p&gt;
&lt;p&gt;The worked example organizes code by domain (&lt;code&gt;user&lt;/code&gt;, &lt;code&gt;order&lt;/code&gt;) rather than by technical layer (&lt;code&gt;models/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;), aligning neatly with idiomatic Go package design. Each domain package contains its model (structs, validation rules, domain errors), a service (pure business logic that talks to storage strictly through a repository interface without caring which database sits underneath), and repository implementations, while transport layers (HTTP, gRPC, WebSockets) sit on the outside and can be swapped without touching domain logic. The biggest win is fast, isolated unit testing of service logic via dependency injection—though the author notes that swapping databases in the real world still requires accounting for differences in transactions, query semantics, and data types beyond just writing a new adapter.&lt;/p&gt;
&lt;h2 id="go-bitwise-flags-and-bitmasks-configuration-pattern-guide"&gt;&lt;a href="https://iampavel.dev/blog/go-bitwise-flags-config" rel="noopener noreferrer"&gt;Go Bitwise Flags and Bitmasks: Configuration Pattern Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Asaduzzaman Pavel starts from a relatable moment: as he was adding an eighth &lt;code&gt;bool&lt;/code&gt; field to a Go configuration struct, he realized it was time to switch to a bitmask. In a bitmask, each flag is a power of two occupying a single bit; flags can be combined with bitwise OR (&lt;code&gt;|&lt;/code&gt;), checked with AND (&lt;code&gt;&amp;amp;&lt;/code&gt;), cleared with AND NOT (&lt;code&gt;&amp;amp;^&lt;/code&gt;), and toggled with XOR (&lt;code&gt;^&lt;/code&gt;), with each check compiling down to a single CPU instruction with zero branching or heap allocation.&lt;/p&gt;
&lt;p&gt;Still, the author is explicit about when &lt;em&gt;not&lt;/em&gt; to use bitmasks: for ordinary application configs or CRUD APIs, a plain struct of booleans is much easier to read. Bitmasks shine when modeling file permissions (&lt;code&gt;Read&lt;/code&gt;, &lt;code&gt;Write&lt;/code&gt;, &lt;code&gt;Execute&lt;/code&gt;), gRPC or HTTP middleware option sets evaluated on every request, query-builder modifiers (&lt;code&gt;Distinct&lt;/code&gt;, &lt;code&gt;ForUpdate&lt;/code&gt;), or when wrapping C libraries and OS syscalls that already use bitfields. The guide shows how to declare flags cleanly in Go using a typed integer alongside &lt;code&gt;1 &amp;lt;&amp;lt; iota&lt;/code&gt;, warns that Go&amp;rsquo;s type system won&amp;rsquo;t stop callers from passing arbitrary out-of-range integers unless you encapsulate operations behind methods like &lt;code&gt;Has()&lt;/code&gt; or an opaque struct, and finishes with custom &lt;code&gt;MarshalJSON&lt;/code&gt; / &lt;code&gt;UnmarshalJSON&lt;/code&gt; implementations so flags serialize as readable string arrays in JSON while staying compact in memory.&lt;/p&gt;
&lt;h2 id="the-best-library-might-do-less"&gt;&lt;a href="https://martiansoftware.com/articles/the-best-library-might-do-less" rel="noopener noreferrer"&gt;The Best Library Might Do Less&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on forty years of programming experience, the author makes a contrarian case for library design: library authors easily catch the &amp;ldquo;generalization bug&amp;rdquo;—trying to anticipate and solve every conceivable edge case, which bloats the library, complicates its API, and makes it less useful. Warning signs include constantly asking &amp;ldquo;what if a developer wants to&amp;hellip;&amp;rdquo; and piling on ceremony: &lt;code&gt;Manager&lt;/code&gt; and &lt;code&gt;Service&lt;/code&gt; classes, transitive third-party dependencies, sprawling type hierarchies, strict temporal ordering of method calls, or needing pages of documentation just to get started.&lt;/p&gt;
&lt;p&gt;By contrast, a library that does less is easier to understand, easier to trust, easier to explain, easier to maintain, and—crucially—easier to &lt;em&gt;replace&lt;/em&gt;, a virtue that is badly underrated. Some libraries genuinely do need to handle every corner case of a complex specification, and this advice isn&amp;rsquo;t for them. For everything else, the author suggests asking three questions: what is the minimal, most common thing users actually need; what is the most natural sequence of calls; and which hard, important failure modes must be handled right—aiming to cover roughly the core 80% cleanly. He closes with a question from a former colleague that has saved him mountains of unnecessary work over the years: &lt;em&gt;&amp;ldquo;What if we just&amp;hellip; didn&amp;rsquo;t?&amp;rdquo;&lt;/em&gt; That isn&amp;rsquo;t laziness—it&amp;rsquo;s clarity about the problem, and a reminder that the best library is often the one that gets out of the user&amp;rsquo;s way.&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 #96</title><link>https://miti99.com/en/post/2026/04/16/</link><pubDate>Thu, 16 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #96.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="clean-architecture--separation-of-concerns-trong-go"&gt;&lt;a href="https://vjerci.com/writings/clean/separation-of-concerns/" rel="noopener noreferrer"&gt;Clean Architecture → Separation of Concerns trong Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the principle of Separation of Concerns in Go: once a responsibility is handled in one place in the system, other parts shouldn&amp;rsquo;t have to worry about it or duplicate it. The author opens with an anti-pattern where a single handler function parses an HTTP request, validates the payload, and executes SQL queries directly. When everything is tangled together like that, changing any detail requires understanding the whole stack, and the codebase quickly becomes unmaintainable as complexity grows.&lt;/p&gt;
&lt;p&gt;The fix is splitting the service into four layers: HTTP handlers only decode requests and encode responses, Services hold pure business logic decoupled from infrastructure, Repositories handle all database queries, and Models define data structures with zero dependencies on other layers. Go makes this natural through structural typing: a struct satisfies an interface implicitly without &lt;code&gt;implements&lt;/code&gt; declarations. The author recommends giving each package a single, obvious responsibility and wiring components together via constructor dependency injection so the dependency graph is visible right in &lt;code&gt;main&lt;/code&gt;. Helpful Go tips include using your IDE&amp;rsquo;s &amp;ldquo;Find Implementations&amp;rdquo; shortcut and adding a compile-time interface check like &lt;code&gt;var _ MyInterface = (*MyStruct)(nil)&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-garbage-collector"&gt;&lt;a href="https://internals-for-interns.com/posts/go-garbage-collector" rel="noopener noreferrer"&gt;The Garbage Collector&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explores Go 1.26&amp;rsquo;s garbage collector, which introduces the GreenTea GC. Go&amp;rsquo;s collector is a non-moving, concurrent, tri-color mark-and-sweep collector: because objects never move in memory over their lifetime, pointers stay valid and interoperating with &lt;code&gt;unsafe&lt;/code&gt; or C code is much simpler. Each GC cycle runs through four phases: sweep termination, concurrent mark (running alongside application goroutines and capped at roughly 25% of CPU), mark termination, and lazy sweep driven by allocation demand—pausing the program (stop-the-world) only twice for very brief intervals.&lt;/p&gt;
&lt;p&gt;GreenTea&amp;rsquo;s key innovation is queuing entire memory spans (contiguous pages holding same-sized objects) rather than individual object pointers during marking, batching marked objects together before scanning to dramatically improve CPU cache locality. When a span has more than 12.5% of its objects marked, the collector uses AVX-512 SIMD instructions on x86-64 to scan it 4–8x faster. A hybrid Yuasa–Dijkstra write barrier shades both overwritten and newly written pointers during concurrent marking so live objects are never missed. If goroutines allocate faster than background workers can mark, &lt;em&gt;mark assist&lt;/em&gt; forces allocating goroutines to do marking work themselves as backpressure. Finally, the GC Pacer schedules cycles using &lt;code&gt;GOGC&lt;/code&gt; (default 100, triggering when the heap doubles) and &lt;code&gt;GOMEMLIMIT&lt;/code&gt; (a soft memory cap for the Go runtime).&lt;/p&gt;
&lt;h2 id="the-skill-of-using-ai-agents-well"&gt;&lt;a href="https://www.lesswrong.com/posts/9xAwybDhtgzGYPnbs/the-skill-of-using-ai-agents-well" rel="noopener noreferrer"&gt;The Skill of Using AI Agents Well&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical habits for working effectively with AI coding agents, centered on one insight: the real bottleneck is human attention, not AI capability. Accordingly, the author designs his workflow to minimize personal friction: always use the strongest frontier model at its highest reasoning setting, turn on verbose debug logging so the agent can diagnose failures on its own, and give every AI session its own isolated branch via &lt;code&gt;git worktree&lt;/code&gt; so multiple agents can run in parallel without stepping on each other&amp;rsquo;s files. Tasks that parallelize naturally—like testing five hypotheses at once—get fanned out to subagents.&lt;/p&gt;
&lt;p&gt;For permissions, he recommends whitelisting obviously safe commands, using a secondary AI classifier to auto-approve routine permission prompts, and enabling audio notifications when an agent blocks waiting for human input. Spinning up a fresh agent session purely to review a diff regularly catches bugs the authoring session missed, while a central dashboard across all active sessions makes it easy to see which agents need attention. He also delegates setup chores like spinning up test databases or driving browser UI checks entirely to agents, switches providers promptly whenever a model feels degraded, and is experimenting with cross-session memory systems—though he hasn&amp;rsquo;t found a silver bullet there yet.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://newsletter.manager.dev/p/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece rounds up seven unwritten laws that software engineers usually learn only after painful production incidents. First, when production breaks right after a deployment, roll back first and investigate second—don&amp;rsquo;t burn hours trying to prove your commit was innocent while users are down. Second, a backup doesn&amp;rsquo;t exist until you have successfully restored from it; you also need to know your recovery point objective, who has permissions to run the restore, and how long a restore actually takes now that the database is ten times larger. Third, logging is an eternal balancing act: either too sparse to diagnose an outage, or a noisy flood missing a shared correlation/request ID across services.&lt;/p&gt;
&lt;p&gt;Fourth, every data migration needs a tested rollback plan, because an untested rollback plan will almost certainly fail when you need it most. Fifth, every external dependency &lt;em&gt;will&lt;/em&gt; eventually fail—know its rate limits, test how your app behaves when it goes down, and prepare caches, queues, or graceful degradation; chaining two independent 99.9% services in series drops combined availability to ~99.8%. Sixth, risky production operations require the &amp;ldquo;four-eyes principle&amp;rdquo;: have a teammate watch, because simply explaining what you are about to do out loud often catches the mistake. Finally, nothing is more permanent than a temporary hack—so build a small, scoped, clean solution rather than a messy kludge.&lt;/p&gt;
&lt;h2 id="big-tech-engineers-need-big-egos"&gt;&lt;a href="https://www.seangoedecke.com/big-tech-needs-big-egos/" rel="noopener noreferrer"&gt;Big tech engineers need big egos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke pushes back against the cliché that there is no room for ego in software engineering, arguing that engineers at big tech companies actually need a healthy dose of ego to succeed. Day to day, senior engineers constantly confront their own mistakes and sprawl across codebases too vast for any one person to hold in their head—requiring stubborn self-belief that they can solve problems that look impossible at first glance. Organizationally, strong self-confidence lets an engineer stake out a clear technical position amid ambiguity, make unpopular calls that affect hundreds of peers, and push back when senior leadership misunderstands a technical constraint.&lt;/p&gt;
&lt;p&gt;The paradox is that effective big-tech engineers must also be able to set their ego aside entirely before the org chart: accepting canceled projects, losing internal political battles, or executing murky top-down priorities without becoming bitter. Goedecke calls this the &amp;ldquo;chameleon&amp;rdquo; posture—assertive with peers, yet adaptable toward hierarchy. Burnout, he argues, rarely comes from working too hard; it comes from unrewarded effort, especially when a technically sound decision gets punished because it clashed with organizational politics. Mastering that delicate balance is a big reason truly effective staff-plus engineers are so rare.&lt;/p&gt;
&lt;h2 id="sorting-algorithms"&gt;&lt;a href="https://simonwillison.net/2026/Mar/11/sorting-algorithms/" rel="noopener noreferrer"&gt;Sorting algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he used Claude Artifacts to build an animated side-by-side visualization of classic sorting algorithms—starting with bubble sort, selection sort, insertion sort, merge sort, quicksort, and heapsort. When asked to add Timsort, Claude autonomously cloned the CPython repository from GitHub and read &lt;code&gt;Objects/listobject.c&lt;/code&gt; and &lt;code&gt;Objects/listsort.txt&lt;/code&gt; to implement it. However, when Willison asked GPT-5.4 Thinking to audit the result, it pointed out that Claude had actually written a simplified adaptive mergesort inspired by Timsort rather than the full algorithm—a great illustration of using one frontier model to cross-check another.&lt;/p&gt;
&lt;p&gt;After a few rounds of UI polish, the artifact gained a &amp;ldquo;Run all&amp;rdquo; button that races all seven algorithms simultaneously in a grid, complete with live comparison and swap counters and color-coded operations: pink for comparisons, orange for swaps, red for pivots, and purple for sorted runs. In the live race, Timsort finishes first, followed closely by quicksort and merge sort, with bubble sort trailing far behind. The post showcases how quickly modern AI tools can turn a conversational prompt into a rich, interactive learning tool.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F438c4c2f-0fa8-4748-9953-b63fd69674f4_2508x3000.png" alt="12 Claude Code Features Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F75e97a13-b186-4f16-ab59-f9a96867f744_1899x1536.jpeg" alt="How does REST API work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0169578f-af50-4b3a-b8ed-542ee7ebf80f_2250x2814.png" alt="7 Key Load Balancer Use Cases"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #95</title><link>https://miti99.com/en/post/2026/04/14/</link><pubDate>Tue, 14 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #95.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="12-claude-code-features-every-engineer-should-know-subagents-claudemd-checkpoints-mcp-and-more"&gt;&lt;a href="https://www.youtube.com/watch?v=E4fzxVMOav4" rel="noopener noreferrer"&gt;12 Claude Code Features Every Engineer Should Know: Subagents, CLAUDE.md, Checkpoints, MCP, and more&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteAI video walks through 12 features every engineer should know when working with Claude Code, Anthropic&amp;rsquo;s terminal-native coding agent. At the top of the list are Subagents, which break a complex task into smaller pieces handled in parallel by isolated worker agents—speeding up execution while keeping the main session&amp;rsquo;s context window clean. Meanwhile, &lt;code&gt;CLAUDE.md&lt;/code&gt; serves as the project&amp;rsquo;s onboarding manual, recording architecture, coding conventions, and team-specific rules so Claude has the right context from the very first prompt.&lt;/p&gt;
&lt;p&gt;Checkpoints snapshot workspace state as you go, letting you rewind cleanly whenever the AI heads down the wrong path instead of untangling changes by hand. MCP (Model Context Protocol) integration extends Claude Code by connecting it directly to external services like databases, APIs, and developer tools. The walkthrough is a solid overview both for newcomers and for regular Claude Code users looking to get more mileage out of the tool.&lt;/p&gt;
&lt;h2 id="quantization-from-the-ground-up"&gt;&lt;a href="https://ngrok.com/blog/quantization" rel="noopener noreferrer"&gt;Quantization from the ground up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sam Rose (ngrok) explains model quantization from first principles—showing how large language models can be compressed to roughly a quarter of their size and run twice as fast while losing only about 5–10% accuracy. He starts with why LLMs are so huge in the first place: an 80-billion-parameter model like &lt;code&gt;Qwen3-Coder-Next&lt;/code&gt; takes around 159 GB of memory because each parameter is stored as a multi-byte floating-point number. Fortunately, parameter weights cluster tightly around zero, meaning we can represent them with far fewer bits without losing much information.&lt;/p&gt;
&lt;p&gt;The post compares two quantization schemes: &lt;em&gt;symmetric&lt;/em&gt; quantization is simple but wastes dynamic range when weights are skewed, whereas &lt;em&gt;asymmetric&lt;/em&gt; quantization adds a zero-point offset and cuts average quantization error from roughly 18% down to 8.5%. In practice, weights are quantized in blocks of 32–256 values so a single outlier only skews its local block rather than distorting the entire model. Measuring post-quantization quality via perplexity, KL divergence, and the GPQA Diamond benchmark shows that 8-bit quantization is nearly lossless, 4-bit loses roughly 5–10%, and 2-bit degrades sharply. In return, inference speed on an M1 Max jumps from 19.45 to 43.32 tokens/sec at 4-bit.&lt;/p&gt;
&lt;h2 id="jpeg-compression"&gt;&lt;a href="https://www.sophielwang.com/blog/jpeg" rel="noopener noreferrer"&gt;JPEG compression&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With rich interactive visualizations, Sophie Wang explains how JPEG compression exploits two things: quirks of the human visual system and the natural smoothness of real-world photographs. Because human eyes are far more sensitive to brightness (luminance) than to color detail (chrominance), JPEG first converts an image from RGB to YCbCr to separate the two. It then performs &lt;em&gt;chroma subsampling&lt;/em&gt;—sharing color values across neighboring pixels—producing an image that looks nearly indistinguishable from the original.&lt;/p&gt;
&lt;p&gt;Next, each 8×8 block of pixels undergoes a Discrete Cosine Transform (DCT), expressing the block as a weighted sum of cosine waves. DCT alone doesn&amp;rsquo;t shrink the data, but it concentrates most of the visual signal into a handful of low-frequency coefficients while leaving high-frequency coefficients near zero. The quantization step divides each coefficient by a quantization table entry and rounds to the nearest integer, turning most high-frequency coefficients—fine details the eye barely notices—into zeros. Finally, the coefficients are scanned in a zigzag order to group long runs of zeros together and entropy-coded into a compact file; decompression simply runs the pipeline in reverse.&lt;/p&gt;
&lt;h2 id="what-81000-people-want-from-ai"&gt;&lt;a href="https://www.anthropic.com/features/81k-interviews" rel="noopener noreferrer"&gt;What 81,000 people want from AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic published the largest multilingual qualitative study of AI users to date: using a custom Claude interviewer, they conducted open-ended conversations with 80,508 opt-in Claude users across 159 countries and 70 languages about their hopes and fears for AI. The overarching message is that people want AI to help them live better lives, not just work faster. Top aspirations include professional excellence (19%), personal growth and transformation (14%), life management (14%), and reclaiming free time (11%). Beneath surface-level productivity requests usually sits a deeper human goal—automating email is really about having more time with family.&lt;/p&gt;
&lt;p&gt;Fully 81% of participants said AI had already helped them move closer to their goals, mainly through productivity gains (32%), acting as a thought partner (17%), and learning (10%). At the same time, respondents voiced an average of 2.3 concerns each: unreliability and hallucinations (27%), job displacement (22%), loss of human agency (22%), cognitive atrophy (16%), and lack of governance (15%). Benefits and anxieties often go hand in hand within the same person: users who value AI for emotional support are three times more likely to worry about unhealthy dependence. Users in lower-income regions expressed more optimism and viewed AI as an economic equalizer, while users in wealthier regions focused more on managing complex, busy lives.&lt;/p&gt;
&lt;h2 id="scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto"&gt;&lt;del&gt;&lt;a href="https://www.semicolonandsons.com/articles/scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto" rel="noopener noreferrer"&gt;Scaling a Monolith to 1M LOC: 113 Pragmatic Lessons from Tech Lead to CTO&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This post distills 113 pragmatic lessons from scaling a monolith to one million lines of code, drawn from the author&amp;rsquo;s journey from Tech Lead to CTO. The central thread is that sound architectural choices matter far more than micro-optimizations: rather than slapping a cache over a slow endpoint, fix the underlying database query or missing index, because a single long-running query can halve the throughput of the entire system. Monitoring and observability should be treated as first-class features, with alerts for latency regressions, N+1 queries, and cache eviction rates, backed by an &amp;ldquo;inbox zero&amp;rdquo; discipline for error tracking where every alert is either fixed or silenced.&lt;/p&gt;
&lt;p&gt;Keeping deployments fast (under two minutes)—by decoupling frontend and backend builds, parallelizing CI steps, and picking fast tooling—dramatically lowers risk because bugs are caught and rolled back quickly. On security, the author recommends starting from concrete threat models like account takeover, spam, or DDoS rather than generic checklists. Finally, the human side matters just as much as the code: avoid blame culture, set clear expectations, and cultivate psychological safety across the team.&lt;/p&gt;
&lt;h2 id="harness-design-for-long-running-application-development"&gt;&lt;a href="https://www.anthropic.com/engineering/harness-design-long-running-apps" rel="noopener noreferrer"&gt;Harness design for long-running application development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic&amp;rsquo;s engineering team tackles two failure modes that plague AI agents on long-running tasks: models lose coherence as the context window fills up, and they consistently grade their own work too generously. Their solution is a GAN-inspired multi-agent harness: a &lt;em&gt;Planner&lt;/em&gt; expands a short user prompt into a detailed product spec, a &lt;em&gt;Generator&lt;/em&gt; builds the application, and a separate &lt;em&gt;Evaluator&lt;/em&gt; grades the running app against explicit criteria and sends critique back. For subjective work like frontend design, the team replaced vague &amp;ldquo;does this look good?&amp;rdquo; prompts with concrete rubrics and let the Generator and Evaluator iterate for 5–15 rounds, sometimes pivoting to a completely new aesthetic direction mid-run.&lt;/p&gt;
&lt;p&gt;In their experiments, starting a fresh session with a structured handoff document worked better than in-place context compaction—especially when models suffered from &amp;ldquo;context anxiety,&amp;rdquo; prematurely wrapping up work because they sensed the context window running out. On a benchmark building a game-maker tool with Opus 4.5, a single solo agent spent $9 and 20 minutes to produce a broken app, whereas the full multi-agent harness spent $200 and 6 hours to deliver a genuinely playable, feature-complete application. Another key lesson: re-evaluate your harness every time the underlying model upgrades, because scaffolding that used to be essential can become dead weight.&lt;/p&gt;
&lt;h2 id="why-i-vibe-in-go-not-rust-or-python"&gt;&lt;a href="https://lifelog.my/episode/why-i-vibe-in-go-not-rust-or-python" rel="noopener noreferrer"&gt;Why I Vibe in Go, Not Rust or Python&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author explains why Go is his language of choice over Rust or Python when coding with AI (&amp;ldquo;vibe coding&amp;rdquo;). Between AI-generated code and production, he argues, you need multiple independent filters—and Go gives you five: the compiler, a static type system, explicit error handling, enforced simplicity, and finally human judgment. Python lacks compile-time verification—type hints are optional—so when an AI generates thousands of lines a day, structural bugs hide until runtime, often in production.&lt;/p&gt;
&lt;p&gt;Rust sits at the other extreme: it gives ironclad correctness guarantees, but the borrow checker and lifetime annotations force the human reviewer to spend mental energy solving language-level puzzles rather than focusing on architecture and domain logic. Go hits the sweet spot between compile-time safety and cognitive simplicity; its backward-compatibility promise means code written in 2024 still compiles cleanly in 2026, and deployment is a single static binary rather than a fragile Python container image.&lt;/p&gt;
&lt;h2 id="the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon"&gt;&lt;a href="https://larstofus.com/2026/03/22/the-gold-standard-of-optimization-a-look-under-the-hood-of-rollercoaster-tycoon/" rel="noopener noreferrer"&gt;The gold standard of optimization: A look under the hood of RollerCoaster Tycoon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Sawyer wrote &lt;em&gt;RollerCoaster Tycoon&lt;/em&gt; almost entirely in x86 assembly—giving him tighter control over performance than C or C++ compilers of the late 1990s could match—and the game remains a gold standard of software optimization. This deep dive examines the tricks that let it simulate a bustling theme park with thousands of guests on modest 1999 hardware. Instead of defaulting to 32-bit integers everywhere, every struct field was sized to the exact byte width of its maximum expected value—even using different integer widths for different in-game currency totals to pack structs tightly in memory.&lt;/p&gt;
&lt;p&gt;The codebase replaces multiplication and division by powers of two with fast bitshifts, and remarkably, the game&amp;rsquo;s simulation formulas themselves were designed around constants that were powers of two—a level of harmony between game design and low-level systems programming rarely seen today. Algorithmically, park guests don&amp;rsquo;t run expensive A* pathfinding across the whole park; they wander semi-randomly with local heuristics until they stumble onto a ride. The engine also skips guest-to-guest collision detection entirely: thousands of visitors can occupy the same tile, with overcrowding simply penalized in their happiness calculation.&lt;/p&gt;
&lt;h2 id="queueing-requests-queues-your-capacity-problems-too"&gt;&lt;a href="https://pushtoprod.substack.com/p/queueing-requests-queues-your-capacity-problems-too" rel="noopener noreferrer"&gt;Queueing Requests Queues Your Capacity Problems, Too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post points out that putting a queue in front of an overloaded service often hides a capacity problem rather than solving it. If a system capable of processing 1,000 requests per second receives 2,000 requests per second, after one hour the queue holds 3.6 million backlogged requests—meaning users wait roughly 60 minutes for a response even though server-side processing time per request is still a brisk 1 second. The trap is that user-perceived latency equals queue wait time plus processing time, whereas server latency metrics only measure processing time—so your dashboards stay green while customers experience a total outage.&lt;/p&gt;
&lt;p&gt;Queue math is unforgiving: exceeding capacity by just 10% for an hour builds a backlog of 360,000 requests and adds 6 minutes of latency, because the capacity deficit accumulates linearly over time. Swapping queueing disciplines (FIFO, LIFO, priority, weighted fair queueing) only redistributes wait time across requests in a zero-sum game. The only real fix is adding capacity (or shedding load): provisioning 50% extra capacity drains a one-hour crisis backlog in about an hour, whereas 10% extra headroom takes nine hours to recover.&lt;/p&gt;
&lt;h2 id="7-more-common-mistakes-in-architecture-diagrams"&gt;&lt;a href="https://www.ilograph.com/blog/posts/more-common-diagram-mistakes/" rel="noopener noreferrer"&gt;7 More Common Mistakes in Architecture Diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ilograph walks through seven common mistakes that make system architecture diagrams hard to read. First is unlabeled resources—every box should include both its technology type and a descriptive role name, never just a vendor icon. Second is &amp;ldquo;island&amp;rdquo; components floating with no connections, which defeats the purpose of showing relationships. Third is the giant &amp;ldquo;everything diagram&amp;rdquo;; it is much clearer to split complex systems into multiple focused views where each diagram tells one coherent story.&lt;/p&gt;
&lt;p&gt;Mistake four is &amp;ldquo;conveyor-belt syndrome&amp;rdquo;—drawing request flows as a simplistic left-to-right pipeline that hides back-and-forth request/response interactions, which are much better shown with a sequence diagram. Fifth is gratuitous animation that distracts without adding meaning, and sixth is the &amp;ldquo;fan trap,&amp;rdquo; where routing everything through a central hub obscures which upstream nodes actually talk to which downstream nodes. Finally, the author cautions against AI-generated architecture diagrams, which today remain vague, prone to hallucinating connections, and bad at deciding which details to include or omit.&lt;/p&gt;
&lt;h2 id="how-to-do-ai-assisted-engineering"&gt;&lt;a href="https://newsletter.eng-leadership.com/p/how-to-do-ai-assisted-engineering" rel="noopener noreferrer"&gt;How to Do AI-Assisted Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article synthesizes advice from 15 experienced engineers and engineering leaders on how to practice AI-assisted software engineering effectively. The strongest consensus is &lt;em&gt;design first, code second&lt;/em&gt;: when AI handles implementation, the bottleneck shifts upstream to system design, which is where engineers should invest their time. Rather than typing ad-hoc prompts from scratch each time, effective practitioners build structured, repeatable workflows using templates, custom commands, and &lt;code&gt;CLAUDE.md&lt;/code&gt; files that codify project standards and architectural constraints.&lt;/p&gt;
&lt;p&gt;Equally important is separation of concerns in the agent loop: decouple code generation from verification, use specialized review agents to audit diffs for security, performance, and correctness from independent angles, and keep humans firmly in the loop for high-stakes decisions like merging and deploying. An AI&amp;rsquo;s first output should be treated as a rough draft, not a finished product—requiring multiple passes of multi-angle review before it ships.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!YJG0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd3e5a12b-4237-4661-b090-d518a6da7f20_2508x3000.png" alt="Load Balancer vs API Gateway"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LrVm!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7a20a0cb-3142-4c32-b772-f002f1a288fd_2880x3862.jpeg" alt="REST vs gRPC"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6SID!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F14a25337-0104-4c6c-b91a-3a2cd6afd6e4_2508x3000.png" alt="Session-Based vs JWT-Based Authentication"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LuLK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa8dd9e12-2979-4040-a138-08723094b8cf_2536x3436.jpeg" alt="A Cheat Sheet on The Most-Used Linux Commands"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #94</title><link>https://miti99.com/en/post/2026/04/02/</link><pubDate>Thu, 02 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #94.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="inside-the-claude-code-source"&gt;&lt;a href="https://gist.github.com/Haseeb-Qureshi/d0dc36844c19d26303ce09b42e7188c1" rel="noopener noreferrer"&gt;Inside the Claude Code source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After the Claude Code CLI source code was inadvertently exposed in late March 2026, Haseeb Qureshi read through its core modules and compared its architecture with OpenAI&amp;rsquo;s Codex CLI. The first surprise is that the terminal UI is actually a React application rendered via Ink, bringing a web mental model to the terminal, whereas Codex&amp;rsquo;s TUI is written entirely in Rust. The entire lifecycle of a request runs through an async generator pipeline: every event flows down a single stream consumed identically by the CLI, SDK, and IDE bridge, which differ only in how they render those events. To survive long coding sessions, Claude Code layers four context-compaction strategies (proactive, reactive, snip, and context collapse), whereas Codex relies on two.&lt;/p&gt;
&lt;p&gt;The system prompt is assembled from roughly 15 functions and split in two by a cache-boundary marker: a static first half (~3,000 tokens of core instructions) cached globally across users, and a dynamic second half holding session-specific context like &lt;code&gt;CLAUDE.md&lt;/code&gt; and MCP instructions. Internal Anthropic engineers even receive different prompt rules than external users—such as a strict 25-word limit between tool calls and an adversarial verification sub-agent. Bun&amp;rsquo;s compile-time feature flags strip dead code from public builds while revealing unreleased internal features like &lt;code&gt;VOICE_MODE&lt;/code&gt; and &lt;code&gt;KAIROS&lt;/code&gt;. The author&amp;rsquo;s takeaway: across ~500,000 lines of TypeScript, actual model API calls take up only a few hundred lines; the underlying model is the easiest part to swap out, while the surrounding &lt;em&gt;harness&lt;/em&gt; encodes years of hard-won operational craft.&lt;/p&gt;
&lt;h2 id="ai-will-accelerate-your-tech-debt"&gt;&lt;del&gt;&lt;a href="https://securosis.com/ai/ai-will-accelerate-your-tech-debt/" rel="noopener noreferrer"&gt;AI Will Accelerate Your Tech Debt&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Chris Farris compares many engineering organizations to families living paycheck to paycheck: after years of prioritizing feature velocity over sustainable architecture, they are one major outage away from bankruptcy, and every minor incident burns the exact hours that should have gone toward paying down technical debt. Pouring AI coding tools into that environment, he argues, is like passing a tax cut on a structural deficit: it feels great and boosts short-term output, but makes the underlying fiscal problem worse. When the cost of generating code drops near zero, the natural economic friction that used to filter out half-baked features vanishes—leaving the same overstretched team with more code, a wider attack surface, and deeper system complexity.&lt;/p&gt;
&lt;p&gt;On the security side, building on Rich Mogull&amp;rsquo;s &amp;ldquo;Core Collapse&amp;rdquo; scenario, the author warns that AI-equipped attackers will discover and exploit vulnerabilities faster than defenders can patch them, and organizations that don&amp;rsquo;t understand their own environments cannot use AI to defend them either. Unlike Mogull, he argues you cannot outsource technical-debt remediation. Instead, he proposes a &amp;ldquo;Technology Troika&amp;rdquo;—bringing Finance/FinOps, Security, and Platform Engineering together to shore up foundations before opening the AI floodgates. That means investing in unglamorous fundamentals like identity management, data classification, and dependency mapping, alongside having the courage to decommission legacy systems outright rather than endlessly refactoring them. Buying more AI tools won&amp;rsquo;t save a rotting foundation.&lt;/p&gt;
&lt;h2 id="how-slack-rebuilt-notifications-"&gt;&lt;a href="https://slack.engineering/how-slack-rebuilt-notifications/" rel="noopener noreferrer"&gt;How Slack Rebuilt Notifications 📣&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s engineering team recounts rebuilding their notification settings from the ground up to reduce notification fatigue. Notifications consistently ranked among the top three drivers of customer support tickets, and the problem wasn&amp;rsquo;t just volume—it was the architecture itself: desktop and mobile had four conflicting mental models, &lt;em&gt;what&lt;/em&gt; you get notified about was tightly coupled to &lt;em&gt;how&lt;/em&gt; it gets delivered, preferences didn&amp;rsquo;t sync cleanly across devices, and advanced overrides were scattered across hidden menus.&lt;/p&gt;
&lt;p&gt;The redesign consolidated everything into a single unified model: every channel now offers three clear choices—&amp;ldquo;All new posts,&amp;rdquo; &amp;ldquo;Mentions only,&amp;rdquo; or &amp;ldquo;Mute&amp;rdquo;—while push delivery is toggled independently per device category (desktop vs. mobile). The hardest part was migrating millions of existing users safely. To preserve backward compatibility and allow instant rollbacks, the team avoided mutating legacy rows in the database and instead translated old preferences on read—for instance, mapping the old &amp;ldquo;Nothing&amp;rdquo; setting to &amp;ldquo;Mentions only&amp;rdquo; with push notifications turned off. They also removed the explicit &amp;ldquo;Save&amp;rdquo; button so changes apply immediately, shared React components across platforms, and rewrote some of Slack&amp;rsquo;s oldest iOS screens. Post-launch, engagement with notification settings jumped 5x and stayed elevated weeks later.&lt;/p&gt;
&lt;h2 id="better-faster-and-even-more"&gt;&lt;a href="https://randsinrepose.com/archives/better-faster-and-even-more/" rel="noopener noreferrer"&gt;Better, Faster, and (Even) More&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) shares the tools and habits he has built over 90 days of working intensively with Claude Code, at a moment when the cost of going from &amp;ldquo;random idea&amp;rdquo; to &amp;ldquo;working software&amp;rdquo; has never been lower. Everything lives under &lt;code&gt;~/Projects/&lt;/code&gt;, with each project in its own Git repository alongside three special repos: &lt;code&gt;dotfiles&lt;/code&gt; for machine configuration symlinked into place, a private &lt;code&gt;credentials&lt;/code&gt; repo for API keys, and &lt;code&gt;scripts&lt;/code&gt; for custom CLI utilities. Every project carries two markdown files: &lt;code&gt;CLAUDE.md&lt;/code&gt; as static instructions on how to build and deploy the project, and &lt;code&gt;WORKLOG.md&lt;/code&gt; as a running session journal recording what was investigated, changed, and decided so the next session can pick right back up.&lt;/p&gt;
&lt;p&gt;Small daily workflow tweaks remove even more friction: having Claude pipe output straight to the macOS clipboard via &lt;code&gt;pbcopy&lt;/code&gt;, capturing a screen region to the clipboard and pasting it directly into Claude instead of describing UI bugs in prose, and running a custom doctor script that verifies 30+ environment checks across his three Macs. He also breaks down how he separates Claude Code&amp;rsquo;s memories, skills, and hooks, configures his status bar to display rate-limit usage, and auto-titles terminal tabs by project name. Going faster, he notes, only makes you want to go faster still—every friction point removed builds momentum for the next.&lt;/p&gt;
&lt;h2 id="java-is-fast-your-code-might-not-be"&gt;&lt;a href="https://jvogel.me/posts/2026/java-is-fast-your-code-might-not-be/" rel="noopener noreferrer"&gt;Java Is Fast. Your Code Might Not Be.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jonathan Vogel built a Java order-processing service for a DevNexus talk that worked outer-loop fine and passed every test—then fixed eight common performance anti-patterns without changing the architecture or upgrading the JDK. Processing time dropped from 1,198ms to 239ms, throughput jumped from 85,000 to 419,000 orders per second, and heap usage fell from over 1GB to 139MB. What makes these eight anti-patterns dangerous is that they compile cleanly, slip past code review, and only stand out under a profiler.&lt;/p&gt;
&lt;p&gt;The eight culprits: string concatenation with &lt;code&gt;+&lt;/code&gt; inside loops causing O(n²) copying (use &lt;code&gt;StringBuilder&lt;/code&gt;); running a full &lt;code&gt;Stream&lt;/code&gt; scan over a list inside a loop—the single biggest hotspot, eating nearly 71% of CPU samples, replaced by a single-pass accumulation using &lt;code&gt;Map.merge()&lt;/code&gt;; calling &lt;code&gt;String.format()&lt;/code&gt; on hot paths; autoboxing &lt;code&gt;Long&lt;/code&gt; instead of primitive &lt;code&gt;long&lt;/code&gt;, churning ~16MB of heap garbage per million elements; using exceptions for normal control flow; overly coarse &lt;code&gt;synchronized&lt;/code&gt; blocks (replaced with &lt;code&gt;ConcurrentHashMap&lt;/code&gt; and &lt;code&gt;LongAdder&lt;/code&gt;); repeatedly instantiating expensive thread-safe objects like Jackson&amp;rsquo;s &lt;code&gt;ObjectMapper&lt;/code&gt;; and pinning virtual threads on JDK 21–23 by performing blocking I/O inside &lt;code&gt;synchronized&lt;/code&gt; blocks (fixed with &lt;code&gt;ReentrantLock&lt;/code&gt;). Part two of the series will walk through the exact JFR profiler traces.&lt;/p&gt;
&lt;h2 id="go-naming-conventions-a-practical-guide"&gt;&lt;a href="https://www.alexedwards.net/blog/go-naming-conventions" rel="noopener noreferrer"&gt;Go Naming Conventions: A Practical Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards puts together a comprehensive, practical guide to naming things in Go, starting from the language&amp;rsquo;s three hard rules for identifiers (only Unicode letters, digits, and underscores; cannot start with a digit; cannot match a reserved keyword) and moving into community conventions. Go uses &lt;code&gt;mixedCaps&lt;/code&gt; (&lt;code&gt;camelCase&lt;/code&gt;) for unexported identifiers and &lt;code&gt;ExportedCaps&lt;/code&gt; (&lt;code&gt;PascalCase&lt;/code&gt;) for exported ones, because the case of the first letter determines package visibility; &lt;code&gt;snake_case&lt;/code&gt; is almost never used. Initialisms and acronyms keep consistent casing across the entire word: &lt;code&gt;apiKey&lt;/code&gt; and &lt;code&gt;APIKey&lt;/code&gt; are idiomatic, whereas &lt;code&gt;ApiKey&lt;/code&gt; is not; likewise, write &lt;code&gt;userID&lt;/code&gt;, never &lt;code&gt;userId&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For identifier length, the guiding principle is that the farther an identifier is used from its declaration, the more descriptive its name needs to be: a loop index over three lines can be &lt;code&gt;i&lt;/code&gt;, while a package-level variable needs a full, self-explanatory name. He advises against encoding types into variable names, shadowing built-in functions or standard-library package names like &lt;code&gt;json&lt;/code&gt; or &lt;code&gt;log&lt;/code&gt;, and exporting identifiers by default—citing &lt;em&gt;The Pragmatic Programmer&lt;/em&gt; that exporting less makes internal refactoring much easier. Package names should be short, all-lowercase single words without underscores (&lt;code&gt;ordermanager&lt;/code&gt;, not &lt;code&gt;order_manager&lt;/code&gt;), avoiding names with special toolchain meaning like &lt;code&gt;vendor&lt;/code&gt;, &lt;code&gt;testdata&lt;/code&gt;, or &lt;code&gt;internal&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="sambercc-skills-golang--a-collection-of-golang-agentic-skills-that-works"&gt;&lt;a href="https://github.com/samber/cc-skills-golang" rel="noopener noreferrer"&gt;samber/cc-skills-golang: 🧑‍🎨 A collection of Golang agentic skills that works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This open-source repository offers a curated collection of Go-specific agent skills compatible with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and Antigravity. Each skill is a modular instruction pack loaded only when relevant, keeping the coding agent&amp;rsquo;s context window lean. Bootstrapped with Claude Code from the author&amp;rsquo;s own production Go commits and then heavily edited, tested, and rewritten by hand, the project comes with a blunt warning from the author: purely AI-generated skills are useless.&lt;/p&gt;
&lt;p&gt;The catalog spans code style, naming conventions, data structures, database patterns, design patterns, documentation, error handling, observability, performance, benchmarking, security, and testing. Skills are split into small, cross-referenced units—for instance, rules about logging errors live inside &lt;code&gt;golang-error-handling&lt;/code&gt; rather than &lt;code&gt;golang-observability&lt;/code&gt;. Each skill includes benchmarked error-reduction numbers comparing agent output with and without the skill, such as a ~40% reduction in style violations and a 53% improvement in documentation compliance. Skills can be installed via the &lt;code&gt;skills&lt;/code&gt; CLI, the Claude Code plugin marketplace, or by copying them into your tool&amp;rsquo;s skill discovery directory.&lt;/p&gt;
&lt;h2 id="small-programming-tricks"&gt;&lt;a href="https://will-keleher.com/posts/small-programming-tricks-matter/" rel="noopener noreferrer"&gt;Small Programming Tricks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Keleher argues that a surprising share of day-to-day engineering speed comes from accumulating &amp;ldquo;small programming tricks&amp;rdquo;—bite-sized techniques that don&amp;rsquo;t require deep theoretical study, but pay off immediately every day. His favorites include fuzzy-searching shell history with &lt;code&gt;fzf&lt;/code&gt; on &lt;code&gt;Ctrl+R&lt;/code&gt; (or &lt;code&gt;atuin&lt;/code&gt; for even richer history), running &lt;code&gt;SELECT&lt;/code&gt; without a &lt;code&gt;FROM&lt;/code&gt; clause to quickly test database functions, using &lt;code&gt;EXPLAIN ANALYZE&lt;/code&gt; to tune queries, word-boundary assertions (&lt;code&gt;\b&lt;/code&gt;) in regular expressions, the &amp;ldquo;git pickaxe&amp;rdquo; (&lt;code&gt;git log -S&lt;/code&gt;) to find commits that added or removed a specific string, and &lt;code&gt;git checkout -&lt;/code&gt; to jump back to the previous branch or commit checkout.&lt;/p&gt;
&lt;p&gt;He also calls out modern JavaScript conveniences like &lt;code&gt;Array.flatMap&lt;/code&gt;, &lt;code&gt;Object.entries&lt;/code&gt;, and &lt;code&gt;Promise.withResolvers&lt;/code&gt;, and recommends &lt;code&gt;ripgrep&lt;/code&gt; (&lt;code&gt;rg&lt;/code&gt;) over &lt;code&gt;grep&lt;/code&gt; alongside shell globs like &lt;code&gt;**/*.md&lt;/code&gt; in place of verbose &lt;code&gt;find&lt;/code&gt; invocations. Inside a company, tribal-knowledge tricks—like which internal dashboard actually shows the right logs for a given failure, or who on another team knows a legacy subsystem inside out—are even more valuable. At a previous job, the author posted one small trick a day in Slack; that daily cadence was lightweight enough not to overwhelm anyone while steadily leveling up the whole team.&lt;/p&gt;
&lt;h2 id="shell-tricks-that-actually-make-life-easier-and-save-your-sanity"&gt;&lt;a href="https://blog.hofstede.it/shell-tricks-that-actually-make-life-easier-and-save-your-sanity/" rel="noopener noreferrer"&gt;Shell Tricks That Actually Make Life Easier (And Save Your Sanity)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christian Hofstede-Kuhn rounds up terminal shortcuts and shell features that many developers miss once they get comfortable with basic &lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;cd&lt;/code&gt;, and &lt;code&gt;grep&lt;/code&gt;. The first half covers Emacs-style line-editing keybindings (depending on your shell configuration): &lt;code&gt;Ctrl+W&lt;/code&gt; deletes the previous word, &lt;code&gt;Ctrl+U&lt;/code&gt; and &lt;code&gt;Ctrl+K&lt;/code&gt; cut to the start or end of the line, &lt;code&gt;Ctrl+Y&lt;/code&gt; yanks the cut text back, and &lt;code&gt;Ctrl+A&lt;/code&gt; / &lt;code&gt;Ctrl+E&lt;/code&gt; jump to the beginning or end of the line; &lt;code&gt;cd -&lt;/code&gt; toggles between your current and previous directory, while &lt;code&gt;pushd&lt;/code&gt; and &lt;code&gt;popd&lt;/code&gt; manage a directory stack. For scripts, &lt;code&gt;set -e&lt;/code&gt; and &lt;code&gt;set -u&lt;/code&gt; help catch errors early (though they have sharp edges and don&amp;rsquo;t replace explicit error handling, and &lt;code&gt;pushd&lt;/code&gt;/&lt;code&gt;popd&lt;/code&gt; aren&amp;rsquo;t part of POSIX &lt;code&gt;sh&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The second half focuses on Bash and Zsh power tools: reverse history search with &lt;code&gt;Ctrl+R&lt;/code&gt;, pressing &lt;code&gt;Ctrl+X&lt;/code&gt; then &lt;code&gt;Ctrl+E&lt;/code&gt; to open the current command line in your &lt;code&gt;$EDITOR&lt;/code&gt; when crafting a complex multi-line command, brace expansion like &lt;code&gt;cp file{,.bak}&lt;/code&gt; for quick backups or &lt;code&gt;mkdir -p project/{src,tests,docs}&lt;/code&gt; to scaffold directories in one shot, process substitution like &lt;code&gt;diff &amp;lt;(sort file1) &amp;lt;(sort file2)&lt;/code&gt;, and &lt;code&gt;disown&lt;/code&gt; to detach a long-running job from the current shell session. His advice: don&amp;rsquo;t try to memorize the whole list at once—pick one trick, force yourself to use it for a week, and then move on to the next.&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 #91</title><link>https://miti99.com/en/post/2026/03/17/</link><pubDate>Tue, 17 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/17/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #91.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages"&gt;&lt;a href="https://dev.to/ganesh-kumar/how-go-slices-work-under-the-hood-what-makes-them-stand-out-from-other-languages-42o4" rel="noopener noreferrer"&gt;How Go Slices Work Under the Hood: What Makes Them Stand Out from Other Languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slices are one of the most heavily used data structures in Go. On the surface they look like simple dynamic arrays, but under the hood every slice is just a three-word header: a pointer to an underlying array, a length (&lt;code&gt;len&lt;/code&gt;), and a capacity (&lt;code&gt;cap&lt;/code&gt;). Slicing with &lt;code&gt;[start:end]&lt;/code&gt; doesn&amp;rsquo;t copy the elements—it simply creates a new slice header pointing into the same backing array, which makes slicing very cheap. The author walks through examples printing &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; after each slice operation, and explains why a slice declared with &lt;code&gt;var s []int&lt;/code&gt; starts out as &lt;code&gt;nil&lt;/code&gt; with both &lt;code&gt;len&lt;/code&gt; and &lt;code&gt;cap&lt;/code&gt; equal to 0.&lt;/p&gt;
&lt;p&gt;The highlight of the post is the growth algorithm inside &lt;code&gt;append&lt;/code&gt;, traced directly from the Go runtime source (&lt;code&gt;runtime/slice.go&lt;/code&gt;). When a slice runs out of capacity, Go allocates a larger backing array: if the current capacity is under 256 elements, it doubles; at 256 and above, the growth factor tapers smoothly from 2x down toward ~1.25x (prior to Go 1.18, that threshold was 1,024). When appending a batch of elements that exceeds double the old capacity, Go jumps straight to the required size and rounds up to the allocator&amp;rsquo;s size class. Because reallocation and copying are expensive, the practical takeaway is to preallocate with &lt;code&gt;make([]T, len, cap)&lt;/code&gt; whenever you know the expected size ahead of time.&lt;/p&gt;
&lt;h2 id="why-go-can"&gt;&lt;a href="https://niketpatel.com/essays/why-go-cant-try" rel="noopener noreferrer"&gt;Why Go Can&amp;rsquo;t Try&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay explains why Go has never gained a &lt;code&gt;try&lt;/code&gt; keyword like Zig or Rust, arguing that the real reason isn&amp;rsquo;t simply the Go team&amp;rsquo;s fondness for explicitness. Ironically, Zig is even more explicit than Go: a return type like &lt;code&gt;!Config&lt;/code&gt; advertises that a function can fail, and the compiler tracks every possible error and enforces exhaustive handling. Go, by contrast, lets you write &lt;code&gt;data, _ := os.ReadFile(path)&lt;/code&gt; without a peep from the compiler, so the explicitness of &lt;code&gt;if err != nil&lt;/code&gt; is largely social convention. While the Go team often argues that &lt;code&gt;try&lt;/code&gt; hides control flow across invisible exit points, the author contends that isn&amp;rsquo;t the root of the problem.&lt;/p&gt;
&lt;p&gt;The real blocker is Go&amp;rsquo;s &lt;code&gt;error&lt;/code&gt; type itself: because &lt;code&gt;error&lt;/code&gt; is just an interface with a single &lt;code&gt;Error() string&lt;/code&gt; method, the compiler has no idea which concrete errors a function can return; utilities like &lt;code&gt;errors.Is()&lt;/code&gt;, &lt;code&gt;errors.As()&lt;/code&gt;, and &lt;code&gt;fmt.Errorf(&amp;quot;%w&amp;quot;)&lt;/code&gt; are purely runtime conventions. Zig&amp;rsquo;s error sets are the exact opposite: finite, compiler-tracked, and represented as zero-overhead 16-bit integers—which means they can&amp;rsquo;t carry arbitrary runtime context, a trade-off Zig offsets with compiler-generated error return traces. Adding &lt;code&gt;try&lt;/code&gt; to Go without changing the &lt;code&gt;error&lt;/code&gt; type would be pure syntactic sugar with no exhaustiveness checking, while changing &lt;code&gt;error&lt;/code&gt; would break the entire standard library and every existing Go program. So &lt;code&gt;if err != nil&lt;/code&gt; is here to stay.&lt;/p&gt;
&lt;h2 id="the-scheduler--understanding-the-go-runtime"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-scheduler" rel="noopener noreferrer"&gt;The Scheduler — Understanding the Go Runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explains the Go runtime scheduler—the component that answers &amp;ldquo;which goroutine runs next?&amp;rdquo; and multiplexes millions of goroutines onto a handful of OS threads. At its core is the GMP model: G is a goroutine, starting with a tiny 2KB stack (compared to 1–8MB for an OS thread); M is an OS thread that actually executes instructions; and P is a logical processor context holding a local run queue of up to 256 goroutines, with the number of Ps equal to &lt;code&gt;GOMAXPROCS&lt;/code&gt;. Decoupling P from M means that when an OS thread blocks in a syscall, its P can be handed off to another thread so queued goroutines keep running. Notably, there is no dedicated central scheduler thread: goroutines park themselves, enqueue themselves onto channel wait queues, and clean themselves up on exit for reuse.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;findRunnable()&lt;/code&gt; function searches for work in a specific order: garbage-collector work, then once every 61 ticks a check of the global run queue to prevent starvation, followed by the local run queue, the global run queue again, the network poller, and finally work stealing—taking half the goroutines from another P&amp;rsquo;s local queue. Threads that run out of work spin briefly looking for new work before parking, with the number of spinning threads capped. The article also covers preemption—both cooperative via function-prologue stack checks and asynchronous via &lt;code&gt;SIGURG&lt;/code&gt; signals. Because a goroutine&amp;rsquo;s saved state is tiny, switching goroutines takes just 50–100 nanoseconds, 10–40x faster than an OS thread context switch.&lt;/p&gt;
&lt;h2 id="go-string-concatenation-performance-benchmark"&gt;&lt;a href="https://www.winterjung.dev/en/string-concat-performance-benchmark-in-go/" rel="noopener noreferrer"&gt;Go String Concatenation Performance Benchmark&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author benchmarks the speed and memory footprint of Go string concatenation techniques, comparing &lt;code&gt;+&lt;/code&gt;, &lt;code&gt;+=&lt;/code&gt;, &lt;code&gt;fmt.Sprintf()&lt;/code&gt;, &lt;code&gt;fmt.Sprint()&lt;/code&gt;, &lt;code&gt;strings.Join()&lt;/code&gt;, &lt;code&gt;bytes.Buffer&lt;/code&gt;, and &lt;code&gt;strings.Builder&lt;/code&gt; (both with and without preallocating via &lt;code&gt;Grow()&lt;/code&gt;). The benchmarks cover two common scenarios: concatenating a fixed, known number of strings—such as building a cache key from a few fields—and concatenating a variable number of strings in a loop, such as assembling dynamic query conditions. All benchmark code and raw results are published so readers can reproduce them.&lt;/p&gt;
&lt;p&gt;The findings are clear: &lt;code&gt;strings.Builder&lt;/code&gt; with &lt;code&gt;Grow()&lt;/code&gt; and &lt;code&gt;strings.Join()&lt;/code&gt; are the fastest and most memory-efficient options across almost every scenario. When concatenating a small, fixed number of strings, the plain &lt;code&gt;+&lt;/code&gt; operator is completely fine, while &lt;code&gt;fmt.Sprintf()&lt;/code&gt; is significantly slower. In the 256-string loop benchmark, the top two methods take just 2.6–2.8 microseconds with a single allocation, whereas using &lt;code&gt;+=&lt;/code&gt; in a loop takes over 37 microseconds, allocates ~185KB of memory, and performs 255 allocations because every iteration creates a brand-new immutable string. The rule of thumb: for loops, reach for &lt;code&gt;strings.Builder&lt;/code&gt; or &lt;code&gt;strings.Join()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="message-passing-is-shared-mutable-state"&gt;&lt;a href="https://causality.blog/essays/message-passing-is-shared-mutable-state/" rel="noopener noreferrer"&gt;Message Passing Is Shared Mutable State&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This essay argues that message passing does not eliminate shared mutable state—it merely relocates it. Back in 2006, Edward Lee predicted that &amp;ldquo;shared memory vs. message passing&amp;rdquo; was a false dichotomy, because swapping locks for messages only changes the shape of concurrency bugs. Go, with its motto &amp;ldquo;share memory by communicating,&amp;rdquo; became the largest real-world test of that thesis: a 2019 study of 171 concurrency bugs across Docker, Kubernetes, etcd, gRPC, and CockroachDB found that roughly 58% of blocking bugs (goroutines hanging forever) were caused by message passing. Worse, Go&amp;rsquo;s built-in deadlock detector caught only 2 of the 21 blocking bugs tested.&lt;/p&gt;
&lt;p&gt;Under the hood, the author points out, a Go channel is literally a shared concurrent queue protected by a mutex, without separate send and receive capability endpoints—so every classic shared-state hazard has a channel equivalent: deadlocks, goroutine leaks, race conditions when multiple goroutines read from the same channel, and protocol violations like sending on a closed channel. A representative Kubernetes bug left a child goroutine blocked forever because nobody read from an unbuffered channel after a timeout; the fix was changing the buffer size to one. Even Erlang, with its strictly isolated processes, was found in academic studies to suffer from race conditions around ETS tables—shared mutable memory bolted back on for performance.&lt;/p&gt;
&lt;h2 id="things-i"&gt;&lt;a href="https://sjer.red/blog/2026/built-with-ai/" rel="noopener noreferrer"&gt;Things I&amp;rsquo;ve Done with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With roughly seven years of professional experience plus seven years of self-taught programming before that, the author traces his journey from AI skeptic to heavy adopter. Having previously ignored GitHub Copilot and dismissed Cursor as hype, he used to care deeply about clean architecture, expressive type systems, and long-term maintainability. The turning point came when he asked &lt;em&gt;why&lt;/em&gt; we care about those things: on the job, what matters is delivering business value, and code doesn&amp;rsquo;t need to be &amp;ldquo;clean&amp;rdquo; in the traditional human sense if it has thorough automated tests that allow AI agents to maintain it safely. Since October 2025, he stopped writing code by hand and now only writes prompts and reviews output.&lt;/p&gt;
&lt;p&gt;Over nine months using Cursor and Claude Code, he shipped more than a dozen personal projects: consolidating everything into a single monorepo, migrating CI to Buildkite and Bazel, building Clauderon—an orchestrator for multiple coding agents—along with Discord bots and mobile apps. At work, AI drafts design docs, builds diagnostic tools, and automates operational chores; small product-manager requests are now nearly free, leaving code review and manual QA as the main work. Still, he admits the review-heavy workflow is mentally tiring, and argues that testing and documentation have become the new bottlenecks where the industry needs better tooling.&lt;/p&gt;
&lt;h2 id="pushing-and-pulling-three-reactivity-algorithms"&gt;&lt;a href="https://jonathan-frere.com/posts/reactivity-algorithms/" rel="noopener noreferrer"&gt;Pushing and Pulling: Three Reactivity Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares three algorithms for building reactive systems—systems that automatically recompute derived values when inputs change, easiest to picture as a spreadsheet where editing one cell updates every formula that depends on it. The author evaluates them against four criteria: efficiency (computing each node at most once per update), granularity (updating only nodes that are actually affected), glitch-freedom (never exposing inconsistent intermediate states), and support for dynamic dependencies. Pure &lt;em&gt;push&lt;/em&gt; reactivity lets each node notify its dependents directly, giving fine granularity, but nodes in diamond dependencies can be recomputed multiple times and expose glitches unless the entire graph is topologically sorted. Pure &lt;em&gt;pull&lt;/em&gt; reactivity works like nested function calls: it is naturally glitch-free and supports dynamic dependencies for free, but has no idea which inputs changed without either recomputing everything or maintaining hard-to-invalidate caches.&lt;/p&gt;
&lt;p&gt;A hybrid &lt;em&gt;push–pull&lt;/em&gt; algorithm gets the best of both worlds: the push phase simply walks downstream to mark affected nodes as &amp;ldquo;dirty&amp;rdquo; and records which output nodes need updating, regardless of traversal order; the pull phase then lazily recomputes only the dirty nodes from the outputs backward and marks them clean. Each node is visited at most once per phase, running in O(n) time where n is the number of affected nodes, and satisfying all four criteria. The main caveat is that the entire pull phase must finish synchronously between two input mutations, so long-running async work has to be handled outside the core graph.&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_!Fevp!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Feb1ae3fa-80a7-464d-97a2-869170caaa2f_2360x2960.png" alt="Git Workflow: Essential Commands"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!huHJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9262eb79-a1cc-4308-8f72-01fdf91e429d_1388x1782.jpeg" alt="How can Cache Systems go wrong?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!7p1w!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd5ebb98a-9f98-4c32-9268-2d14086569d8_2360x2960.png" alt="Top Cyber Attacks Explained"&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 #89</title><link>https://miti99.com/en/post/2026/03/14/</link><pubDate>Sat, 14 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #89.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hybrid-quota-linear-rate-limiter"&gt;&lt;a href="https://dotat.at/@/2026-01-12-hqlr.html" rel="noopener noreferrer"&gt;Hybrid Quota-Linear Rate Limiter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tony Finch points out an underappreciated quirk of linear rate limiters like the leaky bucket or GCRA: they are slow to clamp down on clients that exceed the limit only modestly. Given a quota of &lt;code&gt;q&lt;/code&gt; requests per time window &lt;code&gt;w&lt;/code&gt;, a client sending requests at &lt;code&gt;a&lt;/code&gt; times the allowed rate can still get roughly &lt;code&gt;q*a/(a-1)&lt;/code&gt; requests through before being blocked—double the quota when &lt;code&gt;a=2&lt;/code&gt;. The reason is that the bucket starts full of tokens and continuously refills another quota&amp;rsquo;s worth over the first window. Fixed-window quota-reset limiters enforce a stricter cap, but they use more memory and encourage clients to dump traffic in bursts at window boundaries.&lt;/p&gt;
&lt;p&gt;The author proposes a hybrid algorithm with two modes: a bursty mode for low-volume clients, which allows bursts but refills at most one quota per window; and a smooth mode for heavy clients, which starts with an empty bucket (plus a negative penalty) and forces requests to be paced evenly. The limiter switches to smooth mode when a client drains its last token, and returns to bursty mode once the bucket recovers a full quota. The behavior matches running a quota-reset limiter and a linear limiter side by side, while using less memory. Even so, the author advises against actually using it: a linear rate limiter only looks &amp;ldquo;too generous&amp;rdquo; if you ignore the fact that the client was idle during the previous window. It is better to reframe the requirement and stick with a simple linear limiter like GCRA, which naturally rewards steady traffic.&lt;/p&gt;
&lt;h2 id="go-is-the-best-language-for-ai-agents"&gt;&lt;a href="https://getbruin.com/blog/go-is-the-best-language-for-agents/" rel="noopener noreferrer"&gt;Go is the Best Language for AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Burak Karakan, who has worked professionally with Go for eight years and is building Bruin—an open-source ETL tool written in Go—argues that Go is the best language for coding with AI agents. First, Go is compiled: agents generate lots of plausible-looking code, and a fast compiler with static types lets the agent iterate in a tight loop until entire classes of type and argument errors are eliminated. Compared with Rust, Go has simpler syntax and concepts, compiles faster for a tighter feedback loop, and has a larger corpus of existing code. That simplicity also makes it easy for humans to review diffs and spot when an agent is heading down a strange design path.&lt;/p&gt;
&lt;p&gt;Go is also strongly opinionated: there is one standard way to run tests, format code, and build binaries, so an agent can just invoke &lt;code&gt;gofmt&lt;/code&gt; instead of wrestling with the toolchain sprawl common in JavaScript. Easy cross-compilation lets agents verify builds across operating systems after every change (even if running the tests still requires the target environment or an emulator)—a major advantage when running background agents inside sandboxes whose environment you don&amp;rsquo;t fully control. In the author&amp;rsquo;s experience, agents write working Go on the first try roughly 95% of the time—not because there is more training data than for Python, but because Go usually has one obvious way to do things. He acknowledges this is anecdotal and may matter less as models improve.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-harness-not-a-framework"&gt;&lt;a href="https://x.com/djfarrelly/status/2028556984396452250" rel="noopener noreferrer"&gt;Your Agent Needs a Harness, Not a Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Farrelly from Inngest argues that AI agents need a &amp;ldquo;harness,&amp;rdquo; not a framework. Across engineering disciplines, a harness connects, protects, and coordinates components without doing their job for them—like a wiring harness linking an engine to sensors, or a climbing harness catching you when you fall. For an agent, the LLM is the engine, tools are peripherals, and memory is storage; what you need around them is something that handles an LLM timing out on loop iteration five or two user messages colliding. Agent frameworks keep reinventing retries, state persistence, queues, and event routing from scratch, when durable event-driven infrastructure already solves those problems: every LLM or tool call becomes an independently retryable &amp;ldquo;step,&amp;rdquo; so if a process crashes on iteration five, the first four iterations are already checkpointed.&lt;/p&gt;
&lt;p&gt;To prove the point, the team built Utah (Universally Triggered Agent Harness)—a conversational agent over Telegram or Slack with tools, memory, sub-agent delegation via &lt;code&gt;step.invoke()&lt;/code&gt;, and fault tolerance, written in compact TypeScript with no agent framework, just Inngest functions, steps, and events wrapped around a think → act → observe loop. Their biggest lesson: context management is the real challenge, because bloated tool outputs disorient the model and send it into endless tool-calling loops. They solved this with two-tier pruning of old tool outputs, session history compaction, warnings as the step budget runs low, and automatic re-compaction on context-window overflow errors.&lt;/p&gt;
&lt;h2 id="an-interactive-intro-to-quadtrees"&gt;&lt;a href="https://growingswe.com/blog/quadtrees" rel="noopener noreferrer"&gt;An Interactive Intro to Quadtrees&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide explains quadtrees—a spatial data structure for fast two-dimensional queries, inspired by seeing Uber use spatial indexing in system design write-ups. In a mapping app with millions of places, the naive approach to finding nearby points is computing the distance from the user to every single location, costing millions of operations per query. A quadtree reorganizes space itself: it splits a rectangular region into four quadrants, and whenever a quadrant exceeds its point capacity, it subdivides again. Dense areas get finely divided while sparse areas stay coarse, so looking up a point simply walks down the tree, eliminating three-quarters of the remaining space at each level—roughly 10 steps for a million points.&lt;/p&gt;
&lt;p&gt;The capacity parameter shapes the tree: a low capacity builds a deeper tree that prunes more aggressively but uses more memory; a high capacity builds a shallower tree where leaf nodes scan more points linearly, with 4 to 16 being a good starting range. Range queries only descend into nodes whose bounding boxes intersect the search region, pruning entire subtrees at once; nearest-neighbor search tracks the best distance found so far to prune increasingly aggressively. Beyond geospatial search, quadtrees power broad-phase collision detection in games—avoiding pairwise checks between distant objects—and region-based image compression, where uniform areas are stored as large blocks and detailed regions are subdivided.&lt;/p&gt;
&lt;h2 id="agentic-engineering-patterns"&gt;&lt;a href="https://simonwillison.net/guides/agentic-engineering-patterns/" rel="noopener noreferrer"&gt;Agentic Engineering Patterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison has launched a guide to patterns for getting the most out of coding agents like Claude Code and OpenAI Codex. He draws a sharp line between &amp;ldquo;agentic engineering&amp;rdquo; and &amp;ldquo;vibe coding&amp;rdquo;: vibe coding means letting an LLM write code without paying attention to the code itself, whereas agentic engineering is professional engineers using agents to amplify their existing expertise rather than replace it. The guide is organized into sections covering core principles, working with coding agents (how they work, using Git, sub-agents), testing and quality assurance, understanding codebases through linear walkthroughs and interactive explanations, annotated prompts, and an appendix of prompts he uses regularly.&lt;/p&gt;
&lt;p&gt;A few standout patterns: &amp;ldquo;Writing code is cheap now&amp;rdquo;—the cost of generating code has dropped to near zero, but &lt;em&gt;good&lt;/em&gt; code with tests, documentation, and proper error handling still takes discipline, requiring new habits; &amp;ldquo;Hoard things you know how to do&amp;rdquo;—maintain a collection of working examples you can recombine and feed to agents as reference input; and &amp;ldquo;Red/green TDD&amp;rdquo;—have the agent write a failing test first and verify it fails before implementing the fix, along with running the test suite right at the start of every session. The guide also calls out anti-patterns to avoid—most notably filing unreviewed agent-generated pull requests for teammates to review—and continues to grow with new chapters.&lt;/p&gt;
&lt;h2 id="things-i-miss-about-spring-boot-after-switching-to-go"&gt;&lt;del&gt;&lt;a href="https://sushantdhiman.dev/things-i-miss-about-spring-boot-after-switching-to-go/" rel="noopener noreferrer"&gt;Things I Miss About Spring Boot After Switching to Go&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;After spending a year and a half building production Java and Spring Boot systems at a startup and then switching to Go, Sushant Dhiman reflects on what he misses from the Spring ecosystem. First is the &amp;ldquo;batteries included&amp;rdquo; philosophy: Spring Boot ships with nearly everything needed for production out of the box, whereas Go favors minimalism and a collection of small libraries over a monolithic framework. Specifically, he misses declarative dependency injection via annotations like &lt;code&gt;@Service&lt;/code&gt; and &lt;code&gt;@Autowired&lt;/code&gt;; in Go you wire dependencies manually through constructors—explicit, but startup code balloons once a service has hundreds of dependencies. Similarly, declarative validation with &lt;code&gt;@NotNull&lt;/code&gt; or &lt;code&gt;@Email&lt;/code&gt; avoids chains of manual &lt;code&gt;if/else&lt;/code&gt; checks and regexes.&lt;/p&gt;
&lt;p&gt;Spring&amp;rsquo;s mature ecosystem is another big loss: Spring Security handles JWT, OAuth, and form logins out of the box; Spring Data derives queries directly from method names like &lt;code&gt;findByEmail&lt;/code&gt;; Spring Boot Actuator exposes health checks and metrics with a few lines of configuration; and Spring Cloud provides a full toolkit for microservices. Still, the author is fair to Go: it gives you complete control and transparency over SQL queries, which is much easier to debug than complex multi-table ORM joins. Go also wins on operational simplicity—compiling to a single static binary with no JVM or garbage-collector tuning, near-instant startup, and first-class concurrency built right into the language.&lt;/p&gt;
&lt;h2 id="design-first-collaboration-with-ai"&gt;&lt;a href="https://martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html" rel="noopener noreferrer"&gt;Design-First Collaboration with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on martinfowler.com, Rahul Garg diagnoses the &amp;ldquo;Implementation Trap&amp;rdquo; when working with AI coding assistants: AI generates code so fast that the natural pause between design thinking and coding disappears. The AI still makes design decisions about scope, component boundaries, data flow, and error handling, but buries them quietly inside the implementation. Reviewers have to evaluate too many concerns at once and easily miss flaws, even though fixing a misunderstanding at the design stage is far cheaper than after code is written. Worse, AI assistants routinely slip in unrequested features—what the author calls &amp;ldquo;technical debt injection.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;His solution is to recreate the whiteboard design session across five progressive levels of abstraction: Capabilities (core requirements), Components (building blocks), Interactions (data flow and communication), Contracts (function signatures, types, interfaces), and finally Implementation. The golden rule is no production code until Level 5 is approved. In a notification-service example, reviewing at the Components level let the author scrap an unnecessary &lt;code&gt;RetryQueue&lt;/code&gt; class because BullMQ already handles retries; and once Contracts are agreed upon, the AI can write tests before writing the implementation. Not every task needs all five levels: a simple utility can start at Level 4, while a multi-component feature starts at Level 1. The process takes more upfront time and isn&amp;rsquo;t worth it for throwaway tasks, but pays off handsomely for complex, long-lived features.&lt;/p&gt;
&lt;h2 id="the-two-kinds-of-error"&gt;&lt;a href="https://evanhahn.com/the-two-kinds-of-error/" rel="noopener noreferrer"&gt;The Two Kinds of Error&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn divides software errors into two categories. &lt;em&gt;Expected&lt;/em&gt; errors happen during normal operation and aren&amp;rsquo;t bugs in the program: invalid user input, flaky networks, missing file permissions. These are recoverable—you shouldn&amp;rsquo;t &lt;code&gt;throw&lt;/code&gt;, &lt;code&gt;raise&lt;/code&gt;, or &lt;code&gt;panic&lt;/code&gt;, but instead return an explicit error value (like a &lt;code&gt;Result&lt;/code&gt; type) that forces the caller to handle it, logging at &lt;code&gt;WARN&lt;/code&gt; or &lt;code&gt;INFO&lt;/code&gt; at most. &lt;em&gt;Unexpected&lt;/em&gt; errors should never happen—failed assertions, logic bugs, corrupt data from a database you control—and indicate a bug in the code. Rather than limping along, the program should crash immediately and log at &lt;code&gt;ERROR&lt;/code&gt; or &lt;code&gt;FATAL&lt;/code&gt;; crashing is annoying in the moment, the author argues, but makes software far more reliable over time.&lt;/p&gt;
&lt;p&gt;Where the boundary falls depends on context: in a quick prototype or one-off script, almost every error can be treated as unexpected; in flight software for a 50-year deep-space probe, almost every error—including hardware faults—must be treated as expected. Making software more reliable generally means moving more errors from the unexpected column into the expected one. He also notes that languages like Rust and Zig nudge developers to treat many errors as expected, whereas JavaScript and Python do the opposite, and he prefers stricter compiler enforcement for production systems.&lt;/p&gt;
&lt;h2 id="secure-go-error-handling-best-practices"&gt;&lt;a href="https://blog.jetbrains.com/go/2026/03/02/secure-go-error-handling-best-practices/" rel="noopener noreferrer"&gt;Secure Go Error Handling Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the JetBrains GoLand blog focuses on the security side of error handling in Go. Because Go errors are plain values rather than exceptions, letting them bubble up and return directly to clients can easily leak file paths, SQL queries, credentials, or stack traces. The first rule is a strict separation between what the system sees and what the user sees: define a custom error type carrying both an internal cause and a public message, where &lt;code&gt;Error()&lt;/code&gt; returns only the safe message while technical details go exclusively to internal logs. Next, instead of logging entire request structs that might contain passwords, use a builder or helper that whitelists safe metadata fields; and when you don&amp;rsquo;t want callers inspecting the underlying cause via &lt;code&gt;errors.Is&lt;/code&gt; or &lt;code&gt;errors.As&lt;/code&gt;, wrap errors opaquely rather than using &lt;code&gt;fmt.Errorf&lt;/code&gt; with &lt;code&gt;%w&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;As errors cross architectural boundaries, control them at three levels: between internal layers, translate raw database errors into domain errors; between microservices, map them to standard status codes like gRPC codes or a uniform JSON error schema; and at the user-facing edge, return only predefined static strings or error codes paired with a request ID—never dynamically concatenated error text. For logging, use structured loggers like &lt;code&gt;log/slog&lt;/code&gt;, zap, or zerolog, project only the fields needed for debugging, and implement a &lt;code&gt;Redactor&lt;/code&gt; interface to mask sensitive fields whenever a full request payload must be logged.&lt;/p&gt;
&lt;h2 id="ai-coding-tools-java--compounding-engineering"&gt;&lt;a href="https://www.the-main-thread.com/p/ai-coding-tools-java-compounding-engineering" rel="noopener noreferrer"&gt;AI Coding Tools, Java &amp;amp; Compounding Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Markus Eisele distills Aleksander Stensby&amp;rsquo;s talk from NDC Manchester 2025 around a central thesis: if AI is generating bad code for you, it&amp;rsquo;s usually a workflow problem, not a model problem. Stensby calls the fix &lt;em&gt;Compounding Engineering&lt;/em&gt;—investing in your tools over time the way you mentor a junior developer. Context is both precious and scarce: too little and the model hallucinates, too much and it loses focus, so clear the chat frequently and persist architectural decisions, constraints, and rejected alternatives in markdown files so you can reload only what matters. Rule files like &lt;code&gt;CLAUDE.md&lt;/code&gt; serve as a living knowledge base: every time you fix a subtle bug, update the rules so the agent never makes that mistake again.&lt;/p&gt;
&lt;p&gt;Other habits include always planning before coding to catch bad ideas early, breaking work into small single-responsibility tasks, picking models deliberately (fast models for routine edits, deep reasoning models for architecture), automating repetitive flows with slash commands and sub-agents, using MCP so the AI can inspect real systems, and keeping a Git safety net of frequent checkpoints. Background agents still require thorough human review before merging. An engineer&amp;rsquo;s enduring value lies in taste and judgment—spotting that something is wrong even when all the tests pass—which AI still lacks. Invest in your workflow and the gains compound; skip that investment and you just get &amp;ldquo;faster mediocrity.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="yaml-that"&gt;&lt;a href="https://lab174.com/blog/202601-yaml-norway/" rel="noopener noreferrer"&gt;YAML? That&amp;rsquo;s Norway Problem&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece digs into YAML&amp;rsquo;s infamous &amp;ldquo;Norway problem&amp;rdquo;: the two-letter country code &lt;code&gt;NO&lt;/code&gt; getting parsed by popular libraries like PyYAML as the boolean &lt;code&gt;false&lt;/code&gt; instead of a string. The root cause is implicit typing for unquoted scalars: the final draft of YAML 1.0 (2004) and YAML 1.1 (2005) treated words like &lt;code&gt;yes/no&lt;/code&gt; and &lt;code&gt;on/off&lt;/code&gt; as booleans. YAML 1.2 (2009) dropped that behavior, yet PyYAML and LibYAML—the two &amp;ldquo;official&amp;rdquo; libraries, with open issues requesting v1.2 support dating back to 2016–2017—still implement v1.1. Because LibYAML sits deep inside the dependency tree of countless tools, changing it is slow and risky.&lt;/p&gt;
&lt;p&gt;Most articles stop at &amp;ldquo;just quote &lt;code&gt;&amp;quot;NO&amp;quot;&lt;/code&gt;,&amp;rdquo; but the author shows the ecosystem reality is messier. In Go, the most downloaded library (&lt;code&gt;gopkg.in/yaml.v3&lt;/code&gt;) is unmaintained and mixes v1.1 and v1.2 behaviors, whereas the most popular actively maintained library defaults to v1.2; the &lt;code&gt;yq&lt;/code&gt; CLI also defaults to v1.2, and in 2025 Kubernetes introduced KYAML, a safer, less ambiguous subset of YAML. Online documentation routinely confuses spec versions while users argue over whether the bug is &amp;ldquo;already fixed.&amp;rdquo; The takeaway: the YAML ecosystem is fragmented but gradually migrating toward stricter specs; new projects will likely pick newer v1.2-compliant libraries free of the Norway problem, while older, more widely deployed libraries remain stuck on v1.1.&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 #85</title><link>https://miti99.com/en/post/2026/02/28/</link><pubDate>Sat, 28 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #85.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-i-use-claude-code"&gt;&lt;a href="https://boristane.com/blog/how-i-use-claude-code/" rel="noopener noreferrer"&gt;How I Use Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Boris Tane shares the workflow he has used with Claude Code over roughly nine months, built around one rule: never let Claude write code before a written plan has been carefully reviewed and approved. This keeps architectural decisions in the developer&amp;rsquo;s hands and produces far better results. In the research phase, the author instructs Claude to read the relevant codebase &amp;ldquo;deeply&amp;rdquo; and write its understanding to &lt;code&gt;research.md&lt;/code&gt;; without such emphatic wording, Claude tends to skim. This file makes it easy to verify whether Claude actually understands the system, because the costliest AI coding failures are changes that work in isolation but break everything around them.&lt;/p&gt;
&lt;p&gt;Next, Claude writes &lt;code&gt;plan.md&lt;/code&gt;, covering the approach, illustrative code snippets, files to modify, and trade-offs. The most valuable part is the annotation loop: the author adds inline notes directly into the plan to correct faulty assumptions, strip out unnecessary options, or inject domain knowledge, then asks Claude to update the plan with an explicit &amp;ldquo;don&amp;rsquo;t implement yet&amp;rdquo; guard. This loop repeats one to six times, after which a detailed task checklist is added to the plan. Once every decision is settled, a standard prompt tells Claude to execute everything, mark progress right inside the plan, and continuously run type checks. Implementation then becomes &amp;ldquo;boring&amp;rdquo;: just short course corrections, reverting when things drift, and running the entire workflow in a single long session so Claude accumulates context.&lt;/p&gt;
&lt;h2 id="next-generation-db-ingestion-at-pinterest"&gt;&lt;a href="https://medium.com/pinterest-engineering/next-generation-db-ingestion-at-pinterest-66844b7153b7" rel="noopener noreferrer"&gt;Next-Generation DB Ingestion at Pinterest&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest introduces the first part of a series on its next-generation database ingestion framework, replacing legacy batch pipelines. The old system regularly had latencies exceeding 24 hours, reprocessed entire tables daily even when less than 5% of rows changed, and lacked row-level deletion support. The new framework is built on change data capture (CDC) using Debezium/TiCDC, Kafka, Flink, Spark, and Iceberg, supporting MySQL, TiDB, and KVStore. CDC services publish events to Kafka with sub-second latency, Flink writes them into append-only Iceberg CDC tables on S3 (under 5 minutes of latency), and Spark periodically deduplicates to the latest change per primary key and uses &lt;code&gt;Merge Into&lt;/code&gt; to update the base table—a replica of the online table with 15-minute to one-hour latency.&lt;/p&gt;
&lt;p&gt;The team chose Merge-on-Read over Copy-on-Write because the latter incurred much higher storage costs. The post highlights three optimizations. First, base tables are partitioned by the hash of the primary key via &lt;code&gt;bucket()&lt;/code&gt; so data distributes evenly and Spark can process partitions in parallel. Second, setting &lt;code&gt;WRITE DISTRIBUTED BY PARTITION&lt;/code&gt; groups records from the same partition into a single write, solving the small-files problem. Third, for massive tables, the team stages CDC data into a temporary table with matching partitioning to enable a bucket join, avoiding a full shuffle of the base table before every merge and cutting compute cost by over 40% while significantly reducing latency. Part two will cover automated schema evolution.&lt;/p&gt;
&lt;h2 id="thank-you-ai"&gt;&lt;a href="https://www.kraxel.org/blog/2026/01/thank-you-ai/" rel="noopener noreferrer"&gt;Thank you, AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gerd Hoffmann recounts shutting down the self-hosted git server he had run publicly since 2011, and as a CVS server before that. AI scraper bots hammered the cgit web interface with pointless requests until the modest server collapsed, even though the most efficient way to get an entire repository is simply to clone it. Unwilling to spend his free time fighting bots, the author decided not to bring the server back and instead migrated completely to GitLab and GitHub—where most of his repositories were already mirrored—while updating old links to point there.&lt;/p&gt;
&lt;p&gt;The only remaining self-hosted service is the web server running his blog, which moved from WordPress to Jekyll in 2018 and serves static pages that are very hard to overload. Even so, the bots caused another incident: millions of 404 responses weren&amp;rsquo;t enough to convince them that cgit was gone, and the access logs grew so fast that default &lt;code&gt;logrotate&lt;/code&gt; settings couldn&amp;rsquo;t rotate them in time, filling up the disk. He tuned the configuration to fix it. This short story illustrates the very real burden the AI scraping wave places on people running small self-hosted services.&lt;/p&gt;
&lt;h2 id="java-ui-in-2026-the-complete-guide"&gt;&lt;a href="https://robintegg.com/2026/02/08/java-ui-in-2026-the-complete-guide" rel="noopener noreferrer"&gt;Java UI in 2026: The Complete Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Robin Tegg surveys more than 25 Java UI frameworks and libraries as of 2026 across four platforms: web, desktop, mobile, and terminal. His central point is that these aren&amp;rsquo;t legacy relics hanging on for dear life, but production-ready, actively maintained technologies running at major enterprises, banks, and government agencies serving hundreds of millions of users. On the web, Vaadin and Apache Wicket let you write full UIs in Java without JavaScript, PrimeFaces and Jakarta Faces serve the Jakarta EE ecosystem, HTMX paired with Spring Boot follows a hypermedia approach, j2html generates type-safe HTML, Thymeleaf remains the classic template engine choice, and TeaVM compiles Java bytecode to JavaScript or WebAssembly.&lt;/p&gt;
&lt;p&gt;On the desktop, JavaFX is the modern standard, JCEF embeds Chromium for HTML/CSS interfaces, Swing gets a fresh look via FlatLaf, and the NetBeans Platform and Eclipse RCP suit large modular applications with plugin architectures. For mobile, Codename One offers write-once-run-anywhere with cloud iOS builds that don&amp;rsquo;t require a Mac, while Gluon Mobile extends JavaFX with native compilation via GraalVM. In the terminal space, JLine handles command-line input and powers Maven and Gradle, while Lanterna provides a text-GUI toolkit. Each framework comes with a description, code example, getting-started links, and a decision matrix for picking the right tool for each scenario.&lt;/p&gt;
&lt;h2 id="java-full-stack-development-in-2026"&gt;&lt;a href="https://www.ophion.org/2026/02/java-full-stack-development-in-2026/" rel="noopener noreferrer"&gt;Java Full Stack Development in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author recounts migrating &lt;a href="https://www.scanii.com" rel="noopener noreferrer"&gt;www.scanii.com&lt;/a&gt; from a Spring Boot application using webpack and TypeScript to a leaner architecture where all rendering happens on the server. In his view, React, TypeScript, and split codebases only make sense when you have specialized front-end and back-end teams; for a small team of generalists, simplicity yields much higher productivity. The result is a unified codebase that launches with a single &amp;ldquo;Run&amp;rdquo; button in IntelliJ, zero front-end build time with live reload, partial page updates that still feel like a single-page app, a 100 Lighthouse performance score, and easier debugging with no transpilation step in the way.&lt;/p&gt;
&lt;p&gt;The migration took three steps. First was picking a template engine supported by Spring Boot; the team chose JTE because it gives access to the full JDK right inside templates. Next was dropping the bundler in favor of standard HTML &lt;code&gt;importmaps&lt;/code&gt;, paired with WebJars to serve libraries directly from the app without third-party CDNs. Finally, they added interactivity with Hotwire&amp;rsquo;s Turbo and Stimulus, following the Rails playbook to get partial page updates and a familiar MVC structure for the remaining JavaScript. Two major hurdles were the lack of hot reload—solved by having the browser poll for changes while the server watches the filesystem—and Spring Security&amp;rsquo;s per-form random CSRF tokens, which clashed with Turbo&amp;rsquo;s page caching. The team wrote a custom CSRF filter based on the browser&amp;rsquo;s &lt;code&gt;Sec-Fetch-Site&lt;/code&gt; header.&lt;/p&gt;
&lt;h2 id="sharding-databases-with-spring-boot-patterns-pitfalls-and-failure-modes"&gt;&lt;a href="https://dev.to/adamthedeveloper/sharding-databases-with-spring-boot-patterns-pitfalls-and-failure-modes-4p37" rel="noopener noreferrer"&gt;Sharding Databases with Spring Boot: Patterns, Pitfalls, and Failure Modes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide explains database sharding—horizontally partitioning data across multiple smaller databases—and how to implement it with Spring Boot. Sharding becomes necessary when vertical scaling hits a wall, queries degrade with table size, write throughput becomes a bottleneck, or higher availability is required. The most consequential decision is choosing the shard key, such as a user ID or tenant ID: it needs high cardinality, should keep most queries on a single shard, and must rarely change. The article compares four strategies—range-based, hash-based, directory/lookup-based, and geo-based—and shows why simple modulo hashing forces almost every key to move when shards are added or removed, whereas consistent hashing only disturbs roughly 1/N of the keys on average.&lt;/p&gt;
&lt;p&gt;The implementation walkthrough covers configuring multiple data sources, a shard resolution service, and a routing &lt;code&gt;JdbcTemplate&lt;/code&gt;. Queries that include the shard key go straight to one shard, while queries without it must scatter-gather across all shards. Cross-shard joins are the hardest part and can be handled via denormalization, application-level joins, or co-locating related data on the same shard. Because two-phase commit is slow and prone to blocking when the coordinator fails, the author recommends the Saga pattern and embracing eventual consistency. The post also covers monitoring with Actuator, zero-downtime migration via dual writes, and common pitfalls like picking the wrong shard key, hardcoding the shard count, or lacking per-shard backups. Bottom line: only shard when you truly have to.&lt;/p&gt;
&lt;h2 id="go-made-me-fast-rust-made-me-care-aws-made-me-pay"&gt;&lt;a href="https://dev.to/tirixa-hub/go-made-me-fast-rust-made-me-care-aws-made-me-pay-2f82" rel="noopener noreferrer"&gt;Go Made Me Fast, Rust Made Me Care, AWS Made Me Pay&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author reflects that for years of running Go on AWS everything seemed fine—fast deployments, productive teams—until realizing that in the cloud, systems rarely fail loudly; they &amp;ldquo;fail financially.&amp;rdquo; Go earns its place as a default backend language thanks to its simple concurrency model, strong standard library, small binaries, fast startup, and predictable failure modes. The catch is that inefficiency compounds quietly: an extra 10% CPU here, 200MB of memory there, one more instance &amp;ldquo;just to be safe.&amp;rdquo; Go&amp;rsquo;s garbage collector, good as it is, still costs memory headroom, CPU cycles, tail-latency spikes under load, and lower container density—while AWS simply sends the bill.&lt;/p&gt;
&lt;p&gt;Rust entered the picture when high-throughput services and streaming data pipelines started straining Go. The author stresses that Rust isn&amp;rsquo;t magically faster; it forces developers to confront allocations, ownership, memory layout, and cache behavior. The first Rust service took three times longer to write, but in production its memory graph was flat, latency stayed rock-steady, and CPU usage matched expectations. That translated into smaller EC2 instances, higher container density, fewer OOM kills on ECS/EKS, and lower Lambda bills for CPU-heavy workloads. The takeaway is to put each language where it shines: Go for APIs, business logic, and glue code; Rust for data pipelines, latency-sensitive components, and CPU-bound tasks.&lt;/p&gt;
&lt;h2 id="the-cloud-is-not-your-computer-why-go-and-rust-developers-secretly-miss-the-monolith"&gt;&lt;a href="https://dev.to/tirixa-hub/the-cloud-is-not-your-computer-why-go-and-rust-developers-secretly-miss-the-monolith-594c" rel="noopener noreferrer"&gt;The Cloud Is Not Your Computer: Why Go and Rust Developers Secretly Miss the Monolith&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a companion piece written with a satirical edge, the same author argues that the cloud isn&amp;rsquo;t your computer—it&amp;rsquo;s a negotiation. Writing Go or Rust gives you a sense of determinism and control, yet in the cloud the &amp;ldquo;server&amp;rdquo; is virtual, the &amp;ldquo;disk&amp;rdquo; is over the network, the &amp;ldquo;network&amp;rdquo; is software-defined, and the security boundary is an IAM policy copy-pasted from somewhere, meaning you aren&amp;rsquo;t really running software so much as &amp;ldquo;renting probability.&amp;rdquo; Go assumes everything can fail and calmly returns an &lt;code&gt;error&lt;/code&gt;, while Rust makes you prove memory ownership up front, yet that carefully verified binary still runs behind layers of containers, clusters, VPCs, load balancers, and CDNs. You debug the code while the real culprit is a security group or a missing index.&lt;/p&gt;
&lt;p&gt;The author admits a nostalgia for the monolith because it was predictable, easy to deploy, and straightforward to debug: SSH into one machine, read the logs, and fix the issue, instead of opening CloudWatch, Prometheus, Grafana, and Datadog while still having no idea why a &lt;code&gt;503&lt;/code&gt; happened. Even so, Go and Rust thrive in the cloud because they are honest languages in an dishonest environment: Go treats errors as first-class values, Rust proves memory safety at compile time, and both reduce uncertainty. Consequently, a great cloud engineer today doesn&amp;rsquo;t just write good code—they understand network topology, IAM blast radius, observability strategy, latency budgets, failure domains, and cost models.&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_!V-F7!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F57c857fb-0db2-4701-93f7-343fac614657_2250x2862.png" alt="Must-Know Software Architecture Patterns"&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 #84</title><link>https://miti99.com/en/post/2026/02/26/</link><pubDate>Thu, 26 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #84.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="automatic-programming"&gt;&lt;a href="https://antirez.com/news/159" rel="noopener noreferrer"&gt;Automatic programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, coins the term &amp;ldquo;automatic programming&amp;rdquo; for writing software with AI assistance—and believes that before long, we will simply call it &amp;ldquo;programming.&amp;rdquo; He draws a sharp line between automatic programming and &amp;ldquo;vibe coding&amp;rdquo;: in vibe coding, you hand a vague prompt to an LLM and let it generate software while you stay mostly out of the loop, only nudging it when something breaks. In automatic programming, the human programmer understands everything happening under the hood, continuously steers the model according to their own vision across every level of abstraction—from high-level architecture down to how a specific function should be implemented—and decides &lt;em&gt;what&lt;/em&gt; to build in the first place. Because of that, the same model produces vastly different results depending on who is in the driver&amp;rsquo;s seat.&lt;/p&gt;
&lt;p&gt;Sanfilippo argues that code produced this way is genuinely yours and something you have every right to be proud of. Since the training data behind these models came from humanity&amp;rsquo;s collective output, he sees LLMs more as a shared gift from humanity to itself than as theft. He points to Redis as an example: technically speaking, Redis contained very little novel computer science—just basic data structures and networking code that any competent systems programmer could write; what made Redis valuable was the product vision and taste behind it. His conclusion: programming can now be automated, but vision (for now) cannot.&lt;/p&gt;
&lt;h2 id="software-performance-engineering-the-ideas-i-keep-coming-back-to"&gt;&lt;a href="https://ricomariani.medium.com/software-performance-engineering-the-ideas-i-keep-coming-back-to-6f421b6a9505" rel="noopener noreferrer"&gt;Software Performance Engineering: The Ideas I Keep Coming Back To&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rico Mariani distills eight performance engineering ideas he keeps returning to across decades and programming languages, centered on one core theme: performance is not about clever tricks or micro-optimizations, but a way of thinking. First, performance is a systems problem: the hardest issues almost always stem from architectural choices like excessive allocations, poor data locality, hidden synchronization, or unbounded growth rather than a single slow function. Abstractions are never free—they merely hide cost, so you need to know what they expand into and how often they run. Cost models matter more than APIs: two APIs that look identical on the surface can differ by 10x because one allocates on every call or touches cold memory. And profilers only tell you &lt;em&gt;where&lt;/em&gt; time went, not &lt;em&gt;why&lt;/em&gt; it was spent.&lt;/p&gt;
&lt;p&gt;Memory is the real bottleneck, as the speed gap between CPUs and main memory continues to widen. Meanwhile, Knuth&amp;rsquo;s famous quote that &amp;ldquo;premature optimization is the root of all evil&amp;rdquo; is routinely abused: the real sin is designing systems with zero cost awareness, which leads to &amp;ldquo;premature pessimization.&amp;rdquo; Programming languages also shape how engineers think about cost—languages that make ownership and lifetimes explicit make cost much easier to reason about. Finally, performance rarely dies in a single commit; it erodes through a thousand tiny, invisible cuts, requiring regular check-ins to verify that reality still matches your architectural intent.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://oblique.security/blog/go-synctest/" rel="noopener noreferrer"&gt;Go&amp;rsquo;s synctest is amazing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eric Chiang from Oblique shares his experience using Go 1.25&amp;rsquo;s &lt;code&gt;testing/synctest&lt;/code&gt; package to test a codebase full of background control loops, such as purging expired database sessions or running distributed leader election across instances. The headline feature of &lt;code&gt;synctest&lt;/code&gt; is running tests inside an isolated &amp;ldquo;bubble&amp;rdquo; with a fake clock so &lt;code&gt;time.Sleep&lt;/code&gt; completes almost instantaneously. According to Chiang, however, its even bigger superpower is letting you deterministically reason about the &lt;em&gt;ordering&lt;/em&gt; of concurrent events. &lt;code&gt;synctest&lt;/code&gt; only advances its fake clock when every goroutine inside the bubble is durably blocked—typically on channels, wait groups, or time operations—and then advances the clock just enough to wake the shortest sleep. That lets tests use time itself as a synchronization primitive, something that would be an anti-pattern in production code; for example, a background ticker loop that runs once a minute is guaranteed to execute exactly three times after sleeping for three fake minutes.&lt;/p&gt;
&lt;p&gt;In practice, simply sleeping slightly longer than the interval of &lt;code&gt;RunDeleteExpiredSessions&lt;/code&gt; guarantees the background cleanup pass has finished before the test asserts against the database, and the entire test finishes in under a second. His team even applied &lt;code&gt;synctest&lt;/code&gt; to their database-backed leader election logic spanning dozens of concurrent loops without modifying a single line of production code, pausing execution at arbitrary points in time to inspect database state. He notes two caveats to keep in mind: understanding which operations count as &amp;ldquo;durably blocked&amp;rdquo; (network and file I/O do not) and ensuring all spawned goroutines exit cleanly before the bubble closes.&lt;/p&gt;
&lt;h2 id="why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying"&gt;&lt;a href="https://dev.to/rpereira15/why-clean-architecture-confuses-everyone-and-how-i-learned-to-stop-worrying-1i5k" rel="noopener noreferrer"&gt;Why Clean Architecture Confuses Everyone (And How I Learned to Stop Worrying)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on more than 10 years of software engineering experience, Rômulo Pereira explains why Clean Architecture confuses so many developers: teams spend hours arguing over folder structures while missing the core principle. Frameworks like Spring Boot make violating boundaries effortless—a single annotation on a domain class tightly couples your business logic to JPA, Jackson, and the framework runtime. Organizing packages by technical layer (&lt;code&gt;controller&lt;/code&gt;, &lt;code&gt;service&lt;/code&gt;, &lt;code&gt;repository&lt;/code&gt;, &lt;code&gt;model&lt;/code&gt;) also pulls you into technology-first thinking, whereas organizing by feature (&lt;code&gt;order&lt;/code&gt;, &lt;code&gt;product&lt;/code&gt;, &lt;code&gt;customer&lt;/code&gt;) keeps the focus on what the system actually &lt;em&gt;does&lt;/em&gt;. From his experience building high-volume billing systems and real-time data platforms, he argues that business logic should be &amp;ldquo;boring&amp;rdquo;: completely agnostic to where data is stored, whether requests arrive over REST or a message queue, or which framework is in use. And don&amp;rsquo;t create an interface for every class just because &amp;ldquo;Clean Architecture requires ports and adapters&amp;rdquo;—an interface that will only ever have one implementation is pure ceremony.&lt;/p&gt;
&lt;p&gt;The real litmus test is replaceability: could you swap your database, move from REST to GraphQL, or upgrade your framework without touching your core domain logic? His pragmatic approach is to write plain, annotation-free use cases and push Spring wiring to the outer boundary of the system. Instead of debating package names, ask whether your business rules are easy to unit-test in milliseconds, how many files break when you upgrade a framework, and whether a new teammate can tell what the system does at a glance. Start simple, keep business rules pure, and test them without mocking the entire world.&lt;/p&gt;
&lt;h2 id="the-third-golden-age-of-software-engineering--thanks-to-ai"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-third-golden-age-of-software" rel="noopener noreferrer"&gt;The third golden age of software engineering – thanks to AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt; podcast, Gergely Orosz sits down with Grady Booch, co-creator of UML and Chief Scientist for Software Engineering at IBM. Booch divides the history of computing into three &amp;ldquo;golden ages&amp;rdquo;: the first revolved around algorithms (1940s to 1970s), the second around object-oriented abstractions (1970s to 2000s), and the third—which we are in today—around systems of systems. In his view, this third age began when our unit of abstraction rose to entire libraries, frameworks, and platforms, well before the current AI wave. He reminds listeners that existential dread in software is nothing new: when compilers and high-level languages first appeared, assembly programmers feared they would be replaced, yet the profession evolved and expanded. AI coding tools simply raise the level of abstraction one step further; as he puts it, &amp;ldquo;tools change, the problems remain the same.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Booch notes that today&amp;rsquo;s AI models are trained primarily on problems that have already been solved thousands of times, making them great at automating familiar patterns like web CRUD apps while the true frontier of computing remains vast. When the industry moves at breakneck speed, strong fundamentals become more important, not less. He does acknowledge that routine software delivery plumbing is the easiest target for automation, meaning engineers in purely mechanical roles will need to upskill. His closing message: this is a moment to soar, not to fear the abyss.&lt;/p&gt;
&lt;h2 id="ai-coding-workflow"&gt;&lt;a href="https://newsletter.systemdesign.one/p/ai-coding-workflow" rel="noopener noreferrer"&gt;AI coding workflow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this guest post for &lt;em&gt;The System Design Newsletter&lt;/em&gt;, Louis-François Bouchard shares the workflow he uses to get reliable results from AI coding tools after realizing AI is not a &amp;ldquo;vending machine&amp;rdquo; where you paste a bug and get working production code out. His core mental model: treat AI like a brilliant new teammate who joined your project five minutes ago—it types fast and knows every language, but has zero awareness of your architecture, conventions, or constraints unless you tell it. AI works best inside a tight six-step loop: Context (supplying the README, rules files like &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;CLAUDE.md&lt;/code&gt;, relevant files, and stack traces or logs), Plan (asking for a strategy before any code is written, because fixing a plan is much cheaper than debugging code), Code (making small, incremental changes that are easy to review), Review, Test, and Iterate.&lt;/p&gt;
&lt;p&gt;He also uses a lightweight multi-agent pattern with four distinct roles: a Planner to break down tasks and spot edge cases, an Implementer to write code strictly following the approved plan, a Tester to write unit and edge-case tests, and an Explainer to summarize what changed and why. He pairs a strong reasoning model for planning with a faster model for implementation. The post also catalogs common failure modes like context drift in long chats, hallucinated or outdated APIs, debugging death spirals, gradual codebase rot, and over-reliance on AI. The overarching rule: treat AI output as a first draft, and always rely on human review and automated tests as your safety net.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/625a6789-c32d-4a27-a5f5-c174fb920637_2360x2960.png" alt="Git pull vs. git fetch"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-Lov!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fcf928dd3-de16-4605-a702-762df269c9f2_2250x2862.png" alt="Top Authentication Techniques"&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 #81</title><link>https://miti99.com/en/post/2026/02/18/</link><pubDate>Wed, 18 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/18/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #81.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="java-interview-question---why-you-should-not-use-static-initializers"&gt;&lt;a href="https://javabulletin.substack.com/p/java-interview-question-why-you-should" rel="noopener noreferrer"&gt;Java Interview Question - Why you should not use static initializers?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains why you should avoid static initializer blocks (&lt;code&gt;static { ... }&lt;/code&gt;) in Java, even though they look convenient for setting up complex static state. The biggest hazard is that a static block runs when the JVM initializes the class (the first time an instance is created, a static method is called, or a non-constant static field is accessed): if it throws an uncaught exception, the JVM wraps it in an &lt;code&gt;ExceptionInInitializerError&lt;/code&gt; and marks the class as permanently unusable, causing subsequent accesses and dependent classes to fail in a cascade that is notoriously painful to debug. Static blocks also execute implicitly at times developers rarely control, hiding side effects. Worse, when multiple classes have interdependent static blocks, initialization order depends on whichever class happens to be touched first at runtime rather than clear application logic, breeding subtle order-dependent bugs.&lt;/p&gt;
&lt;p&gt;Instead, the author recommends lazy initialization or constructor-based dependency injection so initialization happens explicitly when needed. That allows exceptions to be handled gracefully, prevents the application from crashing at startup over an unused class, makes unit testing much easier, and keeps code clear and maintainable.&lt;/p&gt;
&lt;h2 id="how-to-write-high-performance-code"&gt;&lt;a href="https://blog.bytebytego.com/p/how-to-write-high-performance-code" rel="noopener noreferrer"&gt;How to Write High-Performance Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteGo article distills foundational principles for writing high-performance code without requiring deep systems expertise, starting with building intuition for where performance actually matters—typically just ~3% of a codebase. The first skill is back-of-the-envelope cost estimation before writing code: CPU cache accesses take nanoseconds, RAM is roughly 100x slower, SSD reads are 40,000x slower, and network calls are slower still. For example, processing one million records with a separate 50 ms database round-trip per record would take nearly 14 hours, whereas batching 1,000 records per query brings total time down to about 50 seconds. The golden rule is to measure first and optimize second, since human intuition about bottlenecks is frequently wrong; always profile against realistic workloads.&lt;/p&gt;
&lt;p&gt;Algorithmic improvements yield the largest speedups—often 10x to 100x: finding common elements between two 1,000-item lists with nested loops takes a million comparisons (&lt;code&gt;O(N²)&lt;/code&gt;), while loading one list into a hash set takes just ~1,000 lookups (&lt;code&gt;O(N)&lt;/code&gt;). Memory layout matters just as much: data accessed together should sit contiguously in memory, which is why arrays usually outperform linked lists by making full use of CPU cache lines. Finally, the post recommends minimizing memory allocations, pre-allocating container capacity, pooling and reusing objects, adding fast paths for common cases, and eliminating unnecessary work altogether.&lt;/p&gt;
&lt;h2 id="introducing-moltworker-a-self-hosted-personal-ai-agent-minus-the-minis"&gt;&lt;a href="https://blog.cloudflare.com/moltworker-self-hosted-ai-agent/" rel="noopener noreferrer"&gt;Introducing Moltworker: a self-hosted personal AI agent, minus the minis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare introduces Moltworker, a way to run Moltbot (the open-source personal AI assistant, renamed OpenClaw in January 2026) entirely on Cloudflare&amp;rsquo;s platform instead of buying a dedicated Mac mini. The architecture consists of an entrypoint Worker acting as an API router and proxy alongside adapted scripts, all protected behind Cloudflare Access. Under the hood, the Sandbox SDK provides isolated containers to run Moltbot&amp;rsquo;s native runtime with a clean API for command execution and lifecycle management; Browser Rendering provides a headless Chromium instance accessed via a thin Chrome DevTools Protocol proxy so the agent can browse the web, fill out forms, and take screenshots; and R2 stores session state and conversation history, mounted as a filesystem volume so data persists across ephemeral container restarts.&lt;/p&gt;
&lt;p&gt;AI Gateway sits between the agent and model providers, supporting Bring Your Own Key (BYOK) or Unified Billing while centralizing cost tracking and logs. Zero Trust Access protects the API and admin UI with custom authentication policies, automatically issuing JWTs validated on every request. Because Cloudflare Workers now offer deep Node.js compatibility (Cloudflare tested the top 1,000 npm packages and found only 15 incompatible after excluding build tools, CLIs, and browser-only packages), most logic can run directly on Workers. The source code is open-sourced on GitHub, and Cloudflare notes that Moltworker is a proof-of-concept demonstrating that their developer platform can host complex, stateful AI agents without dedicated hardware.&lt;/p&gt;
&lt;h2 id="building-a-high-performance-rotating-bloom-filter-in-java"&gt;&lt;a href="https://medium.com/@udaysagar.2177/building-a-high-performance-rotating-bloom-filter-in-java-a9e75de993bf" rel="noopener noreferrer"&gt;Building a High-Performance Rotating Bloom Filter in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uday Sagar walks through building a rotating Bloom filter in his open-source Java library to answer &amp;ldquo;have I seen this element recently?&amp;rdquo; over an unbounded data stream while keeping memory usage strictly bounded. Instead of a single fixed-capacity filter whose false-positive rate climbs toward 100% as it fills up, a rotating Bloom filter partitions stream data into time windows and automatically expires old windows (based on first-insertion time rather than LRU), making it ideal for stream deduplication. For lock-free concurrent writes, threads set bits using Compare-And-Swap (&lt;code&gt;CAS&lt;/code&gt;) loops on an &lt;code&gt;AtomicLongArray&lt;/code&gt; and retry on contention; because bits are spread across millions of positions, collisions are rare, yielding 3–4x higher throughput than lock-based synchronization. When a time window expires, the active filter is copied into an immutable &lt;code&gt;long[]&lt;/code&gt; array for faster reads, forming a chain &lt;code&gt;[ReadOnly-1, ReadOnly-2, ReadOnly-3, Active]&lt;/code&gt;: writes go exclusively to &lt;code&gt;Active&lt;/code&gt;, while reads check from newest to oldest.&lt;/p&gt;
&lt;p&gt;To prevent lost writes when a thread is mid-write as a window rotates, the write path acquires the read lock of a &lt;code&gt;ReentrantReadWriteLock&lt;/code&gt; while the rare rotation step acquires the write lock, leaving queries completely lock-free. Across &lt;em&gt;N&lt;/em&gt; independent windows, the cumulative false-positive rate compounds as &lt;code&gt;1 - (1 - p)^N&lt;/code&gt;, so five windows configured at 1% each produce nearly a 5% overall false-positive rate; configuring per-window rates lower balances retention duration against accuracy. Combined with double hashing and &lt;code&gt;xxHash&lt;/code&gt;, the library achieves millions of operations per second.&lt;/p&gt;
&lt;h2 id="what-every-java-developer-should-know-about-thread-pools"&gt;&lt;a href="https://dev.to/realnamehidden1_61/what-every-java-developer-should-know-about-thread-pools-4jam" rel="noopener noreferrer"&gt;What Every Java Developer Should Know About Thread Pools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article covers the essentials of thread pools in Java. The author compares spawning a brand-new OS thread for every incoming task to hiring, training, and firing a delivery driver for every single pizza order: it wastes memory and CPU and can crash your server under a traffic spike. A thread pool managed via &lt;code&gt;ExecutorService&lt;/code&gt; maintains a steady pool of worker threads for reuse, bounding the maximum thread count, cutting latency because threads are already warm, and providing a clean API for delayed or periodic scheduling. The post reviews four main flavors: &lt;code&gt;FixedThreadPool&lt;/code&gt; for predictable workloads, &lt;code&gt;CachedThreadPool&lt;/code&gt; which spawns threads on demand and reuses them for short-lived tasks, &lt;code&gt;ScheduledThreadPool&lt;/code&gt; for delayed or recurring jobs, and Java 21&amp;rsquo;s Virtual Threads (&lt;code&gt;newVirtualThreadPerTaskExecutor()&lt;/code&gt;), which run millions of concurrent blocking tasks with minimal overhead.&lt;/p&gt;
&lt;p&gt;On best practices, always shut pools down cleanly (using &lt;code&gt;try-with-resources&lt;/code&gt; in Java 19+), as forgetting to shut down an &lt;code&gt;ExecutorService&lt;/code&gt; is a classic source of memory and thread leaks. For CPU-bound workloads, size the pool to the number of CPU cores; for I/O-bound workloads like database or API calls, use virtual threads. Always give threads meaningful names via a custom &lt;code&gt;ThreadFactory&lt;/code&gt; to make stack traces and thread dumps readable, and avoid &lt;code&gt;newCachedThreadPool()&lt;/code&gt; behind public APIs where a sudden traffic burst can spawn unbounded OS threads.&lt;/p&gt;
&lt;h2 id="goodbye-java-hello-go"&gt;&lt;a href="https://wso2.com/library/blogs/goodbye-java-hello-go" rel="noopener noreferrer"&gt;Goodbye Java, Hello Go!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WSO2, the 20-year-old enterprise middleware company whose server-side codebase was roughly 95% Java, announced it is moving to Go for its next generation of products. The primary driver is how cloud infrastructure has changed: in the container era, servers no longer run continuously for months—they spin up, handle traffic, and scale down, while middleware is increasingly embedded as a library inside a single process. Java&amp;rsquo;s post-startup JIT warmup model is a poor fit for ephemeral containers, startup times are measured in seconds rather than milliseconds, and its heavy ecosystem bloats memory and CPU footprints, driving up cloud bills. In WSO2&amp;rsquo;s view, GraalVM native images and Project Loom are band-aids on a language and runtime designed for a different era.&lt;/p&gt;
&lt;p&gt;WSO2 also evaluated Rust but concluded they didn&amp;rsquo;t need it: Rust shines for OS kernels, browsers, and low-level systems software, whereas WSO2 builds API gateways and identity platforms much higher up the stack. Go hits the sweet spot with efficient memory management, pragmatic concurrency primitives, and straightforward cross-compilation to native binaries, backed by a proven track record in cloud-native infrastructure (Kubernetes, Docker), rich libraries, and a large talent pool. The company has already used Go for nearly a decade across projects like OpenChoreo, the Ballerina compiler rewrite, and its Thunder identity platform. Existing Java products will continue to be supported indefinitely.&lt;/p&gt;
&lt;h2 id="tbm-399-10-prioritization-traps"&gt;&lt;a href="https://cutlefish.substack.com/p/tbm-399-10-prioritization-traps" rel="noopener noreferrer"&gt;TBM 399: 10 Prioritization Traps&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;John Cutler shares 10 product prioritization traps, each named after a classic song; the goal isn&amp;rsquo;t making perfect decisions, but making &amp;ldquo;good enough&amp;rdquo; decisions while avoiding catastrophic ones. &amp;ldquo;Burning Down the House&amp;rdquo; is constantly chasing urgent, low-value fires; combat it by ring-fencing 10–20% of capacity for preventative work. &amp;ldquo;Too Much Time on My Hands&amp;rdquo; is over-polishing medium-value work instead of finding the 80/20 cut; force yourself to define the smallest version shippable in 2–4 weeks. &amp;ldquo;Everybody Wants to Rule the World&amp;rdquo; is when everything is labeled &amp;ldquo;top priority&amp;rdquo; and nothing gets dropped; explicitly name one effort that is allowed to slip. &amp;ldquo;Just Enough Is Never Enough&amp;rdquo; is shipping fast MVPs that only capture 20% of the value before moving on; pre-approve a follow-on investment tranche up front. &amp;ldquo;Running on Empty&amp;rdquo; is letting long projects drift without kill signals; set explicit re-commitment checkpoints.&lt;/p&gt;
&lt;p&gt;&amp;ldquo;Dreamer&amp;rdquo; is open-ended innovation work with no forcing function; add a hard constraint like a live customer demo or integration deadline. &amp;ldquo;Slow Ride&amp;rdquo; is ignoring internal developer friction; measure wasted time as cost of delay. &amp;ldquo;Someday Never Comes&amp;rdquo; is deferring high-upside bets forever due to low confidence; run cheap, failure-tolerant experiments to buy information. &amp;ldquo;The Logical Song&amp;rdquo; is ignoring the cost of increasing confidence; always ask, &amp;ldquo;What is the cheapest way to raise our confidence?&amp;rdquo; Finally, &amp;ldquo;Takin&amp;rsquo; Care of Business&amp;rdquo; is when blocked teams invent busywork to stay utilized; maintain a small, well-vetted queue of high-value fallback tasks instead.&lt;/p&gt;
&lt;h2 id="assessing-internal-quality-while-coding-with-an-agent"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/ccmenu-quality.html" rel="noopener noreferrer"&gt;Assessing internal quality while coding with an agent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on Martin Fowler&amp;rsquo;s site, Erik Doernenburg recounts using AI coding agents to add GitLab support to CCMenu, a macOS Swift menu-bar app that displays CI/CD build status. He tested Windsurf with Claude Sonnet 3.5 and later Claude Code with Sonnet 4.5, focusing on an under-discussed dimension: the internal code quality of AI-generated code. The most telling issue occurred when the agent declared the API token parameter on wrapper functions as a non-optional &lt;code&gt;String&lt;/code&gt;, even though the underlying &lt;code&gt;makeRequest&lt;/code&gt; helper accepted an optional &lt;code&gt;String?&lt;/code&gt;; when a caller needed to pass an optional token, the agent patched the call site with &lt;code&gt;apiToken ?? &amp;quot;&amp;quot;&lt;/code&gt; instead of fixing the wrapper&amp;rsquo;s signature—unidiomatic Swift that erased the type system&amp;rsquo;s distinction between &amp;ldquo;no token&amp;rdquo; and an empty string. Beyond that, the agent proposed unnecessary caching, failed to notice fundamental API differences between GitHub and GitLab and wrote convoluted logic for a non-existent problem, duplicated URL-building logic instead of reusing an existing helper, and spun its wheels trying to fetch avatar URLs that lived on a separate endpoint.&lt;/p&gt;
&lt;p&gt;Doernenburg concludes that AI agents naturally gravitate toward accumulating technical debt, making future changes harder for both humans and agents alike. With Windsurf and Sonnet 3.5, the constant supervision required made it not worth the trouble; Claude Code with Sonnet 4.5 was a marked improvement, needing far less hand-holding and proving good enough for regular use. Even so, actively guarding internal code quality remains essential for sustainable software development.&lt;/p&gt;
&lt;h2 id="a"&gt;&lt;a href="https://www.jtolio.com/2026/01/tinyemu-go/" rel="noopener noreferrer"&gt;A &amp;ldquo;Pure Go&amp;rdquo; Linux environment, ported by Claude, inspired by Fabrice Bellard&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;JT Olio recounts using Claude to port Fabrice Bellard&amp;rsquo;s TinyEMU RISC-V emulator from C to pure Go. The result is a pure-Go Linux environment complete with VirtIO devices, filesystem mounting, and networking: a simple &lt;code&gt;go run&lt;/code&gt; boots a Linux environment with root access inside the emulator, requiring no host privileges or containers and running anywhere Go compiles. The first 80% was exhilarating as Claude rapidly translated the foundational subsystems, but the final 20% was grueling: Linux booted the kernel yet failed to mount the &lt;code&gt;initrd&lt;/code&gt;, the project stalled for weeks, and the author lacked mental context because he hadn&amp;rsquo;t written the code himself. Claude repeatedly drifted from instructions, inventing &amp;ldquo;better&amp;rdquo; error handling or ignoring directives to preserve exact C behavior, forcing the author to switch to batch-by-batch function audits cross-referenced against the original C source. He also found the popular agent task tracker Beads overly bloated (294k lines of Go, 128 MB repo) and recommends the lightweight &lt;code&gt;ticket&lt;/code&gt; CLI instead.&lt;/p&gt;
&lt;p&gt;His hard-won lessons for agentic coding: break work into the smallest, most concrete tickets possible; enforce strict commit and test-coverage gates; clear the agent&amp;rsquo;s context window frequently; require the agent to file tickets for any follow-up work or behavioral deviations it encounters; and never expect a cohesive architecture or clean internal API to emerge organically across sessions. The project left him simultaneously impressed and more cautious about LLM coding: writing code by hand is less frustrating and yields higher quality, but at lower throughput; succeeding with Claude means treating it like an eager junior developer who needs tight supervision.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F36412c2b-8782-476e-9db4-aaf794629b74_2250x2624.png" alt="How to Scale An API"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4V7B!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc9589feb-6f59-4971-9da4-26712d1a2ca1_2360x2960.png" alt="HTTP/2 over TCP vs HTTP/3 over QUIC"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ihnd!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ffe954900-e8d8-40d0-a4b1-2f8e14068882_2360x2960.png" alt="How Git Really Stores Your Data"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5SHy!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fcbddfb5f-a652-4749-b0b9-210102774f4f_2360x2960.png" alt="How NAT Works"&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 #80</title><link>https://miti99.com/en/post/2026/02/03/</link><pubDate>Tue, 03 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #80.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-agent-skills-directory"&gt;&lt;a href="https://www.skills.sh/" rel="noopener noreferrer"&gt;The Agent Skills Directory&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Skills.sh is an open directory of reusable skills for AI coding agents. Each skill packages procedural knowledge for a specific domain—such as UI design workflows, React and Next.js best practices, code review checklists, or debugging playbooks—and can be installed into an agent with a single command (&lt;code&gt;npx skills add ...&lt;/code&gt;). Instead of figuring out workflows from scratch on every session, agents gain instant access to standardized, battle-tested instructions.&lt;/p&gt;
&lt;p&gt;The site features a leaderboard ranked by total installs alongside 24-hour trending and rising categories, making it easy to discover skills for your stack. It is a community-driven ecosystem where anyone can publish and share skills alongside official skill packs from companies like Vercel, Anthropic, Expo, and Supabase. For developers getting started with coding agents, it offers a convenient way to equip agents with capabilities spanning coding, testing, deployment, and operations.&lt;/p&gt;
&lt;h2 id="results-from-the-2025-go-developer-survey"&gt;&lt;a href="https://go.dev/blog/survey2025" rel="noopener noreferrer"&gt;Results from the 2025 Go Developer Survey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Go team published the results of the 2025 Go Developer Survey, gathering responses from 5,379 developers. Three headline findings stood out: Go developers want more guidance on identifying and applying Go best practices, getting the most out of the standard library, and seeing more modern features in the language and toolchain; most respondents already use AI-powered coding tools to look up information or generate boilerplate, but overall satisfaction with AI tools remains lukewarm; and a surprising share of developers regularly have to look up documentation for everyday commands like &lt;code&gt;go build&lt;/code&gt;, &lt;code&gt;go run&lt;/code&gt;, and &lt;code&gt;go mod&lt;/code&gt;, highlighting room for improvement in the &lt;code&gt;go&lt;/code&gt; CLI&amp;rsquo;s built-in help system.&lt;/p&gt;
&lt;p&gt;Overall sentiment remains strong: 91% of respondents are satisfied working with Go, with nearly two-thirds &amp;ldquo;very satisfied&amp;rdquo;—a figure that has held steady since 2019. The top three pain points are writing idiomatic Go code, missing features familiar from other languages, and finding trustworthy third-party modules. On AI tooling, 53% use AI assistants daily, yet only 13% report being &amp;ldquo;very satisfied,&amp;rdquo; primarily because generated code frequently fails to compile or is low quality. CLI tools and API/RPC services remain the most common workloads, with 55% of respondents building both; over a third build cloud infrastructure tooling, and 11% work on ML models, tools, or agents. On development environments, 60% develop on macOS and 58% on Linux, while 96% deploy to Linux targets.&lt;/p&gt;
&lt;h2 id="an-honest-review-of-go"&gt;&lt;a href="https://benraz.dev/blog/golang_review.html" rel="noopener noreferrer"&gt;An Honest Review of Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming from a Rust background, the author shares his candid impressions after a few months of building small projects in Go. Go&amp;rsquo;s standout strength is concurrency: goroutines and channels are baked right into the language, are effortless to use, and avoid the &amp;ldquo;colored functions&amp;rdquo; problem (&lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; contagion) that plagues many other concurrency models. The type system is intentionally minimal with no complex inheritance hierarchies; struct embedding is essentially syntactic sugar. Because types implement interfaces implicitly without an explicit declaration, functions like &lt;code&gt;Printf&lt;/code&gt; and template libraries are easy to write without needing macros. He also appreciates Go&amp;rsquo;s clean syntax and its capitalization-based visibility rules.&lt;/p&gt;
&lt;p&gt;On the flip side, Go has notable rough edges. The language lacks true enums: the idiomatic workaround using &lt;code&gt;const&lt;/code&gt; and &lt;code&gt;iota&lt;/code&gt; doesn&amp;rsquo;t enforce a closed set of values, and &lt;code&gt;switch&lt;/code&gt; statements don&amp;rsquo;t check for exhaustiveness. Go also lacks true immutability, since &lt;code&gt;const&lt;/code&gt; only supports compile-time primitives and any exported package-level &lt;code&gt;var&lt;/code&gt; can be mutated by callers. Finally, the &lt;code&gt;error&lt;/code&gt; type is just a bare interface with an &lt;code&gt;Error() string&lt;/code&gt; method, making it easy to obscure structured failure details; even with &lt;code&gt;errors.Is&lt;/code&gt; and &lt;code&gt;errors.As&lt;/code&gt;, he finds Go&amp;rsquo;s error handling far less expressive than Rust&amp;rsquo;s enums and sum types.&lt;/p&gt;
&lt;h2 id="the-challenges-of-soft-delete"&gt;&lt;a href="https://atlas9.dev/blog/soft-delete.html" rel="noopener noreferrer"&gt;The challenges of soft delete&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Soft delete—adding an &lt;code&gt;archived_at&lt;/code&gt; or &lt;code&gt;deleted&lt;/code&gt; column to a database table—looks deceptively simple at first, but introduces compounding complexity over time. Dead data accumulates indefinitely even though 99% of archived rows are never read again; every query, view, and unique index must remember to filter out soft-deleted rows; schema migrations have to account for stale historical records; and restoring a deleted record is rarely as simple as setting &lt;code&gt;archived_at = null&lt;/code&gt; when external systems and side effects are involved.&lt;/p&gt;
&lt;p&gt;The author evaluates three PostgreSQL alternatives that separate archived data from live operational tables. First is application-level archiving: emitting a deletion event for a separate service to persist, which keeps the primary database lean but risks data loss on failure and requires extra infrastructure. Second is a &lt;code&gt;BEFORE DELETE&lt;/code&gt; database trigger that copies the deleted row into a JSONB archive table, keeping live tables clean and making retention cleanup trivial. Third is Change Data Capture (CDC) from the write-ahead log (WAL) using tools like Debezium, which requires zero application code changes but adds operational complexity and can fill up the primary server&amp;rsquo;s disk if the consumer falls behind. He also floats an untested idea of a replication follower configured to ignore &lt;code&gt;DELETE&lt;/code&gt; statements. Starting a new project today, he would pick the trigger approach because it is easy to set up, requires no extra infrastructure, and keeps archived rows queryable whenever needed.&lt;/p&gt;
&lt;h2 id="i-got-paid-minimum-wage-to-solve-an-impossible-problem"&gt;&lt;a href="https://tiespetersen.substack.com/p/i-got-paid-minimum-wage-to-solve" rel="noopener noreferrer"&gt;I got paid minimum wage to solve an impossible problem.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Computer science student Ties Petersen had a minimum-wage part-time job sweeping the floors of an Albert Heijn supermarket. Instead of just pushing a broom, he modeled the store floorplan as a grid graph, built a visual editor in Processing, and wrote a C++ route optimizer using simulated annealing with 2-opt swaps—essentially solving a variant of the Traveling Salesperson Problem. His first &amp;ldquo;optimal&amp;rdquo; route was nearly as short as mathematically possible, yet completely useless in practice because it was full of sharp zig-zag turns nobody could physically push a broom through. The algorithm did exactly what was asked; the question itself was wrong. Once he added a &amp;ldquo;turn penalty&amp;rdquo; to the cost function, the route became smooth and walkable at the cost of a slightly longer distance—tuning that penalty was all about balancing theoretical efficiency against physical reality.&lt;/p&gt;
&lt;p&gt;From there, he zooms out to the broader tech industry: social media algorithms optimize for engagement rather than human well-being, recommendation engines optimize for watch time until users spend six hours down conspiracy rabbit holes, large language models optimize for sounding confident rather than being truthful, and corporations optimize for quarterly profit while ignoring environmental and ethical externalities. His core takeaway: technical precision is meaningless if you&amp;rsquo;re solving the wrong problem, so defining what you are actually optimizing for is the most important step of all.&lt;/p&gt;
&lt;h2 id="command-completion--in-intellij-idea"&gt;&lt;a href="https://foojay.io/today/command-completion-intellij-idea/" rel="noopener noreferrer"&gt;Command completion (..) in IntelliJ IDEA&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Command completion (&lt;code&gt;..&lt;/code&gt;) is a new feature in IntelliJ IDEA that extends familiar code completion so you can discover and execute IDE actions right inside the editor without memorizing keyboard shortcuts. Typing a single dot &lt;code&gt;.&lt;/code&gt; surfaces context-aware IDE commands alongside standard API suggestions and postfix completions, while typing two dots &lt;code&gt;..&lt;/code&gt; filters the popup exclusively to IDE commands and lets you search through them. You can use it to fix errors and warnings with richer previews than &lt;code&gt;Alt+Enter&lt;/code&gt;, run file-level actions like reformatting code or optimizing imports on any blank line, generate classes, methods, fields, or &lt;code&gt;toString()&lt;/code&gt;, and convert a class into a modern Java &lt;code&gt;record&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;It also supports navigation, renaming via &lt;code&gt;..rename&lt;/code&gt;, extracting methods, introducing local variables, and adding Javadoc comments—and you can enable it in read-only files via settings to jump to implementations or find usages. Many commands include natural aliases, such as &lt;code&gt;..change name&lt;/code&gt; for &lt;code&gt;..rename&lt;/code&gt;, so you don&amp;rsquo;t need to remember exact action names. Command completion complements rather than replaces keyboard shortcuts, postfix completion, and live templates, helping you stay in flow, focus on &lt;em&gt;what&lt;/em&gt; you want to do rather than &lt;em&gt;how&lt;/em&gt; to trigger it, and discover powerful IDE features along the way.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/8d53556e-5fbc-4ceb-ac64-cc5f3b211c5d_2250x2624.png" alt="The Must-Know Fundamentals of Distributed Systems"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yb_V!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F16cec58a-02f8-4daf-8669-d1208ac5fc18_2360x2960.jpeg" alt="What Happens When You Enter Google.com"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LIIv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F631f49cf-2eff-4941-ba22-b2c482eb24ec_2360x2960.png" alt="Understanding the Linux Directory Structure"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gxq4!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F11498f7e-5457-425f-9d50-90f5ebc31187_2360x2960.jpeg" alt="Symmetric vs. Asymmetric Encryption"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!XFaF!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5140ecd2-ac9e-46d1-bde6-00f727309778_800x1003.jpeg" alt="Network Troubleshooting Test Flow"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=oP6DS_x5K0Y" rel="noopener noreferrer"&gt;What Are AI Agents &amp;amp; How Do They Work?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; 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 #77</title><link>https://miti99.com/en/post/2026/01/24/</link><pubDate>Sat, 24 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #77.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="stop-forwarding-errors-start-designing-them"&gt;&lt;a href="https://fast.github.io/blog/stop-forwarding-errors-start-designing-them/" rel="noopener noreferrer"&gt;Stop Forwarding Errors, Start Designing Them&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that most Rust developers merely &amp;ldquo;forward&amp;rdquo; errors rather than truly handling them: catching an error, wrapping it thinly, and propagating it up the call stack as fast as possible. The original low-level message survives intact, but almost all higher-level context is lost. The author points out the limitations of familiar tools: &lt;code&gt;std::error::Error&lt;/code&gt; assumes a linear chain of causes via &lt;code&gt;source()&lt;/code&gt; even though real-world failures often have multiple contributing causes; stack traces are expensive, misleading in async code, and only show where an error originated rather than the logical path execution took. Meanwhile, &lt;code&gt;thiserror&lt;/code&gt; categorizes errors by origin rather than by how callers can react, &lt;code&gt;anyhow&lt;/code&gt; makes adding context optional so it is routinely skipped, and the dynamic &lt;code&gt;Provide&lt;/code&gt;/&lt;code&gt;Request&lt;/code&gt; API makes behavior hard to predict.&lt;/p&gt;
&lt;p&gt;The proposed solution is to design errors for two distinct audiences. For machines, use a flat error struct categorized by error kind (similar to Apache OpenDAL&amp;rsquo;s design) with explicit retryability status—such as permanent, temporary, or persistent—so code can decide whether to retry or abort without walking nested error chains. For humans, use tree-structured context tracking that automatically records call sites via &lt;code&gt;#[track_caller]&lt;/code&gt; at near-zero cost and enforces adding context across module boundaries through the type system (as in the &lt;code&gt;exn&lt;/code&gt; crate). The guiding question when designing errors should be: &amp;ldquo;If the system breaks at 3 a.m., what do you want the logs to say?&amp;rdquo;&lt;/p&gt;
&lt;h2 id="clock-synchronization-is-a-nightmare"&gt;&lt;a href="https://arpitbhayani.me/blogs/clock-sync-nightmare/" rel="noopener noreferrer"&gt;Clock Synchronization Is a Nightmare&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains why synchronizing time across distributed systems is far harder than intuition suggests: there simply is no &amp;ldquo;global clock.&amp;rdquo; Every computer keeps time using a quartz crystal oscillating at 32,768 Hz, but manufacturing tolerances and temperature swings cause clocks to drift; two machines started at the exact same instant can drift hundreds of milliseconds apart after a single day. Instantaneous clock skew between two machines leads to subtle bugs: in a distributed &lt;code&gt;make&lt;/code&gt; build, a compiled object file can appear newer than a freshly edited source file and fail to recompile; in banking, a withdrawal timestamped earlier than a preceding deposit can make an account appear overdrawn.&lt;/p&gt;
&lt;p&gt;Physical clock synchronization techniques include Cristian&amp;rsquo;s algorithm (estimating one-way network delay as half the round-trip time), the Berkeley algorithm (averaging time across nodes and sending relative adjustments), hierarchical NTP backed by atomic or GPS clocks (achieving millisecond accuracy over the internet), and PTP using hardware timestamping on network interface cards for sub-microsecond accuracy. Google Spanner&amp;rsquo;s TrueTime returns a bounded uncertainty interval &lt;code&gt;[earliest, latest]&lt;/code&gt; instead of a single point in time. Logical clocks include Lamport Timestamps, Vector Clocks that capture causality rather than wall-clock time, and Hybrid Logical Clocks (used in CockroachDB) that combine both. The takeaway: there is no perfect clock sync, only trade-offs between accuracy, latency, and complexity depending on your system&amp;rsquo;s needs.&lt;/p&gt;
&lt;h2 id="java---learning-roadmap"&gt;&lt;a href="https://nemorize.com/roadmaps/java" rel="noopener noreferrer"&gt;Java - Learning Roadmap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a structured Java learning roadmap on the Nemorize platform that guides learners from foundational setup through enterprise application development. It begins with prerequisites like basic Linux, Git version control, and choosing an IDE, then moves into object-oriented programming (classes, objects, inheritance, polymorphism, encapsulation, abstraction), and covers core language features including the Collections Framework, exception handling, and Streams. Advanced topics include concurrency and multithreading, JVM internals, design patterns, and Dependency Injection.&lt;/p&gt;
&lt;p&gt;The final sections focus on professional engineering skills: testing (unit, integration, contract), build tools like Maven and Gradle, working with databases, Spring Boot for enterprise applications, and principles like Clean Code, SOLID, API design, and system monitoring. Each topic follows a three-step loop: read the lesson, practice with quizzes, and track progress (requires sign-in). At the time of writing, roughly 14 of the 44 topics have full lessons available with the rest being added progressively, making it a useful reference roadmap for beginners wondering what order to learn Java in.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-successfully-adopting-kotlin-in-a-java-dominated-environment"&gt;&lt;a href="https://blog.jetbrains.com/kotlin/2025/12/the-ultimate-guide-to-successfully-adopting-kotlin-in-a-java-dominated-environment/" rel="noopener noreferrer"&gt;The Ultimate Guide to Successfully Adopting Kotlin in a Java-Dominated Environment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;JetBrains&amp;rsquo; guide frames introducing Kotlin into a predominantly Java organization not as flipping a switch or rewriting everything from scratch, but as a challenge of people, timing, risk management, and trust. The roadmap spans five stages. First, get comfortable with Kotlin in test suites (using Kotest and MockK) where production isn&amp;rsquo;t at risk, answering the question, &amp;ldquo;Is this language genuinely nicer to work with?&amp;rdquo; Next, evaluate Kotlin in real production work by building a small new service or adding a Kotlin module to an existing system while avoiding the trap of &amp;ldquo;writing Java in Kotlin syntax&amp;rdquo;: use extension functions instead of static utility classes, nullable types instead of &lt;code&gt;Optional&lt;/code&gt;, and data classes instead of boilerplate POJOs.&lt;/p&gt;
&lt;p&gt;Stage three is building internal momentum through short demos, starter template repositories, and pair programming. Stage four is making the business case to management: less code to maintain, fewer bugs thanks to null safety, 100% Java interoperability so no big-bang rewrite is required, and predictable ramp-up costs. Finally, when scaling adoption across the organization, treat each system according to its lifecycle: leave sunsetting applications alone, default to Kotlin for greenfield projects, and migrate active systems incrementally with the help of IDE conversion tools, JSpecify nullability annotations, and AI-assisted refactoring.&lt;/p&gt;
&lt;h2 id="rust-vs-go"&gt;&lt;a href="https://bitfieldconsulting.com/posts/rust-vs-go" rel="noopener noreferrer"&gt;Rust vs Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;John Arundel compares Rust and Go across performance, simplicity, safety, features, scalability, and concurrency, summing up the trade-off in a single phrase: &amp;ldquo;Rust for high stakes, Go for low cost.&amp;rdquo; Both are compiled languages that produce small, fast native binaries and come with great built-in tooling (&lt;code&gt;gofmt&lt;/code&gt;, &lt;code&gt;rustfmt&lt;/code&gt;). Their difference lies in philosophy: Go is a small, easy-to-learn, fast-compiling garbage-collected language that prioritizes developer velocity and stability, with goroutines and channels making concurrency remarkably approachable. Rust prioritizes correctness, peak performance, and low-level control, using its borrow checker to eliminate memory bugs at compile time without a garbage collector, at the cost of a steeper learning curve.&lt;/p&gt;
&lt;p&gt;For error handling, Go uses explicit &lt;code&gt;if err != nil&lt;/code&gt; checks, while Rust uses &lt;code&gt;Option&lt;/code&gt;/&lt;code&gt;Result&lt;/code&gt; types paired with the &lt;code&gt;?&lt;/code&gt; operator. Go shines when fast onboarding, rapid prototyping, and cost-effective delivery matter most—such as web services, microservices, infrastructure tooling, and business automation. Rust shines when reliability, predictable latency, and resource efficiency are mission-critical—such as automotive, aerospace, medical devices, and industrial systems. He views the two languages as complementary tools rather than rivals, and to the question &amp;ldquo;Should I learn Rust or Go?&amp;rdquo;, his answer is: learn both.&lt;/p&gt;
&lt;h2 id="the-most-popular-go-dependency-is"&gt;&lt;a href="https://blog.thibaut-rousseau.com/blog/the-most-popular-go-dependency-is/" rel="noopener noreferrer"&gt;The most popular Go dependency is…&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thibaut Rousseau sets out to find the most depended-upon library in the Go ecosystem by tapping into Go&amp;rsquo;s centralized module proxy infrastructure. Instead of cloning individual repositories, he downloaded the full module index from &lt;code&gt;index.golang.org&lt;/code&gt; (listing every module version published since the Go proxy launched in 2019), fetched each module&amp;rsquo;s &lt;code&gt;go.mod&lt;/code&gt; file via &lt;code&gt;proxy.golang.org&lt;/code&gt; to extract its dependencies, and loaded everything into a Neo4j graph database. The resulting graph contains roughly 40 million nodes and 400 million relationships, averaging about 10 direct dependencies per module version node in the dataset.&lt;/p&gt;
&lt;p&gt;Topping the leaderboard is &lt;code&gt;testify&lt;/code&gt; with 259,237 dependent modules, far ahead of the runners-up: &lt;code&gt;google/uuid&lt;/code&gt; (104,877), &lt;code&gt;golang.org/x/crypto&lt;/code&gt; (100,633), &lt;code&gt;grpc&lt;/code&gt; (97,228), &lt;code&gt;cobra&lt;/code&gt; (93,062), &lt;code&gt;pkg/errors&lt;/code&gt; (92,491), &lt;code&gt;golang.org/x/net&lt;/code&gt;, &lt;code&gt;protobuf&lt;/code&gt;, &lt;code&gt;logrus&lt;/code&gt;, and &lt;code&gt;viper&lt;/code&gt;. Testing and utility libraries dominate the list, alongside Go&amp;rsquo;s extended standard library packages (&lt;code&gt;golang.org/x/&lt;/code&gt;). Notably, even though &lt;code&gt;pkg/errors&lt;/code&gt; has been deprecated and archived for years, version &lt;code&gt;v0.9.1&lt;/code&gt; alone still had 16,001 transitive dependents in 2025. The post also demonstrates how to query Neo4j with Cypher to trace direct and transitive dependencies, showing how naturally graph databases fit dependency analysis. He shares the dataset dump via BitTorrent so the community can run their own queries and plans to enrich it with metadata like GitHub stars.&lt;/p&gt;
&lt;h2 id="gosum-is-not-a-lockfile"&gt;&lt;a href="https://words.filippo.io/gosum/" rel="noopener noreferrer"&gt;go.sum Is Not a Lockfile&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Filippo Valsorda clears up a widespread misconception: many developers treat &lt;code&gt;go.sum&lt;/code&gt; as a lockfile analogous to Node&amp;rsquo;s &lt;code&gt;package-lock.json&lt;/code&gt; or Rust&amp;rsquo;s &lt;code&gt;Cargo.lock&lt;/code&gt;, when in reality &lt;code&gt;go.sum&lt;/code&gt; is merely a local cache of the Go Checksum Database—a lookup table mapping module versions to their cryptographic hashes. Versions listed in &lt;code&gt;go.sum&lt;/code&gt; may or may not actually be used in a build, and the file plays zero role in version resolution; in the original Go modules design, it wasn&amp;rsquo;t even enabled by default because it has no effect on build selection. The sole purpose of &lt;code&gt;go.sum&lt;/code&gt; is security: the Checksum Database ensures the entire ecosystem receives identical bytes for a given module version, and &lt;code&gt;go.sum&lt;/code&gt; makes that guarantee work locally and offline.&lt;/p&gt;
&lt;p&gt;The file you actually want to look at is &lt;code&gt;go.mod&lt;/code&gt;, which serves as both manifest and lockfile. Since Go 1.17 (August 2021), &lt;code&gt;go.mod&lt;/code&gt; records every transitive dependency needed to build the main module and run its tests, pinned to exact versions in a single human-readable file. Combined with Minimal Version Selection (MVS), this lets Go avoid diamond dependency conflicts, prevents accidentally relying on features from newer transitive versions than declared, and never silently pulls the latest (potentially compromised) version of a package when adding a new dependency—all while making dependency resolution so fast that nobody even notices it. To analyze a Go dependency graph, parse &lt;code&gt;go.mod&lt;/code&gt; using &lt;code&gt;golang.org/x/mod/modfile&lt;/code&gt; or &lt;code&gt;go mod edit -json&lt;/code&gt;, and never parse &lt;code&gt;go.sum&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="forgejo-actions-notification-development"&gt;&lt;a href="https://chris-besch.com/articles/forgejo_actions_notification/" rel="noopener noreferrer"&gt;Forgejo Actions Notification Development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christopher Besch shares his experience contributing to Forgejo, a self-hosted software forge similar to GitHub and GitLab. He needed email and webhook notifications when CI workflows failed—a feature Forgejo lacked—so he built it himself. The post explains how Go projects organize code into modules (via &lt;code&gt;go.mod&lt;/code&gt;) and packages without a central registry like npm, then walks through Forgejo&amp;rsquo;s layered architecture consisting of &lt;code&gt;/routers&lt;/code&gt; (APIs and web UI), &lt;code&gt;/services&lt;/code&gt; (business logic), &lt;code&gt;/models&lt;/code&gt; (database access), and &lt;code&gt;/modules&lt;/code&gt; (self-contained utilities), where lower layers are forbidden from importing higher layers. To avoid circular dependencies, Forgejo uses a publish–subscribe pattern in &lt;code&gt;forgejo.org/services/notify&lt;/code&gt;: packages publish events to a topic, and interested packages subscribe to it.&lt;/p&gt;
&lt;p&gt;He split the feature across four pull requests to keep reviews manageable: PR #7510 moved code from &lt;code&gt;/models/actions&lt;/code&gt; to &lt;code&gt;/services/actions&lt;/code&gt; to respect architectural boundaries, PR #7491 added an &lt;code&gt;ActionRunNowDone&lt;/code&gt; hook to the pub-sub notifier, PR #7509 subscribed the mailer service to send emails when workflows fail or recover, and PR #7508 added webhook delivery. He also recounts having to rename a struct due to a merge conflict with a parallel PR. The final section walks through setting up a local development environment: compiling Forgejo with debug symbols, running the Forgejo Runner, spinning up a MailDev SMTP server in Docker, writing a tiny Node.js webhook receiver script, and running unit tests, integration tests, and the Delve debugger. His takeaway: thorough tests are the key to earning maintainers&amp;rsquo; trust in your contributions.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F3ec94ed4-46b2-40bd-8d28-a25fdde639c8_2250x2624.png" alt="Message Brokers 101"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!hXRV!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe99863c7-7ab7-4f61-9961-af7e4c6ee64f.png" alt="Cloud Load Balancer Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!XvtW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1ded3402-4eb5-4818-861f-7661f1cefe82.tif" alt="How CQRS Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SUjA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd91a5538-a69e-468c-bf83-058bb78753ca_2360x2770.png" alt="How does Docker Work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4qBZ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff0945414-9cea-4e64-8dd4-3abcc404f73e_2360x2960.png" alt="Containerization Explained: From Build to Runtime"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!n8BK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa51a75cc-09a9-4fed-af8a-c32a64f8ab60_2250x2624.png" alt="Must-Know Message Broker Patterns"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #73</title><link>https://miti99.com/en/post/2025/12/20/</link><pubDate>Sat, 20 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/20/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I recently learned that &lt;a href="https://openrouter.ai/docs/guides/guides/claude-code-integration" rel="noopener noreferrer"&gt;OpenRouter now supports Claude Code integration&lt;/a&gt;, so I&amp;rsquo;m giving it a try today. This post was generated using &lt;a href="https://claude.com/product/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt; + &lt;a href="https://openrouter.ai/" rel="noopener noreferrer"&gt;Open Router&lt;/a&gt; + &lt;a href="https://openrouter.ai/z-ai/glm-4.5-air:free" rel="noopener noreferrer"&gt;Z.AI: GLM 4.5 Air (free)&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #73.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="system-design-deep-dive-time-series-databases-tsdbs-explained"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-deep-dive-time-series" rel="noopener noreferrer"&gt;System Design Deep Dive: Time Series Databases (TSDBs) Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Time series databases (TSDBs) are purpose-built for data that streams in continuously in chronological order, such as IoT sensor readings, application logs, or server monitoring metrics. Every measurement is stored with a timestamp, making it straightforward to track fluctuations and spot trends. The article highlights three core characteristics: efficient data compression using delta encoding and run-length encoding to exploit repeating patterns; automated data lifecycle management through retention policies (deleting or archiving old data) and downsampling (aggregating older data into coarser intervals like hourly averages); and fast time-range queries because time serves as the primary index, with many systems able to query compressed data directly.&lt;/p&gt;
&lt;p&gt;Compared with relational databases, TSDBs excel at high-frequency writes and aggregations over long time windows—such as &amp;ldquo;the per-minute average over 90 days&amp;rdquo;—thanks to columnar storage layouts, append-only writes, and time-based partitioning. Conversely, if an application requires frequent table joins or individual record updates, a relational database remains a better fit. This is handy knowledge when preparing for system design interviews.&lt;/p&gt;
&lt;h2 id="how-memory-maps-mmap-deliver-25x-faster-file-access-in-go"&gt;&lt;a href="https://info.varnish-software.com/blog/how-memory-maps-mmap-deliver-25x-faster-file-access-in-go" rel="noopener noreferrer"&gt;How Memory Maps (mmap) Deliver 25x Faster File Access in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;System calls carry kernel context-switch overhead that adds up when small operations are repeated millions of times. Author Per Buer (Varnish Software) introduces memory mapping (&lt;code&gt;mmap&lt;/code&gt;): mapping a file directly into virtual memory and reading it via pointers instead of seeking and reading with &lt;code&gt;pread()&lt;/code&gt;. In benchmarks of his Go library, random lookups dropped from 416.4 ns/op to 3.3 ns/op, and sequential iteration fell from 333.3 ns/op to 1.3 ns/op; working directly with pointers also reduces memory pressure and latency.&lt;/p&gt;
&lt;p&gt;The weakness of &lt;code&gt;mmap&lt;/code&gt; lies in writes: when writing to a page not yet in physical memory, the CPU triggers a page fault and the OS must allocate a new page and read the file contents from disk before the application can overwrite them, making performance entirely dependent on whether the page is already cached; &lt;code&gt;pwrite&lt;/code&gt; is far more predictable. That is why Varnish Cache later added a &lt;code&gt;malloc&lt;/code&gt; backend and Massive Storage Engines built on &lt;code&gt;io_uring&lt;/code&gt;. In a real-world application building an HTTP-backed filesystem, replacing CDB file reads with &lt;code&gt;mmap&lt;/code&gt; yielded 25x faster lookups.&lt;/p&gt;
&lt;h2 id="bloom-filters"&gt;&lt;a href="https://eli.thegreenplace.net/2025/bloom-filters" rel="noopener noreferrer"&gt;Bloom filters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Bloom filter is a probabilistic data structure proposed by Burton Bloom in 1970 for quickly testing whether an element belongs to a set using minimal time and memory. It acts like a probabilistic cache: if it says &amp;ldquo;no,&amp;rdquo; the element is 100% guaranteed not to be in the set; if it says &amp;ldquo;yes,&amp;rdquo; there is a small probability of a false positive. That makes Bloom filters especially effective when most queries return negative results—for example, checking whether a key exists in an on-disk file before paying the cost of reading the file. Structurally, it consists of an array of &lt;em&gt;m&lt;/em&gt; bits and &lt;em&gt;k&lt;/em&gt; hash functions: on insert, the element is hashed by all &lt;em&gt;k&lt;/em&gt; functions and the corresponding bits are set to 1; on lookup, a single 0 bit is enough to immediately conclude the element is absent.&lt;/p&gt;
&lt;p&gt;Eli Bendersky walks through a step-by-step example along with a Go implementation that uses double hashing to generate &lt;em&gt;k&lt;/em&gt; hash functions from two base hashes, plus the formulas for choosing optimal parameters: m/n ≈ -ln(ε)/ln²(2) and k = (m/n)·ln(2). For 1 billion elements and a 1% false-positive rate, the filter requires about 9.6 billion bits (roughly 1.2 GB) and 7 hash functions. Lookup cost is just &lt;em&gt;k&lt;/em&gt; bit checks—effectively constant and independent of how many elements have been inserted or the characteristics of the data.&lt;/p&gt;
&lt;h2 id="what-the-heck-is-aead-again"&gt;&lt;a href="https://ochagavia.nl/blog/what-the-heck-is-aead-again/" rel="noopener noreferrer"&gt;What the heck is AEAD again?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;AEAD (Authenticated Encryption with Associated Data) is the modern encryption standard: TLS 1.3 models all encryption algorithms as AEAD, QUIC (the foundation of HTTP/3) mandates it, and Google&amp;rsquo;s Tink library exclusively supports AEAD for data encryption. The author breaks down each part of the term. &amp;ldquo;Authenticated&amp;rdquo; means proving the ciphertext was not tampered with after encryption; previously, developers had to manually combine encryption with an HMAC step, which was notoriously error-prone (as seen in Apple&amp;rsquo;s iMessage vulnerability). Libraries like libsodium bundled both steps into a single API to make misuse much harder.&lt;/p&gt;
&lt;p&gt;&amp;ldquo;Associated Data&amp;rdquo; is unencrypted data that still needs protection against tampering. In a chat application, for example, the server needs to read &lt;code&gt;conversation_id&lt;/code&gt; in plaintext to route messages; if an attacker in the middle swaps that ID for a different conversation between the same two users and the recipient doesn&amp;rsquo;t authenticate it, the message still decrypts cleanly and gets processed in the wrong context. An AEAD API enforces simultaneous authentication of both the ciphertext and the associated data. Standardized AEAD algorithms like AES256-GCM and ChaCha20-Poly1305 are widely supported across libraries and languages; the author recommends following Tink&amp;rsquo;s guidance unless your system has specialized requirements.&lt;/p&gt;
&lt;h2 id="ceilometer-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/ceilometer-ubers-adaptive-benchmarking-framework/" rel="noopener noreferrer"&gt;Ceilometer: Uber&amp;rsquo;s Adaptive Benchmarking Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every new server SKU, OS kernel upgrade, or configuration change at Uber must be thoroughly vetted before reaching production, but their legacy process was manual, fragmented across teams, and scattered results across spreadsheets. Ceilometer was built to solve this: an adaptive benchmarking platform featuring standardized test configurations for fair comparisons, containerized benchmark suites that hardware vendors can run themselves, and context-rich reporting. Its architecture comprises distributed test orchestration on dedicated clusters, a result ingestion and normalization service, blob storage, a centralized data warehouse, and an analytics service. It supports synthetic benchmarks, stateful database benchmarks via Uber&amp;rsquo;s Odin platform, and stateless service benchmarks via Ballast.&lt;/p&gt;
&lt;p&gt;Its two primary use cases are shape qualification for new server hardware—from early vendor development through testing inside Uber&amp;rsquo;s environment—and infrastructure change verification alongside service owners to isolate, reproduce, and fix performance regressions. Ceilometer has also recently been used to validate &amp;ldquo;touchless&amp;rdquo; upgrades from cloud providers. Future directions include deeper AI/ML integration, broader ecosystem support, advanced anomaly detection, and component-level utilization metrics.&lt;/p&gt;
&lt;h2 id="useful-patterns-for-building-html-tools"&gt;&lt;a href="https://simonwillison.net/2025/Dec/10/html-tools/" rel="noopener noreferrer"&gt;Useful patterns for building HTML tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison uses the term &amp;ldquo;HTML tools&amp;rdquo; for small single-file applications that bundle HTML, JavaScript, and CSS together; over the past two years he has built more than 150 of them, mostly written by LLMs. This post distills design patterns from that experience: keep each tool in a single file, avoid React or build steps, and load dependencies from CDNs; prototype quickly in Artifacts or Canvas before moving to a coding agent as the project grows more complex; and self-host your tools rather than leaving them on LLM platforms that run inside restrictive sandboxes.&lt;/p&gt;
&lt;p&gt;On the technical side, he recommends using copy-and-paste as a primary I/O channel, storing state in the URL for easy sharing, using &lt;code&gt;localStorage&lt;/code&gt; for API keys or larger state, collecting CORS-friendly APIs (including calling LLMs directly from the browser), and supporting local file uploads and generated file downloads. Pyodide and WebAssembly open up running Python or heavy libraries right in the browser. He also encourages building debugging tools to explore browser capabilities, remixing existing tools into new ones, and archiving prompts and conversation transcripts alongside the code. Finally, he encourages readers to start their own collections hosted on platforms like GitHub Pages.&lt;/p&gt;
&lt;h2 id="memory-allocation-in-go"&gt;&lt;a href="https://nghiant3223.github.io/2025/06/03/memory_allocation_in_go.html" rel="noopener noreferrer"&gt;Memory Allocation in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post takes a deep dive into memory allocation in the Go runtime—essential knowledge for optimizing application performance. Go manages the heap across three tiers: &lt;code&gt;mheap&lt;/code&gt; manages global memory in pages and spans, &lt;code&gt;mcentral&lt;/code&gt; distributes spans by size class, and &lt;code&gt;mcache&lt;/code&gt; acts as a per-processor (&lt;code&gt;P&lt;/code&gt;) local cache enabling fast lock-free allocations. Objects are grouped into three categories: tiny (under 16 bytes with no pointers, packed together into 16-byte blocks by a dedicated allocator), small (16 to 32,760 bytes, managed via spans across 68 size classes), and large (over 32,760 bytes, allocated directly from &lt;code&gt;mheap&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;A goroutine&amp;rsquo;s stack starts at 2 KB and doubles as needed using contiguous stacks, replacing the segmented stacks that caused performance cliffs in older Go versions. The compiler&amp;rsquo;s escape analysis decides whether a variable lives on the stack or the heap to guarantee memory safety. Three case studies at the end demonstrate how to reduce allocations: reusing a slice&amp;rsquo;s backing array, grouping multiple variables into a single struct, and recycling objects with &lt;code&gt;sync.Pool&lt;/code&gt;. Understanding these mechanics helps Go developers write efficient code and avoid memory-management bottlenecks.&lt;/p&gt;
&lt;h2 id="system-design-masterclass-building-a-global-cdn-and-edge-caching-strategy"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-masterclass-building" rel="noopener noreferrer"&gt;System Design Masterclass: Building a Global CDN and Edge Caching Strategy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide walks step by step through designing a global Content Delivery Network (CDN) and edge caching strategy around one core principle: move content closer to users. First, identify where your users are and classify content into static (images, CSS/JS files, video) and dynamic (API responses, personalized pages). Next, pick a CDN provider with Points of Presence (PoPs) near your main user base and route intelligently using Anycast or GeoDNS; very large services can adopt a multi-CDN setup for redundancy. Then configure caching rules: set long TTLs (days or weeks) for static assets, handle dynamic content carefully with short TTLs or a few seconds of micro-caching, and design clean cache keys.&lt;/p&gt;
&lt;p&gt;To keep users from seeing stale content indefinitely, combine three cache invalidation approaches: letting TTLs expire naturally, purging manually via API, and versioning filenames. Finally, continuously monitor cache hit ratios, measure performance across regions, test failure scenarios, and take advantage of CDN features like DDoS mitigation and SSL offloading. The author likens a CDN to a network of neighborhood library branches around the world, letting readers borrow books from their local branch instead of traveling to the central library.&lt;/p&gt;
&lt;h2 id="protect-your-api-a-developer"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-blueprint-designing" rel="noopener noreferrer"&gt;Protect Your API: A Developer&amp;rsquo;s Guide to Rate Limiting and Throttling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every system has finite resources, and a sudden traffic spike, a credential-stuffing bot, or even a buggy frontend loop can overwhelm a server. Rate limiting puts a cap on how many times a user can perform an action within a given time window, much like speed limit signs on a highway. It helps mitigate DDoS attacks (though it cannot stop every type) by flagging IP addresses sending abnormal request volumes, ensures fair resource allocation so one &amp;ldquo;noisy neighbor&amp;rdquo; doesn&amp;rsquo;t slow the app down for everyone else, and prevents brute-force login attacks by locking accounts after a handful of failed attempts.&lt;/p&gt;
&lt;p&gt;Rate limiting is typically placed at the application or middleware layer: each request is identified by IP address, user ID, or API key, its recent call count is checked against the allowed threshold, and excess requests are rejected with HTTP &lt;code&gt;429 Too Many Requests&lt;/code&gt;. The post introduces four common algorithms: Token Bucket, which allows short bursts and is used by Amazon and Stripe; Leaky Bucket, which smooths traffic into a steady outflow rate ideal for database writes; plus Fixed Window and Sliding Window. Later sections discuss implementing distributed rate limiting with Redis, a frequent topic in system design interviews.&lt;/p&gt;
&lt;h2 id="acid-vs-base-the-system-design-interview"&gt;&lt;a href="https://designgurus.substack.com/p/acid-vs-base-the-system-design-interview" rel="noopener noreferrer"&gt;ACID vs BASE: The System Design Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every large-scale system has to balance speed against reliability, and when designing a database layer, you must choose between two philosophies: ACID and BASE. ACID is the &amp;ldquo;strict perfectionist&amp;rdquo; and the gold standard of relational databases like MySQL and PostgreSQL: Atomicity ensures a transaction either completes in full or rolls back via logs; Consistency enforces schema constraints; Isolation uses locks so two people cannot buy the last ticket at the same time; and Durability writes changes to a write-ahead log so data survives crashes. ACID&amp;rsquo;s weakness is that it is very hard to scale horizontally across hundreds of servers.&lt;/p&gt;
&lt;p&gt;BASE emerged for the big-data era and is common in NoSQL databases like Cassandra, DynamoDB, and MongoDB: the system stays Basically Available, its state may change over time as replicas sync (Soft State), and data reaches Eventual Consistency—much like how an Instagram photo you post might take a few seconds to show up for your friends. ACID fits financial systems, inventory management, and medical records; BASE suits social networks, real-time analytics, and content delivery. Put simply, ACID is pessimistic and locks everything, while BASE is optimistic and runs fast; the deciding question is, &amp;ldquo;If the data is wrong for two seconds, does anyone lose money?&amp;rdquo;&lt;/p&gt;
&lt;h2 id="hash-tables-in-go-and-advantage-of-self-hosted-compilers"&gt;&lt;a href="https://rushter.com/blog/go-and-hashmaps/" rel="noopener noreferrer"&gt;Hash tables in Go and advantage of self-hosted compilers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go has no built-in set type, so developers commonly use a map to store unique values. A well-known trick is to use &lt;code&gt;map[int]struct{}&lt;/code&gt; instead of &lt;code&gt;map[int]bool&lt;/code&gt;, since an empty struct takes 0 bytes and the value slot shouldn&amp;rsquo;t consume any memory. However, when the author applied this in production, memory usage didn&amp;rsquo;t budge—even though both Google searches and LLMs (with web search enabled) insisted the trick still worked in Go 1.24.&lt;/p&gt;
&lt;p&gt;Because the Go compiler is self-hosted (written in Go itself), the author could easily read the runtime source code and track down the reason. Starting in Go 1.24, maps switched to a Swiss Tables implementation where keys and values are stored together inside a single slot struct. When the last field of a struct has size 0, the compiler forces it to occupy 1 byte so pointers to it don&amp;rsquo;t point past the allocation, and then adds 7 bytes of padding to align with the 8-byte &lt;code&gt;int&lt;/code&gt; key; &lt;code&gt;bool&lt;/code&gt; also takes 1 byte, so both types end up using the exact same amount of memory. Prior to Go 1.24, keys and values lived in separate arrays, allowing the compiler to omit the value array entirely for &lt;code&gt;struct{}&lt;/code&gt;. The takeaway: the old trick no longer saves memory while making code harder to read—and don&amp;rsquo;t blindly trust everything an LLM tells you.&lt;/p&gt;
&lt;h2 id="gist-of-go-concurrency"&gt;&lt;a href="https://antonz.org/go-concurrency/" rel="noopener noreferrer"&gt;Gist of Go: Concurrency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Gist of Go: Concurrency&lt;/em&gt; is an interactive book by Anton Zhiyanov that teaches concurrent programming in Go from the ground up through hands-on exercises. Unlike resources that merely introduce goroutines, channels, and &lt;code&gt;select&lt;/code&gt; before leaving readers to fend for themselves—or list concurrency patterns without explanation—the book focuses on truly understanding and properly applying these primitives. Each exercise is short enough to solve in about a page of code while staying grounded in realistic scenarios, runs right in the browser with automated tests for instant feedback, and includes reference solutions with explanations. It targets developers who already know basic Go (up through interfaces and error handling), with no prior knowledge of goroutines or channels required.&lt;/p&gt;
&lt;p&gt;Topics progress from goroutines, channels, pipelines, time, and &lt;code&gt;context&lt;/code&gt; to wait groups, data races, race conditions, semaphores, signaling, atomics, testing, and runtime internals. The book features over 500 interactive examples, 50 self-check exercises with solutions, and a 448-page PDF edition, all 100% original and human-written without AI. It grew out of a Go concurrency course the author launched in 2022 that 250 students have completed with an average 5-star rating; you can read it online or purchase full access to all exercises.&lt;/p&gt;
&lt;h2 id="the-state-of-ai-coding-2025--greptile"&gt;&lt;a href="https://www.greptile.com/state-of-ai-coding" rel="noopener noreferrer"&gt;The State of AI Coding 2025 | Greptile&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Greptile published a cross-industry report on AI software development trends in 2025, drawing on internal data from pull requests reviewed by its tool alongside public package download metrics from PyPI and npm. On engineering velocity, median PR size grew 33% between March and November 2025 (from 57 to 76 lines changed), lines of code per developer rose 76% (from 4,450 to 7,839), and mid-sized teams of 6–15 engineers saw an 89% jump. On tooling adoption, &lt;code&gt;mem0&lt;/code&gt; captured 59% market share among AI memory packages, the vector database market remains fragmented (led by Weaviate at 25%), &lt;code&gt;CLAUDE.md&lt;/code&gt; is the most popular AI rules file format at 67%, the Anthropic SDK reached 43 million monthly downloads (an 8x increase), and LiteLLM grew 4x to 41 million.&lt;/p&gt;
&lt;p&gt;On model trends, the OpenAI SDK still leads with 130 million downloads, but the OpenAI-to-Anthropic download ratio narrowed from 47:1 in January 2024 to 4.2:1 by November 2025. A performance benchmark compared GPT-5.1, GPT-5-Codex, Claude Sonnet 4.5, Claude Opus 4.5, and Gemini 3 Pro as coding agent backends: Anthropic&amp;rsquo;s two models delivered the fastest time to first token (under 2.5 seconds at p50), OpenAI&amp;rsquo;s two models achieved the highest output throughput, and Gemini 3 Pro trailed on both metrics. The report concludes with a roundup of recent research on foundation models and applications.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!VQTW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fee73de9e-d2ee-407a-ac6e-93679bdd887d_2250x2624.png" alt="A Guide to Retry Pattern in Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;URL processing was painfully slow—it took me way more time than usual to process a single URL. The summaries varied wildly in length and even had random Chinese characters mixed in from time to time (probably due to Z.AI&amp;rsquo;s model).&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>