Enjoy Newsletter #129.

Hacking the Method Name

In Java, when you need a property name as a string—for parsing CSVs, mapping query results, or calling REST APIs—you usually hardcode "title" or "author" directly into the source, which is prone to typos and invisible to the compiler. This post demonstrates a technique to extract method names directly from method references, such as nameOf(Book::title), keeping names refactoring-safe and in sync with your code. The trick relies on SerializedLambda, introduced in Java 8: the author defines a Getter<T, R> functional interface that extends both Function and Serializable, so when the JVM serializes a method reference of that type, it replaces it with a SerializedLambda instance containing metadata about the target method. A custom ObjectOutputStream enables enableReplaceObject(true), writes to a no-op stream, overrides replaceObject() to intercept the replacement object, and reads the method name via getImplMethodName(). From nameOf(), it’s trivial to build beanNameOf() to strip the get prefix.

The catch is that this stays clean only for zero-argument getters. Supporting multi-parameter methods like save(title, author) requires manually declaring serializable interfaces like Function2 and Function3 along with corresponding nameOf() overloads, which gets repetitive fast. To solve that, the author introduces the safety-mirror library, which handles all the boilerplate out of the box and returns full java.lang.reflect.Method objects rather than just method name strings.

Control the ideas, not the code

Redis creator antirez argues that in the age of LLMs, programmers should focus on controlling the ideas and design of their software rather than reading every single line of AI-generated code—though that doesn’t mean barking “build me a product” and walking away. He offers three reasons: the sheer volume of code generated daily is too large to review meaningfully (who can earnestly review 5,000 lines a day?); LLMs excel at writing locally optimal code but are weaker at big-picture architecture, so discussing and evaluating design with the model is much higher leverage than inspecting every function; and with only eight hours in a workday, reading code steals time from what matters most—steering the project, conceiving features, finding optimization angles, and testing. His fully AI-written project DwarfStar showed that you still need a deep understanding of how everything works and the taste to pick the right design.

For Redis, he still reviews AI-generated code out of respect for human maintainers who will edit it by hand, while admitting the ritual feels largely pointless; given free rein, he would spend that time testing and having the LLM maintain a DESIGN.md file describing the ideas and design of each data structure in plain English. For younger developers who haven’t yet built strong mental models, however, he advises writing programs from scratch—such as an interpreter, a small database, or a hash table—by hand.

Good Tools Are Invisible

Odin creator gingerBill argues that a good tool should be “invisible”: once mastered, it fades into the background so you only think about the task at hand. He pushes back against the habit of turning a tool’s shortcomings into “fun puzzles” and citing them as proof of the tool’s superiority. Take Vim: someone proudly recounts crafting a clever macro for a one-off text edit that gingerBill finished in under a minute using multiple cursors in Sublime Text. Such rationalizations take root when a tool becomes part of someone’s personal identity—admitting the tool is flawed feels like admitting a personal flaw. He also distinguishes feeling productive from being productive: the honest metric is actual time spent and errors made, not how clever you felt along the way.

He extends the argument to several perennial debates. If a GUI is hard to navigate by keyboard, that’s because its creators didn’t implement good keyboard navigation, not because GUIs are inherently mouse-bound; mistaking the current limitations of a tool category for its essence is a common fallacy. Similarly, the culture of endless configuration is part of why desktop Linux hasn’t gone mainstream: shipping sensible defaults is the toolmaker’s responsibility and a sign of respect for the user’s time. A steep learning curve is a cost, not a badge of honor. His takeaway: use whatever tool you like, as long as it disappears from your conscious awareness while you work.

Mysteries of Telegram DC

Coxxs investigates Telegram’s five data centers (DC1–DC5): DC1 and DC3 in Miami, DC2 and DC4 in Amsterdam, and DC5 in Singapore. Every account is assigned to a home DC upon registration based on phone number prefix, never changes with travel or number changes, and cannot be chosen manually. A popular statistics bot once reported zero users in DC2 and DC3, sparking rumors that they were merely auxiliary or slave DCs. Testing all three common DC-detection methods on a fresh DC2 account—calling auth.sendCode over MTProto to read the PHONE_MIGRATE_2 error, inspecting the dc_id field in profile photo metadata, and parsing Web CDN domains—reveals the culprit. The third method fails because DC2 and DC3 “borrow” the Web CDN domains of co-located DC4 and DC1, causing every DC2 user to be misclassified as DC4—the exact bug in that statistics bot.

