<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Web Development on miti99</title><link>https://miti99.com/en/tags/web-development/</link><description>Recent content in Web Development 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/web-development/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #129</title><link>https://miti99.com/en/post/2026/09/07/</link><pubDate>Mon, 07 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #129.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hacking-the-method-name"&gt;&lt;a href="https://maxxedev.github.io/2026/08/05/hacking-the-method-name.html" rel="noopener noreferrer"&gt;Hacking the Method Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In Java, when you need a property name as a string—for parsing CSVs, mapping query results, or calling REST APIs—you usually hardcode &lt;code&gt;&amp;quot;title&amp;quot;&lt;/code&gt; or &lt;code&gt;&amp;quot;author&amp;quot;&lt;/code&gt; 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 &lt;code&gt;nameOf(Book::title)&lt;/code&gt;, keeping names refactoring-safe and in sync with your code. The trick relies on &lt;code&gt;SerializedLambda&lt;/code&gt;, introduced in Java 8: the author defines a &lt;code&gt;Getter&amp;lt;T, R&amp;gt;&lt;/code&gt; functional interface that extends both &lt;code&gt;Function&lt;/code&gt; and &lt;code&gt;Serializable&lt;/code&gt;, so when the JVM serializes a method reference of that type, it replaces it with a &lt;code&gt;SerializedLambda&lt;/code&gt; instance containing metadata about the target method. A custom &lt;code&gt;ObjectOutputStream&lt;/code&gt; enables &lt;code&gt;enableReplaceObject(true)&lt;/code&gt;, writes to a no-op stream, overrides &lt;code&gt;replaceObject()&lt;/code&gt; to intercept the replacement object, and reads the method name via &lt;code&gt;getImplMethodName()&lt;/code&gt;. From &lt;code&gt;nameOf()&lt;/code&gt;, it&amp;rsquo;s trivial to build &lt;code&gt;beanNameOf()&lt;/code&gt; to strip the &lt;code&gt;get&lt;/code&gt; prefix.&lt;/p&gt;
&lt;p&gt;The catch is that this stays clean only for zero-argument getters. Supporting multi-parameter methods like &lt;code&gt;save(title, author)&lt;/code&gt; requires manually declaring serializable interfaces like &lt;code&gt;Function2&lt;/code&gt; and &lt;code&gt;Function3&lt;/code&gt; along with corresponding &lt;code&gt;nameOf()&lt;/code&gt; overloads, which gets repetitive fast. To solve that, the author introduces the &lt;code&gt;safety-mirror&lt;/code&gt; library, which handles all the boilerplate out of the box and returns full &lt;code&gt;java.lang.reflect.Method&lt;/code&gt; objects rather than just method name strings.&lt;/p&gt;
&lt;h2 id="control-the-ideas-not-the-code"&gt;&lt;a href="https://antirez.com/news/169" rel="noopener noreferrer"&gt;Control the ideas, not the code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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&amp;rsquo;t mean barking &amp;ldquo;build me a product&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;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 &lt;code&gt;DESIGN.md&lt;/code&gt; file describing the ideas and design of each data structure in plain English. For younger developers who haven&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="good-tools-are-invisible"&gt;&lt;a href="https://www.gingerbill.org/article/2026/07/10/good-tools-are-invisible/" rel="noopener noreferrer"&gt;Good Tools Are Invisible&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Odin creator gingerBill argues that a good tool should be &amp;ldquo;invisible&amp;rdquo;: 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&amp;rsquo;s shortcomings into &amp;ldquo;fun puzzles&amp;rdquo; and citing them as proof of the tool&amp;rsquo;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&amp;rsquo;s personal identity—admitting the tool is flawed feels like admitting a personal flaw. He also distinguishes &lt;em&gt;feeling&lt;/em&gt; productive from &lt;em&gt;being&lt;/em&gt; productive: the honest metric is actual time spent and errors made, not how clever you felt along the way.&lt;/p&gt;
&lt;p&gt;He extends the argument to several perennial debates. If a GUI is hard to navigate by keyboard, that&amp;rsquo;s because its creators didn&amp;rsquo;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&amp;rsquo;t gone mainstream: shipping sensible defaults is the toolmaker&amp;rsquo;s responsibility and a sign of respect for the user&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="mysteries-of-telegram-dc"&gt;&lt;a href="https://dev.moe/en/3025" rel="noopener noreferrer"&gt;Mysteries of Telegram DC&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coxxs investigates Telegram&amp;rsquo;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 &lt;code&gt;auth.sendCode&lt;/code&gt; over MTProto to read the &lt;code&gt;PHONE_MIGRATE_2&lt;/code&gt; error, inspecting the &lt;code&gt;dc_id&lt;/code&gt; field in profile photo metadata, and parsing Web CDN domains—reveals the culprit. The third method fails because DC2 and DC3 &amp;ldquo;borrow&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;The investigation concludes that DC1, DC2, DC4, and DC5 are actively assigned by phone country code at sign-up (for instance, Germany&amp;rsquo;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&amp;rsquo;s server code is closed-source.&lt;/p&gt;
&lt;h2 id="how-i-use-htmx-with-go"&gt;&lt;a href="https://www.alexedwards.net/blog/how-i-use-htmx-with-go" rel="noopener noreferrer"&gt;How I use HTMX with Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &lt;code&gt;html/template&lt;/code&gt;, illustrated through a small app that filters a user list in real time. The template directory is organized into &lt;code&gt;base.tmpl&lt;/code&gt; for the shared layout, &lt;code&gt;pages/&lt;/code&gt; for individual page content, and &lt;code&gt;partials/&lt;/code&gt; for reusable HTML fragments, all embedded into the binary alongside static assets via &lt;code&gt;//go:embed&lt;/code&gt;. At the heart of the setup is an &lt;code&gt;htmlRenderer&lt;/code&gt; type: it parses the shared templates (base and all partials) once at startup, and its &lt;code&gt;render()&lt;/code&gt; method clones that template set, adds the specific page template, and executes the named template block. By extracting the table rows into a named &lt;code&gt;users:rows&lt;/code&gt; template block, the exact same template file can render either a full HTML page or just the partial fragment for HTMX to swap in.&lt;/p&gt;
&lt;p&gt;The server detects HTMX requests via the &lt;code&gt;HX-Request: true&lt;/code&gt; header and always sets &lt;code&gt;Vary: HX-Request&lt;/code&gt; so intermediate caches don&amp;rsquo;t serve fragments as full pages. To keep the browser&amp;rsquo;s back button working properly, &lt;code&gt;historyRestoreAsHxRequest&lt;/code&gt; must be set to &lt;code&gt;false&lt;/code&gt;; otherwise, navigating back fetches a bare HTML fragment instead of a full page. Redirects can&amp;rsquo;t use standard &lt;code&gt;3xx&lt;/code&gt; responses because &lt;code&gt;fetch()&lt;/code&gt; follows them transparently before HTMX can intervene; instead, the server returns a &lt;code&gt;2xx&lt;/code&gt; status with an &lt;code&gt;HX-Redirect&lt;/code&gt; header for HTMX requests while keeping standard &lt;code&gt;3xx&lt;/code&gt; redirects for normal requests. Finally, configuring &lt;code&gt;responseHandling&lt;/code&gt; lets &lt;code&gt;4xx&lt;/code&gt;/&lt;code&gt;5xx&lt;/code&gt; error pages replace the full document while still allowing &lt;code&gt;422&lt;/code&gt; validation errors to swap into their target form container.&lt;/p&gt;
&lt;h2 id="quadrupling-code-performance-with-a"&gt;&lt;a href="https://purplesyringa.moe/blog/quadrupling-code-performance-with-a-useless-if/" rel="noopener noreferrer"&gt;Quadrupling code performance with a &amp;ldquo;useless&amp;rdquo; if&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;purplesyringa recounts optimizing a specialized string compressor whose hot loop for backtracking the optimal encoding path consisted of a single assignment, &lt;code&gt;j = next_j[i][j]&lt;/code&gt;, compiling down to a single &lt;code&gt;mov&lt;/code&gt; 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 &lt;code&gt;j&lt;/code&gt; produced by the previous iteration, execution was bottlenecked by memory latency rather than throughput. Noticing that with small block counts &lt;code&gt;next_j[i][j]&lt;/code&gt; usually equals &lt;code&gt;j&lt;/code&gt; itself, the author exploited branch prediction by wrapping the assignment in &lt;code&gt;if (j != next_j[i][j])&lt;/code&gt;. When the CPU predicts the branch is not taken, the cross-iteration dependency vanishes and speculative execution races ahead; on the rare occasion &lt;code&gt;j&lt;/code&gt; actually changes, branch misprediction recovery flushes the speculative work and resumes with the updated value.&lt;/p&gt;
&lt;p&gt;The hurdle was getting the compiler to emit the branch at all, since &lt;code&gt;if (j != x) j = x;&lt;/code&gt; is a dead-code no-op that optimizers immediately strip out. The author had to cast through a &lt;code&gt;volatile&lt;/code&gt; pointer to make the condition and assignment appear independent to the compiler; readers later pointed out that &lt;code&gt;[[unlikely]]&lt;/code&gt; or &lt;code&gt;__builtin_expect&lt;/code&gt; achieves a similar effect in LLVM, though &lt;code&gt;volatile&lt;/code&gt; 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.&lt;/p&gt;
&lt;h2 id="reverse-engineering-chatgpt-web-how-openai-built-for-a-billion-users"&gt;&lt;a href="https://performance.dev/chatgpt" rel="noopener noreferrer"&gt;Reverse Engineering ChatGPT Web: How OpenAI Built for a Billion Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky reverse-engineers the frontend web architecture of ChatGPT, which serves roughly a billion users. What stands out first is how &amp;ldquo;boring&amp;rdquo; 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&amp;rsquo;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 &lt;code&gt;deferStartupImportsUntilComposerTTFI&lt;/code&gt; flag.&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;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&amp;rsquo;t measure it, you can&amp;rsquo;t improve it.&lt;/p&gt;
&lt;h2 id="broker-visible-vs-client-local-parallelism"&gt;&lt;a href="https://jack-vanlightly.com/blog/2026/6/3/broker-visible-vs-client-local-parallelism" rel="noopener noreferrer"&gt;Broker-Visible vs Client-Local Parallelism&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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.&lt;/p&gt;
&lt;p&gt;To size parallelism, Vanlightly uses Little&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="work-loudly"&gt;&lt;a href="https://ben.balter.com/2026/07/14/work-loudly/" rel="noopener noreferrer"&gt;Work Loudly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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&amp;rsquo;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&amp;rsquo;t fix it either, because the most valuable part—your reasoning, trade-offs, and dead ends—has already vanished. The solution is to &amp;ldquo;work loudly&amp;rdquo;: make your work visible while it is happening by opening an issue before writing code, writing PR descriptions that explain the &lt;em&gt;why&lt;/em&gt; 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&amp;rsquo;t loud enough.&lt;/p&gt;
&lt;p&gt;Balter compares working loudly to wearing a bear bell on a hike: you don&amp;rsquo;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?&lt;/p&gt;
&lt;h2 id="building-service-topology-at-scale-architecture-challenges-and-lessons-learned"&gt;&lt;a href="https://netflixtechblog.com/building-service-topology-at-scale-architecture-challenges-and-lessons-learned-f4b792f3f0d8" rel="noopener noreferrer"&gt;Building Service Topology at Scale: Architecture, Challenges, and Lessons Learned&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &amp;ldquo;archaeology,&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;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 &amp;ldquo;best practices&amp;rdquo; are only a starting point.&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_!lpxK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff9fb99a2-ec71-476d-a9cb-6c1a43339d90_2484x3002.png" alt="MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!LZtJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6456348c-5d92-4524-8dd6-d75b4dc7feaf_1280x1547.png" alt="LLM vs RAG vs Agent evals"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!ULeT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe81b4572-820e-4790-8861-8efe14f38700_2252x2752.png" alt="How Distributed Tracing Works at the High Level?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!6UyI!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F9f8ea7bf-2170-4466-92f3-edd7eab11de4_3000x3900.png" alt="The Life of a Redis Query"&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 #82</title><link>https://miti99.com/en/post/2026/02/19/</link><pubDate>Thu, 19 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/19/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #82.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-lobsters-front-page-works"&gt;&lt;a href="https://blog.nilenso.com/blog/2026/01/20/lobsters-front-page/" rel="noopener noreferrer"&gt;How the Lobsters front page works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Because the source code for Lobsters—the computing-focused link-aggregation community—is open source, the author dug into its front-page ranking algorithm. The core formula is &lt;code&gt;hotness = -1 × (base + order × sign + age)&lt;/code&gt;, where a more negative value ranks higher on the page. &lt;code&gt;base&lt;/code&gt; is the sum of tag modifiers (each tag carries a weight between -10 and +10; for instance, &lt;code&gt;culture&lt;/code&gt; and &lt;code&gt;rant&lt;/code&gt; are penalized), plus a &lt;code&gt;0.25&lt;/code&gt; boost if the submitter marked themselves as the article&amp;rsquo;s author. &lt;code&gt;order&lt;/code&gt; is the base-10 logarithm of story points plus comment points, meaning the jump from 0 to 100 upvotes has a much larger impact than going from 1,000 to 1,100. Comment points count for half an upvote each, are capped so they never exceed the story&amp;rsquo;s own score, and are ignored entirely when &lt;code&gt;base&lt;/code&gt; is negative—preventing low-quality flamebaits from rising on comment volume alone. The &lt;code&gt;sign&lt;/code&gt; term turns out to be effectively a no-op in practice, while &lt;code&gt;age&lt;/code&gt; is the submission timestamp divided by a 22-hour window, growing linearly and steadily overpowering the logarithmic vote score.&lt;/p&gt;
&lt;p&gt;The author finds the algorithm solid: new stories get a fair shot at visibility and nothing camps on the front page forever. Still, Lobsters&amp;rsquo; distinct character comes primarily from opinionated moderation, a narrow focus on computing, and its invite-tree membership model rather than the ranking formula itself. Even when disagreeing with the most vocal commenters, the author notes that disengaging only hands them more influence, since just a few early upvotes from active users are enough to propel a story onto the front page.&lt;/p&gt;
&lt;h2 id="software-engineers-can-no-longer-neglect-their-soft-skills"&gt;&lt;a href="https://www.qu8n.com/posts/most-important-software-engineering-skill-2026" rel="noopener noreferrer"&gt;Software engineers can no longer neglect their soft skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Quan argues that starting in 2026, communication has become the single most important skill for a software engineer—surpassing raw coding speed, system design, or deep mastery of a language like Rust. The reason is the rapid leap in AI coding agents: he uses Claude Code for nearly every non-trivial task and spent over $500 on usage in December alone. With Claude Opus 4.5, vanilla Claude Code out of the box handles roughly 80% of implementation work, meaning prompt tricks and custom MCP setups are no longer real differentiators. The bottleneck has shifted from implementation to specification: the clearer the spec, the better the agent satisfies both technical and business requirements—yet arriving at a clear spec is deceptively hard.&lt;/p&gt;
&lt;p&gt;In reality, tickets rarely capture the full requirements. Engineers have to ask probing questions to surface unstated assumptions stakeholders didn&amp;rsquo;t even realize they were making, facilitate trade-off discussions, push back on scope creep without damaging relationships, and exercise judgment on edge cases nobody thought to specify. Previously, an engineer with mediocre communication skills could still thrive on the strength of exceptional coding output; today, the non-coding parts of the job are mandatory. Engineers are conditioned to believe every problem has a deterministic solution and a &amp;ldquo;best practice,&amp;rdquo; whereas working with humans is messy and ambiguous. And you can&amp;rsquo;t outsource human communication to AI, because real communication requires empathy—something everyone needs more of right now.&lt;/p&gt;
&lt;h2 id="dithering---part-2"&gt;&lt;a href="https://visualrambling.space/dithering-part-2/" rel="noopener noreferrer"&gt;Dithering - Part 2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of this interactive visual series on dithering—the technique of creating the illusion of more colors than a palette actually has—focuses on ordered dithering, which uses a spatial threshold map to decide each pixel&amp;rsquo;s final color when converting grayscale images to 1-bit black and white. The author starts with basic quantization: using a single threshold collapses every shade of gray into solid black or white, whereas applying multiple thresholds across neighboring pixels turns a uniform gray region into a mix of black and white dots that preserves perceived brightness. When tiling a small threshold map across an entire image, arranging thresholds sequentially produces distracting vertical stripes because the output mirrors the map&amp;rsquo;s internal layout. A 2×2 Bayer matrix fixes this by arranging thresholds in a crosshatch pattern that distributes dots evenly; with only 4 threshold levels, however, tonal transitions still show harsh banding, which a 16-level 4×4 Bayer matrix smooths out considerably.&lt;/p&gt;
&lt;p&gt;How the threshold map is arranged defines the visual texture of the dithered image. An 8×8 Bayer matrix (64 levels) yields finer gradients with diminishing returns; a Cluster Dot matrix groups pixels into circular halftone-like dots reminiscent of vintage newsprint; and Void and Cluster—the author&amp;rsquo;s personal favorite—uses a blue-noise threshold map to produce an organic, non-repetitive texture that blends smoothly into gray. The next installment will cover error diffusion, a family of dithering algorithms that doesn&amp;rsquo;t use a threshold map at all.&lt;/p&gt;
&lt;h2 id="what-came-first-the-cname-or-the-a-record"&gt;&lt;a href="https://blog.cloudflare.com/cname-a-record-order-dns-standards/" rel="noopener noreferrer"&gt;What came first: the CNAME or the A record?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On January 8, 2026, a memory-optimization update to Cloudflare&amp;rsquo;s &lt;code&gt;1.1.1.1&lt;/code&gt; public DNS resolver inadvertently broke DNS resolution for a subset of users. The bug lurked in the code that merges cached &lt;code&gt;CNAME&lt;/code&gt; chains when only part of a chain has expired: previously, the resolver allocated a new list, placed the &lt;code&gt;CNAME&lt;/code&gt; records first, and appended the final &lt;code&gt;A&lt;/code&gt;/&lt;code&gt;AAAA&lt;/code&gt; records at the end; to reduce allocations and copying, the new code appended the refreshed &lt;code&gt;CNAME&lt;/code&gt; records onto the end of the existing answer list. Many stub resolvers process answer records sequentially in a single pass, tracking the &amp;ldquo;current target name&amp;rdquo; and updating it only when they encounter a matching &lt;code&gt;CNAME&lt;/code&gt;—so if the &lt;code&gt;CNAME&lt;/code&gt; appears after the &lt;code&gt;A&lt;/code&gt; record, the &lt;code&gt;A&lt;/code&gt; record is skipped and the response is treated as empty. Linux&amp;rsquo;s &lt;code&gt;glibc&lt;/code&gt; (&lt;code&gt;getaddrinfo&lt;/code&gt;) hit this exact failure mode, and certain Cisco switches even entered boot loops, whereas &lt;code&gt;systemd-resolved&lt;/code&gt; was unaffected because it searches across the entire record set.&lt;/p&gt;
&lt;p&gt;The deeper root cause was a decades-old ambiguity in RFC 1034 from 1987: the spec merely says the answer is &amp;ldquo;possibly preface[d]&amp;rdquo; by &lt;code&gt;CNAME&lt;/code&gt; records, without normative &lt;code&gt;MUST&lt;/code&gt; or &lt;code&gt;SHOULD&lt;/code&gt; keywords (which RFC 2119 didn&amp;rsquo;t standardize until 1997). While the RFCs explicitly state that record order &lt;em&gt;within&lt;/em&gt; a single RRset is insignificant, they say nothing about the relative order &lt;em&gt;between&lt;/em&gt; different RRsets in the same message section—or even the order of links within a &lt;code&gt;CNAME&lt;/code&gt; chain. Cloudflare had historically placed &lt;code&gt;CNAME&lt;/code&gt;s first, but had no regression test enforcing that ordering. They rolled back the change, committed to preserving &lt;code&gt;CNAME&lt;/code&gt;-first ordering permanently, and submitted an Internet-Draft to the IETF proposing to formally require &lt;code&gt;CNAME&lt;/code&gt; records to appear in canonical chain order before final answer records.&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 #32</title><link>https://miti99.com/en/post/2025/07/21/</link><pubDate>Mon, 21 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/21/</guid><description>&lt;p&gt;&lt;em&gt;It&amp;rsquo;s been a while since I last wrote a post. And honestly, my earlier newsletters felt a bit like &amp;ldquo;chasing KPIs&amp;rdquo;—&lt;del&gt;I just stuffed in a ton of links and let an AI Agent do the rest&lt;/del&gt;. This time I&amp;rsquo;ll curate the articles more carefully, &lt;del&gt;though I&amp;rsquo;m still letting AI do the writing because I&amp;rsquo;m lazy hehe =)))&lt;/del&gt;. Hope you enjoy it. Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="claude-code-best-practices-for-agentic-coding"&gt;&lt;a href="https://code.claude.com/docs/en/best-practices" rel="noopener noreferrer"&gt;Claude Code: Best Practices for Agentic Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official guide distilling effective workflows for Claude Code—an agentic coding environment that can read files, run commands, edit code, and work through problems while you supervise or steer. Most of its advice stems from a single constraint: the context window fills up fast, and response quality degrades as it fills. That makes giving Claude a way to verify its own work—such as a test suite, a build command, or screenshots to compare against—the single highest-leverage thing you can do, letting it iterate until the check passes instead of forcing you to catch every mistake yourself. For complex tasks, split the work into four phases: explore, plan (using plan mode), implement, and commit; for small fixes like a typo, just ask it to make the change directly.&lt;/p&gt;
&lt;p&gt;The guide also recommends writing specific prompts (naming files, edge cases, and existing project patterns) and configuring the environment thoughtfully: a concise &lt;code&gt;CLAUDE.md&lt;/code&gt; with project commands, conventions, and gotchas; an allowlist of safe permissions; CLI tools like &lt;code&gt;gh&lt;/code&gt;; MCP servers; hooks for deterministic checks; and skills or subagents for specialized knowledge. During a session, course-correct early, run &lt;code&gt;/clear&lt;/code&gt; between unrelated tasks, and delegate exploratory research to subagents to keep the main context clean. Once you have the basics down, you can scale out with non-interactive &lt;code&gt;claude -p&lt;/code&gt; runs, parallel sessions, and an independent review pass before considering a task done.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="openai-windsurf-and-the-future-of-work"&gt;&lt;a href="https://www.subtle.so/openai-windsurf-and-the-future-of-ai-workspaces.html" rel="noopener noreferrer"&gt;OpenAI, Windsurf, and the future of work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on Subtle analyzes reports that OpenAI wants to acquire Windsurf for around $3 billion, after previously eyeing Cursor. Technically, Windsurf&amp;rsquo;s core product (a VS Code fork with an AI agent and code autocomplete) isn&amp;rsquo;t uniquely hard to build, so the real value lies elsewhere: tools like this can become general-purpose AI workspaces far beyond coding. They give AI direct access to files and folders to assist with writing, research, and content management, while baking in Git for version history—something traditional productivity suites still lack. For instance, The Pragmatic Engineer connected Windsurf to a PostgreSQL database to query business metrics in plain English. The author compares this trajectory to how IRC evolved from a niche developer tool into Slack&amp;rsquo;s $27 billion business.&lt;/p&gt;
&lt;p&gt;On top of that, interaction data from millions of Windsurf sessions provides valuable training signal that could help OpenAI&amp;rsquo;s models catch up with Anthropic on coding benchmarks. The competitive web is tangled too: Microsoft owns both VS Code and GitHub Copilot while backing OpenAI, even as OpenAI&amp;rsquo;s startup fund has invested in Cursor. All of it points to a rapidly consolidating AI developer-tools market with massive commercial expectations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="vibe-coding-is-not-an-excuse-for-low-quality-work"&gt;&lt;a href="https://addyo.substack.com/p/vibe-coding-is-not-an-excuse-for" rel="noopener noreferrer"&gt;Vibe Coding is Not an Excuse for Low-Quality Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that &amp;ldquo;vibe coding&amp;rdquo; with AI is a useful accelerator, but not an excuse to abandon software engineering rigor. AI can generate huge amounts of code in minutes, yet volume does not equal quality: vibe-coded projects routinely skip error handling, miss security flaws, resist maintenance, and collapse like a &amp;ldquo;house of cards.&amp;rdquo; As Osmani puts it, speed means nothing if the wheels come off mid-drive, because technical debt compounds quickly when nobody is watching the architecture.&lt;/p&gt;
&lt;p&gt;His recommended mental model is to treat AI like a blazingly fast junior developer: a human still needs to review every output, refactor when needed, cover edge cases, and write thorough tests. He lays out practical rules: always review AI-generated code, enforce coding standards, use AI for acceleration rather than decision-making, prioritize testing, iterate and refine, recognize when to write code by hand, and document carefully. Vibe coding shines for rapid prototypes, throwaway scripts, learning a new stack, or generating boilerplate, but falls short for enterprise systems, mission-critical software, or long-lived codebases. That is also why experienced engineers get more out of AI—they know enough to spot flaws and refine its suggestions.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="event-hidden-architectures"&gt;&lt;a href="https://skiplabs.io/blog/event-hidden-arch" rel="noopener noreferrer"&gt;Event-Hidden Architectures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Charles Zedlewski, an advisor to SkipLabs, argues that event-driven architecture—long treated as the default for distributed cloud applications—is showing its age, and proposes replacing it with &amp;ldquo;event-hidden&amp;rdquo; architectures. Distributed applications aren&amp;rsquo;t going away, but forcing developers to manage events by hand creates constant friction: juggling complex asynchronous flows, maintaining queues and schemas, and debugging across service boundaries. In his view, that complexity was a necessary tax around 2020, but no longer has to be.&lt;/p&gt;
&lt;p&gt;Three categories of technology make this shift possible: on the frontend, React and modern state-management libraries; on the backend write path, durable execution engines like Temporal, Restate, and DBOS that guarantee correctness across service boundaries; and on the read path, reactive frameworks like Skip that aggregate distributed data efficiently. What they share is hiding infrastructure plumbing, handling asynchrony transparently, and treating state as a first-class concern. That lets developers write simpler, more maintainable code while gaining better observability, cleaner state management, and the ability to replay application execution. Zedlewski predicts event-hidden architectures will become the default for web applications over the next decade.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="lessons-from-distributed-systems"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2025/04/19/lessons-from-distributed-systems/" rel="noopener noreferrer"&gt;Lessons from Distributed Systems&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from 16elt.com shares practical lessons from building and operating distributed systems at scale. The author distills hard-won experience around common failure modes and how to handle them when working with distributed architectures.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Isolate cache clusters: avoid sharing a single cache cluster across multiple services because a heavy workload from Service A can evict critical data needed by Service B, causing hard-to-diagnose performance issues&lt;/del&gt;
&lt;del&gt;- Use message queues: queues absorb traffic spikes and smooth service load, providing buffering and resilience between services like &amp;ldquo;a responsible adult in the room&amp;rdquo; that prevents service overload&lt;/del&gt;
&lt;del&gt;- Measure end-to-end latency: look beyond service response times to include &amp;ldquo;dequeue latency&amp;rdquo;—how long messages sit waiting in a queue before processing begins&lt;/del&gt;
&lt;del&gt;- Design for failure: expect and plan for network and service failures by implementing retry policies, circuit breakers, and dead-letter queues for failed messages&lt;/del&gt;
&lt;del&gt;- Ensure idempotency: assume duplicate messages will happen and design handlers to process repeated events gracefully, since message queues typically guarantee &amp;ldquo;at least once&amp;rdquo; delivery&lt;/del&gt;
&lt;del&gt;- Distributed systems demand proactive design, robust monitoring, and resilient architecture to keep complexity and failure points under control&lt;/del&gt;
&lt;del&gt;- Monitoring and observability are key to understanding how a system actually behaves in production&lt;/del&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="better-error-handling"&gt;&lt;del&gt;&lt;a href="https://meowbark.dev/Better-error-handling" rel="noopener noreferrer"&gt;Better error handling&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post from meowbark.dev explores modern error-handling approaches in software development, from traditional try/catch blocks to Go-style error returns and monadic Result types. The author weighs the pros and cons of each style and offers guidance on choosing the right fit.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Three main approaches to error handling: traditional try/catch, Go-style return tuples, and monadic Result types&lt;/del&gt;
&lt;del&gt;- Challenges of traditional error handling: lack of type safety, unpredictable control flow, and limited integration with the type system&lt;/del&gt;
&lt;del&gt;- Go-style approach: return errors as part of a tuple, handle failure scenarios explicitly, and attach clear error context&lt;/del&gt;
&lt;del&gt;- Monadic Result approach: treat errors as values using container types like &lt;code&gt;Result&amp;lt;T,E&amp;gt;&lt;/code&gt;, enabling functional-style error chaining&lt;/del&gt;
&lt;del&gt;- Core best practices: distinguish recoverable from unrecoverable errors, wrap external library errors early, and use type-safe error-handling mechanisms&lt;/del&gt;
&lt;del&gt;- Weigh performance and developer experience when picking a strategy&lt;/del&gt;
&lt;del&gt;- Recommended techniques: use libraries like &lt;code&gt;neverthrow&lt;/code&gt; for structured error management, and implement error mapping and transformation&lt;/del&gt;
&lt;del&gt;- Build centralized error-handling layers to manage failures systematically&lt;/del&gt;
&lt;del&gt;- Choose an error-handling strategy that balances type safety, readability, and team familiarity&lt;/del&gt;
&lt;del&gt;- Maintain clear error communication and recovery paths across the application&lt;/del&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></channel></rss>