Newsletter #68
Enjoy Newsletter #68. This post was created using Claude Code, Claude Code Router, iFlow Open Platform & GLM-4.6 (For this post I configured CCR to use multiple models on iFlow Platform)
Conscious Debugging: 10 Effective Strategies That Actually Work 🐛
Petar Ivanov argues that debugging isn’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.
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 “rubber duck” 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’ve tried so far, take an intentional break, and use AI smartly by feeding it full context—AI isn’t magic, but it’s a valuable assistant when given complete information.
The fate of “small” open source
Nolan Lawson looks back at blob-util, 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 Blob-to-ArrayBuffer 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: blob-util 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.
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’s training distribution, such as his memory-leak hunter fuite or Dominic Gannaway’s Ripple.js framework—work that demands original research and creative engineering.
Programming Languages in the Age of AI Agents
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.
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 “comprehension debt”—when no one on the team understands how the system actually works anymore—and cites Peter Naur’s view that programming is fundamentally about building a shared human “theory” 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.
“Numbers Everyone Should Know” from Jeff Dean
This page collects Jeff Dean’s famous “Numbers Everyone Should Know” table from Google—reference latencies for fundamental computer operations meant as historical order-of-magnitude rules of thumb rather than benchmarks for today’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.
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.
The Internet is Cool. Thank you, TCP
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’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’t have to reinvent reliability. Alongside that, flow control (the window field) tells the sender how much room remains in the receiver’s buffer, while congestion control was born after the “congestion collapse” of 1986, when throughput across an early Internet link plunged to just 40 bits per second.
On the hands-on side, the post walks through C code for a TCP echo server and a minimal “fake” HTTP server just complete enough to fool curl, illustrating Berkeley socket calls like socket, bind, listen, accept, send, and recv. 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 SYN → SYN-ACK → ACK three-way handshake establishes a connection, how FIN or RST tears it down, and how sequence numbers and acknowledgment numbers keep byte streams intact and in order.
Myths Programmers Believe about CPU Caches
Drawing on experience working on CPU caches at Intel and Sun, the author debunks a widespread misconception: that concurrency is hard because “each CPU core can hold different, stale values in its private cache,” and that Java’s volatile 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 volatile read actually had to go all the way to RAM every time, it would be ~200x slower; in practice, a volatile read can be as cheap as an L1 cache hit.
Why, then, do we still need volatile and atomics? Because CPU registers are not 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 volatile 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.
Why NaN !== NaN in JavaScript (and the IEEE 754 story behind it)
In JavaScript, typeof NaN returns "number", and many operations like addition, subtraction, or Math.max propagate NaN—though not every operation does. Tracing through the source code of Firefox and V8, the author finds that both delegate to C++’s std::isnan, a clue that NaN’s behavior wasn’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—x != x evaluates to true when x is NaN—and inspecting the compiled assembly shows the comparison is executed directly by the CPU via the ucomisd instruction on x86. In other words, NaN !== NaN is intentional hardware-level behavior, not a JavaScript quirk.
Before IEEE 754, every hardware vendor handled arithmetic errors differently, often causing expressions like 0/0 to trap and crash the program immediately, making portable numerical code a nightmare—imagine that happening inside flight-control software. NaN 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 NaN are Number.isNaN() or x !== x.
Towards interplanetary QUIC traffic
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.
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’s time-skipping test clock. Thanks to the modular design of quinn—Rust’s most popular QUIC implementation—everything plugged together cleanly: tests run almost instantaneously, behave deterministically (identical seeds yield identical runs), and dump .pcap 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.
Bloom filters: the niche trick behind a 16× faster API
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 "team" or "feature" packed inside a JSONB column. Their old algorithm fetched batches of 500 rows, deserialized the JSONB 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 JSONB—or a Bloom filter, a probabilistic data structure that tells you whether an element is “definitely not in the set” or “possibly in the set.”
They chose a Bloom filter out of concern that a GIN index would balloon disk and memory usage while slowing down writes. Each alert’s attribute key-value pairs are hashed into a bit(512) column sized for a ~1% false-positive rate at their attribute cardinality. At query time, Postgres performs a fast bitwise AND check (bitmap & bitmask == bitmask) to discard non-matching rows cheaply, then runs the exact JSONB 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.
making things true
In this thread, Ryo Lu argues that design isn’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’t set out to make yet another note-taking app or project tracker; instead, they searched for the “atoms” 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.
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’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.
What Good Execution Looks Like
Yusuf Aytas observes that great execution feels “quiet”—not slow or passive, but smooth enough that people coordinate naturally and management’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’s view, strong execution rests on a handful of foundations: clear direction (what matters, where we’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.
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’t a lack of urgency—it’s the sound of an organization that isn’t fighting itself.
Bonus
Images:

Videos: Why is Kafka Popular?
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.
Comments