The investigation concludes that DC1, DC2, DC4, and DC5 are actively assigned by phone country code at sign-up (for instance, Germany’s +49 maps to DC2) and all host large user populations. DC3, by contrast, is alive but practically empty: the author found only two DC3 accounts in the wild, and their older profile photos on DC3 alongside newer ones on DC1 suggest accounts were migrated from DC3 to DC1 around 2020. Probing over 10,000 phone numbers worldwide via the login flow confirmed that DC3 no longer accepts new registrations. The post includes a country-code-to-DC lookup table, while noting that many conclusions remain informed speculation since Telegram’s server code is closed-source.

How I use HTMX with Go

Alex Edwards walks through how he pairs HTMX with Go to add snappy, app-like interactivity with minimal JavaScript while keeping the consistency and safety of server-side HTML rendering via html/template, illustrated through a small app that filters a user list in real time. The template directory is organized into base.tmpl for the shared layout, pages/ for individual page content, and partials/ for reusable HTML fragments, all embedded into the binary alongside static assets via //go:embed. At the heart of the setup is an htmlRenderer type: it parses the shared templates (base and all partials) once at startup, and its render() method clones that template set, adds the specific page template, and executes the named template block. By extracting the table rows into a named users:rows template block, the exact same template file can render either a full HTML page or just the partial fragment for HTMX to swap in.

The server detects HTMX requests via the HX-Request: true header and always sets Vary: HX-Request so intermediate caches don’t serve fragments as full pages. To keep the browser’s back button working properly, historyRestoreAsHxRequest must be set to false; otherwise, navigating back fetches a bare HTML fragment instead of a full page. Redirects can’t use standard 3xx responses because fetch() follows them transparently before HTMX can intervene; instead, the server returns a 2xx status with an HX-Redirect header for HTMX requests while keeping standard 3xx redirects for normal requests. Finally, configuring responseHandling lets 4xx/5xx error pages replace the full document while still allowing 422 validation errors to swap into their target form container.

Quadrupling code performance with a “useless” if

purplesyringa recounts optimizing a specialized string compressor whose hot loop for backtracking the optimal encoding path consisted of a single assignment, j = next_j[i][j], compiling down to a single mov instruction that looked impossible to speed up. The catch is that modern CPUs rely on instruction-level parallelism to execute multiple instructions across loop iterations simultaneously, but they cannot overlap instructions that have data dependencies on one another. Because each iteration needed the j produced by the previous iteration, execution was bottlenecked by memory latency rather than throughput. Noticing that with small block counts next_j[i][j] usually equals j itself, the author exploited branch prediction by wrapping the assignment in if (j != next_j[i][j]). When the CPU predicts the branch is not taken, the cross-iteration dependency vanishes and speculative execution races ahead; on the rare occasion j actually changes, branch misprediction recovery flushes the speculative work and resumes with the updated value.

The hurdle was getting the compiler to emit the branch at all, since if (j != x) j = x; is a dead-code no-op that optimizers immediately strip out. The author had to cast through a volatile pointer to make the condition and assignment appear independent to the compiler; readers later pointed out that [[unlikely]] or __builtin_expect achieves a similar effect in LLVM, though volatile produced tighter assembly and worked in GCC as well. The result was a 4x speedup on synthetic benchmarks (dropping from 320 to 80 microseconds) and roughly a 2x speedup in real-world workloads.

Reverse Engineering ChatGPT Web: How OpenAI Built for a Billion Users

Dennis Brotzky reverse-engineers the frontend web architecture of ChatGPT, which serves roughly a billion users. What stands out first is how “boring” the stack is: React 19 with React Router 7, TanStack Query, Tailwind CSS, and Radix UI, with almost no bespoke framework magic. Launched in November 2022 on Next.js, the app migrated to Remix in 2024 and followed Remix’s merger into React Router 7. To serve users quickly on every device, the site uses streaming server-side rendering with Suspense boundaries: the logged-out HTML document weighs just 84 KB compressed with a 50–65 ms TTFB, and 556 feature gates, 144 dynamic configs, and 192 experiments are pre-evaluated on the server and embedded straight into the initial payload. It skips custom web fonts in favor of system fonts, splits CSS by feature, and orchestrates its 160 content-hashed startup chunks around a single north-star question: can the user type into the composer yet?—complete with a dedicated deferStartupImportsUntilComposerTTFI flag.

