<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Debugging on miti99</title><link>https://miti99.com/en/tags/debugging/</link><description>Recent content in Debugging 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/debugging/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #88</title><link>https://miti99.com/en/post/2026/03/13/</link><pubDate>Fri, 13 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #88.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-broken-heart"&gt;&lt;a href="https://allenpike.com/2026/a-broken-heart/" rel="noopener noreferrer"&gt;A Broken Heart&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allen Pike recounts a memorable debugging war story: the dashboard of a web app his team was building suddenly started taking ten seconds to load instead of one. He immediately suspected React and asked Claude to audit the components, but fixing redundant renders and missing memoization barely moved the needle. Digging deeper, he noticed the slowdown only happened in Safari, where the profiler showed the browser spending 94% of CPU time in Layout—over 1,600ms per pass, roughly 100 times slower than normal. Pairing binary search with a coding agent, he systematically stripped out pieces of the UI to narrow down the culprit. Within about ten minutes, the offender emerged: a single heart emoji ❤️ inside a &amp;ldquo;Send Feedback&amp;rdquo; button. Removing the emoji dropped Layout time to 2ms.&lt;/p&gt;
&lt;p&gt;With the coding agent&amp;rsquo;s help, he quickly put together a minimal reproduction for a bug report and uncovered the root cause: Google&amp;rsquo;s Noto Color Emoji webfont, which had been added so emojis would render consistently on Linux. The font uses the COLRv1 format and falls back to embedded SVGs on browsers that don&amp;rsquo;t support it, including Safari; the WebKit team confirmed the bottleneck was inside Apple&amp;rsquo;s CoreSVG. The bug was even glyph-specific: ❤️ and 🤯 took 1,600ms, while 🧺 and 🫠 took just 0.2ms. The workaround was placing &lt;code&gt;&amp;quot;Apple Color Emoji&amp;quot;&lt;/code&gt; ahead of &lt;code&gt;&amp;quot;Noto Color Emoji&amp;quot;&lt;/code&gt; in the &lt;code&gt;font-family&lt;/code&gt; stack. The punchline: Claude was the one that had suggested adding Noto Color Emoji in the first place, prompting the author to compare coding agents to a chainsaw—wildly productive, and proportionally dangerous.&lt;/p&gt;
&lt;h2 id="wrapping-code-comments"&gt;&lt;a href="https://matklad.github.io/2026/02/21/wrapping-code-comments.html" rel="noopener noreferrer"&gt;Wrapping Code Comments&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this short note, matklad makes two observations about line wrapping: code and comments should be wrapped at different widths, and comment width should be measured relative to where the comment starts. A hard limit around 100 columns makes sense for code because it still fits two editor panes side by side, whereas prose reads best at around 60–70 columns. The apparent contradiction disappears once you account for indentation eating into the line and code being much sparser horizontally than prose. Accordingly, the author wants code lines wrapped at 100 columns and comment text wrapped at roughly 70 columns; deeply indented comments shift to the right while keeping the same measure of text, as long as the total line length stays under 100.&lt;/p&gt;
&lt;p&gt;Simple as that sounds, popular editors don&amp;rsquo;t support it well: VS Code&amp;rsquo;s Rewrap extension lets you configure a separate width for comments, but measures it from column zero, making deeply indented comments narrower and narrower, while Emacs&amp;rsquo;s &lt;code&gt;M-q&lt;/code&gt; doesn&amp;rsquo;t wrap comments to a relative width by default either. The author also explains why soft wrapping in the editor isn&amp;rsquo;t a substitute: proper wrapping requires understanding the structure of the text—for example, a wrapped line inside a Markdown list item needs to align with the item&amp;rsquo;s indentation, which only works when the comment is parsed as Markdown.&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_!h2M_!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1d6d88ea-4355-4f29-96fa-9770907beebb_2360x2960.png" alt="RabbitMQ vs Kafka vs Pulsar"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!8P-v!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6039d506-e02f-4313-ab97-2c04f8c94d90_2360x2960.png" alt="REST vs GraphQL"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yela!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5ac3310f-e380-48c2-93ff-051f7606b533_2250x2624.png" alt="Eventual Consistency in Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!vB9v!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fbc02c74f-e91f-438a-8ad8-d5ba6831e7f0_2250x2624.png" alt="Strong Consistency In Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!h8d0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc5f67fe5-0efa-4fc6-98da-d176b60b1a92_2508x3000.jpeg" alt="PostgreSQL versus MySQL"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_roW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fdbdb9cae-3bda-4a62-9077-3f9d1e13fede_2360x2960.jpeg" alt="Network Protocols Explained"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=z_NbVtbgBJw" rel="noopener noreferrer"&gt;Video: What Is Redis Really About? - ByteByteGo&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #68</title><link>https://miti99.com/en/post/2025/12/11/</link><pubDate>Thu, 11 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #68. &lt;del&gt;This post was created using &lt;a href="https://github.com/anthropics/claude-code" rel="noopener noreferrer"&gt;Claude Code&lt;/a&gt;, &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt;, &lt;a href="https://platform.iflow.cn" rel="noopener noreferrer"&gt;iFlow Open Platform&lt;/a&gt; &amp;amp; GLM-4.6 (For this post I configured CCR to use multiple models on iFlow Platform)&lt;/del&gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="conscious-debugging-10-effective-strategies-that-actually-work-"&gt;&lt;a href="https://thetshaped.dev/p/conscious-debugging-10-effective-debugging-strategies-debug-like-pro" rel="noopener noreferrer"&gt;Conscious Debugging: 10 Effective Strategies That Actually Work 🐛&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Petar Ivanov argues that debugging isn&amp;rsquo;t a matter of luck, but a trainable skill—and mastering it saves time, effort, money, and stress. The article organizes 10 debugging strategies into three groups. The first group lays the groundwork: reproduce the bug consistently with concrete steps, shorten the reproduction cycle so you can test more hypotheses quickly, and gather full context from logs, session recordings, or user reports before diving into the code. In microservice architectures, sketching the end-to-end request flow across services gives you a clear mental map of the system.&lt;/p&gt;
&lt;p&gt;The second group covers active debugging techniques: narrow down the culprit via binary search (commenting out half the suspected code path to see whether the bug persists), use a real debugger to set breakpoints and inspect variables, explain the code line by line to a &amp;ldquo;rubber duck&amp;rdquo; or a teammate, and work like a scientist—form a hypothesis, test it, observe the outcome, fix, and verify. When you hit a wall, write down everything you&amp;rsquo;ve tried so far, take an intentional break, and use AI smartly by feeding it full context—AI isn&amp;rsquo;t magic, but it&amp;rsquo;s a valuable assistant when given complete information.&lt;/p&gt;
&lt;h2 id="the-fate-of"&gt;&lt;a href="https://nolanlawson.com/2025/11/16/the-fate-of-small-open-source/" rel="noopener noreferrer"&gt;The fate of &amp;ldquo;small&amp;rdquo; open source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson looks back at &lt;code&gt;blob-util&lt;/code&gt;, a small npm library he wrote roughly 10 years ago that still gets over 5 million weekly downloads. Now that around 80% of developers use AI in their workflow, tiny utilities like this can be generated on demand by an LLM—he asked Claude to write a &lt;code&gt;Blob&lt;/code&gt;-to-&lt;code&gt;ArrayBuffer&lt;/code&gt; helper and got code nearly identical to his own. Many see this as pure progress: fewer dependencies and less performance, maintenance, and supply-chain risk. Yet Lawson argues something valuable is being lost: &lt;code&gt;blob-util&lt;/code&gt; was written in the spirit of a teacher, complete with documentation that helped developers understand how to work effectively with binary data in JavaScript. When we prioritize instant answers over learning and understanding, the motivation to publish small libraries and explain underlying concepts fades too.&lt;/p&gt;
&lt;p&gt;His conclusion: the era of small, low-complexity open-source packages is over—a decline that started as Node.js and browsers built more features into the platform, with LLMs serving as the final nail in the coffin. Even so, open source still has a bright future in larger, more ambitious projects or niche domains outside an LLM&amp;rsquo;s training distribution, such as his memory-leak hunter &lt;code&gt;fuite&lt;/code&gt; or Dominic Gannaway&amp;rsquo;s Ripple.js framework—work that demands original research and creative engineering.&lt;/p&gt;
&lt;h2 id="programming-languages-in-the-age-of-ai-agents"&gt;&lt;a href="https://alexn.org/blog/2025/11/16/programming-languages-in-the-age-of-ai-agents/" rel="noopener noreferrer"&gt;Programming Languages in the Age of AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexandru Nedelcu asks: when AI agents write our code, does programming language choice still matter, or will everyone converge on a handful of mainstream languages simply because AI has the most training data for them? He acknowledges the feedback loop is real—Python is popular, so AI writes good Python, making Python even more popular—but offers two reasons for optimism. First, compilers with expressive static type systems (Scala, Haskell, Rust) give AI agents faster, tighter feedback than unit tests alone, helping them iterate toward a working solution and curbing hallucinations. For example, AI can successfully write Scala 3 macros despite scarce public training examples by iteratively fixing compiler errors.&lt;/p&gt;
&lt;p&gt;Second, humans still have to review and understand AI-generated code, because merely running a program and eyeballing the output is far too shallow a check. Nedelcu warns of &amp;ldquo;comprehension debt&amp;rdquo;—when no one on the team understands how the system actually works anymore—and cites Peter Naur&amp;rsquo;s view that programming is fundamentally about building a shared human &amp;ldquo;theory&amp;rdquo; of the problem. Because source code remains the ultimate source of truth, good code must clearly express design intent and invariants; high-level expressive languages preserve that specification without loss. Deductive and equational reasoning from functional programming therefore become even more valuable when collaborating with AI.&lt;/p&gt;
&lt;h2 id="heading"&gt;&lt;a href="https://brenocon.com/dean_perf.html" rel="noopener noreferrer"&gt;&amp;ldquo;Numbers Everyone Should Know&amp;rdquo; from Jeff Dean&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page collects Jeff Dean&amp;rsquo;s famous &amp;ldquo;Numbers Everyone Should Know&amp;rdquo; table from Google—reference latencies for fundamental computer operations meant as historical order-of-magnitude rules of thumb rather than benchmarks for today&amp;rsquo;s hardware. An L1 cache reference takes ~0.5 ns, L2 cache ~7 ns, a branch mispredict ~5 ns, and a mutex lock/unlock or main memory reference ~100 ns. Compressing 1 KB with Zippy or sending 1 KB over a 1 Gbps network takes ~10,000 ns (0.01 ms); reading 1 MB sequentially from memory takes 0.25 ms, while a round trip within the same datacenter takes 0.5 ms. A disk seek takes 10 ms, reading 1 MB sequentially from disk takes 30 ms, and sending a packet from California to the Netherlands and back takes 150 ms.&lt;/p&gt;
&lt;p&gt;The lasting value of the table lies in the relative orders of magnitude between operations rather than the exact numbers: main memory is roughly 200x slower than L1 cache, and a disk seek is tens of millions of times slower than L1. For engineers, internalizing these gaps lets you do quick back-of-the-envelope performance estimates during design, understand why caching and minimizing I/O matter so much, and avoid common performance traps when building distributed or data-intensive systems.&lt;/p&gt;
&lt;h2 id="the-internet-is-cool-thank-you-tcp"&gt;&lt;a href="https://cefboud.com/posts/tcp-deep-dive-internals/" rel="noopener noreferrer"&gt;The Internet is Cool. Thank you, TCP&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Moncef Abboud explains why TCP is the workhorse of the Internet, underpinning HTTP, SMTP, and SSH. Underlying networks are inherently unreliable: packets can be dropped, corrupted, duplicated, or delivered out of order. While IP routes packets from host to host, the transport layer uses ports to deliver data to the right process—like a building&amp;rsquo;s street address versus an apartment number. TCP handles retransmissions, checksums, and ordering right at the two endpoints so intermediate routers stay simple and application developers don&amp;rsquo;t have to reinvent reliability. Alongside that, flow control (the &lt;code&gt;window&lt;/code&gt; field) tells the sender how much room remains in the receiver&amp;rsquo;s buffer, while congestion control was born after the &amp;ldquo;congestion collapse&amp;rdquo; of 1986, when throughput across an early Internet link plunged to just 40 bits per second.&lt;/p&gt;
&lt;p&gt;On the hands-on side, the post walks through C code for a TCP echo server and a minimal &amp;ldquo;fake&amp;rdquo; HTTP server just complete enough to fool &lt;code&gt;curl&lt;/code&gt;, illustrating Berkeley socket calls like &lt;code&gt;socket&lt;/code&gt;, &lt;code&gt;bind&lt;/code&gt;, &lt;code&gt;listen&lt;/code&gt;, &lt;code&gt;accept&lt;/code&gt;, &lt;code&gt;send&lt;/code&gt;, and &lt;code&gt;recv&lt;/code&gt;. The author also dissects the TCP segment header: how every connection is uniquely identified by a 5-tuple (protocol, source IP and port, destination IP and port), how the &lt;code&gt;SYN&lt;/code&gt; → &lt;code&gt;SYN-ACK&lt;/code&gt; → &lt;code&gt;ACK&lt;/code&gt; three-way handshake establishes a connection, how &lt;code&gt;FIN&lt;/code&gt; or &lt;code&gt;RST&lt;/code&gt; tears it down, and how sequence numbers and acknowledgment numbers keep byte streams intact and in order.&lt;/p&gt;
&lt;h2 id="myths-programmers-believe-about-cpu-caches"&gt;&lt;a href="https://software.rajivprab.com/2018/04/29/myths-programmers-believe-about-cpu-caches/" rel="noopener noreferrer"&gt;Myths Programmers Believe about CPU Caches&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on experience working on CPU caches at Intel and Sun, the author debunks a widespread misconception: that concurrency is hard because &amp;ldquo;each CPU core can hold different, stale values in its private cache,&amp;rdquo; and that Java&amp;rsquo;s &lt;code&gt;volatile&lt;/code&gt; keyword exists to force reads and writes straight to main memory. In reality, caches on modern x86 CPUs are kept coherent automatically by hardware cache-coherency protocols like MESI, where every cache line is tagged as Modified, Exclusive, Shared, or Invalid. If a &lt;code&gt;volatile&lt;/code&gt; read actually had to go all the way to RAM every time, it would be ~200x slower; in practice, a &lt;code&gt;volatile&lt;/code&gt; read can be as cheap as an L1 cache hit.&lt;/p&gt;
&lt;p&gt;Why, then, do we still need &lt;code&gt;volatile&lt;/code&gt; and atomics? Because CPU registers are &lt;em&gt;not&lt;/em&gt; coherent across cores, and compilers are free to keep variables in registers or reorder instructions under the assumption of single-threaded execution. In Java, a &lt;code&gt;volatile&lt;/code&gt; write establishes a happens-before relationship with subsequent reads of that same variable. That guarantee governs both compiler optimizations and hardware memory ordering; single-cache-line coherency alone does not guarantee that all threads observe changes across multiple variables in the same order. Misunderstanding this leads to flawed designs, such as assuming a single-core machine is immune to race conditions. The author also shows how hardware cache-coherency principles map directly onto distributed systems and database isolation levels.&lt;/p&gt;
&lt;h2 id="why-nan--nan-in-javascript-and-the-ieee-754-story-behind-it"&gt;&lt;a href="https://pzarycki.com/en/posts/js-nan/" rel="noopener noreferrer"&gt;Why NaN !== NaN in JavaScript (and the IEEE 754 story behind it)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In JavaScript, &lt;code&gt;typeof NaN&lt;/code&gt; returns &lt;code&gt;&amp;quot;number&amp;quot;&lt;/code&gt;, and many operations like addition, subtraction, or &lt;code&gt;Math.max&lt;/code&gt; propagate &lt;code&gt;NaN&lt;/code&gt;—though not every operation does. Tracing through the source code of Firefox and V8, the author finds that both delegate to C++&amp;rsquo;s &lt;code&gt;std::isnan&lt;/code&gt;, a clue that &lt;code&gt;NaN&lt;/code&gt;&amp;rsquo;s behavior wasn&amp;rsquo;t invented by JavaScript at all, but comes from the 1985 IEEE 754 floating-point standard. Rewriting the example in C produces the exact same result—&lt;code&gt;x != x&lt;/code&gt; evaluates to true when &lt;code&gt;x&lt;/code&gt; is &lt;code&gt;NaN&lt;/code&gt;—and inspecting the compiled assembly shows the comparison is executed directly by the CPU via the &lt;code&gt;ucomisd&lt;/code&gt; instruction on x86. In other words, &lt;code&gt;NaN !== NaN&lt;/code&gt; is intentional hardware-level behavior, not a JavaScript quirk.&lt;/p&gt;
&lt;p&gt;Before IEEE 754, every hardware vendor handled arithmetic errors differently, often causing expressions like &lt;code&gt;0/0&lt;/code&gt; to trap and crash the program immediately, making portable numerical code a nightmare—imagine that happening inside flight-control software. &lt;code&gt;NaN&lt;/code&gt; solved this by propagating quietly through a chain of calculations so programmers can check for errors once at the end rather than after every single arithmetic step. In JavaScript, the reliable ways to check for &lt;code&gt;NaN&lt;/code&gt; are &lt;code&gt;Number.isNaN()&lt;/code&gt; or &lt;code&gt;x !== x&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="towards-interplanetary-quic-traffic"&gt;&lt;a href="https://ochagavia.nl/blog/towards-interplanetary-quic-traffic/" rel="noopener noreferrer"&gt;Towards interplanetary QUIC traffic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Adolfo Ochagavía recounts a consulting project to prove that QUIC—the reliable transport protocol underlying HTTP/3—can operate across deep space, such as communicating between Earth and a rover on Mars. The challenges are extreme: one-way signal delay ranges from 3 to 23 minutes, and links drop regularly as relay satellites pass out of view. With default settings, QUIC times out long before completing a handshake. The limitation, however, lies in default parameters tuned for terrestrial broadband rather than in the protocol itself: QUIC allows deep tuning of initial RTT estimates, idle timeouts, and congestion control algorithms, whereas TCP is fundamentally ill-suited for deep space.&lt;/p&gt;
&lt;p&gt;Testing against virtual machines with real simulated delays would be painfully slow when a single Mars round trip takes up to 46 minutes. Ochagavía solved this by running both client and server inside a single process, routing packets through a custom in-memory network simulator, and enabling Tokio&amp;rsquo;s time-skipping test clock. Thanks to the modular design of &lt;code&gt;quinn&lt;/code&gt;—Rust&amp;rsquo;s most popular QUIC implementation—everything plugged together cleanly: tests run almost instantaneously, behave deterministically (identical seeds yield identical runs), and dump &lt;code&gt;.pcap&lt;/code&gt; packet captures at both endpoints for inspection in Wireshark. Mars rovers still transmit images over CFDP today, but in a few years the answer might well be QUIC.&lt;/p&gt;
&lt;h2 id="bloom-filters-the-niche-trick-behind-a-16-faster-api"&gt;&lt;a href="https://incident.io/blog/bloom-filters" rel="noopener noreferrer"&gt;Bloom filters: the niche trick behind a 16× faster API&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The engineering team at incident.io shares how they cut the P95 latency of an alert-filtering API from 5 seconds down to 0.3 seconds. Alerts are stored in PostgreSQL, with customer-defined custom attributes like &lt;code&gt;&amp;quot;team&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;feature&amp;quot;&lt;/code&gt; packed inside a &lt;code&gt;JSONB&lt;/code&gt; column. Their old algorithm fetched batches of 500 rows, deserialized the &lt;code&gt;JSONB&lt;/code&gt; payloads into Go structs, and filtered them in memory, looping until it filled a single page of results. For large enterprise customers with millions of alerts, this forced the API to scan and deserialize massive amounts of irrelevant data. The team weighed two options: a PostgreSQL GIN index—the standard textbook choice for &lt;code&gt;JSONB&lt;/code&gt;—or a Bloom filter, a probabilistic data structure that tells you whether an element is &amp;ldquo;definitely not in the set&amp;rdquo; or &amp;ldquo;possibly in the set.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;They chose a Bloom filter out of concern that a GIN index would balloon disk and memory usage while slowing down writes. Each alert&amp;rsquo;s attribute key-value pairs are hashed into a &lt;code&gt;bit(512)&lt;/code&gt; column sized for a ~1% false-positive rate at their attribute cardinality. At query time, Postgres performs a fast bitwise AND check (&lt;code&gt;bitmap &amp;amp; bitmask == bitmask&lt;/code&gt;) to discard non-matching rows cheaply, then runs the exact &lt;code&gt;JSONB&lt;/code&gt; check on the surviving candidates to filter out false positives. Combined with a mandatory time-window filter (defaulting to 30 days) that exploits the chronological sort order of ULID primary keys, query performance became fast and predictable even for their largest customers. The takeaway: sometimes a niche computer science trick beats the standard off-the-shelf index.&lt;/p&gt;
&lt;h2 id="making-things-true"&gt;&lt;a href="https://threadreaderapp.com/thread/1990057444253241545.html" rel="noopener noreferrer"&gt;making things true&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this thread, Ryo Lu argues that design isn&amp;rsquo;t about surface aesthetics like picking colors or polishing UI chrome, but about seeing through the surface to the underlying structure: decomposing a complex domain into fundamental building blocks, understanding how they relate, and recombining them into something simpler and more powerful. When building Notion, the team didn&amp;rsquo;t set out to make yet another note-taking app or project tracker; instead, they searched for the &amp;ldquo;atoms&amp;rdquo; of software: blocks, databases, views, and relations. Viewed through that lens, Asana, Linear, Evernote, and Airtable are just rigid presets of the same underlying concepts, whereas Notion hands users Lego bricks to assemble whatever tool they need. Cursor does something similar one layer deeper, removing friction between human intent and working software: you describe what you want, and AI handles the decomposition into code.&lt;/p&gt;
&lt;p&gt;Lu zooms out further: human language, music, and DNA are all finite sets of primitives that combine in infinite ways. The true turning points in computing history weren&amp;rsquo;t flashy features, but new primitives—the command line, the GUI, the hyperlink, mobile sensors—and AI is the newest primitive of that kind. For software builders, the lesson is to practice spotting the core primitives of a system by asking what a thing truly is at its core and how much you can strip away before it stops being itself.&lt;/p&gt;
&lt;h2 id="what-good-execution-looks-like"&gt;&lt;a href="https://yusufaytas.com/what-good-execution-looks-like/" rel="noopener noreferrer"&gt;What Good Execution Looks Like&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Yusuf Aytas observes that great execution feels &amp;ldquo;quiet&amp;rdquo;—not slow or passive, but smooth enough that people coordinate naturally and management&amp;rsquo;s presence almost fades into the background. Poor execution, by contrast, is loud and full of heroics: projects stall, approval layers multiply, processes calcify, status updates turn defensive, and meetings explode. In Aytas&amp;rsquo;s view, strong execution rests on a handful of foundations: clear direction (what matters, where we&amp;rsquo;re going, and why), stable priorities, unambiguous ownership with a single directly responsible individual, lightweight process designed solely to reduce uncertainty, maintain momentum, and surface problems early, mutual trust, a steady cadence, and fast, honest feedback loops.&lt;/p&gt;
&lt;p&gt;Signs of healthy execution include low operational noise, psychological safety to raise risks early without fear of blame, and genuine autonomy where leaders clear roadblocks instead of micromanaging details. Execution is measurable, too: predictable lead times and throughput, small frequent releases, high-signal alerts instead of pager fatigue, and a low change-failure rate. The core message: quietness isn&amp;rsquo;t a lack of urgency—it&amp;rsquo;s the sound of an organization that isn&amp;rsquo;t fighting itself.&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_!tANe!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7f80d730-11c4-4d55-81bf-fa4629cc2f0f_2360x2960.png" alt="How to Design Good APIs"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!gReB!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2e93eb2-84ab-427f-b587-e14b599e0fee_2360x2960.png" alt="Types of Virtualization"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=7_wkWQ9rB5I" rel="noopener noreferrer"&gt;Why is Kafka Popular?&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 #45</title><link>https://miti99.com/en/post/2025/08/04/</link><pubDate>Mon, 04 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/04/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;This post was put together using Cline + Kimi K2.&lt;/del&gt; Enjoy Newsletter #45.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-best"&gt;&lt;a href="https://www.paulgraham.com/best.html" rel="noopener noreferrer"&gt;The Best&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his essay &amp;ldquo;The Best Essay,&amp;rdquo; Paul Graham asks: what would the best possible essay look like? His first answer is that it must tackle the most important topic about which one can still say something surprising—but that line of thought leads toward major scientific discoveries, which are tied to the moment of their discovery rather than being timeless. So he reframes it into a more practical question: how do you write a truly great essay? According to Graham, everything starts with a compelling initial question where the writer has a fresh perspective or a distinct approach.&lt;/p&gt;
&lt;p&gt;The writing process turns vague ideas into concrete prose, followed by ruthless rereading and revision until the gap between the current answer and the truth becomes visible—sometimes opening up an entirely new direction. An essay works like a recursive exploration: each answer spawns new questions, and the writer should follow whichever branch offers the best combination of generality and novelty, ready to discard whole passages already written if they no longer serve the main thread. Although the initial question caps the maximum quality of the essay, Graham advises against being overly cautious when choosing topics; instead, write a lot, because most questions can yield a good essay. The ability to ask great questions comes from broad knowledge and deep experience across multiple fields.&lt;/p&gt;
&lt;h2 id="ai-tools-make-developers-19-slower-not-faster"&gt;&lt;a href="https://threadreaderapp.com/thread/1943360399220388093.html" rel="noopener noreferrer"&gt;AI Tools Make Developers 19% Slower, Not Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The research organization METR conducted a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories, which averaged over 22,000 stars and more than one million lines of code. Each task was randomly assigned to either allow or disallow AI tools (primarily Cursor Pro with Claude 3.5/3.7). The results were surprising: before the experiment, developers predicted AI would make them 24% faster; after finishing, they still felt they had been 20% faster; yet the actual measurements showed they were 19% slower when assisted by AI.&lt;/p&gt;
&lt;p&gt;The researchers emphasize that these findings apply specifically to this setting and do not represent the entire software industry; future models or more effective usage patterns could yield different outcomes. The slowdown appeared consistently across multiple metrics and stemmed from several factors at once: when allowed to use AI, developers spent time prompting the AI, waiting for responses, reviewing AI output, and idling, rather than directly writing code or looking up documentation. The takeaway is that the gap between subjective perception and actual productivity can be huge, so measure rather than relying on gut feeling when evaluating new tools.&lt;/p&gt;
&lt;h2 id="evolution-of-uber"&gt;&lt;a href="https://www.uber.com/in/en/blog/evolution-of-ubers-search-platform/" rel="noopener noreferrer"&gt;Evolution of Uber&amp;rsquo;s Search Platform&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article recounts the three-stage evolution of Uber&amp;rsquo;s search platform. Initially, Uber treated Elasticsearch (built on Apache Lucene) almost as a &amp;ldquo;black box,&amp;rdquo; with engineers focused mainly on keeping operations stable. A major limitation was Lucene&amp;rsquo;s near-real-time mechanism: new data became searchable only after being flushed to the index, introducing latency in time-sensitive scenarios like matching riders with drivers. Starting in 2019, Uber built Sia in-house, extending Lucene with an in-memory live index for real-time search, switching to lighter-weight gRPC/Protobuf communication, pull-based ingestion via Kafka, and active-active multi-region deployment. However, the complex custom architecture made it very difficult to adopt new Lucene features such as vector search, while most use cases didn&amp;rsquo;t actually need real-time freshness.&lt;/p&gt;
&lt;p&gt;In 2024, with Project Sunrise, Uber recognized that maintaining a custom fork was no longer sustainable and migrated to OpenSearch, becoming a founding member of the OpenSearch Software Foundation. The current architecture separates the write path from the read path: data from Kafka is compacted into optimized segments and uploaded to remote storage, while search nodes simply download them to serve queries, keeping all ingestion overhead off the query path. Uber also contributed features back to OpenSearch 3.0, including pull-based ingestion and gRPC APIs. The lesson: custom-built solutions are expensive to maintain when the ecosystem moves fast, and complexity should only be accepted where it is genuinely needed.&lt;/p&gt;
&lt;h2 id="vercel"&gt;&lt;a href="https://leerob.com/vercel" rel="noopener noreferrer"&gt;Vercel&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson reflects on his five years at Vercel, where he grew from an individual engineer to VP, watching the company scale from 30 people and $1 million in ARR to 650 people and over $200 million. His first lesson is work-life balance: he once answered work messages even during his honeymoon, and only broke free by building processes and hiring people capable enough to run things themselves. Second, speed is a competitive advantage: asking &amp;ldquo;what would it take to ship this next week?&amp;rdquo; forces teams to find creative solutions, and even if you miss the deadline, you still finish faster than if you had set none at all.&lt;/p&gt;
&lt;p&gt;Third, scaling requires hiring rather than doing everything yourself—always be recruiting, keep the bar high, and only hire candidates who genuinely excite you. Fourth, avoid unilateral decisions: he once parachuted into a product launch at the last minute and demanded changes without full context, something he regrets; leaders should get involved early and build consensus before making calls. Finally, stay adaptable and admit mistakes: personally reviewing every company social media post created a bottleneck, and delegating ownership alongside clear quality guidelines produced better results. These are valuable lessons for any developer moving toward a leadership role.&lt;/p&gt;
&lt;h2 id="tools"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/3/tools/" rel="noopener noreferrer"&gt;Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that when working with AI agents, &amp;ldquo;code is all you need.&amp;rdquo; He critiques the MCP protocol, which lets language models invoke external tools and services: this approach is hard to compose because every step depends on model inference, consumes substantial context on each tool call, and scales poorly when automating repetitive tasks. In his view, without AI, a software engineer solves problems by writing code—so AI should do the same.&lt;/p&gt;
&lt;p&gt;Model-generated code has explicit logic that humans can inspect, runs repeatedly at low cost once written, and is easier to debug. As an illustration, Armin describes migrating his entire blog from reStructuredText to Markdown: the model wrote AST-based conversion scripts, wrote additional scripts comparing the old and new HTML to verify the output, and iterated on that feedback loop with almost no human intervention. Here, the model acted as a code quality evaluator rather than manually executing each step. He concludes that MCP looks like a dead end for large-scale automation, and a more promising path is combining code generation with having the model evaluate the results after execution.&lt;/p&gt;
&lt;h2 id="how-i-build-software-quickly"&gt;&lt;a href="https://evanhahn.com/how-i-build-software-quickly/" rel="noopener noreferrer"&gt;How I Build Software Quickly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn shares how he builds software quickly while maintaining acceptable quality. The core principle is balancing speed and quality: aim for &amp;ldquo;8 out of 10, delivered on time&amp;rdquo; rather than chasing perfection. What counts as &amp;ldquo;good enough&amp;rdquo; depends on context—a 24-hour game jam tolerates messy code, whereas a pacemaker demands excellence—so you need to understand what your team considers good enough. He recommends building a rough draft first, full of TODOs, hardcoded data, and unhandled errors, to uncover unforeseen problems early, avoid wasting effort on code that will be thrown away, and prevent premature abstraction.&lt;/p&gt;
&lt;p&gt;Doing less is also a way to move faster: question the scope, combine screens, skip unnecessary edge cases, or trim API parameters. To stay focused, he sets timers for tasks and pair-programs. Small changes are easier to write, review, revert, and debug—for instance, fixing a bug, upgrading a library, and adding a feature in separate changes. The skills that speed him up most include reading code (the most important one), data modeling, writing automation scripts, using a debugger, taking breaks, writing pure functions, and leveraging LLM tools.&lt;/p&gt;
&lt;h2 id="the-most-mysterious-bug-i-solved-at-work"&gt;&lt;a href="https://cadence.moe/blog/2025-07-02-the-most-mysterious-bug-i-solved-at-work/" rel="noopener noreferrer"&gt;The Most Mysterious Bug I Solved at Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cadence recounts the most mysterious bug she ever solved on an electronic patient referral application in Australia, a system that converts referral data into HL7, CDA, or PDF formats to send to healthcare providers. Occasionally, the system threw the error &lt;code&gt;Illegal Character entity: expansion character (code 0x2) not a valid XML character&lt;/code&gt;. Character &lt;code&gt;0x2&lt;/code&gt; (Start of Text) is an obsolete control character from the early days of computing with virtually no modern use—yet it was showing up inside referral letters typed by doctors.&lt;/p&gt;
&lt;p&gt;Investigation gradually uncovered the clues: the affected letters all had unusual hard line breaks, and the same doctor was submitting identical letters multiple times. It turned out the doctor was copying text from PDFs of previous referrals stored in their practice management software, and character &lt;code&gt;0x2&lt;/code&gt; appeared right where hyphens sat at the ends of lines in the PDF. The culprit was Microsoft Edge&amp;rsquo;s built-in PDF viewer—the default on Windows—which mistakenly converted end-of-line hyphens into &lt;code&gt;0x2&lt;/code&gt; when copying text. The team fixed the issue by automatically replacing &lt;code&gt;0x2&lt;/code&gt; with a hyphen rather than stripping it, preserving the intended text. The story reminds developers that the root cause of a bug sometimes lies outside the codebase, in users&amp;rsquo; habits and the tools they rely on.&lt;/p&gt;
&lt;h2 id="how-to-think-about-time-in-programming"&gt;&lt;a href="https://shanrauf.com/archive/how-to-think-about-time-in-programming" rel="noopener noreferrer"&gt;How to Think About Time in Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shan Rauf lays out a clear mental model for handling time in programming. The foundation is absolute time, consisting of &amp;ldquo;instants&amp;rdquo; and &amp;ldquo;durations&amp;rdquo;: an instant is represented as seconds elapsed since a reference point called an epoch (Unix uses January 1, 1970), while a duration is the length of time between two instants, so comparisons and calculations require only basic arithmetic. Humans, however, use civil time based on the Gregorian calendar, with months of varying lengths. UTC defines the second using atomic clocks and occasionally inserts leap seconds to stay aligned with Earth&amp;rsquo;s rotation, meaning a day can be 86,401 or 86,399 seconds long; JavaScript&amp;rsquo;s &lt;code&gt;Date&lt;/code&gt; ignores leap seconds. Time zones are not fixed offsets but evolving sets of rules: during daylight saving transitions, certain civil times are skipped or repeated twice, and the IANA time zone database (such as &lt;code&gt;America/New_York&lt;/code&gt;) records known rules and historical transitions, though it does not guarantee accuracy for every location prior to 1970.&lt;/p&gt;
&lt;p&gt;In practice, chat messages should be stored in UTC and displayed in the viewer&amp;rsquo;s local time zone. For events, intent matters: a class held at a physical location should be stored as local time plus a time zone identifier, whereas an absolute event like a solar eclipse should be stored in UTC. The author recommends bundling the IANA database and updating it regularly, using Unicode CLDR data to display friendly time zone names, and never assuming a UTC offset is immutable. The advice &amp;ldquo;just use UTC&amp;rdquo; isn&amp;rsquo;t enough, because converting to UTC too early discards information about the user&amp;rsquo;s original intent.&lt;/p&gt;
&lt;h2 id="phrase-origin-why-do-we"&gt;&lt;a href="https://quuxplusone.github.io/blog/2025/04/04/etymology-of-call/" rel="noopener noreferrer"&gt;Phrase origin: Why do we &amp;ldquo;call&amp;rdquo; functions?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arthur O&amp;rsquo;Dwyer investigates why we say we &amp;ldquo;call&amp;rdquo; a function. There are three intuitive hypotheses: calling as in visiting a friend (dropping by, staying a while, then leaving), calling as in summoning a servant to do a task, or calling on the telephone to ask a question and get an answer. The real answer is closest to the second hypothesis, but via a detour through library science: in closed-stack libraries, patrons &amp;ldquo;called for&amp;rdquo; books by their shelf mark—the term &amp;ldquo;call number&amp;rdquo; coined by Melvil Dewey in 1876. Early computer scientists borrowed this metaphor for subroutine libraries, where programmers &amp;ldquo;called&amp;rdquo; prewritten routines off the shelf much like a librarian retrieving a book by its call number.&lt;/p&gt;
&lt;p&gt;The timeline shows the evolution clearly: in 1947, John Mauchly wrote about subroutines being &amp;ldquo;called in&amp;rdquo; from a library on magnetic tape; in 1956, MANIAC II assembly used a &amp;ldquo;call number&amp;rdquo; to identify subroutines; in 1958, Fortran II introduced the &lt;code&gt;CALL&lt;/code&gt; statement, turning &amp;ldquo;call&amp;rdquo; into a runtime action; around 1959–1960, Algol and other languages adopted the term; in 1961, the verb phrase &amp;ldquo;call a subroutine&amp;rdquo; was first recorded in Burroughs documentation; and by 1963, modern usage had settled into MIT&amp;rsquo;s curriculum. The author concludes that Fortran II&amp;rsquo;s &lt;code&gt;CALL&lt;/code&gt; keyword is what cemented &amp;ldquo;call&amp;rdquo; as the standard verb for invoking a function.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing again with many URLs, it seems Cline + Kimi K2 overflowed its context window; after compacting, it forgot parts of the context and easily got confused, needing repeated reminders that this environment is Windows and requires PowerShell-compatible commands instead of Linux ones. On top of that, it made a few silly mistakes like summarizing&amp;hellip; the wrong URL :&amp;gt;&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>