<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Caching on miti99</title><link>https://miti99.com/en/tags/caching/</link><description>Recent content in Caching 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/caching/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #73</title><link>https://miti99.com/en/post/2025/12/20/</link><pubDate>Sat, 20 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/20/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I recently learned that &lt;a href="https://openrouter.ai/docs/guides/guides/claude-code-integration" rel="noopener noreferrer"&gt;OpenRouter now supports Claude Code integration&lt;/a&gt;, so I&amp;rsquo;m giving it a try today. This post was generated using &lt;a href="https://claude.com/product/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt; + &lt;a href="https://openrouter.ai/" rel="noopener noreferrer"&gt;Open Router&lt;/a&gt; + &lt;a href="https://openrouter.ai/z-ai/glm-4.5-air:free" rel="noopener noreferrer"&gt;Z.AI: GLM 4.5 Air (free)&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #73.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="system-design-deep-dive-time-series-databases-tsdbs-explained"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-deep-dive-time-series" rel="noopener noreferrer"&gt;System Design Deep Dive: Time Series Databases (TSDBs) Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Time series databases (TSDBs) are purpose-built for data that streams in continuously in chronological order, such as IoT sensor readings, application logs, or server monitoring metrics. Every measurement is stored with a timestamp, making it straightforward to track fluctuations and spot trends. The article highlights three core characteristics: efficient data compression using delta encoding and run-length encoding to exploit repeating patterns; automated data lifecycle management through retention policies (deleting or archiving old data) and downsampling (aggregating older data into coarser intervals like hourly averages); and fast time-range queries because time serves as the primary index, with many systems able to query compressed data directly.&lt;/p&gt;
&lt;p&gt;Compared with relational databases, TSDBs excel at high-frequency writes and aggregations over long time windows—such as &amp;ldquo;the per-minute average over 90 days&amp;rdquo;—thanks to columnar storage layouts, append-only writes, and time-based partitioning. Conversely, if an application requires frequent table joins or individual record updates, a relational database remains a better fit. This is handy knowledge when preparing for system design interviews.&lt;/p&gt;
&lt;h2 id="how-memory-maps-mmap-deliver-25x-faster-file-access-in-go"&gt;&lt;a href="https://info.varnish-software.com/blog/how-memory-maps-mmap-deliver-25x-faster-file-access-in-go" rel="noopener noreferrer"&gt;How Memory Maps (mmap) Deliver 25x Faster File Access in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;System calls carry kernel context-switch overhead that adds up when small operations are repeated millions of times. Author Per Buer (Varnish Software) introduces memory mapping (&lt;code&gt;mmap&lt;/code&gt;): mapping a file directly into virtual memory and reading it via pointers instead of seeking and reading with &lt;code&gt;pread()&lt;/code&gt;. In benchmarks of his Go library, random lookups dropped from 416.4 ns/op to 3.3 ns/op, and sequential iteration fell from 333.3 ns/op to 1.3 ns/op; working directly with pointers also reduces memory pressure and latency.&lt;/p&gt;
&lt;p&gt;The weakness of &lt;code&gt;mmap&lt;/code&gt; lies in writes: when writing to a page not yet in physical memory, the CPU triggers a page fault and the OS must allocate a new page and read the file contents from disk before the application can overwrite them, making performance entirely dependent on whether the page is already cached; &lt;code&gt;pwrite&lt;/code&gt; is far more predictable. That is why Varnish Cache later added a &lt;code&gt;malloc&lt;/code&gt; backend and Massive Storage Engines built on &lt;code&gt;io_uring&lt;/code&gt;. In a real-world application building an HTTP-backed filesystem, replacing CDB file reads with &lt;code&gt;mmap&lt;/code&gt; yielded 25x faster lookups.&lt;/p&gt;
&lt;h2 id="bloom-filters"&gt;&lt;a href="https://eli.thegreenplace.net/2025/bloom-filters" rel="noopener noreferrer"&gt;Bloom filters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Bloom filter is a probabilistic data structure proposed by Burton Bloom in 1970 for quickly testing whether an element belongs to a set using minimal time and memory. It acts like a probabilistic cache: if it says &amp;ldquo;no,&amp;rdquo; the element is 100% guaranteed not to be in the set; if it says &amp;ldquo;yes,&amp;rdquo; there is a small probability of a false positive. That makes Bloom filters especially effective when most queries return negative results—for example, checking whether a key exists in an on-disk file before paying the cost of reading the file. Structurally, it consists of an array of &lt;em&gt;m&lt;/em&gt; bits and &lt;em&gt;k&lt;/em&gt; hash functions: on insert, the element is hashed by all &lt;em&gt;k&lt;/em&gt; functions and the corresponding bits are set to 1; on lookup, a single 0 bit is enough to immediately conclude the element is absent.&lt;/p&gt;
&lt;p&gt;Eli Bendersky walks through a step-by-step example along with a Go implementation that uses double hashing to generate &lt;em&gt;k&lt;/em&gt; hash functions from two base hashes, plus the formulas for choosing optimal parameters: m/n ≈ -ln(ε)/ln²(2) and k = (m/n)·ln(2). For 1 billion elements and a 1% false-positive rate, the filter requires about 9.6 billion bits (roughly 1.2 GB) and 7 hash functions. Lookup cost is just &lt;em&gt;k&lt;/em&gt; bit checks—effectively constant and independent of how many elements have been inserted or the characteristics of the data.&lt;/p&gt;
&lt;h2 id="what-the-heck-is-aead-again"&gt;&lt;a href="https://ochagavia.nl/blog/what-the-heck-is-aead-again/" rel="noopener noreferrer"&gt;What the heck is AEAD again?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;AEAD (Authenticated Encryption with Associated Data) is the modern encryption standard: TLS 1.3 models all encryption algorithms as AEAD, QUIC (the foundation of HTTP/3) mandates it, and Google&amp;rsquo;s Tink library exclusively supports AEAD for data encryption. The author breaks down each part of the term. &amp;ldquo;Authenticated&amp;rdquo; means proving the ciphertext was not tampered with after encryption; previously, developers had to manually combine encryption with an HMAC step, which was notoriously error-prone (as seen in Apple&amp;rsquo;s iMessage vulnerability). Libraries like libsodium bundled both steps into a single API to make misuse much harder.&lt;/p&gt;
&lt;p&gt;&amp;ldquo;Associated Data&amp;rdquo; is unencrypted data that still needs protection against tampering. In a chat application, for example, the server needs to read &lt;code&gt;conversation_id&lt;/code&gt; in plaintext to route messages; if an attacker in the middle swaps that ID for a different conversation between the same two users and the recipient doesn&amp;rsquo;t authenticate it, the message still decrypts cleanly and gets processed in the wrong context. An AEAD API enforces simultaneous authentication of both the ciphertext and the associated data. Standardized AEAD algorithms like AES256-GCM and ChaCha20-Poly1305 are widely supported across libraries and languages; the author recommends following Tink&amp;rsquo;s guidance unless your system has specialized requirements.&lt;/p&gt;
&lt;h2 id="ceilometer-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/ceilometer-ubers-adaptive-benchmarking-framework/" rel="noopener noreferrer"&gt;Ceilometer: Uber&amp;rsquo;s Adaptive Benchmarking Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every new server SKU, OS kernel upgrade, or configuration change at Uber must be thoroughly vetted before reaching production, but their legacy process was manual, fragmented across teams, and scattered results across spreadsheets. Ceilometer was built to solve this: an adaptive benchmarking platform featuring standardized test configurations for fair comparisons, containerized benchmark suites that hardware vendors can run themselves, and context-rich reporting. Its architecture comprises distributed test orchestration on dedicated clusters, a result ingestion and normalization service, blob storage, a centralized data warehouse, and an analytics service. It supports synthetic benchmarks, stateful database benchmarks via Uber&amp;rsquo;s Odin platform, and stateless service benchmarks via Ballast.&lt;/p&gt;
&lt;p&gt;Its two primary use cases are shape qualification for new server hardware—from early vendor development through testing inside Uber&amp;rsquo;s environment—and infrastructure change verification alongside service owners to isolate, reproduce, and fix performance regressions. Ceilometer has also recently been used to validate &amp;ldquo;touchless&amp;rdquo; upgrades from cloud providers. Future directions include deeper AI/ML integration, broader ecosystem support, advanced anomaly detection, and component-level utilization metrics.&lt;/p&gt;
&lt;h2 id="useful-patterns-for-building-html-tools"&gt;&lt;a href="https://simonwillison.net/2025/Dec/10/html-tools/" rel="noopener noreferrer"&gt;Useful patterns for building HTML tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison uses the term &amp;ldquo;HTML tools&amp;rdquo; for small single-file applications that bundle HTML, JavaScript, and CSS together; over the past two years he has built more than 150 of them, mostly written by LLMs. This post distills design patterns from that experience: keep each tool in a single file, avoid React or build steps, and load dependencies from CDNs; prototype quickly in Artifacts or Canvas before moving to a coding agent as the project grows more complex; and self-host your tools rather than leaving them on LLM platforms that run inside restrictive sandboxes.&lt;/p&gt;
&lt;p&gt;On the technical side, he recommends using copy-and-paste as a primary I/O channel, storing state in the URL for easy sharing, using &lt;code&gt;localStorage&lt;/code&gt; for API keys or larger state, collecting CORS-friendly APIs (including calling LLMs directly from the browser), and supporting local file uploads and generated file downloads. Pyodide and WebAssembly open up running Python or heavy libraries right in the browser. He also encourages building debugging tools to explore browser capabilities, remixing existing tools into new ones, and archiving prompts and conversation transcripts alongside the code. Finally, he encourages readers to start their own collections hosted on platforms like GitHub Pages.&lt;/p&gt;
&lt;h2 id="memory-allocation-in-go"&gt;&lt;a href="https://nghiant3223.github.io/2025/06/03/memory_allocation_in_go.html" rel="noopener noreferrer"&gt;Memory Allocation in Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post takes a deep dive into memory allocation in the Go runtime—essential knowledge for optimizing application performance. Go manages the heap across three tiers: &lt;code&gt;mheap&lt;/code&gt; manages global memory in pages and spans, &lt;code&gt;mcentral&lt;/code&gt; distributes spans by size class, and &lt;code&gt;mcache&lt;/code&gt; acts as a per-processor (&lt;code&gt;P&lt;/code&gt;) local cache enabling fast lock-free allocations. Objects are grouped into three categories: tiny (under 16 bytes with no pointers, packed together into 16-byte blocks by a dedicated allocator), small (16 to 32,760 bytes, managed via spans across 68 size classes), and large (over 32,760 bytes, allocated directly from &lt;code&gt;mheap&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;A goroutine&amp;rsquo;s stack starts at 2 KB and doubles as needed using contiguous stacks, replacing the segmented stacks that caused performance cliffs in older Go versions. The compiler&amp;rsquo;s escape analysis decides whether a variable lives on the stack or the heap to guarantee memory safety. Three case studies at the end demonstrate how to reduce allocations: reusing a slice&amp;rsquo;s backing array, grouping multiple variables into a single struct, and recycling objects with &lt;code&gt;sync.Pool&lt;/code&gt;. Understanding these mechanics helps Go developers write efficient code and avoid memory-management bottlenecks.&lt;/p&gt;
&lt;h2 id="system-design-masterclass-building-a-global-cdn-and-edge-caching-strategy"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-masterclass-building" rel="noopener noreferrer"&gt;System Design Masterclass: Building a Global CDN and Edge Caching Strategy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide walks step by step through designing a global Content Delivery Network (CDN) and edge caching strategy around one core principle: move content closer to users. First, identify where your users are and classify content into static (images, CSS/JS files, video) and dynamic (API responses, personalized pages). Next, pick a CDN provider with Points of Presence (PoPs) near your main user base and route intelligently using Anycast or GeoDNS; very large services can adopt a multi-CDN setup for redundancy. Then configure caching rules: set long TTLs (days or weeks) for static assets, handle dynamic content carefully with short TTLs or a few seconds of micro-caching, and design clean cache keys.&lt;/p&gt;
&lt;p&gt;To keep users from seeing stale content indefinitely, combine three cache invalidation approaches: letting TTLs expire naturally, purging manually via API, and versioning filenames. Finally, continuously monitor cache hit ratios, measure performance across regions, test failure scenarios, and take advantage of CDN features like DDoS mitigation and SSL offloading. The author likens a CDN to a network of neighborhood library branches around the world, letting readers borrow books from their local branch instead of traveling to the central library.&lt;/p&gt;
&lt;h2 id="protect-your-api-a-developer"&gt;&lt;a href="https://designgurus.substack.com/p/system-design-blueprint-designing" rel="noopener noreferrer"&gt;Protect Your API: A Developer&amp;rsquo;s Guide to Rate Limiting and Throttling&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every system has finite resources, and a sudden traffic spike, a credential-stuffing bot, or even a buggy frontend loop can overwhelm a server. Rate limiting puts a cap on how many times a user can perform an action within a given time window, much like speed limit signs on a highway. It helps mitigate DDoS attacks (though it cannot stop every type) by flagging IP addresses sending abnormal request volumes, ensures fair resource allocation so one &amp;ldquo;noisy neighbor&amp;rdquo; doesn&amp;rsquo;t slow the app down for everyone else, and prevents brute-force login attacks by locking accounts after a handful of failed attempts.&lt;/p&gt;
&lt;p&gt;Rate limiting is typically placed at the application or middleware layer: each request is identified by IP address, user ID, or API key, its recent call count is checked against the allowed threshold, and excess requests are rejected with HTTP &lt;code&gt;429 Too Many Requests&lt;/code&gt;. The post introduces four common algorithms: Token Bucket, which allows short bursts and is used by Amazon and Stripe; Leaky Bucket, which smooths traffic into a steady outflow rate ideal for database writes; plus Fixed Window and Sliding Window. Later sections discuss implementing distributed rate limiting with Redis, a frequent topic in system design interviews.&lt;/p&gt;
&lt;h2 id="acid-vs-base-the-system-design-interview"&gt;&lt;a href="https://designgurus.substack.com/p/acid-vs-base-the-system-design-interview" rel="noopener noreferrer"&gt;ACID vs BASE: The System Design Interview&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every large-scale system has to balance speed against reliability, and when designing a database layer, you must choose between two philosophies: ACID and BASE. ACID is the &amp;ldquo;strict perfectionist&amp;rdquo; and the gold standard of relational databases like MySQL and PostgreSQL: Atomicity ensures a transaction either completes in full or rolls back via logs; Consistency enforces schema constraints; Isolation uses locks so two people cannot buy the last ticket at the same time; and Durability writes changes to a write-ahead log so data survives crashes. ACID&amp;rsquo;s weakness is that it is very hard to scale horizontally across hundreds of servers.&lt;/p&gt;
&lt;p&gt;BASE emerged for the big-data era and is common in NoSQL databases like Cassandra, DynamoDB, and MongoDB: the system stays Basically Available, its state may change over time as replicas sync (Soft State), and data reaches Eventual Consistency—much like how an Instagram photo you post might take a few seconds to show up for your friends. ACID fits financial systems, inventory management, and medical records; BASE suits social networks, real-time analytics, and content delivery. Put simply, ACID is pessimistic and locks everything, while BASE is optimistic and runs fast; the deciding question is, &amp;ldquo;If the data is wrong for two seconds, does anyone lose money?&amp;rdquo;&lt;/p&gt;
&lt;h2 id="hash-tables-in-go-and-advantage-of-self-hosted-compilers"&gt;&lt;a href="https://rushter.com/blog/go-and-hashmaps/" rel="noopener noreferrer"&gt;Hash tables in Go and advantage of self-hosted compilers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go has no built-in set type, so developers commonly use a map to store unique values. A well-known trick is to use &lt;code&gt;map[int]struct{}&lt;/code&gt; instead of &lt;code&gt;map[int]bool&lt;/code&gt;, since an empty struct takes 0 bytes and the value slot shouldn&amp;rsquo;t consume any memory. However, when the author applied this in production, memory usage didn&amp;rsquo;t budge—even though both Google searches and LLMs (with web search enabled) insisted the trick still worked in Go 1.24.&lt;/p&gt;
&lt;p&gt;Because the Go compiler is self-hosted (written in Go itself), the author could easily read the runtime source code and track down the reason. Starting in Go 1.24, maps switched to a Swiss Tables implementation where keys and values are stored together inside a single slot struct. When the last field of a struct has size 0, the compiler forces it to occupy 1 byte so pointers to it don&amp;rsquo;t point past the allocation, and then adds 7 bytes of padding to align with the 8-byte &lt;code&gt;int&lt;/code&gt; key; &lt;code&gt;bool&lt;/code&gt; also takes 1 byte, so both types end up using the exact same amount of memory. Prior to Go 1.24, keys and values lived in separate arrays, allowing the compiler to omit the value array entirely for &lt;code&gt;struct{}&lt;/code&gt;. The takeaway: the old trick no longer saves memory while making code harder to read—and don&amp;rsquo;t blindly trust everything an LLM tells you.&lt;/p&gt;
&lt;h2 id="gist-of-go-concurrency"&gt;&lt;a href="https://antonz.org/go-concurrency/" rel="noopener noreferrer"&gt;Gist of Go: Concurrency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Gist of Go: Concurrency&lt;/em&gt; is an interactive book by Anton Zhiyanov that teaches concurrent programming in Go from the ground up through hands-on exercises. Unlike resources that merely introduce goroutines, channels, and &lt;code&gt;select&lt;/code&gt; before leaving readers to fend for themselves—or list concurrency patterns without explanation—the book focuses on truly understanding and properly applying these primitives. Each exercise is short enough to solve in about a page of code while staying grounded in realistic scenarios, runs right in the browser with automated tests for instant feedback, and includes reference solutions with explanations. It targets developers who already know basic Go (up through interfaces and error handling), with no prior knowledge of goroutines or channels required.&lt;/p&gt;
&lt;p&gt;Topics progress from goroutines, channels, pipelines, time, and &lt;code&gt;context&lt;/code&gt; to wait groups, data races, race conditions, semaphores, signaling, atomics, testing, and runtime internals. The book features over 500 interactive examples, 50 self-check exercises with solutions, and a 448-page PDF edition, all 100% original and human-written without AI. It grew out of a Go concurrency course the author launched in 2022 that 250 students have completed with an average 5-star rating; you can read it online or purchase full access to all exercises.&lt;/p&gt;
&lt;h2 id="the-state-of-ai-coding-2025--greptile"&gt;&lt;a href="https://www.greptile.com/state-of-ai-coding" rel="noopener noreferrer"&gt;The State of AI Coding 2025 | Greptile&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Greptile published a cross-industry report on AI software development trends in 2025, drawing on internal data from pull requests reviewed by its tool alongside public package download metrics from PyPI and npm. On engineering velocity, median PR size grew 33% between March and November 2025 (from 57 to 76 lines changed), lines of code per developer rose 76% (from 4,450 to 7,839), and mid-sized teams of 6–15 engineers saw an 89% jump. On tooling adoption, &lt;code&gt;mem0&lt;/code&gt; captured 59% market share among AI memory packages, the vector database market remains fragmented (led by Weaviate at 25%), &lt;code&gt;CLAUDE.md&lt;/code&gt; is the most popular AI rules file format at 67%, the Anthropic SDK reached 43 million monthly downloads (an 8x increase), and LiteLLM grew 4x to 41 million.&lt;/p&gt;
&lt;p&gt;On model trends, the OpenAI SDK still leads with 130 million downloads, but the OpenAI-to-Anthropic download ratio narrowed from 47:1 in January 2024 to 4.2:1 by November 2025. A performance benchmark compared GPT-5.1, GPT-5-Codex, Claude Sonnet 4.5, Claude Opus 4.5, and Gemini 3 Pro as coding agent backends: Anthropic&amp;rsquo;s two models delivered the fastest time to first token (under 2.5 seconds at p50), OpenAI&amp;rsquo;s two models achieved the highest output throughput, and Gemini 3 Pro trailed on both metrics. The report concludes with a roundup of recent research on foundation models and applications.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!VQTW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fee73de9e-d2ee-407a-ac6e-93679bdd887d_2250x2624.png" alt="A Guide to Retry Pattern in Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict:&lt;/strong&gt; &lt;em&gt;URL processing was painfully slow—it took me way more time than usual to process a single URL. The summaries varied wildly in length and even had random Chinese characters mixed in from time to time (probably due to Z.AI&amp;rsquo;s model).&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #64</title><link>https://miti99.com/en/post/2025/12/06/</link><pubDate>Sat, 06 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #64. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; Qwen3-Coder-Plus&lt;sup id="fnref:1"&gt;&lt;a href="#fn:1" class="footnote-ref" role="doc-noteref"&gt;1&lt;/a&gt;&lt;/sup&gt;&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="caching"&gt;&lt;a href="https://planetscale.com/blog/caching" rel="noopener noreferrer"&gt;Caching&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains caching from first principles: pairing a small amount of fast, expensive storage with a large amount of slow, cheap storage so that frequently accessed data lives in the fast tier. The key metric is the hit rate (the percentage of requests served from the cache rather than the backing store); the higher the hit rate, the less often you pay the latency penalty of slow storage. Familiar examples include CPU L1, L2, and L3 caches, RAM acting as a cache for disk, or a social network keeping recent posts in fast memory while pushing older posts to colder storage.&lt;/p&gt;
&lt;p&gt;The author breaks down two forms of locality: temporal locality (data accessed recently is likely to be accessed again soon, such as caching posts from the last 48 hours) and spatial locality (accessing one item makes nearby items likely to be needed next, such as a photo app prefetching adjacent images). CDNs tackle geographic distance by placing cached copies close to end users. When a cache fills up, it needs an eviction policy: FIFO is simple but naive, LRU evicts the least recently used item to better match real-world access patterns, and time-aware LRU expires stale entries automatically. Finally, databases layer caches of their own—PostgreSQL combines &lt;code&gt;shared_buffers&lt;/code&gt; with the OS page cache, while MySQL uses its buffer pool—delivering multi-tier caching while preserving ACID guarantees.&lt;/p&gt;
&lt;h2 id="consistent-hashing"&gt;&lt;a href="https://eli.thegreenplace.net/2025/consistent-hashing/" rel="noopener noreferrer"&gt;Consistent Hashing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Distributing keys across N nodes with a simple &lt;code&gt;hash % N&lt;/code&gt; formula works fine until the node count changes: adding or removing even a single node remaps nearly every key to a different server, triggering a thundering herd of cache misses right when the system is already under load. Consistent hashing solves this by using the same hash function to map both nodes and keys onto a ring, assigning each key to the next node clockwise on the ring. When a node joins or leaves, only about M/N keys (where M is the total number of keys and N is the number of nodes, assuming an even distribution) need to move instead of nearly all of them.&lt;/p&gt;
&lt;p&gt;For the implementation, the author stores node positions in a sorted array representing a discrete ring, turning key lookup into a fast, cache-friendly binary search. The remaining catch is that random placement leaves uneven gaps between nodes on the ring: with 20 nodes, one node can end up owning roughly 40x as many keys as another. The fix is virtual nodes—mapping each physical node to multiple points around the ring; testing with 10 virtual nodes per physical node smooths out the distribution dramatically. Originally invented at MIT for distributed web caching, consistent hashing became the foundation of Akamai and influenced AWS&amp;rsquo;s Dynamo storage system.&lt;/p&gt;
&lt;h2 id="how-to-stop-linux-threads-cleanly"&gt;&lt;a href="https://mazzo.li/posts/stopping-linux-threads.html" rel="noopener noreferrer"&gt;How to stop Linux threads cleanly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post tackles a problem far trickier than spawning threads: stopping a Linux thread cleanly while still giving it a chance to run cleanup code. The simplest approach is a quasi-busy loop where the thread checks an atomic flag after each unit of work, assuming each iteration finishes quickly enough. It&amp;rsquo;s easy to reason about, but forces you to structure your code around short work slices. &lt;code&gt;pthread_cancel()&lt;/code&gt; looks tempting at first glance but has serious pitfalls: on &lt;code&gt;glibc&lt;/code&gt;/&lt;code&gt;libstdc++&lt;/code&gt;, cancellation is implemented via forced stack unwinding; if unwinding crosses a &lt;code&gt;noexcept&lt;/code&gt; boundary—such as cancelling inside a destructor—the program terminates immediately, and cancelling mid-operation can corrupt shared application state.&lt;/p&gt;
&lt;p&gt;A signal-based approach using &lt;code&gt;SIGUSR1&lt;/code&gt; and careful signal-mask manipulation can interrupt blocking system calls, but still suffers from a race condition because checking the stop flag and entering the syscall isn&amp;rsquo;t atomic. For syscalls that have signal-mask-aware variants—such as &lt;code&gt;ppoll&lt;/code&gt;, &lt;code&gt;pselect&lt;/code&gt;, and &lt;code&gt;epoll_pwait&lt;/code&gt;—this race is solved cleanly. For all other blocking syscalls, the author demonstrates a clever trick using &lt;code&gt;rseq&lt;/code&gt; (restartable sequences, available since Linux 4.18) to wrap the flag check and the syscall instruction in a single atomic critical section that the kernel aborts and restarts if interrupted mid-way. The takeaway is that no single solution is perfect: polling a flag works for most applications, signals suit I/O-heavy threads, and &lt;code&gt;rseq&lt;/code&gt; requires inline assembly and is best reserved for specialized low-level code.&lt;/p&gt;
&lt;h2 id="advice-for-new-principal-tech-ics-ie-notes-to-myself"&gt;&lt;a href="https://eugeneyan.com/writing/principal/" rel="noopener noreferrer"&gt;Advice for New Principal Tech ICs (i.e., Notes to Myself)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eugene Yan compiles 31 pieces of advice for newly minted Principal Engineers and Applied Scientists, distilled from observing experienced peers. The starting premise is that what got you promoted to senior levels becomes secondary at Principal: writing code yourself isn&amp;rsquo;t always the highest-leverage use of your time, even though you must stay close enough to the tech to maintain credibility and context. Principals come in different archetypes—some go deep technically, others drive broad cross-org alignment—and the role frequently blends parts of product management, design, and culture-building. Being right isn&amp;rsquo;t enough; you have to persuade others to care and act—one mentor shared that out of every 10 proposal docs they write, only about 3 actually get built.&lt;/p&gt;
&lt;p&gt;Yan advises picking work that wouldn&amp;rsquo;t happen without you, sitting at the intersection of your unique strengths and the organization&amp;rsquo;s gaps, and splitting your portfolio across three modes: leading (roughly 50%), sponsoring (20%), and advising (30%). Scaling your impact means helping others make decisions the way you would and setting aside dedicated weekly time for mentoring, including interns. In meetings, ask questions to create space for others, and explicitly label whether you are stating a known fact or just wondering aloud so a casual remark isn&amp;rsquo;t mistaken for a mandate. Greater autonomy comes with greater accountability: protect time for deep thinking and ultimately aim to make the organization succeed without depending on you.&lt;/p&gt;
&lt;h2 id="how-fast-is-java-teaching-an-old-dog-new-tricks"&gt;&lt;a href="https://dgerrells.com/blog/how-fast-is-java-teaching-an-old-dog-new-tricks" rel="noopener noreferrer"&gt;How fast is java? Teaching an old dog new tricks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author tests whether modern Java can keep up with Rust by building a particle simulation using Java&amp;rsquo;s new Vector API for SIMD math. The Vector API abstracts CPU-specific vector instructions behind the concept of a &amp;ldquo;species,&amp;rdquo; letting you write SIMD code once that runs across hardware architectures. To squeeze out maximum performance, the author decouples the physics simulation from the UI event thread, manages worker threads manually instead of using parallel streams, and gives each worker thread its own pixel buffer before merging them at the end to avoid cache contention from concurrent writes.&lt;/p&gt;
&lt;p&gt;On an M1 MacBook Air, Rust still runs roughly 2x faster across most particle counts—for instance, simulating 100 million particles takes ~69 ms per frame in Rust versus ~119 ms in Java. Java also carries higher baseline overhead from heap allocations, whereas Rust&amp;rsquo;s memory allocation is much leaner. While the author acknowledges Java has come a long way with lambdas and the Vector API, the surrounding ecosystem remains a pain point: just pulling in a couple of small libraries required frustrating build-system ceremony. His verdict: the old dog can indeed learn new tricks, but it&amp;rsquo;s still weighed down by legacy tooling.&lt;/p&gt;
&lt;h2 id="50-things-i-know"&gt;&lt;a href="https://usefulfictions.substack.com/p/50-things-i-know" rel="noopener noreferrer"&gt;50 things I know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cate Hall shares 50 lessons she has learned about relationships, decision-making, and personal growth. On people, she notes that you can care deeply for someone who doesn&amp;rsquo;t reciprocate, and that loving without needing anything back is the essence of selflessness; she separates admiration, obsession, and infatuation from real love, and observes that revenge is rarely worth it because difficult people are already their own punishment. Many social dynamics are paradoxical: actions that feel weak from the inside, when done without apology, are perceived by others as strength.&lt;/p&gt;
&lt;p&gt;On decision-making, she pushes back against the idea that effort times time equals results, highlights the importance of spotting asymmetric payoffs where being wrong in one direction is far costlier than the other, and advises doubling both time and budget estimates because you can never fully correct for the planning fallacy. If you want better opinions, start by having fewer of them. Knowing when to quit is an underrated skill, and she avoids totalizing ideologies because no moral framework survives every edge case intact. She closes with reminders that being of service to others is the only reliable way to feel better yourself, and that ten years from now you&amp;rsquo;ll look back and marvel at how great you had it today—so why not see it that way right now?&lt;/p&gt;
&lt;h2 id="programming-languages-that-blew-my-mind"&gt;&lt;a href="https://yoric.github.io/post/programming-languages-that-blew-my-mind/" rel="noopener noreferrer"&gt;Programming Languages That Blew My Mind&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Teller looks back at the programming languages that reshaped how he thinks about software. BASIC introduced arrays and &lt;code&gt;GOTO&lt;/code&gt;/&lt;code&gt;GOSUB&lt;/code&gt; control flow; Turbo Pascal brought IDEs, debuggers, structured programming, and modules; x86 assembly taught him memory addressing, registers, and talking directly to hardware. HyperCard introduced visual programming, natural-language-like scripting, and garbage collection. OCaml—with parametric polymorphism, type inference, pattern matching, and higher-order functions—humbled him, while Prolog taught declarative programming, where instead of writing an algorithm you teach the computer how to reason.&lt;/p&gt;
&lt;p&gt;In industry, Java stood out for its batteries-included standard library, thorough documentation, and the JVM; Erlang impressed him with its &amp;ldquo;let it fail&amp;rdquo; philosophy and actor model for distributed systems; Coq turned specifications into types and programs into formally verified proofs. Opalang experimented with multi-tier compilation that automatically split code across client, server, and database, while Rust combined functional-language safety guarantees with systems-programming performance. Teller notes that many ideas from academic languages eventually filter into mainstream software, and says he is still waiting for the next truly mind-expanding programming paradigm.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9cfa2d94-1602-47c2-8942-b585c1d8d285_2252x2752.jpeg" alt="Docker vs Kubernetes"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!P-gB!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c9090b5-77c7-4f04-88bc-481df27de32d.tif" alt="Batch vs Stream Processing"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!f0s-!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb6d1ef48-faea-4d57-b2ea-f8411efc8334_2360x2770.png" alt="What are Modular Monoliths?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MDHC!,w_1456,c_limit,f_webp,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7cf3f3a0-726f-47a3-94e4-755fa9aa8036_2196x2319.jpeg" alt="What is the difference between Process and Thread?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!-jEP!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa7885eb0-3b6d-4be3-bbb7-332b3f9fc0e0_2360x2920.jpeg" alt="How to Debug a Slow API?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!uW-M!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd7494e44-82ec-43fc-bd7f-eabea7776dd1_2250x2624.png" alt="Top Service-to-Service Communication Patterns"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict: Overall this is still a fairly solid post. However, the summaries are a bit on the long side and will need further refinement.&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;
&lt;div class="footnotes" role="doc-endnotes"&gt;
&lt;hr&gt;
&lt;ol&gt;
&lt;li id="fn:1"&gt;
&lt;p&gt;&lt;del&gt;Qwen3-Coder-480B-A35B-Instruct&lt;/del&gt;&amp;#160;&lt;a href="#fnref:1" class="footnote-backref" role="doc-backlink"&gt;&amp;#x21a9;&amp;#xfe0e;&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/div&gt;</description></item><item><title>Newsletter #54</title><link>https://miti99.com/en/post/2025/09/10/</link><pubDate>Wed, 10 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/10/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Since my personal finances haven&amp;rsquo;t been great lately, I decided to cancel my Claude subscription and am no longer using Claude Code. Right now I&amp;rsquo;m using Roo Code with the Z.AI: GLM 4.5 Air model via OpenRouter.&lt;/del&gt; Hopefully the post is still high enough quality for you all. Enjoy Newsletter #54.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="controlling-the-rollout-of-large-scale-monorepo-changes"&gt;&lt;a href="https://www.uber.com/in/en/blog/controlling-the-rollout-of-large-scale-monorepo-changes/" rel="noopener noreferrer"&gt;Controlling the Rollout of Large-Scale Monorepo Changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;At Uber, source code is organized into a few massive monorepos—one per major programming language—and most microservices deploy to production automatically via continuous deployment. This raises a thorny question: when a single commit can touch thousands of services—say, upgrading an RPC library used by nearly every Go service—how do you contain the blast radius if that change introduces a bug? An analysis of 500,000 commits in Uber&amp;rsquo;s Go monorepo showed that 1.4% of commits affected more than 100 services and 0.3% affected more than 1,000 services, meaning several changes every week touch a huge slice of production. Even when individual services detect failures and roll back automatically, a bug can still slip into production on services whose checks didn&amp;rsquo;t catch it.&lt;/p&gt;
&lt;p&gt;Uber&amp;rsquo;s solution is cross-service rollout orchestration. The team added a new rollout gate to the commit promotion pipeline: an asynchronous worker maintains a state machine for each large-scale commit, grouping affected services by criticality from tier 5 down to tier 0, and unlocking a more critical tier only after a required percentage of services in the preceding tier have deployed successfully. If the failure rate exceeds a threshold, the commit is flagged as unhealthy, the author is notified immediately, and further rollouts are blocked until a fix lands. Because the initial parameters were too conservative—blocking tier 1 services for up to 40 hours—the team built a simulator backed by historical deployment data to tune the thresholds, hitting their target of unlocking all tiers within 24 hours, with real-world results matching the simulation. The same mechanism is now also used to progressively roll out hundreds of machine learning model-serving services that differ only by configuration.&lt;/p&gt;
&lt;h2 id="string-length"&gt;&lt;a href="https://hsivonen.fi/string-length/" rel="noopener noreferrer"&gt;String Length&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Henri Sivonen pushes back against the popular meme mocking JavaScript because &lt;code&gt;&amp;quot;🤦🏼‍♂️&amp;quot;.length&lt;/code&gt; evaluates to 7. That emoji actually consists of five Unicode scalar values (a base character, a skin-tone modifier, a zero-width joiner, the male sign, and a variation selector), meaning the exact same string has at least four valid &amp;ldquo;lengths&amp;rdquo;: 17 UTF-8 code units (Rust), 7 UTF-16 code units (JavaScript, Java), 5 scalar values (Python 3), and 1 extended grapheme cluster (Swift). The first three numbers are fixed for any valid string and can be computed without lookup tables, whereas the grapheme cluster count depends on which version of the Unicode database the runtime bundles—so two programs can legitimately count different lengths for the same string.&lt;/p&gt;
&lt;p&gt;The author argues that reporting length in the string&amp;rsquo;s native storage code units makes complete sense, because that is the exact number needed for memory allocation and fast string concatenation, whereas higher-level counts should only be computed on demand. In his view, UTF-8 is the best internal representation, O(1) random access by scalar value is rarely needed in practice, Swift&amp;rsquo;s approach isn&amp;rsquo;t necessarily right for every language, and Python 3&amp;rsquo;s representation gives the worst trade-off. The closing section examines why applications measure string length in the first place: estimating display width (where terminals rely on East Asian Width, giving CJK characters two cells) and enforcing fair character limits across languages, illustrated through length statistics from translations of the Universal Declaration of Human Rights and Twitter&amp;rsquo;s rule counting each CJK character or emoji as two units.&lt;/p&gt;
&lt;h2 id="an-illustrated-guide-to-oauth"&gt;&lt;a href="https://www.ducktyped.org/p/an-illustrated-guide-to-oauth/" rel="noopener noreferrer"&gt;An Illustrated Guide to OAuth&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aditya Bhargava explains OAuth with clear illustrations, starting from its origin story: in 2007, Twitter needed a way for third-party apps to post tweets on a user&amp;rsquo;s behalf without the user handing over their password. The core building block of OAuth is the access token, which acts like a user-specific, scoped API key. Using the example of the budgeting app YNAB connecting to Chase Bank, the article walks through the two-step flow: the user logs in at Chase and approves the requested permissions (scopes), after which Chase redirects back to YNAB with a short-lived authorization code rather than the access token itself, since URLs can leak via browser history or server logs. YNAB&amp;rsquo;s backend then exchanges that code for an access token over an authenticated HTTPS &lt;code&gt;POST&lt;/code&gt; request that includes its &lt;code&gt;client_secret&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The guide introduces the standard terminology (&lt;code&gt;resource owner&lt;/code&gt;, &lt;code&gt;OAuth client&lt;/code&gt;, &lt;code&gt;authorization server&lt;/code&gt;, &lt;code&gt;resource server&lt;/code&gt;, &lt;code&gt;scope&lt;/code&gt;) alongside the developer&amp;rsquo;s perspective: registering the app to obtain a client ID and client secret, and whitelisting a &lt;code&gt;redirect_uri&lt;/code&gt; so the authorization server refuses to redirect users to malicious domains. The author contrasts the front-channel (passing through the user&amp;rsquo;s browser via URL parameters visible to anyone along the path) with the back-channel (direct server-to-server calls via &lt;code&gt;POST&lt;/code&gt; bodies), and explains why single-page and mobile apps—which cannot keep a &lt;code&gt;client_secret&lt;/code&gt; confidential—use PKCE instead, a mechanism now recommended even for backend web apps. The post wraps up with a quick tour of the legacy implicit flow, refresh tokens, and OpenID Connect, the identity layer built on top of OAuth that powers &amp;ldquo;Sign in with Google.&amp;rdquo; As the author sums up, OAuth feels complex because every step was added to close a specific attack vector.&lt;/p&gt;
&lt;h2 id="professional-development-is-a-choice"&gt;&lt;a href="https://alexchesser.medium.com/professional-development-is-a-choice-e90fb8719259" rel="noopener noreferrer"&gt;Professional Development Is a Choice&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Chesser, a developer with over 20 years of experience, argues that intentional professional development is very different from the passive growth that happens through day-to-day work: it requires a conscious choice. Looking back on his own career—maintaining Perl scripts at Nortel, getting laid off in the dot-com crash, spending five years teaching, and eventually returning to software engineering—he admits that for most of his career he learned reactively, picking up only what was needed for the task right in front of him. He also points out why top-down corporate career-development frameworks usually fail: the power imbalance between managers and direct reports makes it risky for employees to be completely honest about what they actually want.&lt;/p&gt;
&lt;p&gt;He proposes a four-step personal framework. First, put a recurring one-hour &amp;ldquo;career retrospective&amp;rdquo; on your calendar every week. Second, work through structured reflection questions—what you&amp;rsquo;re good at, what you enjoy, what the market pays you for, where you need to improve, and where you want to be in 1–3, 3–5, and 5–10 years—and turn the answers into SMART goals, making sure to include health, family, and non-work passions so you don&amp;rsquo;t burn out. Third, protect focused execution blocks using deep work or Pomodoro techniques, and fourth, revisit the loop weekly to adjust your targets. The author stresses that choosing not to invest extra time in career growth is also a completely valid choice—as long as you make it consciously.&lt;/p&gt;
&lt;h2 id="replacing-a-cache-service-with-a-database"&gt;&lt;a href="https://avi.im/blag/2025/db-cache/" rel="noopener noreferrer"&gt;Replacing a cache service with a database&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Avi asks a provocative question: can a database completely replace a dedicated caching service? Caches solve a vital problem—serving precomputed data at sub-millisecond latency—typically using the cache-aside pattern, where the application talks to both the cache and the database and takes responsibility for keeping them in sync. To simplify the architecture, you might try using a read replica as a cache: databases already keep hot pages in memory via their buffer pool, and if the application can tolerate replication lag, an asynchronous read replica can serve reads using the exact same SQL queries while eliminating custom cache-invalidation code. Embedded read replicas go further by avoiding network round-trips altogether, though synchronization still requires dedicated tooling (Litestream, for example, continuously streams SQLite backups to object storage rather than maintaining a live queryable replica out of the box).&lt;/p&gt;
&lt;p&gt;Still, dedicated caches hold major advantages: spinning them up or tearing them down is cheap, developers control exactly which keys are stored, caches can hold precomputed results of expensive multi-table joins, they natively support per-key TTLs and eviction policies, they don&amp;rsquo;t require replicating terabytes of cold data just to serve a few gigabytes of hot keys, and they effortlessly handle hundreds of thousands of concurrent connections whereas database connections are resource-heavy. To close the gap, the author argues databases would need partial read replicas, support for massive numbers of lightweight replicas, and built-in Incremental View Maintenance (IVM) to keep query results precomputed the way Noria (now ReadySet) does. His conclusion: we aren&amp;rsquo;t there yet.&lt;/p&gt;
&lt;h2 id="bonus-cool-diagrams-from-bytebytego"&gt;Bonus: Cool diagrams from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/f8993d4d-8879-4eeb-9635-3a5aa13816cc_2250x2624.png" alt="A Detailed Guide to Content Delivery Networks"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/607358c5-2e0b-41fc-9cdd-a350e1faf144_3780x4096.jpeg" alt="CI/CD Pipeline Explained"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/8b1bd4d5-a708-4793-a9e6-aa96db182f54_3000x3900.png" alt="What are some of the most popular versioning strategies?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c34a8b8b-feff-4473-9eb1-dd399f5a81eb_2360x2664.jpeg" alt="The Testing Pyramid"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, I think this experiment went pretty well. The summaries are still a bit wordy and there were a few minor phrasing hiccups in Vietnamese, though for the price of free, it&amp;rsquo;s more than good enough :))) See you in upcoming posts!&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #43</title><link>https://miti99.com/en/post/2025/08/02/</link><pubDate>Sat, 02 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/02/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I switched the tool to Qwen Code and the model to Qwen 3 Coder, running via the OpenRouter API. Just experimenting a bit to see how it goes.&lt;/del&gt; Enjoy Newsletter #43.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="augmented-coding-beyond-the-vibes"&gt;&lt;a href="https://tidyfirst.substack.com/p/augmented-coding-beyond-the-vibes" rel="noopener noreferrer"&gt;Augmented Coding: Beyond the Vibes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck distinguishes between two ways of working with AI: &amp;ldquo;vibe coding&amp;rdquo; only cares that the system exhibits the right behavior, ignoring code quality and simply feeding errors back to the AI to fix; while &amp;ldquo;augmented coding&amp;rdquo; preserves the values of traditional programming—such as clean code, low complexity, testing, and full coverage—with the only difference being that the programmer types less. To illustrate, he built a B+ Tree library called BPlusTree3 in Rust and Python, which took about four weeks and three rewrites because the first two versions accumulated too much complexity and left the AI stuck. He applied TDD alongside a strict system prompt: separate structural changes from behavioral changes, work on only one unchecked test in &lt;code&gt;plan.md&lt;/code&gt; at a time, and write just enough code for that test to pass. When Rust&amp;rsquo;s memory model caused complexity to spike, he switched to writing in Python and had the agent translate it back into Rust.&lt;/p&gt;
&lt;p&gt;Beck points out three signs that the AI is going off track: looping, adding unrequested features on its own, and &amp;ldquo;cheating&amp;rdquo; by disabling or deleting tests. As a result, the Rust and Python versions achieved competitive performance—slower than standard libraries on a few operations, but faster on range scans; the AI even wrote a C extension for Python with good performance, though its code quality still fell short of his standards. According to Beck, programming with AI remains enjoyable: most setup tedium disappears, and programmers make more consequential decisions per hour of work.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;With the combo above, after writing the first entry, it started looping—sending 3–4 requests to OpenRouter and then getting completely stuck. And that first entry also took a very long time. Next, I&amp;rsquo;ll try Qwen Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Update: it seems Qwen Code doesn&amp;rsquo;t work with Kimi K2—I ran into &lt;code&gt;API Error: Internal Server Error&lt;/code&gt; :v Next up, let&amp;rsquo;s try Cline with Qwen 3 Coder.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-agents-have-crossed-a-chasm"&gt;&lt;a href="https://blog.singleton.io/posts/2025-06-14-coding-agents-cross-a-chasm/" rel="noopener noreferrer"&gt;Coding agents have crossed a chasm&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Singleton argues that in recent months, coding agents have crossed a &amp;ldquo;chasm&amp;rdquo;: from smart autocomplete tools, to real-time pair-programming collaborators, they now resemble a dedicated intern capable of taking on an entire task end-to-end. He uses Claude Code to write small personal tools while barely reading the source code, just running and tweaking them iteratively; a photo-reorganizing script cost only $0.31 in tokens. At work, he hands off simple bugs for Codex to handle end-to-end, and uses GitHub-integrated Claude Code for code reviews, catching issues humans missed. The most impressive example was a race condition in an OAuth integration flow: after 45 minutes of fruitless manual debugging, he asked Claude to draw an ASCII sequence diagram of the entire flow and found the root cause in 10 minutes.&lt;/p&gt;
&lt;p&gt;The author also warns of the &amp;ldquo;mirror effect&amp;rdquo;: the tool amplifies both the user&amp;rsquo;s strengths and weaknesses. On one occasion, the model kept proposing increasingly convoluted solutions and he kept following along, when the actual fix was embarrassingly simple. AI is also prone to band-aiding architectural problems rather than encouraging refactoring, and developers without a solid foundation can be misled by plausible-sounding but wrong suggestions. Even so, he believes the line between &amp;ldquo;AI-assisted&amp;rdquo; and &amp;ldquo;autonomous AI&amp;rdquo; will continue to blur: humans retain ownership of design and key decisions, while AI handles implementation so developers can focus on architecture, user experience, and business logic.&lt;/p&gt;
&lt;h2 id="how-databases-store-your-tables-on-disk"&gt;&lt;a href="https://www.deepintodev.com/blog/how-databases-store-your-tables-on-disk" rel="noopener noreferrer"&gt;How Databases Store Your Tables on Disk&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kaan Pekşen explains how databases actually store tables on disk. The fundamental unit is a page, a fixed-size block of data—for example, 8KB in PostgreSQL and 16KB in MySQL. A database does not read individual rows; it reads an entire page in a single I/O operation, so once a page is in the buffer cache, every row inside it is readily available. Table pages are stored in a heap, where data is placed wherever free space exists, leaving pages in no particular order; searching a heap therefore usually requires a full table scan. An index is a separate structure, typically a B-Tree, containing the indexed column values along with row identifiers, making it possible to pinpoint the exact page to read instead of scanning everything; the index itself is also stored as pages and costs I/O to read.&lt;/p&gt;
&lt;p&gt;With a clustered index, table data is physically sorted according to the index key, so each table can have only one such index; MySQL&amp;rsquo;s InnoDB uses the primary key as the clustered index by default, or a qualifying unique index, falling back to a hidden 6-byte ID if the table has no primary key. Consequently, in InnoDB, secondary indexes point to the primary key value before reaching the data, whereas PostgreSQL points directly to the row&amp;rsquo;s location in the heap via the &lt;code&gt;ctid&lt;/code&gt; column. The article draws several practical lessons: reduce I/O operations through sensible indexing, avoid random UUIDs as primary keys in InnoDB because random inserts degrade performance (auto-incrementing integers are better), and understand that under MVCC, PostgreSQL handles an update as a DELETE plus an INSERT.&lt;/p&gt;
&lt;h2 id="software-engineering-with-llms-in-2025-reality-check"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/software-engineering-with-llms-in-2025" rel="noopener noreferrer"&gt;Software engineering with LLMs in 2025: reality check&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz synthesizes his keynote at the LDX3 conference in London along with interviews across AI tooling companies, Big Tech, AI startups, and veteran engineers to assess the reality of using LLMs in software engineering. On one side are bold CEO claims like &amp;ldquo;within a year, all code will be written by AI&amp;rdquo;; on the other are real-world failures like a tool causing a $733 bug or the GitHub Copilot agent repeatedly stumbling on .NET repositories. At AI tooling companies, the numbers are very high: roughly 90% of Claude Code&amp;rsquo;s codebase is written by Claude Code itself, Windsurf is around 95%, and Cursor is at 40–50%. Google is building AI-integrated internal tools and preparing for a tenfold increase in code volume, while Amazon is becoming an &amp;ldquo;MCP-first&amp;rdquo; company built on thousands of internal APIs. Among startups, incident.io uses Claude Code heavily, whereas a biotech startup found AI tools less useful than traditional tools like ruff or uv.&lt;/p&gt;
&lt;p&gt;Many veteran engineers—such as Armin Ronacher, Simon Willison, Kent Beck, and Martin Fowler—are enthusiastic about agentic tools. Still, open questions remain: why executives are more enthusiastic than developers, why only about half of developers use AI tools weekly, and why median time savings sit at around 4 hours per week, far from the promised 10x productivity boost. The article concludes that agentic tools could represent a major shift akin to moving from assembly to high-level languages, but writing code faster does not automatically translate to shipping software faster unless the surrounding infrastructure and processes evolve alongside it.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Overall, the Cline + Qwen 3 Coder combo works, but it&amp;rsquo;s a bit slow and the output is somewhat rambling—I asked for a summary, yet it wrote very long passages (this might be because I haven&amp;rsquo;t optimized the prompt yet, since I only told it to read &lt;code&gt;CLAUDE.md&lt;/code&gt;). Next, let&amp;rsquo;s try Cline with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="continuous-ai"&gt;&lt;a href="https://www.seangoedecke.com/continuous-ai/" rel="noopener noreferrer"&gt;Continuous AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke defines &amp;ldquo;Continuous AI&amp;rdquo; as any way of automatically integrating AI tools into existing development workflows, much like how tests or type checks run continuously without a developer having to manually trigger them. Instead of only using AI when opening a chat window, AI becomes an ever-present support layer: automated pull request reviews, issue and pull request labeling, periodic summary digests for team coordination, or Copilot-style code completion. The author&amp;rsquo;s view shifted after trying Copilot&amp;rsquo;s pull request review feature: most comments aren&amp;rsquo;t particularly valuable, but roughly once every five to ten times it catches something he missed, and since skimming the comments takes very little effort, it is still worth using.&lt;/p&gt;
&lt;p&gt;For experimentation, the author suggests combining GitHub Models (an inference API with a free tier) with GitHub Actions, bringing AI into existing workflows at very low cost. In his view, rather than chasing fully autonomous &amp;ldquo;AI engineers,&amp;rdquo; a more realistic near-term future is multiple layers of AI systems handling automated checks, organization, and other parts of the software engineering workflow alongside human developers.&lt;/p&gt;
&lt;h2 id="caching-is-an-abstraction-not-an-optimization"&gt;&lt;a href="https://buttondown.com/jaffray/archive/caching-is-an-abstraction-not-an-optimization/" rel="noopener noreferrer"&gt;Caching is an abstraction, not an optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Jaffray argues that caching should be understood first and foremost as an abstraction that simplifies software, rather than merely a performance optimization to avoid hitting slow storage tiers. This perspective creates a clean boundary between storage layers: the rest of the system simply reads and writes data without needing to know whether that data currently resides in a fast tier or a slow tier. The author points to database buffer pools and operating system page caches as examples: they automatically promote frequently accessed data to faster storage without developer intervention, completely hiding the management of storage tiers.&lt;/p&gt;
&lt;p&gt;From this, the author draws two conclusions. First, data access patterns in real-world workloads are too unpredictable, making reliance on heuristics and caching algorithms unavoidable; hand-crafting custom solutions for each case is not a practical option. Second, caching is such a good abstraction that it deserves careful study to operate better in practice: precisely because it succeeds, its importance usually remains invisible until something goes wrong.&lt;/p&gt;
&lt;h2 id="you-should-delete-tests"&gt;&lt;a href="https://andre.arko.net/2025/06/30/you-should-delete-tests/" rel="noopener noreferrer"&gt;You should delete tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;André Arko pushes back against the common industry dogma that tests should never be deleted. In his view, tests have only one purpose: giving humans confidence that they can change code without breaking existing functionality. Any test that no longer serves that purpose should be deleted rather than kept out of principle.&lt;/p&gt;
&lt;p&gt;He outlines several specific cases. Flaky tests do the most harm because they fail randomly, eroding engineers&amp;rsquo; trust even in real failures; the phrase &amp;ldquo;it failed because of that flaky test, it&amp;rsquo;s actually fine&amp;rdquo; gets repeated even when the code is genuinely broken, and spending days debugging such a test often costs more than a future bug would. Over-specified tests—where changing a single line of code requires updating 150 tests—also create false confidence; three meaningful checks are worth more than 150 of those. A test suite so slow that nobody runs it between merges is no different from a fake &amp;ldquo;pass.&amp;rdquo; And tests for old business requirements after a product pivot should be replaced with tests for the new behavior, not patched just to pass. The author isn&amp;rsquo;t against writing tests; he simply wants the test suite to actually do its job of building confidence.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;I found that Cline + Kimi K2 also generates long outputs (likely due to the prompt as mentioned above), but on the bright side, its response time is quite fast, so at least I don&amp;rsquo;t have to wait long. I&amp;rsquo;ll try to improve the prompt in the &amp;ldquo;distant&amp;rdquo; future. Tomorrow I&amp;rsquo;ll test Roo Code + Qwen 3 Coder / Kimi K2 first. See you in tomorrow&amp;rsquo;s post!&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #30</title><link>https://miti99.com/en/post/2025/05/17/</link><pubDate>Sat, 17 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/17/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #30 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2025/04/what-id-do-as-college-freshman.html" rel="noopener noreferrer"&gt;What I&amp;rsquo;d do as a College Freshman in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Computer science professor Murat Demirbas asks what he would do if he were starting college over as a freshman in 2025, and his first answer is still to study Computer Science. Against the claim that &amp;ldquo;nobody needs to learn programming anymore,&amp;rdquo; he argues that AI tools cannot replace real mastery: debugging skills, abstract thinking, and fast adaptability have to be forged firsthand. He advises building a strong foundation in both computer science and AI, then pairing AI with a deep domain such as systems, databases, or programming languages—aiming to become &amp;ldquo;π-shaped,&amp;rdquo; with depth in two areas and broad literacy across many others.&lt;/p&gt;
&lt;p&gt;Beyond technical depth, soft skills are indispensable: clear communication powers remote work, learning in public, and even working with LLMs, while management starts with managing yourself. Demirbas still views the US as the best launchpad for a tech career and university as the best place to meet talented peers and build projects together. Borrowing a friend&amp;rsquo;s metaphor, he says you should either be an all-terrain Jeep with an entrepreneurial mindset, or a specialized, high-speed Ferrari when a paved track exists—just don&amp;rsquo;t be an easily replaceable Corolla, because in the AI era that is what gets automated away. Finally, play the long game, compounding skills and relationships rather than chasing trends.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="llms-are-weird-computers"&gt;&lt;a href="https://www.phillipcarter.dev/posts/llms-computers" rel="noopener noreferrer"&gt;LLMs Are Weird Computers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phillip Carter proposes a useful mental model for large language models (LLMs): treat them as a &amp;ldquo;weird&amp;rdquo; or &amp;ldquo;inverted&amp;rdquo; kind of computer alongside the &amp;ldquo;normal&amp;rdquo; computers we already know. Traditional computers execute with exact precision but struggle with ambiguity, whereas LLMs do the opposite: they excel at handling ambiguity but struggle when absolute precision is required.&lt;/p&gt;
&lt;p&gt;Viewing LLMs as a new class of computer with its own distinct properties helps developers better understand their strengths and limits, making it clearer which tasks to hand to an LLM and when traditional computation is still the right tool.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="every-caching-strategy-explained-in-5-minutes"&gt;&lt;a href="https://www.swequiz.com/blog/every-caching-strategy-explained-in-5-minutes" rel="noopener noreferrer"&gt;Every Caching Strategy Explained in 5 Minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This SWE Quiz post gives a quick tour of common caching strategies, a foundational topic for optimizing application performance. With Cache-Aside (also called lazy loading), the application manages the cache directly: it checks the cache first and queries the database only on a miss, which fits read-heavy systems that can tolerate briefly stale data. Read-Through instead has the application talk only to the cache while the cache itself loads missing data from the database, keeping application code cleaner.&lt;/p&gt;
&lt;p&gt;On the write side, Write-Through writes synchronously to both the cache and the database, guaranteeing consistency at the cost of slower writes. Write-Behind (Write-Back) writes only to the cache and flushes to the database asynchronously later, speeding up writes but risking data loss if the cache fails before syncing. Write-Around bypasses the cache on writes and uses it only for reads, which suits data that is rarely re-read immediately after being written. Choosing the right strategy depends on an application&amp;rsquo;s specific trade-offs across performance, consistency, and fault tolerance.&lt;/p&gt;
&lt;h2 id="some-features-that-every-javascript-developer-should-know-in-2025"&gt;&lt;a href="https://waspdev.com/articles/2025-04-06/features-that-every-js-developer-must-know-in-2025" rel="noopener noreferrer"&gt;Some features that every JavaScript developer should know in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This WaspDev article rounds up modern JavaScript features every developer should know to write cleaner, more efficient code. Standouts include iterator helper methods like &lt;code&gt;drop()&lt;/code&gt;, &lt;code&gt;take()&lt;/code&gt;, and &lt;code&gt;filter()&lt;/code&gt;, which process large datasets lazily one element at a time without allocating memory-hungry intermediate arrays. The &lt;code&gt;at()&lt;/code&gt; method supports negative indexing on arrays, such as &lt;code&gt;arr.at(-1)&lt;/code&gt; to grab the last element, while &lt;code&gt;Promise.withResolvers()&lt;/code&gt; cleanly exposes &lt;code&gt;resolve&lt;/code&gt; and &lt;code&gt;reject&lt;/code&gt; alongside a newly created Promise.&lt;/p&gt;
&lt;p&gt;The post also highlights underused techniques: passing a callback function to &lt;code&gt;replace()&lt;/code&gt; and &lt;code&gt;replaceAll()&lt;/code&gt; for complex string substitutions, swapping two variables via &lt;code&gt;[a, b] = [b, a]&lt;/code&gt; instead of a temporary variable, and deep-cloning objects with &lt;code&gt;structuredClone()&lt;/code&gt; rather than &lt;code&gt;JSON.parse(JSON.stringify())&lt;/code&gt;. Rounding out the list are tagged templates for flexible template-literal processing, &lt;code&gt;WeakMap&lt;/code&gt;/&lt;code&gt;WeakSet&lt;/code&gt; for attaching metadata to objects without preventing garbage collection, and new &lt;code&gt;Set&lt;/code&gt; operations like &lt;code&gt;union()&lt;/code&gt;, &lt;code&gt;intersection()&lt;/code&gt;, and &lt;code&gt;difference()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="what-makes-a-great-developer-experience"&gt;&lt;a href="https://www.codesimplicity.com/post/what-makes-a-great-developer-experience/" rel="noopener noreferrer"&gt;What Makes a Great Developer Experience?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Kanat-Alexander, who has spent over 20 years working on developer experience (DX) and helped design key parts of DX at Google and LinkedIn, distills the field&amp;rsquo;s core principles. In his view, a great DX optimizes three things: cycle time, the elapsed time from when a developer forms an intent to when that intent is fulfilled; focus, the ability to work in uninterrupted flow; and cognitive load, the amount of knowledge required and the number of decisions a developer must make to get something done.&lt;/p&gt;
&lt;p&gt;Most of the post focuses on the practical challenges of improving DX: understanding the real problem through data and developer feedback, managing change through gradual rollouts and driving adoption, building high-leverage tools that save human time rather than just machine resources, saying &amp;ldquo;no&amp;rdquo; or &amp;ldquo;not yet&amp;rdquo; kindly to requests that don&amp;rsquo;t fit, and placing the burden on the party actually causing the problem. The overarching lesson is that the hardest part of DX is usually human rather than technical.&lt;/p&gt;
&lt;h2 id="when-life-gives-you-java"&gt;&lt;a href="https://oblac.rs/when-life-gives-you-java/" rel="noopener noreferrer"&gt;When Life Gives You Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Igor Spasić shares how he writes Java when he has to use the language but still wants clean code, borrowing ideas from more expressive functional languages. He makes classes package-private by default and exposes them publicly only when strictly necessary, treating each package as a module. Roughly 95% of references are marked &lt;code&gt;final&lt;/code&gt; to embrace immutability, which makes &lt;code&gt;null&lt;/code&gt; nearly disappear outside very narrow boundaries. He no longer uses inheritance in his own code, favoring object composition instead, while still accepting inheritance where external libraries require it.&lt;/p&gt;
&lt;p&gt;Spasić thinks in terms of &amp;ldquo;input, process, output&amp;rdquo; functions: because Java lacks true first-class functions, each class typically wraps a single function or a small group of closely related ones. Algebraic data types (ADTs) are modeled as &lt;code&gt;record&lt;/code&gt;s implementing a &lt;code&gt;sealed interface&lt;/code&gt;, and domain errors are returned as part of the result via dedicated ADTs, reserving exceptions for genuine runtime failures like out-of-memory errors, I/O failures, or lost database connections. That produces more small classes, which he considers a worthwhile trade-off for more modular code with fewer surprises.&lt;/p&gt;
&lt;h2 id="just-throw-it-into-postgres"&gt;&lt;a href="https://simonsafar.com/2025/throw_it_into_postgres/" rel="noopener noreferrer"&gt;Just Throw It Into Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Safar argues that between the two extremes of forcing all data into a strictly normalized relational schema and dumping raw data into countless files in a directory tree, there is a practical middle ground: just throw the data straight into PostgreSQL without overthinking upfront organization. Thanks to &lt;code&gt;JSONB&lt;/code&gt;, PostgreSQL can query fields inside JSON documents directly, while indexes and dedicated columns can be added later once the data is already there.&lt;/p&gt;
&lt;p&gt;He illustrates this with three examples. First, he built a custom Java code-navigation tool for Emacs: it parsed compiled class files to record relationships like &amp;ldquo;function A calls function B,&amp;rdquo; then loaded hundreds of thousands of records into PostgreSQL via &lt;code&gt;COPY&lt;/code&gt; in a few dozen seconds—fast enough to invoke &lt;code&gt;psql&lt;/code&gt; multiple times per second for autocomplete. Second, he loaded tens of thousands of Chinese character SVGs from the Make Me a Hanzi project into a table with a &lt;code&gt;JSONB&lt;/code&gt; column and joined it against a dictionary table for fast lookups. Third, he stored temperature sensor readings arriving over MQTT so Grafana could chart them. The takeaway: get the data stored first and organize it later, rather than trying to design the perfect schema on day one.&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>