The heavy engineering is concentrated where users spend their time: the prompt composer is a ProseMirror editor, code blocks use CodeMirror, and math rendering uses KaTeX paired with a hidden MathML tree for screen readers. Under the hood, Cloudflare proof-of-work challenges and OpenAI’s Sentinel anti-abuse system run silently at page load, while logged-out visitors still receive real anonymous identifiers to enforce rate limits without forcing a login wall. Above all, the team instruments time-to-interactive for every user: if you can’t measure it, you can’t improve it.

Broker-Visible vs Client-Local Parallelism

In a side note to his series on Kafka Share Groups, Jack Vanlightly reminds readers that share groups were designed to bring queue semantics to a log, not primarily to scale out consumption parallelism. The deeper architectural question is where the unit of parallelism lives. If the consumer instance itself is the unit of parallelism, every unit is visible to the broker as protocol interactions, state to track, and one or more TCP connections. If parallelism happens inside the client application—via virtual threads, async tasks, or OS threads—the broker is completely oblivious to it, requiring far fewer consumers, connections, and broker-side state. This trade-off applies across all messaging systems, not just Kafka.

To size parallelism, Vanlightly uses Little’s Law: required concurrency equals message arrival rate multiplied by average processing duration. Processing 60,000 messages per second when each message takes one second requires 60,000 messages in flight at once; if each unit is a single-threaded consumer, you need 60,000 consumers, and if processing takes ten seconds, that balloons to 600,000 consumers and over a million TCP connections. If the workload is mostly I/O-bound and each client instance can process 1,000 messages concurrently on virtual threads, you only need 60 consumers. Managing virtual threads in user space is orders of magnitude cheaper than managing TCP connections and broker metadata per concurrency unit; the trade-off is higher client-side complexity, though modern client libraries increasingly handle that plumbing for you.

Work Loudly

Ben Balter observes that in a physical office, a baseline level of visibility comes for free: coworkers see you sketching at a whiteboard or helping a teammate debug over coffee. In remote work, that ambient signal drops to zero; your work doesn’t become less valuable, just less visible—to the point where even a supportive manager may struggle to articulate what you accomplished come performance review time. Writing a summary after the fact doesn’t fix it either, because the most valuable part—your reasoning, trade-offs, and dead ends—has already vanished. The solution is to “work loudly”: make your work visible while it is happening by opening an issue before writing code, writing PR descriptions that explain the why behind your approach, sharing 40%-done drafts, and asking questions in public channels rather than DMs. If it only exists in your head or in private messages, it isn’t loud enough.

Balter compares working loudly to wearing a bear bell on a hike: you don’t ring it to show off, you ring it so nobody gets startled—because stakeholders who discover a decision only after it ships tend to react defensively. Early visibility also invites teammates to catch bugs early, point out existing solutions, and rally around hard problems; for managers, it enables evaluating people by their actual artifacts rather than performative online presence. The ultimate litmus test: could your manager write your performance review solely from the public trail of artifacts you left behind?

Building Service Topology at Scale: Architecture, Challenges, and Lessons Learned

The Netflix engineering team shares how they built Service Topology, a near-real-time dependency map across Netflix microservices designed to speed up debugging and blast-radius analysis during incidents. They chose stream processing over batch because an hour-old dependency map at 3 a.m. is “archaeology,” using reactive streams backpressure so that whenever downstream stages slow down, the signal propagates all the way back to the Kafka consumer, buffering data safely in Kafka rather than dropping it. Because raw network flow logs only capture individual hops like App A → Load Balancer → App B, the pipeline runs in three stages: stage one filters and aggregates flows over five-minute windows; stage two repartitions events so hops traversing the same intermediate component land on the same node and stitch together into a direct App A → App B edge; and stage three enriches edges with metadata and writes them to a graph database. Stages communicate over Server-Sent Events instead of CPU-heavy gRPC, using consistent hashing to rebalance automatically as cluster nodes scale.

The most valuable lessons came from production pain: Kafka consumers falling hours behind, hot nodes receiving 100x the traffic of peers, and garbage collection burning more CPU than business logic—forcing the team to adopt mutable data structures on the hot path against standard Scala idioms. Their takeaway: scale changes everything, fixing one bottleneck immediately exposes the next, and “best practices” are only a starting point.

Bonus

Images: MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other LLM vs RAG vs Agent evals How Distributed Tracing Works at the High Level? The Life of a Redis Query


This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.