<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Databases on miti99</title><link>https://miti99.com/en/tags/databases/</link><description>Recent content in Databases 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/databases/index.xml" rel="self" type="application/rss+xml"/><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 #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 #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 #78</title><link>https://miti99.com/en/post/2026/02/01/</link><pubDate>Sun, 01 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #78.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-next-two-years-of-software-engineering"&gt;&lt;a href="https://addyosmani.com/blog/next-two-years/" rel="noopener noreferrer"&gt;The Next Two Years of Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani observes that the software industry is at an inflection point: AI coding tools have evolved from autocomplete suggestions into autonomous agents that execute end-to-end tasks, while the hiring boom has given way to an efficiency mandate where companies favor experienced engineers and small, well-tooled teams. Rather than making single-track predictions, he poses five open questions through 2026, each paired with two contrasting scenarios. Junior hiring could collapse (a Harvard study found junior roles dropped roughly 9–10% after companies adopted generative AI) or rebound as software expands into every industry. Foundational computer science skills could atrophy or become more valuable than ever. The developer role could narrow into an AI code reviewer or expand into a full-system orchestrator. Narrow specialists risk displacement, while T-shaped engineers (deep in one or two areas, broad across many) are in high demand. And traditional CS degrees could be overtaken by bootcamps, online courses, and internal apprenticeships.&lt;/p&gt;
&lt;p&gt;With 84% of developers already using or planning to use AI, value lies in reviewing AI output for logic bugs, security vulnerabilities, and requirement drift; the best engineers aren&amp;rsquo;t the ones who write code the fastest, but the ones who know when not to trust AI. Juniors should use AI to learn rather than as a crutch; seniors should anchor quality assurance, mentorship, and architecture. The common denominator is continuous learning.&lt;/p&gt;
&lt;h2 id="databases-in-2025-a-year-in-review"&gt;&lt;a href="https://www.cs.cmu.edu/~pavlo/blog/2026/01/2025-databases-retrospective.html" rel="noopener noreferrer"&gt;Databases in 2025: A Year in Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Pavlo (Carnegie Mellon University) looks back at the database world in 2025, starting with PostgreSQL&amp;rsquo;s continued dominance. Version 18 added an asynchronous I/O subsystem and B-tree skip scans. The business side was even livelier: Databricks paid $1 billion to acquire Neon, Snowflake paid $250 million for CrunchyData, Microsoft launched HorizonDB, and three horizontally scalable PostgreSQL sharding projects—Multigres (Supabase), Neki (PlanetScale), and PgDog—entered the ring. 2025 was also the year every DBMS shipped an MCP (Model Context Protocol) server, exploding after OpenAI backed the standard in March. Pavlo cautions that these servers mostly just forward queries to the database, making least-privilege access essential. The columnar file format space heated up as well, with five new formats challenging Parquet: FastLanes, F3, Vortex, AnyBlox, and Amudai.&lt;/p&gt;
&lt;p&gt;The industry roundup covers a wave of acquisitions: IBM bought DataStax (for an estimated $3 billion) and Confluent, Salesforce acquired Informatica ($8 billion), and Fivetran and dbt Labs announced a surprise merger. Databricks raised two massive funding rounds of $4 billion and $1 billion, while several database startups shut down, including Fauna, PostgresML, Hydra, MyScaleDB, and Voltron Data. The post closes with Oracle founder Larry Ellison briefly becoming the richest person in the world with an estimated net worth of $393 billion—which Pavlo notes makes him the richest database person in history, surpassing even John D. Rockefeller on an inflation-adjusted basis.&lt;/p&gt;
&lt;h2 id="12-predictions-for-2026"&gt;&lt;a href="https://tomtunguz.com/2026-predictions/" rel="noopener noreferrer"&gt;12 Predictions for 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz shares 12 predictions for 2026 centered on AI agents moving into real production work. For the first time, enterprises will spend more on agents than on human labor in certain workflows, much as riders willingly pay a ~31% premium to take a Waymo over an Uber. 2026 is poised to set a liquidity record with potential IPOs from SpaceX, OpenAI, Anthropic, Stripe, and Databricks. Vector databases will enjoy a renaissance as essential agent infrastructure. According to METR, the task duration AI can reliably complete doubles every seven months, putting agents on track to run 8+ hour workflows autonomously by year&amp;rsquo;s end. AI budgets will face real scrutiny for the first time, pushing small and open-source models ahead thanks to up to 10x lower costs, while Google widens its lead through strength across frontier models, video generation, and search.&lt;/p&gt;
&lt;p&gt;Agent observability will become the most fiercely contested infrastructure layer. Stablecoins are projected to capture 30% of cross-border payments, eating into SWIFT&amp;rsquo;s volume. Agents will issue at least an order of magnitude more queries than humans, forcing database architectures to adapt. US data center investment will reach 3.5% of GDP, rivaling the railroad boom. The web will shift toward agent-first design as purchasing decisions increasingly begin with agent-led research, and Cloudflare will emerge as the toll collector for agent payments via the x402 protocol, reviving the long-dormant HTTP &lt;code&gt;402 Payment Required&lt;/code&gt; status code.&lt;/p&gt;
&lt;h2 id="the-garbage-collection-handbook"&gt;&lt;a href="https://gchandbook.org/index.html" rel="noopener noreferrer"&gt;The Garbage Collection Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page introduces the second edition of &lt;em&gt;The Garbage Collection Handbook&lt;/em&gt;, the classic reference on automatic memory management. Descending from Richard Jones&amp;rsquo;s original &lt;em&gt;Garbage Collection&lt;/em&gt; (Wiley, 1996) and the first Handbook edition in 2012, this new edition thoroughly updates the material to reflect modern hardware, software, and runtime environments. It progresses from simple, traditional algorithms to modern parallel, incremental, concurrent, and real-time collectors, illustrated throughout with pseudocode and diagrams. The book analyzes high-performance commercial collectors in detail, explains tricky runtime interface mechanics, and adds over 90 pages of new material including chapters on persistence (non-volatile memory) and energy-aware garbage collection.&lt;/p&gt;
&lt;p&gt;Because nearly all modern programming languages rely on garbage collection, understanding how collectors work helps developers confidently select and tune them for their workloads. The e-book edition features over 37,000 internal cross-references linking chapters, sections, algorithms, figures, and original research papers, accompanied by an online bibliography database of nearly 3,400 garbage-collection publications. The first edition of the Handbook was also translated into Chinese and Japanese in 2016.&lt;/p&gt;
&lt;h2 id="vibe-coded-is-the-new"&gt;&lt;a href="https://gabriel-afonso.com/blog/vibe-coded-is-the-new-made-in-china/" rel="noopener noreferrer"&gt;Vibe-Coded Is the New &amp;ldquo;Made in China&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel Afonso notices that on &lt;code&gt;r/selfhosted&lt;/code&gt;, any new project labeled &amp;ldquo;vibe-coded&amp;rdquo; is immediately met with skepticism. Coined by Andrej Karpathy in early 2025, &amp;ldquo;vibe coding&amp;rdquo; means giving in to the vibes and letting large language models handle the implementation while you focus only on what you want to build. In Afonso&amp;rsquo;s view, the backlash usually isn&amp;rsquo;t about the code quality itself, but what the label signals. Historically, the sheer difficulty of building software acted as a natural filter: anyone who shipped an open-source project had invested enough sweat equity that they were likely to stick around and maintain it. Now that anyone can spin up an app in a few hours and code far beyond their actual skill level, a project&amp;rsquo;s author might not even understand the code they published. As a result, &amp;ldquo;vibe-coded&amp;rdquo; has become like the old &amp;ldquo;Made in China&amp;rdquo; label—shorthand for cheap, disposable software.&lt;/p&gt;
&lt;p&gt;He draws a parallel to chess: after Deep Blue defeated Kasparov in 1997, chess became even more popular as humans learned to work alongside engines. Respected developers like DHH, Tanner Linsley, and Boris Cherny (creator of Claude Code, who shared that 100% of his contributions over the prior 30 days were written by Claude Code) use AI heavily without drawing backlash because they remain true authors who understand and own their systems. Time remains the most reliable filter: a project maintained for two years with real users proves a level of commitment that cannot be faked. Today&amp;rsquo;s skepticism is simply the ecosystem&amp;rsquo;s immune system adapting while the rules are being rewritten.&lt;/p&gt;
&lt;h2 id="the-production-bug-that-made-me-care-about-undefined-behavior"&gt;&lt;a href="https://gaultier.github.io/blog/the_production_bug_that_made_me_care_about_undefined_behavior.html" rel="noopener noreferrer"&gt;The production bug that made me care about undefined behavior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philippe Gaultier recounts a production bug in a C++ system processing billions of euros in payments each year. An HTTP endpoint was supposed to return either &lt;code&gt;error&lt;/code&gt; or &lt;code&gt;succeeded&lt;/code&gt; set to &lt;code&gt;true&lt;/code&gt;—never both—yet clients occasionally received responses with both fields set to &lt;code&gt;true&lt;/code&gt;, even though each field was assigned at most once in mutually exclusive branches. The culprit was the declaration &lt;code&gt;Response response;&lt;/code&gt;. In C, reading an uninitialized struct field is straightforward undefined behavior; C++ is subtler: because &lt;code&gt;Response&lt;/code&gt; contained a &lt;code&gt;std::string&lt;/code&gt;, it was a non-POD type, so the compiler synthesized and called a default constructor—which default-constructed the &lt;code&gt;std::string&lt;/code&gt; but left the two &lt;code&gt;bool&lt;/code&gt; fields uninitialized with garbage stack bytes.&lt;/p&gt;
&lt;p&gt;The fix is to use value initialization (&lt;code&gt;Response response{};&lt;/code&gt;) to zero-initialize every field, or provide explicit default member initializers. Compilers emit no warning even with all warning flags enabled; &lt;code&gt;clang-tidy&lt;/code&gt; catches it statically, and AddressSanitizer paired with UndefinedBehaviorSanitizer (or Valgrind) catches it at runtime, though only if test coverage hits that code path and the stack happens to contain non-zero bytes. Gaultier wrote a custom &lt;code&gt;libclang&lt;/code&gt; plugin to scan the entire codebase for similar bugs. The post also highlights a bizarre C++ quirk: reading an uninitialized &lt;code&gt;std::byte&lt;/code&gt; or &lt;code&gt;unsigned char&lt;/code&gt; is permitted in many cases without triggering undefined behavior, whereas reading an uninitialized &lt;code&gt;bool&lt;/code&gt; is instant UB. His takeaway: C++ has far too many initialization syntaxes, looks deceptively like C while behaving differently, and changes its rules across language standards.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://antirez.com/news/158" rel="noopener noreferrer"&gt;Don&amp;rsquo;t fall into the anti-AI hype&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, loves crafting software line by line, yet admits that AI has changed programming forever. He used to think this inflection point was still a few years away, but changed his mind now that modern LLMs can complete major features or medium-sized projects almost autonomously. In a single week, by writing prompts and occasionally reviewing code to steer direction, he finished four projects in hours that would otherwise have taken weeks: adding UTF-8 support to his &lt;code&gt;linenoise&lt;/code&gt; library along with a pseudo-terminal test harness; fixing transient timing and TCP deadlock test failures in Redis; having Claude Code write a 700-line pure C library in 5 minutes to run BERT-style embedding inference within 15% of PyTorch&amp;rsquo;s speed; and having Claude Code reproduce internal Redis Streams changes from a design spec in about 20 minutes.&lt;/p&gt;
&lt;p&gt;In his view, writing code by hand is no longer necessary for most projects. He is happy that his open-source code was used to train models, seeing it as a continuation of the open-source mission to democratize code and knowledge; AI will empower small teams to compete with tech giants just as open source did in the 1990s. Still, he worries about this technology concentrating in the hands of a few corporations. His advice: don&amp;rsquo;t fall for anti-AI hype—give modern tools a serious multi-week trial rather than a five-minute test, because the joy of programming is building, and we can now build more and better than ever.&lt;/p&gt;
&lt;h2 id="performance-hints"&gt;&lt;a href="https://abseil.io/fast/hints.html" rel="noopener noreferrer"&gt;Performance Hints&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the &amp;ldquo;Performance Hints&amp;rdquo; guide written by Jeff Dean and Sanjay Ghemawat on Google&amp;rsquo;s Abseil site, distilling the principles and techniques they use when optimizing software performance. They quote Donald Knuth in full: we should forget about small efficiencies about 97% of the time, yet we should not pass up our opportunities in that critical 3%. The common advice to &amp;ldquo;write it simply first and optimize later&amp;rdquo; often fails in practice because large systems built without regard for performance end up with flat profiles where CPU time is diffused across thousands of functions with no obvious hotspot; instead, engineers should instinctively choose the faster alternative whenever it doesn&amp;rsquo;t noticeably harm readability. The guide shows how to do back-of-the-envelope estimates using basic latency numbers (L1 cache ~0.5 ns, branch mispredict ~5 ns, main memory ~50 ns), measure with profilers, and tackle flat CPU profiles by stacking many 1% wins or restructuring higher-level architecture.&lt;/p&gt;
&lt;p&gt;The remainder of the document is a catalog of concrete techniques with code examples: designing APIs that allow optimization behind encapsulation boundaries (such as bulk operations and passing buffers); algorithmic improvements; compact memory representations that touch fewer cache lines (indices instead of pointers, arenas, arrays instead of maps, bitvectors); reducing allocations by pre-sizing containers, reusing objects, and avoiding copies; avoiding unnecessary work via fast paths, precomputation, caching, and keeping logging off hot paths; controlling code size; and parallelizing with short critical sections, sharding to reduce contention, SIMD, and avoiding false sharing. It concludes with specific advice for Protocol Buffers and containers like &lt;code&gt;absl::flat_hash_map&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-job-market-2026-data-trends-and-outlook"&gt;&lt;a href="https://www.finalroundai.com/blog/software-engineering-job-market-2026" rel="noopener noreferrer"&gt;Software Engineering Job Market 2026: Data, Trends and Outlook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article analyzes why software engineering—once considered the safest career track—now feels vulnerable amid near-weekly layoff headlines. Indeed job-posting data via FRED shows software roles peaked in mid-2022, plunged through 2024, and have yet to rebound to pandemic highs. The primary driver isn&amp;rsquo;t AI, but the 2021–2022 digitization bubble: fear of missing out and near-zero interest rates led everyone from Big Tech to startups to overhire massively. When demand normalized, AI became a convenient scapegoat for headcount reductions. Another major factor is global remote hiring: a senior engineer might cost $100,000+ per year in the US versus $40,000 in India, and telling investors &amp;ldquo;we&amp;rsquo;re replacing roles with AI&amp;rdquo; sounds much more forward-looking than &amp;ldquo;we&amp;rsquo;re offshoring.&amp;rdquo; A METR study even found that experienced developers were 19% slower when using AI tools across 246 tasks.&lt;/p&gt;
&lt;p&gt;Even so, the profession isn&amp;rsquo;t disappearing—only demand for basic boilerplate coding is shrinking. The US Bureau of Labor Statistics still projects ~15% employment growth for software developers, SignalFire reports that Meta, Netflix, Uber, and Google are hiring faster than attrition, and Antler founder Magnus Grimeland points out that more AI-generated code means more bugs that require human engineers to fix. What has changed is the skill bar: system design, performance, security, and effective AI orchestration. Entry-level candidates face the toughest market, with junior postings down roughly 40% compared to pre-2022 levels. The article closes with recommended languages to learn in 2026: Python for AI/ML, JavaScript/TypeScript for frontend, Go for backend and cloud infrastructure, Java for enterprise, and Swift for iOS.&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/$s_!0P7Z!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7546f89c-8b6f-4ced-8d40-4e0137ab5941_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Co3P!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb7f3c175-c0d6-4d02-992d-114ac588b45c_2252x2752.png" alt="Top Developer Tools You Can Use in 2026"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Ty5s!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fecc68f5e-6353-4487-a779-92bb11440bc5_2360x2960.png" alt="5 Rate Limiting Strategies To Protect the System"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!dPjo!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2543392-5e04-4dd6-b39a-72fdfe3a3048_2360x2770.png" alt="How Live Streaming Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MJUT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F06243bf8-f149-4075-bc81-99af15be3579_6001x7802.png" alt="5 Leader Election Algorithms Powering Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Xrbz!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c99d0d5-8e5b-4e82-bb28-9fbd470e3bc6_2250x2624.png" alt="A Guide to Database Sharding"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!NCWv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0adc9c84-37f2-4a96-96a6-f7f26bbd1b7e_2360x2960.jpeg" alt="Modern Storage Systems"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #74</title><link>https://miti99.com/en/post/2025/12/27/</link><pubDate>Sat, 27 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/27/</guid><description>&lt;p&gt;&lt;em&gt;It&amp;rsquo;s been a while since I paid for anything AI-related (not since my Claude subscription to test out Claude Code). Today I decided to subscribe to &lt;a href="https://z.ai" rel="noopener noreferrer"&gt;Z.ai&lt;/a&gt;&amp;rsquo;s &lt;a href="https://z.ai/subscribe" rel="noopener noreferrer"&gt;GLM Coding Plan&lt;/a&gt; to give it a spin. The plan currently gives access to Z.ai&amp;rsquo;s latest model, GLM-4.7. From now on I&amp;rsquo;ll be pairing &lt;a href="https://claude.com/product/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt; with the &lt;a href="https://z.ai/model-api" rel="noopener noreferrer"&gt;Z.ai API&lt;/a&gt; to squeeze every bit of value out of what I paid for^^. Enjoy Newsletter #74.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="goodbye-microservices-from-100s-of-problem-children-to-1-superstar"&gt;&lt;a href="https://www.twilio.com/en-us/blog/developers/best-practices/goodbye-microservices" rel="noopener noreferrer"&gt;Goodbye Microservices: From 100s of problem children to 1 superstar&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Twilio Segment recounts why they moved away from a microservices architecture for forwarding events to server-side destinations. Initially, all events flowed through a single shared queue, so whenever one destination slowed down or failed, retries caused head-of-line blocking across the entire system. To isolate failures, the team created a dedicated service and queue per destination and split each destination&amp;rsquo;s code into its own repository. That worked well at first, but once the number of destinations grew past 140, shared libraries drifted out of sync across repositories, each service had a distinct traffic profile that made autoscaling painful to configure, and three engineers were spending most of their time just keeping the lights on.&lt;/p&gt;
&lt;p&gt;Their solution was to consolidate everything back into a single service inside a monorepo, unify 120 dependencies onto a single version each, and build a Traffic Recorder to record and replay HTTP traffic during tests—shrinking the test suite for all 140+ destinations from an hour down to a few milliseconds. The result: noticeably faster development velocity (46 shared library improvements in a year compared to 32 previously), simpler scaling, and no more middle-of-the-night pages from traffic spikes. The trade-offs are harder fault isolation, less effective in-process caching, and the risk that upgrading a shared library can break multiple destinations at once. The lesson: moving back to a monolith requires a rock-solid test suite and a clear-eyed acceptance of the trade-offs.&lt;/p&gt;
&lt;h2 id="5-engineering-dogmas-it"&gt;&lt;a href="https://newsletter.manager.dev/p/5-engineering-dogmas-its-time-to" rel="noopener noreferrer"&gt;5 engineering dogmas it&amp;rsquo;s time to retire&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides proposes rethinking five familiar &amp;ldquo;truths&amp;rdquo; in software engineering. First, &amp;ldquo;don&amp;rsquo;t reinvent the wheel, use a library&amp;rdquo;: over-relying on third-party dependencies exposes projects to security vulnerabilities and constant update churn, famously illustrated when the ~11-line &lt;code&gt;left-pad&lt;/code&gt; package was unpublished from npm and broke builds at Facebook, Spotify, and Netflix. Second, &amp;ldquo;every PR must be reviewed&amp;rdquo;: code reviews are valuable, but rigid mandatory review gates slow teams down; at Pylon, engineers merge their own PRs and only request reviews when they want feedback, when a change is risky, or when onboarding, and pair programming is a strong alternative. Third, &amp;ldquo;2–4 week sprints are the modern way to work&amp;rdquo;: Basecamp&amp;rsquo;s Shape Up—with 6-week cycles followed by a 1–2 week scheduled cool-down off project work—shows there are viable ways to organize work beyond Scrum and Kanban.&lt;/p&gt;
&lt;p&gt;Fourth, &amp;ldquo;every change should be behind a feature flag&amp;rdquo;: when overused, hundreds of active flags make the codebase complex, combinatorially hard to test, and create a false sense of security; sometimes thorough testing in staging followed by a direct release is all you need. Fifth, &amp;ldquo;if your code needs comments, it&amp;rsquo;s too complex&amp;rdquo;: extremes in either direction miss the mark, as a one- or two-line comment can save hours for the next person reading the code. He concludes that none of these dogmas are completely wrong, but a good engineering manager knows how to balance them against their team&amp;rsquo;s reality.&lt;/p&gt;
&lt;h2 id="what-does-a-database-for-ssds-look-like"&gt;&lt;a href="https://brooker.co.za/blog/2025/12/15/database-for-ssd.html" rel="noopener noreferrer"&gt;What Does a Database for SSDs Look Like?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker asks what a relational database designed from scratch for SSDs in 2025 would look like, given that Postgres and MySQL were born in the era of spinning disks while modern NVMe SSDs are roughly 1,000x faster in both throughput and latency. Re-evaluating Jim Gray&amp;rsquo;s &amp;ldquo;five-minute rule&amp;rdquo; against current EC2 pricing, a buffer pool should cache pages expected to be re-read within about 30 seconds to optimize cost. Because SSDs are throughput-bound for transfers above ~32 KB and IOPS-bound for smaller blocks, average transfer sizes shouldn&amp;rsquo;t be much smaller than 32 KB. And since writing to a local SSD only provides single-machine durability, a modern database should synchronously replicate across Availability Zones (AZs)—paying cross-AZ latency only at commit time—while using high-precision hardware clocks to support strongly consistent scale-out reads.&lt;/p&gt;
&lt;p&gt;On write-ahead logging (WAL), he argues that flushing to a local disk on a single machine is both unnecessary and insufficient; instead, transactions should commit to a distributed log that guarantees durability across multiple machines and AZs, recovering by replaying the log on any replica. His conclusion: keep the relational model, SQL, atomicity, isolation (defaulting to SNAPSHOT), and strong consistency, but turn durability, read/write scalability, and high availability into distributed problems while stripping out most legacy optimizations built around local disk durability and recovery.&lt;/p&gt;
&lt;h2 id="the-economics-of-system-design-finops-auto-scaling-and-spot-instances"&gt;&lt;a href="https://designgurus.substack.com/p/cloud-cost-optimization-101-5-strategies" rel="noopener noreferrer"&gt;The Economics of System Design: FinOps, Auto-Scaling, and Spot Instances&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post emphasizes that cost is often an afterthought in system design, even though an estimated 30% of cloud spend is wasted on underutilized resources. Small inefficiencies like a redundant query or an idle server might be negligible with 100 users, but balloon into massive bills at millions of users. Cost should therefore be treated as a first-class concern from the initial design phase, because retrofitting cost efficiency onto an inherently expensive architecture is far harder.&lt;/p&gt;
&lt;p&gt;The author outlines five strategies: design for efficiency from day one by weighing the overhead of microservices and favoring simplicity; right-size resources and use autoscaling and pay-per-use serverless offerings; add caching layers like Redis and optimize queries (fetching only needed fields and indexing properly) to reduce database load; regularly hunt down and terminate idle resources like forgotten test environments and schedule non-production systems to shut down overnight; and finally, monitor spend, set cost alerts, and build a FinOps culture where engineers treat cost as a performance metric. A well-designed system isn&amp;rsquo;t just scalable and fast—it&amp;rsquo;s also cost-effective.&lt;/p&gt;
&lt;h2 id="the-big-o-complexity-of-vibe-coders"&gt;&lt;a href="https://www.shiveesh.com/thoughts-and-ideas/the-big-o-complexity-of-vibe-coders" rel="noopener noreferrer"&gt;The Big-O Complexity of Vibe Coders&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Today, vibe coding (programming by conversing with an LLM) is mostly judged by how quickly it produces results, but the author predicts that as enterprise LLM adoption scales, the question will shift to how costs grow—much like analyzing an algorithm&amp;rsquo;s Big-O complexity. Teams that don&amp;rsquo;t use vibe coding move slowly, while teams that abuse it with rapid fire-and-retry prompting rack up huge token bills without understanding why. Every prompt and every correction consumes tokens, so a workflow with many quick retry loops can exhibit closer to O(n²) token complexity rather than O(n). Vague prompts widen the solution space and force repeated corrections, whereas precise prompts that state constraints up front converge much faster.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, the best vibe coders aren&amp;rsquo;t the ones who iterate the fastest, but the ones with the lowest token &amp;ldquo;Big-O&amp;rdquo; per shipped outcome; vibe coding makes individuals faster, while token-efficient vibe coding lets whole teams scale. That said, this lens doesn&amp;rsquo;t apply to creative or exploratory work like brainstorming or exploring dead ends, which is inherently token-inefficient yet still valuable and shouldn&amp;rsquo;t be forced into an optimization metric.&lt;/p&gt;
&lt;h2 id="design-is-more-than-code"&gt;&lt;a href="https://linear.app/now/design-is-more-than-code" rel="noopener noreferrer"&gt;Design is more than code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Karri Saarinen, co-founder of Linear, argues that the &amp;ldquo;should designers code?&amp;rdquo; debate is far too narrow. The bigger question is how the designer&amp;rsquo;s role evolves with AI and modern tools, and what we lose if we push designers to jump straight into code. Design takes many forms depending on the domain, customers, and people involved—and even engineers regularly step away from code to sketch architecture or weigh trade-offs. In his view, the first step is &amp;ldquo;problem design&amp;rdquo;: questioning whether the problem is real and who defines it rather than taking it as a given, since the most common reason design projects drag on or fail is an unclear problem where everyone has a different mental model.&lt;/p&gt;
&lt;p&gt;Next comes &amp;ldquo;solution design,&amp;rdquo; which has two phases: a conceptual phase to find the overall shape (at Linear, for example, a project is modeled as a distinct entity with its own properties rather than just a label grouping issues), and an execution phase that brings the idea to the screen, where code and real materials are essential. He likens the upfront work to preparing the goal, context, and prompt for an agent. What worries him isn&amp;rsquo;t the tooling itself, but the erosion of deliberate thought when building straight in production becomes the default; to him, design is always about finding the right problem, the right intent, and the right vision.&lt;/p&gt;
&lt;h2 id="how-we-saved-70-cpu-and-60-memory-in-refinery"&gt;&lt;a href="https://www.honeycomb.io/blog/how-we-saved-70-cpu-60-memory-refinery" rel="noopener noreferrer"&gt;How we saved 70% CPU and 60% memory in Refinery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Honeycomb shares how Refinery 3.0, their Go-based tail-based trace sampling proxy, cut CPU usage by 70% and memory usage by 60% on their internal cluster—enough to shrink a 72-node cluster in half. Profiling revealed that the root cause was deserializing every incoming span in full into a &lt;code&gt;map[string]any&lt;/code&gt; with hundreds of fields: roughly 50% of CPU time went to memory allocation and nearly a quarter to garbage collection, while the actual sampling logic took only about 12%—and most spans were ultimately discarded anyway.&lt;/p&gt;
&lt;p&gt;The fix was to stop deserializing altogether: Refinery now selectively extracts only the handful of fields needed for sampling directly from the serialized MessagePack payload and keeps the span in its compact serialized form. In benchmarks, selective extraction took about 17 ns with zero allocations, compared to roughly 296 ns and 9 allocations when unmarshaling into a map. Other input formats (JSON, OTLP) are transcoded directly into MessagePack on ingest. The team also optimized metrics instrumentation, pooled large buffers for reuse, and parallelized the decision loop. The resulting code is longer and more complex, but it didn&amp;rsquo;t require fancy algorithms or a rewrite in Rust—just redefining what the process actually needed to do and doing only that.&lt;/p&gt;
&lt;h2 id="from-junior-to-senior-7-api-design-patterns-that-scale"&gt;&lt;a href="https://designgurus.substack.com/p/from-junior-to-senior-7-api-design" rel="noopener noreferrer"&gt;From Junior to Senior: 7 API Design Patterns That Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through seven architectural decisions that help APIs scale—and that distinguish junior developers (who focus on internal logic) from seniors (who focus on how systems communicate). First, resource-oriented design: instead of RPC-style endpoints like &lt;code&gt;POST /updateUserEmail&lt;/code&gt;, use nouns like &lt;code&gt;/users&lt;/code&gt; and let HTTP methods (&lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, &lt;code&gt;PATCH&lt;/code&gt;, &lt;code&gt;DELETE&lt;/code&gt;) express the action, making the API predictable. Second, return proper HTTP status codes instead of always returning &lt;code&gt;200 OK&lt;/code&gt; with an error message in the body, since monitoring tools, load balancers, and caches rely on status codes; distinguishing &lt;code&gt;4xx&lt;/code&gt; (client error) from &lt;code&gt;5xx&lt;/code&gt; (server error) is crucial during debugging. Third, pagination: offset pagination slows down as datasets grow because the database still has to scan past skipped rows, whereas cursor-based pagination uses an indexed value to keep performance steady.&lt;/p&gt;
&lt;p&gt;Fourth, idempotency keys prevent duplicate processing of retried requests, such as charging a customer twice when they tap submit again on a flaky connection. Fifth, rate limiting protects the system from overload. Sixth, API versioning prevents breaking existing clients. Seventh, comprehensive documentation with OpenAPI/Swagger keeps teams aligned. Good API design lays a stable foundation for business growth, while poor design quickly becomes a bottleneck.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!3GQA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F82f1e76a-8fbf-4e8f-b030-e20037c66f70_3000x3900.png" alt="Evolution of HTTP"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Zyn0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F063ae714-8714-4695-8b0e-16a765c5c1a8_2360x2960.png" alt="System Performance Metrics Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ta7a!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe42382d5-9be5-443a-9f75-56ecfa22569c_2360x2960.png" alt="Why Is Nginx So Popular?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!sXIK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa25e1401-cc6f-49f1-9ed1-6f093a01ac6c_2360x2664.png" alt="Network Debugging Commands Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!BXWB!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F09a8b52f-2b80-4762-92cd-c5d18d5a7a3c_2360x2960.png" alt="Hub, Switch, &amp;amp; Router Explained"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;Z.ai processes individual URLs relatively quickly and looked pretty decent at first, though the more URLs I added, the longer and more English-heavy the summaries became. I had to ask it to trim them down a bit. Hopefully I can tune it further (since I already paid for it and it&amp;rsquo;s non-refundable, haha).&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #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 #8</title><link>https://miti99.com/en/post/2025/03/24/</link><pubDate>Mon, 24 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #8.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="let"&gt;&lt;a href="https://info.michael-simons.eu/2025/02/05/lets-deadlock-all-the-things/" rel="noopener noreferrer"&gt;Let&amp;rsquo;s deadlock all the things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael J. Simons recounts a &amp;ldquo;rookie mistake&amp;rdquo; he made while migrating code from legacy &lt;code&gt;HttpURLConnection&lt;/code&gt; to Java&amp;rsquo;s modern &lt;code&gt;HttpClient&lt;/code&gt;. Because &lt;code&gt;HttpClient&lt;/code&gt; does not directly expose an &lt;code&gt;OutputStream&lt;/code&gt; for streaming data into a request body (for instance, when using Jackson to serialize a large JSON payload), he connected a &lt;code&gt;PipedInputStream&lt;/code&gt; and a &lt;code&gt;PipedOutputStream&lt;/code&gt; and ended up performing both the write and the read on the same thread—even though the JavaDoc explicitly warns that doing so can deadlock. Initial unit tests passed because the test payloads were tiny, but as soon as a payload exceeded the default 1,024-byte pipe buffer in production, the thread blocked forever; repeated enough times, it starves the entire thread pool.&lt;/p&gt;
&lt;p&gt;What could have prevented the bug, the author reflects, was a little less overconfidence, a second pair of eyes in code review, and thorough boundary testing. AI assistants might help generate larger test payloads, he notes, but rarely catch subtle API misuses—and even IntelliJ didn&amp;rsquo;t flag a warning. The fix was to create the two streams independently, connect them outside both the reader and writer lambdas, run the write operation on a dedicated virtual thread, and close the output stream inside that thread. It&amp;rsquo;s a great reminder to read the JavaDoc carefully and understand the threading model of the APIs you use.&lt;/p&gt;
&lt;h2 id="engineers-who-won"&gt;&lt;a href="https://www.seangoedecke.com/taking-a-position/" rel="noopener noreferrer"&gt;Engineers who won&amp;rsquo;t commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that sitting on the fence in technical discussions is only acceptable when you are a junior engineer. Once you are the person in the room with the most context, skill, or influence, you have a responsibility to take a position—even when you are only 55–60% confident. Staying silent forces less-informed teammates to guess, creates a vacuum where the loudest, least-competent voice can steer the group into a bad idea, and ultimately punts hard technical decisions onto engineering managers. The author bluntly calls this refusal to commit cowardice, rooted in a fear of being wrong that he himself had to overcome earlier in his career.&lt;/p&gt;
&lt;p&gt;Managers, he notes, are generally quite forgiving when you make a well-reasoned call that turns out to be wrong, as long as you aren&amp;rsquo;t wrong all the time. Refusing to give time estimates is the same failure mode: managers need a rough ballpark to plan around, and answering &amp;ldquo;it depends&amp;rdquo; just forces them to make up a number themselves. The one exception is genuinely toxic workplaces where engineers are punished for missed estimates—there, keeping your head down is understandable. He also adds that when brainstorming with peers who share your level of context, staying open-minded and exploratory is completely fine.&lt;/p&gt;
&lt;h2 id="patterns-for-building-realtime-features"&gt;&lt;a href="https://zknill.io/posts/patterns-for-building-realtime/" rel="noopener noreferrer"&gt;Patterns for building realtime features&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zak Knill surveys four common architectural patterns for building real-time features where a server pushes one user&amp;rsquo;s changes out to other connected clients. The &lt;strong&gt;poke/pull&lt;/strong&gt; pattern is the easiest to bolt onto an existing system: the server sends a lightweight &amp;ldquo;poke&amp;rdquo; notification prompting clients to refetch the latest state via standard HTTP APIs, though this can trigger a thundering herd of simultaneous requests that must be mitigated with caching or client-side jitter. &lt;strong&gt;Push state&lt;/strong&gt; sends the entire updated state payload directly, preventing client drift, but scales poorly as state objects grow and makes it hard for clients to tell exactly what changed. &lt;strong&gt;Push ops&lt;/strong&gt; sends only the delta operation (such as flipping a todo item&amp;rsquo;s &lt;code&gt;completed&lt;/code&gt; field), keeping payloads small, but requires a way to fetch initial state and demands that the server track each client&amp;rsquo;s current state version. &lt;strong&gt;Event sourcing&lt;/strong&gt; broadcasts the domain event itself, requiring every client to reimplement the business logic needed to interpret and fold that event into local state.&lt;/p&gt;
&lt;p&gt;At the transport layer, WebSockets, Server-Sent Events (SSE), and long polling all operate as 1-to-1 HTTP connections between a single client and a single server instance. Once you scale horizontally across multiple server replicas, the instance that processes a write is often not the instance holding open connections to the other clients that need the update. Rather than having every server replica poll the database, the author recommends using a Pub/Sub backbone to fan updates out across instances and manage connection infrastructure.&lt;/p&gt;
&lt;h2 id="optimizing-the-databases-at-quora"&gt;&lt;a href="https://quoraengineering.quora.com/Optimizing-the-databases-at-Quora" rel="noopener noreferrer"&gt;Optimizing the databases at Quora&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Quora engineering team shares how they optimized their database tier as the platform scaled to handle massive data volumes while keeping user-facing latency low. Their first strategy was partitioning data (sharding) by &lt;code&gt;user_id&lt;/code&gt; to distribute load across multiple database servers. Alongside sharding, the team profiled common query patterns, added targeted indexes, and eliminated redundant queries. Quora also built a multi-layered caching architecture—spanning application-level caches for hot objects, database-level query caching, and a distributed Memcached tier—while separating read and write paths so each side could scale independently.&lt;/p&gt;
&lt;p&gt;Beyond those core techniques, Quora invested heavily in comprehensive monitoring and alerting to track database health and catch anomalies early. Key takeaways include treating performance optimization as an ongoing discipline rather than a one-off project, building automation tooling for routine database administration, and constantly balancing raw performance gains against system simplicity.&lt;/p&gt;
&lt;h2 id="failure-mitigation-for-microservices-an-intro-to-aperture"&gt;&lt;a href="https://careersatdoordash.com/blog/failure-mitigation-for-microservices-an-intro-to-aperture/" rel="noopener noreferrer"&gt;Failure Mitigation for Microservices: An Intro to Aperture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cong Ma and Matt Ranney from DoorDash examine common failure modes in microservice architectures: cascading failures rippling across service dependencies, retry storms where aggressive retries pile extra load onto an already degraded service, death spirals where failed nodes shift traffic onto surviving nodes until they collapse too, and metastable failures where a positive feedback loop keeps a system wedged even after the original trigger disappears. Traditional defenses like local load shedding, circuit breakers, and reactive autoscaling only see a single service&amp;rsquo;s local state, require brittle threshold tuning, and cannot coordinate with one another; the authors also advocate predictive autoscaling over reactive scaling that kicks in only after load has already spiked.&lt;/p&gt;
&lt;p&gt;From there, the post evaluates Aperture, an open-source reliability management platform from FluxNinja designed around global visibility and closed-loop control. Aperture collects telemetry from service nodes into Prometheus, uses a standalone controller to monitor deviations from SLOs based on declarative YAML policies, and actuates proportional responses—such as load shedding or distributed rate limiting—at individual nodes. After integrating Aperture into a core service in their staging environment, DoorDash found it worked well as an easy-to-configure load shedder compared to their existing setup, though more advanced capabilities like coordinated multi-service failure mitigation remained to be tested.&lt;/p&gt;
&lt;h2 id="zero-configuration-service-mesh-with-on-demand-cluster-discovery"&gt;&lt;a href="https://netflixtechblog.com/zero-configuration-service-mesh-with-on-demand-cluster-discovery-ac6483b52a51" rel="noopener noreferrer"&gt;Zero Configuration Service Mesh with On-Demand Cluster Discovery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team recounts their journey migrating to a service mesh. Netflix began moving to the cloud in 2008, with the streaming platform running entirely on AWS by 2010. Back when cloud-native tooling barely existed, they built Eureka for service discovery and Ribbon for inter-process communication (IPC). That architecture served them well for a decade, but as internal traffic diversified across REST, GraphQL, and gRPC in multiple programming languages—and teams needed advanced capabilities like adaptive concurrency limits and circuit breaking—maintaining polyglot client libraries became unsustainable. Moving to an Envoy-based service mesh let them centralize IPC logic in an out-of-process proxy.&lt;/p&gt;
&lt;p&gt;The biggest roadblock was that Envoy expects every upstream cluster a service might call to be declared ahead of time, whereas a typical Netflix service talks to dozens of upstream clusters whose owners often don&amp;rsquo;t know the full dependency list—and pushing every cluster in the company to every Envoy proxy was impossible with millions of endpoints. Netflix partnered with Kinvolk and the Envoy community to build &lt;strong&gt;On-Demand Cluster Discovery&lt;/strong&gt;: when an outgoing request targets an unknown cluster, Envoy pauses the request, queries the control plane via CDS (Cluster Discovery Service), fetches its endpoints via EDS backed by Eureka, and resumes the request. This made migration completely zero-configuration for service owners, at the cost of a few extra milliseconds on the very first request to a new cluster—meaning only ultra-latency-sensitive services need to pre-declare clusters or pre-warm connections.&lt;/p&gt;
&lt;h2 id="the-quest-to-understand-metric-movements"&gt;&lt;a href="https://medium.com/pinterest-engineering/the-quest-to-understand-metric-movements-8ab12ae97cda" rel="noopener noreferrer"&gt;The Quest to Understand Metric Movements&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Pinterest engineering team introduces the three pillars behind their automated Root Cause Analysis (RCA) system for investigating sudden spikes or drops in core business metrics—movements that can stem from anything from an OS upgrade to a broken data pipeline. The first approach, &lt;strong&gt;Slice and Dice&lt;/strong&gt;, breaks a metric down across dimensions like country, device type, and Pin format into a hierarchical segment tree (inspired by LinkedIn&amp;rsquo;s ThirdEye) and scores each segment&amp;rsquo;s anomaly contribution; this proved especially effective for video playback metrics. The second approach, &lt;strong&gt;General Similarity&lt;/strong&gt;, searches for other metrics that moved in a similar pattern over the same time window using Pearson correlation, Spearman rank correlation, Euclidean distance, and dynamic time warping—with Pearson and Spearman proving most useful because they provide p-values and capture inverse relationships cleanly (with the standard caveat that correlation does not imply causation).&lt;/p&gt;
&lt;p&gt;The third approach, &lt;strong&gt;Experiment Effects&lt;/strong&gt;, inverts traditional A/B test analysis: given a moving metric, it ranks active experiments that had the strongest statistically significant impact on that metric using Welch&amp;rsquo;s t-test and noise filters, and is now integrated into Pinterest&amp;rsquo;s experimentation platform covering nearly 2,000 metrics. Analysts can chain all three techniques iteratively to narrow down root causes. Looking ahead, Pinterest plans to incorporate user feedback loops, explore causal discovery to map cause-and-effect graphs across metrics, and embed RCA directly into their data discovery and visualization tools.&lt;/p&gt;
&lt;h2 id="meta"&gt;&lt;a href="https://cacm.acm.org/research/metas-hyperscale-infrastructure-overview-and-insights/" rel="noopener noreferrer"&gt;Meta&amp;rsquo;s Hyperscale Infrastructure: Overview and Insights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chunqiang Tang provides a sweeping overview of Meta&amp;rsquo;s hyperscale infrastructure and the lessons learned along the way, arguing that while few engineers directly build infrastructure at this scale, many mainstream industry technologies originate there. Meta&amp;rsquo;s engineering culture revolves around four pillars: moving fast with continuous deployment, technological openness via a unified monorepo and major open-source projects like PyTorch, Llama, and Presto, conducting systems research directly on production infrastructure rather than in an isolated research lab, and standardizing on shared infrastructure building blocks (for instance, converging product teams onto ZippyDB as a common key-value store). To maximize developer productivity, Meta pushes continuous deployment to extreme scale—executing over 100,000 configuration changes per day with 97% of services deploying completely automatically, while roughly 50% more engineers write serverless functions than traditional long-running services.&lt;/p&gt;
&lt;p&gt;To drive down hardware costs, Meta treats its global fleet of data centers as a single planet-scale computer, automatically placing and migrating workloads across regions, co-designing hardware and software to compensate for commodity hardware failure rates, and tiering storage across hot, warm, and cold media. On the AI front, Meta co-designs the entire stack—from PyTorch, custom AI accelerators, and datacenter fabrics up to foundation models like Llama—and projects that before the end of the decade, more than half of its datacenter power capacity will be dedicated to AI workloads.&lt;/p&gt;
&lt;h2 id="incremental-platforms-monolithic-modular-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-platforms-monolithic" rel="noopener noreferrer"&gt;Incremental Platforms: Monolithic Modular Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kicking off a series on incremental architecture for SaaS products, Marcos F. Lobo introduces the &lt;strong&gt;Modular Monolith&lt;/strong&gt;: packaging and deploying the entire application as a single artifact while structuring the internal codebase into well-defined modules with clear responsibilities that communicate strictly through explicit interfaces and contracts. This approach retains the operational simplicity of a monolith while capturing the modularity benefits of decoupled design. To pull it off, the author advises defining strict module boundaries and using patterns like Facade to hide internal implementation details, enforcing high cohesion and low coupling within each module, aligning package structure with module boundaries so modules can be extracted later if needed, pairing use-case testing with CI/CD, and wiring dependencies via dependency injection or in-process messaging and events.&lt;/p&gt;
&lt;p&gt;The benefits include simple single-artifact deployment and operations, easier refactoring and local development, fast in-memory calls between modules instead of network RPCs, straightforward transactional consistency, and natural alignment with Domain-Driven Design when modules map to bounded contexts. According to the author, a modular monolith is an ideal starting point for early-stage products, small teams, and systems that prioritize strong consistency, while serving as a clean stepping stone toward microservices if and when business scale demands it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos-from-bytebytego"&gt;Bonus: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Kqal7QaCCM" rel="noopener noreferrer"&gt;How the Garbage Collector Works in Java, Python, and Go!&lt;/a&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus 2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c3beec9e-cd04-4748-ae7e-3299b42883f6_2360x2824.png" alt="How to Build Idempotent APIs"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2f632296-4214-4ec8-a1d2-280e9b7f2696_1280x1532.gif" alt="12 Algorithms for System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/65a92a81-f2c5-4aed-9faa-35a66124cffe_1283x1536.gif" alt="How Kubernetes Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a6903386-4b5f-450e-b64d-839c6fdf8238_1280x1601.gif" alt="PostgreSQL 101: The Everything Database"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/06c5ad46-faaf-479b-bde3-b5de8033b4e9_1280x1664.gif" alt="Top 12 Tips for API Security"&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-images-from-designgurus"&gt;Bonus 3: Interesting images from &lt;a href="https://designgurus.io/" rel="noopener noreferrer"&gt;DesignGurus&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://www.designgurus.io/_next/image?url=https%3A%2F%2Fstorage.googleapis.com%2Fdownload%2Fstorage%2Fv1%2Fb%2Fdesigngurus-prod.appspot.com%2Fo%2Fee5726e8e29469477b999c100%3Fgeneration%3D1726724098184989%26alt%3Dmedia&amp;amp;w=3840&amp;amp;q=75&amp;amp;dpl=dpl_3Rx6M949Pc1cQKT3QTdj87FcKNdg" alt="System Design Master Template"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #2</title><link>https://miti99.com/en/post/2025/02/16/</link><pubDate>Sun, 16 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/16/</guid><description>&lt;i&gt;
Hello everyone, right on schedule, here is my Newsletter #2. I went on a weekend trip to Xuyên Mộc and just got back today, which is why this issue is going up a bit late.
&lt;p&gt;Without further ado, let&amp;rsquo;s jump straight into MiTi&amp;rsquo;s Newsletter #2.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="some-things-to-expect-in-2025"&gt;&lt;a href="https://lwn.net/Articles/1003780/" rel="noopener noreferrer"&gt;Some things to expect in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In keeping with his New Year tradition, LWN.net&amp;rsquo;s Jonathan Corbet shares a set of predictions for the Linux and free software communities in 2025. Sched-ext—the mechanism for loading CPU schedulers from user space as BPF programs—will ship in more distributions, sparking a wave of new scheduling ideas tested rapidly on real production systems. More Rust code will land in the Linux kernel, this time in components that everyday users will actually run without realizing it. The author also expects another XZ-style backdoor attempt to come to light, and predicts that single-maintainer projects will increasingly be viewed as a risk, both for security and maintainer burnout.&lt;/p&gt;
&lt;p&gt;A major project may discover it has merged a substantial amount of AI-generated code that the contributor didn&amp;rsquo;t actually understand, forcing a revert; alongside that, efforts to build truly free generative AI systems will continue. Free software foundations will keep facing funding struggles, though a dedicated fund to support maintainers may emerge. More cloud-dependent consumer devices will turn into &amp;ldquo;bricks&amp;rdquo; when their manufacturers go under, creating opportunities for open solutions like Home Assistant; open hardware like the OpenWrt One will gain traction, and alternative mobile Linux distributions will see renewed interest. Finally, the author worries that global geopolitical tensions will spill over into the community and urges everyone to hold fast to the spirit of building systems for all and welcoming contributions from anyone.&lt;/p&gt;
&lt;h2 id="why-you-should-use-compact-table-columns"&gt;&lt;a href="https://vladmihalcea.com/compact-table-columns/" rel="noopener noreferrer"&gt;Why you should use compact table columns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vlad Mihalcea explains why choosing compact column types matters when designing database schemas. Relational database management systems cache disk pages in a Buffer Pool (such as PostgreSQL&amp;rsquo;s shared buffers); because RAM is orders of magnitude faster than SSDs, narrower columns pack more rows and index entries into each page, allowing more queries to be served directly from memory. StackOverflow is a prime example: they serve roughly 11,000 queries per second from a single active SQL Server node thanks to 1.5 TB of RAM fronting a 2.8 TB database and a Frugal Schema—avoiding 16-byte UUIDs for primary and foreign keys, using 4-byte &lt;code&gt;int&lt;/code&gt; or 1-byte &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;bigint&lt;/code&gt; for most primary keys, keeping enums to 1 byte, and bounding &lt;code&gt;VARCHAR&lt;/code&gt; column lengths.&lt;/p&gt;
&lt;p&gt;The author backs this up with concrete measurements. On MySQL, in a five-million-row &lt;code&gt;customer&lt;/code&gt; table, using &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;smallint&lt;/code&gt; for a single indexed foreign key saves about 71.59 MB; across ten such columns on a 100-million-row table, that adds up to roughly 14.3 GB. PostgreSQL lacks a 1-byte integer type and enforces column data alignment, so columns should be ordered using &amp;ldquo;Column Tetris&amp;rdquo; to avoid wasted padding bytes; even so, using &lt;code&gt;smallint&lt;/code&gt; instead of &lt;code&gt;int&lt;/code&gt; shrinks the &lt;code&gt;customer&lt;/code&gt; table by 38 MB. The takeaway: right-sizing column types is a proven performance optimization strategy that has served StackOverflow well for over 15 years.&lt;/p&gt;
&lt;h2 id="rate-limiting-with-redis-an-essential-guide"&gt;&lt;a href="https://foojay.io/today/rate-limiting-with-redis-an-essential-guide/" rel="noopener noreferrer"&gt;Rate limiting with Redis: An essential guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio opens with familiar encounters with rate limiting, such as &amp;ldquo;429 Too Many Requests&amp;rdquo; errors or tiered API quotas. Rate limiting prevents abuse, ensures fair access, smooths traffic spikes, controls costs, and protects service availability: Figma famously stopped a mass-invite spam attack using a Redis-backed rate limiter, while Stripe relies on rate limiting to keep misconfigured scripts or bad actors from monopolizing resources. Redis is a popular choice thanks to its speed, reliability, atomic operations, persistence options, and Lua scripting; GitHub also migrated to a Redis-based rate-limiting setup with client-side sharding.&lt;/p&gt;
&lt;p&gt;The article compares five common algorithms. Leaky Bucket processes requests at a steady rate, ideal for smooth traffic flows but unforgiving of bursts; Token Bucket allows short bursts as long as tokens remain; Fixed Window Counter is simple to implement but vulnerable to boundary spikes across adjacent time windows; Sliding Window Log is the most accurate but consumes significant memory and CPU at scale; and Sliding Window Counter balances accuracy with resource efficiency. Choosing the right algorithm depends on traffic patterns, required precision, resource constraints, and user experience. As the author notes, rate limiting isn&amp;rsquo;t just about setting caps—it&amp;rsquo;s about designing efficient, fair, and user-friendly systems; follow-up posts implementing each algorithm in Java and Redis will roll out weekly.&lt;/p&gt;
&lt;h2 id="why-does-cloudflare-pages-have-such-a-generous-free-tier"&gt;&lt;a href="https://mattsayar.com/why-does-cloudflare-pages-have-such-a-generous-free-tier/" rel="noopener noreferrer"&gt;Why does Cloudflare Pages have such a generous Free tier?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Sayar, who hosts his personal site on Cloudflare Pages, wonders why there are so many high-quality free hosting tiers available today. The biggest concern with free hosting is bandwidth, since a surprise viral post can stick you with a massive bill or knock your site offline. Comparing providers, GitHub Pages has a soft limit of 100 GB per month, Netlify and AWS S3 offer around 100 GB, GitLab Pages throttles by requests per minute, whereas Cloudflare Pages offers completely unlimited bandwidth.&lt;/p&gt;
&lt;p&gt;The author outlines three practical reasons behind this generosity. First, static sites are tiny—his own site is only about 2.2 MB—so with Cloudflare&amp;rsquo;s massive edge network, aggressive caching, and optimization techniques, the marginal cost of serving them is negligible. Second, Cloudflare benefits from a fast, secure internet: the more people and businesses come online, the more enterprises need commercial security products—which is exactly what Cloudflare sells, in the same spirit as its free 1.1.1.1 DNS resolver and unmetered DDoS protection. Third is the classic freemium flywheel: developers try the free tier, have a great experience, and later champion Cloudflare&amp;rsquo;s paid plans at work. Although the author initially couldn&amp;rsquo;t find an official statement explaining the bandwidth policy, the Hacker News community pointed him to a Cloudflare post affirming their commitment to the free tier; even so, he keeps a mirror on GitHub just in case policies change.&lt;/p&gt;
&lt;h2 id="how-i-program-with-llms"&gt;&lt;a href="https://crawshaw.io/blog/programming-with-llms" rel="noopener noreferrer"&gt;How I program with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Crawshaw reflects on a year of actively programming with large language models (LLMs) and concludes that they deliver a clear productivity boost. He uses LLMs in three ways: code autocomplete, search engine replacement, and chat-driven programming—the hardest mode to master, but also the most valuable. Chat is especially helpful when you know what needs to be written but lack the energy to set up a new file and look up library APIs: the LLM produces a first draft with good structure, the right imports, and a few bugs, and fixing bugs is much easier than staring at a blank page. His advice is to frame prompts like exam questions: specific goals, self-contained context, and verifiable outputs—and always compile and run tests before reading the generated code closely.&lt;/p&gt;
&lt;p&gt;As a concrete example, he walks through writing a reservoir sampler in Go to estimate quartiles. The LLM generated a well-structured package with clean interfaces, though the initial code failed to compile due to an unused variable and included fabricated expected values in the unit test. When prompted, it wrote a naive reference implementation for comparison and a fuzz test that initially passed the wrong argument types, which it fixed as soon as the compiler error was pasted back; in the author&amp;rsquo;s experience, over 80% of tool-reported errors can be resolved by the LLM on its own. He argues that LLMs shift traditional software engineering trade-offs: favoring smaller packages, more thorough tests, and a looser adherence to DRY—such as generating a 200-line custom wrapper for the exact subset of an API you need rather than pulling in a bloated official SDK. He is currently automating these workflows at sketch.dev.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;p&gt;This week comes with quite a few bonuses from various sources.&lt;/p&gt;
&lt;h3 id="bonus-1-a-couple-of-ebooks-i-found"&gt;Bonus #1: A couple of ebooks I found&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://info.microsoft.com/rs/157-GQE-382/images/EN-CNTNT-eBook-DesigningDistributedSystems.pdf" rel="noopener noreferrer"&gt;Designing Distributed Systems&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://drive.google.com/file/d/1U7EchvgzCjTtF5JzGVVCFgjXC-qw7lIG/view" rel="noopener noreferrer"&gt;Quastor Summaries&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus #2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/11b53f30-8dba-4520-9b1a-425b54b9b84a_1280x1585.gif" alt="Cookies Vs Sessions Vs JWT Vs PASETO"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fdbcc119-8f5d-4d27-9a4b-2c8bde82b537_4026x8030.jpeg" alt="Algorithms you should know before taking System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/12dffcce-f231-48cc-915f-d53c0f8bce0c_3735x3573.jpeg" alt="Top 6 Load Balancing Algorithms"&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 #1</title><link>https://miti99.com/en/post/2025/02/08/</link><pubDate>Sat, 08 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/08/</guid><description>&lt;i&gt;
Hello everyone, here I am returning to blogging after another long lazy streak :D
&lt;p&gt;One problem I&amp;rsquo;ve noticed about myself—but have been too lazy to fix—is that I read a lot of blog posts and tinker with plenty of tools, yet rarely dive seriously enough into any single topic to turn it into a high-quality standalone post. And even when I do find something I really like, I&amp;rsquo;m too lazy to write a full post about it.&lt;/p&gt;
&lt;p&gt;So I&amp;rsquo;m trying a different format: rounding up the interesting blog posts I&amp;rsquo;ve stumbled upon and read over the past week into a weekly newsletter. I hope you&amp;rsquo;ll support it.&lt;/p&gt;
&lt;p&gt;Without further ado, here is my Newsletter #1.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="seconds-since-the-epoch"&gt;&lt;a href="https://aphyr.com/posts/378-seconds-since-the-epoch" rel="noopener noreferrer"&gt;Seconds Since the Epoch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many people still believe that POSIX time (or Unix time) is the number of seconds elapsed since 00:00:00 on January 1, 1970. The author points out that this is not strictly true: the IEEE 1003.1 standard defines POSIX time in terms of UTC and assumes every day is exactly 86,400 seconds long. In reality, the length of a day varies over time, so astronomers periodically insert leap seconds into UTC to keep it from drifting too far from the solar day. As a result, at the time of writing (late 2024), the POSIX timestamp is 27 seconds behind the actual number of elapsed seconds, and every few years the POSIX clock jumps backward by a second—a quirk that has caused major outages across the Internet.&lt;/p&gt;
&lt;p&gt;The article quotes the standard&amp;rsquo;s rationale appendix, showing that the committee was well aware of this discrepancy yet deliberately ignored leap seconds to keep arithmetic simple. As for solutions, the author recommends using &lt;code&gt;CLOCK_MONOTONIC&lt;/code&gt; or &lt;code&gt;CLOCK_BOOTTIME&lt;/code&gt; when measuring intervals on a single machine; using TAI or GPS time if you don&amp;rsquo;t need to exchange timestamps with external systems; and smearing leap seconds over a longer window if you must stay compatible with POSIX-time systems. The post concludes by noting ongoing efforts to abolish leap seconds altogether, slated to take effect by 2035.&lt;/p&gt;
&lt;h2 id="b-trees-more-than-i-thought-i"&gt;&lt;a href="https://benjamincongdon.me/blog/2021/08/17/B-Trees-More-Than-I-Thought-Id-Want-to-Know/" rel="noopener noreferrer"&gt;B-Trees: More Than I Thought I&amp;rsquo;d Want to Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on Alex Petrov&amp;rsquo;s &lt;em&gt;Database Internals&lt;/em&gt;, the author revisits B-Trees from a practical engineering perspective rather than dry textbook formulas. The motivating question is straightforward: when a key-value dataset no longer fits in memory, how do you design a disk-friendly data structure? Because disk reads and writes are orders of magnitude slower than RAM and always operate on whole pages, an on-disk binary search tree (BST) costs roughly one disk seek per key comparison. B-Trees solve this by packing hundreds of keys into a single node (high fanout), allowing each disk read to cover many more key comparisons.&lt;/p&gt;
&lt;p&gt;The author then walks through concrete implementation details: slotted pages consisting of a header, data cells, and an offset pointer array so keys can be reordered without moving cell payloads; separator key truncation in internal nodes to pack more keys per page; overflow pages that keep prefixes of oversized keys in the main page so most queries avoid extra reads; and sibling pointers that allow range scans without traversing back up to parent nodes. The post wraps up with variants like Lazy B-Trees, FD-Trees, and Bw-Trees, concluding that while these implementation optimizations don&amp;rsquo;t change Big-O complexity, they make a massive difference to real-world database performance.&lt;/p&gt;
&lt;h2 id="sql-nulls-are-weird"&gt;&lt;a href="http://raymondtukpe.com/sql-nulls-are-weird.html" rel="noopener noreferrer"&gt;SQL NULLs are Weird!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares a surprising behavior encountered while working on Convoy and LiteQueue: in SQL, &lt;code&gt;NULL = NULL&lt;/code&gt; evaluates to NULL rather than true, because NULL represents an unknown value. Consequently, under a UNIQUE constraint, every NULL is treated as distinct, meaning a column (or a composite constraint like &lt;code&gt;UNIQUE(email, deleted_at)&lt;/code&gt;) can still hold multiple &amp;ldquo;duplicate&amp;rdquo; rows whenever NULL is involved. This behavior is verified across SQLite, PostgreSQL, and MySQL, and SQLite&amp;rsquo;s own documentation acknowledges the inconsistency: NULL values are considered distinct in UNIQUE columns yet identical in &lt;code&gt;SELECT DISTINCT&lt;/code&gt; and &lt;code&gt;UNION&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;To enforce uniqueness properly, the post presents two approaches. The first adds a generated column using &lt;code&gt;COALESCE&lt;/code&gt; to replace NULL with a fixed sentinel value; however, this widens the table and still causes collisions if two rows share the same email and deletion timestamp. The second—recommended by the author—is a partial unique index on &lt;code&gt;email&lt;/code&gt; with &lt;code&gt;WHERE deleted_at IS NULL&lt;/code&gt;, which uses less space and is less error-prone because it constrains only active (non-deleted) rows. Additionally, modern relational databases support &lt;code&gt;IS [NOT] DISTINCT FROM&lt;/code&gt; for explicit NULL-safe comparisons.&lt;/p&gt;
&lt;h2 id="understanding-jvm-garbage-collector-performance"&gt;&lt;a href="https://mill-build.org/blog/6-garbage-collector-perf.html" rel="noopener noreferrer"&gt;Understanding JVM Garbage Collector Performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Li Haoyi&amp;rsquo;s post on the Mill blog explains JVM garbage collection (GC) from theoretical foundations to empirical benchmarks. The author starts with a simple copying GC: trace references from the roots to find live objects (the live-set), copy them to the empty half of the heap, and wipe the old half clean; this is contrasted with reference counting, which cannot compact the heap or reclaim cyclic references. Several key insights follow from this model: allocation is dirt cheap, pause times scale with the size of the live-set rather than the amount of garbage, and GC overhead shrinks as the total heap grows relative to the live-set.&lt;/p&gt;
&lt;p&gt;Benchmarks on Java 23 using G1 (the default GC) and ZGC confirm these takeaways. Adding more memory does not reduce individual pause times—it increases throughput by making collections less frequent; short-lived objects are collected much faster thanks to generational optimizations; and ZGC can bring pause times down to a few milliseconds if you are willing to provision roughly double the memory (with a heap at least four times the live-set, pauses drop to just a few milliseconds). The closing section offers practical advice: shrink the live-set by moving large datasets out of process (into SQLite, Redis, or Memcached), be careful with in-process LRU caches, and keep in mind that consolidating many small processes into one giant process can worsen GC pause times.&lt;/p&gt;
&lt;h2 id="a-deep-dive-into-jvm-start-up"&gt;&lt;a href="https://www.youtube.com/watch?v=ED1oc7gn5uY" rel="noopener noreferrer"&gt;A Deep Dive into JVM Start-Up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Before the familiar &lt;code&gt;System.out.println(&amp;quot;Hello World&amp;quot;)&lt;/code&gt; line ever runs, the JVM has already done a tremendous amount of work behind the scenes. This presentation on the official Java YouTube channel walks through the entire JVM startup sequence: parsing command-line arguments, probing system resources, initializing the runtime environment, and then loading, linking, and initializing classes—everything the JVM must do to &amp;ldquo;create the universe&amp;rdquo; for your application.&lt;/p&gt;
&lt;p&gt;The final part of the video previews upcoming changes under Project Leyden, which promises substantial improvements to JVM startup time and warmup performance. It is a great reference for Java developers who want a deeper understanding of the core platform they rely on every day.&lt;/p&gt;
&lt;h2 id="parallel-processing-with-virtual-threads---a-comparative-analysis"&gt;&lt;a href="https://www.dhaval-shah.com/parallel-processing-virtual-threads-reactor-vs-jdk/" rel="noopener noreferrer"&gt;Parallel processing with Virtual Threads - A comparative analysis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on an earlier post comparing parallel processing between Spring Core Reactor and JDK 21, the author evaluates both approaches when running on virtual threads. The article recaps the limitations of OS platform threads: heavy resource footprint, a bounded number of concurrent threads, reduced scalability under blocking operations, and expensive context switches. Virtual threads from Project Loom are managed by the JVM, making them cheap to create and block, capable of scaling to millions of threads, and ideal for I/O-heavy workloads. The author shares code for both implementations: one using JDK &lt;code&gt;CompletableFuture&lt;/code&gt; backed by a virtual-thread executor, and one using Reactor&amp;rsquo;s &lt;code&gt;Flux&lt;/code&gt; and &lt;code&gt;Mono&lt;/code&gt; scheduled on that same executor.&lt;/p&gt;
&lt;p&gt;Benchmarks over lists of 100,000, 250,000, and 500,000 objects show that the pure JDK version is dramatically faster than Reactor, with the gap widening as the dataset grows. In exchange, the JDK version consumes significantly more Old Gen memory and incurs higher GC pause times and GC CPU usage, though the author notes these do not meaningfully hurt application latency. The takeaway: with virtual threads, the standard JDK approach is the clear winner, whereas on traditional platform threads, Spring Core Reactor remains slightly faster.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2ae8b491-b794-446b-8ca5-25ac552161be_1417x1600.png" alt="A Cheatsheet On Message Queues"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/015e9750-7334-424b-b0c4-9c39bc5dd2d2_1600x1596.png" alt="From Monolith to Microservices: Key Transition 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></channel></rss>