<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Kafka on miti99</title><link>https://miti99.com/en/tags/kafka/</link><description>Recent content in Kafka 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/kafka/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #66</title><link>https://miti99.com/en/post/2025/12/09/</link><pubDate>Tue, 09 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;I&amp;rsquo;ve used iFlow&amp;rsquo;s free API quite a lot already, so today I&amp;rsquo;m trying out iFlow&amp;rsquo;s CLI—&lt;a href="https://github.com/iflow-ai/iflow-cli" rel="noopener noreferrer"&gt;iFlow CLI&lt;/a&gt;—to see how it goes, using the GLM-4.6 model.&lt;/del&gt; Enjoy Newsletter #66.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-ultimate-list-of-best-software-architecture-books-2026"&gt;&lt;a href="https://www.workingsoftware.dev/the-ultimate-list-of-software-architecture-books/?&amp;amp;aid=recmw058VtqAJCyyK" rel="noopener noreferrer"&gt;The Ultimate List of Best Software Architecture Books (2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Software architecture is the foundation that determines a product&amp;rsquo;s quality: good design reduces bug risk and makes adding features later far easier. Patrick Roos curates a reading list of software architecture books for 2026, spanning classics like Richards and Ford&amp;rsquo;s &lt;em&gt;Fundamentals of Software Architecture&lt;/em&gt;, &lt;em&gt;Software Architecture in Practice&lt;/em&gt; (4th edition), &lt;em&gt;Designing Data-Intensive Applications&lt;/em&gt;, and &lt;em&gt;Enterprise Integration Patterns&lt;/em&gt;, as well as modern practical guides like &lt;em&gt;Software Architecture: The Hard Parts&lt;/em&gt; on distributed-systems trade-offs and &lt;em&gt;Building Multi-Tenant SaaS Architectures&lt;/em&gt; for cloud platforms.&lt;/p&gt;
&lt;p&gt;The list also emphasizes the human and organizational side of architecture: Susanne Kaiser&amp;rsquo;s &lt;em&gt;Architecture for Flow&lt;/em&gt; combines Wardley Mapping, Domain-Driven Design, and Team Topologies to align business strategy with architecture; Gregor Hohpe&amp;rsquo;s &lt;em&gt;The Software Architect Elevator&lt;/em&gt; helps architects bridge the gap between engineering and the business; &lt;em&gt;Collaborative Software Design&lt;/em&gt; shows how to involve stakeholders in the design process; and &lt;em&gt;Facilitating Software Architecture&lt;/em&gt; and &lt;em&gt;Reviewing Software Systems&lt;/em&gt; (introducing the lightweight LASR architecture review method) help architects and developers collaborate more effectively. The list also highlights two new/upcoming titles for late 2025–2026: Lilienthal and Schwentner&amp;rsquo;s &lt;em&gt;Domain-Driven Transformation&lt;/em&gt;, offering a roadmap for modernizing legacy systems, and Simon Brown&amp;rsquo;s &lt;em&gt;The C4 Model&lt;/em&gt; on communicating software architecture through structured diagrams.&lt;/p&gt;
&lt;h2 id="how-i-use-ai-oct-2025"&gt;&lt;a href="https://ben.stolovitz.com/posts/how_use_ai_oct_2025/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;How I use AI (Oct 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Stolovitz shares how he uses AI—primarily large language models (LLMs)—in his daily work as of October 2025. Coding is where AI has made the biggest difference: he calls GitHub Copilot&amp;rsquo;s autocomplete &amp;ldquo;magical&amp;rdquo; for finishing boilerplate and discovering idiomatic patterns in unfamiliar languages, even if it struggles with complex algorithms. Agent mode is increasingly helpful for larger changes, though it still requires solid tests, clear documentation, and human oversight. For search and research, AI excels at tracking down tip-of-the-tongue articles or explaining general concepts, but falls short when shopping for products or finding academic papers, and remains prone to hallucinating citations or sycophantically validating whatever assumption the user feeds it.&lt;/p&gt;
&lt;p&gt;Summarization and transcription are standout strengths: AI can condense hundreds of pages of documentation or an entire meeting recording in minutes. Conversely, Stolovitz refuses to let AI write for him because he views his blog as personal self-expression; he uses AI only as a tough copy editor to suggest better phrasing, then rewrites the text in his own voice. He is most skeptical of AI-generated visual art and music, finding them lacking in creative depth and genuine human connection.&lt;/p&gt;
&lt;h2 id="stop-vibe-coding-your-unit-tests"&gt;&lt;a href="https://www.andy-gallagher.com/blog/stop-vibe-coding-your-unit-tests/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Stop Vibe Coding Your Unit Tests&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Gallagher warns against handing unit test writing over to LLMs on autopilot. Left to their own devices, LLMs tend to generate far too many tests that merely assert what the code currently does rather than verifying what the code &lt;em&gt;should&lt;/em&gt; do. Given a simple React button component, for instance, Claude Sonnet 4 generated roughly 30 tests spanning ~200 lines, mostly testing trivialities like default rendering, prop passthrough, or HTML attributes that React and the browser already guarantee. Such tests lock the codebase to its current implementation so every refactor breaks a pile of tests, while polluting the agent&amp;rsquo;s context window, degrading semantic code search, and turning pull requests into a slog for teammates to review.&lt;/p&gt;
&lt;p&gt;Gallagher&amp;rsquo;s remedy is intentional, test-by-test authoring: explicitly specify which behavior you want to test, carefully review what the AI generates, and keep test files lean and focused. LLMs still do well on self-contained, algorithmic code, but for everyday product code, what actually needs testing is whether the team is building the right thing. The core principle: fewer, higher-quality tests beat bloated test suites every time.&lt;/p&gt;
&lt;h2 id="game-design-is-simple-actually"&gt;&lt;a href="https://www.raphkoster.com/2025/11/03/game-design-is-simple-actually/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;Game design is simple, actually&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raph Koster outlines a systematic 12-step framework for understanding game design. At their core, games are about mastering problems: fun comes from making progress in our ability to predict outcomes, not from surface-level flash. A toy is a system with constraints; add a goal and it becomes a game, centered on a core mechanic—a &amp;ldquo;problem object&amp;rdquo; to be solved. Players interact through loops: an operational loop (act, receive feedback, learn) and a progression loop where situations continually escalate and shift so old strategies stop working. Good feedback must tell players what they can do, what they just did, what happened as a result, and whether they are getting closer to their goal, while difficulty must match their learning curve.&lt;/p&gt;
&lt;p&gt;At the macro level, a game is assembled from smaller sub-games whose loops interlock to form economies and value chains. How a problem is dressed up—through narrative, visuals, audio, and metaphor—strongly shapes the player&amp;rsquo;s experience, making game design a synthetic art form that demands both systems design and experience design. Player motivations vary widely too, which is why no single game appeals to everyone. The individual principles sound simple, but executing all 12 well at the same time is the real challenge.&lt;/p&gt;
&lt;h2 id="architectural-debt-is-not-just-technical-debt"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2025-10-31-architectural-debt-is-not-just-technical-debt/?&amp;amp;aid=recufcl24hU9MXCJC" rel="noopener noreferrer"&gt;Architectural debt is not just technical debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Frederick Van Brabant distinguishes architectural debt from technical debt. While technical debt usually refers to localized shortcuts inside a codebase, architectural debt consists of structural decisions with long-term consequences that reach far beyond code. He breaks architectural debt down across three layers. At the application and infrastructure layer, enterprise architects should focus on integration patterns, overlapping systems, and vendor lock-in, because debt here inflates costs and slows delivery. The business layer involves ownership, governance responsibilities, and outdated processes—where inaccurate documentation can create serious trouble during audits. The strategic layer is the most dangerous: poorly defined capabilities or half-baked framework rollouts plant flawed assumptions across the organization for the next three to five years.&lt;/p&gt;
&lt;p&gt;Enterprise architects have the vantage point and time horizon to spot this kind of debt, but merely raising the alarm isn&amp;rsquo;t enough: they need to build a compelling business case laying out the current state, target state, and business upside backed by concrete numbers to win leadership buy-in. Van Brabant also advises picking your battles wisely: it&amp;rsquo;s fine to tolerate more debt in experimental innovation systems than in systems of record, provided you clean it up once the experiment concludes and secure real resources to pay the debt down.&lt;/p&gt;
&lt;h2 id="the-search-problem-why-your-computer-finds-things-faster-than-you-do"&gt;&lt;a href="https://deyaa1251.github.io/deyaa1251/posts/b_tree/?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;The Search Problem: Why Your Computer Finds Things Faster Than You Do&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains why B-trees are so foundational in modern storage systems. The author recounts implementing a binary search tree (BST) from scratch and watching it fall apart once simulated disk reads and writes were introduced. A BST&amp;rsquo;s lookup cost scales with its height: O(log n) when balanced, but degrading to O(n) when unbalanced. Under a model where each node visit costs one disk read, searching across 100,000 files takes roughly 17 disk reads with a balanced BST, whereas a B-tree needs only 3. That&amp;rsquo;s because a B-tree packs many keys into each node (&amp;ldquo;fat nodes&amp;rdquo;) sized to fit a single 4KB disk block, keeping the tree extremely shallow. In the author&amp;rsquo;s simulation, inserting 100,000 sequential items caused the BST to degenerate into a 40,000-level linked list that took roughly 23.5 minutes, while the B-tree stayed 3 levels tall and finished in 3 seconds.&lt;/p&gt;
&lt;p&gt;Because they guarantee predictable worst-case performance regardless of insertion order, B-trees and their variants power indexes in MySQL, PostgreSQL, MongoDB, and countless filesystems. The broader lesson extends beyond data structures: hardware context dictates optimal design. B-trees trade away theoretical best-case simplicity in exchange for rock-solid worst-case guarantees—which is what matters in production systems.&lt;/p&gt;
&lt;h2 id="kafka-is-fast"&gt;&lt;a href="https://topicpartition.io/blog/postgres-pubsub-queue-benchmarks?utm_source=bonobopress&amp;amp;utm_medium=newsletter&amp;amp;utm_campaign=2155" rel="noopener noreferrer"&gt;Kafka is fast &amp;ndash; I&amp;rsquo;ll use Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post benchmarks PostgreSQL as a pub/sub and job queue system in place of dedicated message brokers like Kafka. With 1 KiB messages in a pub/sub workload, a 4-vCPU instance in the author&amp;rsquo;s test setup achieved roughly 5,000 messages per second on writes (4.8 MiB/s) and 24.6 MiB/s on reads with a 5x fan-out, at a 60ms p99 latency. A three-node replicated cluster maintained the same throughput while increasing p99 latency to 186ms. Scaling up to a 96-vCPU instance reached 238 MiB/s on writes and 1.16 GiB/s on reads while using only about 10% CPU. In a work-queue pattern, the 4-vCPU machine handled roughly 2.81 MiB/s at a 17.7ms p99 latency, while the 96-vCPU machine reached 19.7 MiB/s.&lt;/p&gt;
&lt;p&gt;The author&amp;rsquo;s takeaway is simple: use Postgres until you genuinely outgrow it. For the vast majority of organizations operating below a few megabytes per second, Postgres covers 80% of use cases with 20% of the effort, whereas the operational overhead and organizational complexity of adopting a separate distributed broker usually outweigh its benefits at modest scale. That simplicity and reliability are exactly why the &amp;ldquo;Just Use Postgres&amp;rdquo; movement keeps gaining traction.&lt;/p&gt;
&lt;h2 id="you-need-to-become-a-full-stack-person"&gt;&lt;a href="https://den.dev/blog/full-stack-person/?utm_source=tldrnewsletter" rel="noopener noreferrer"&gt;You Need To Become A Full Stack Person&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Den Delimarsky argues that in the AI era, everyone needs to become a &amp;ldquo;full-stack person.&amp;rdquo; As LLMs commoditize many narrow coding skills, combining creativity, critical thinking, and execution speed becomes the durable career moat. Boundaries between traditional roles are blurring, reflected in the rise of the product engineer who owns frontend, backend, and customer empathy end to end. In Delimarsky&amp;rsquo;s view, the T-shaped skill model (one deep specialty atop a broad base) is obsolete; replacing it is the Pi-shaped model with two deep pillars—product sense and technical craft—resting on broad interdisciplinary knowledge.&lt;/p&gt;
&lt;p&gt;The post highlights ten skills to cultivate: creativity and taste, critical thinking, communication, interdisciplinary breadth, AI leverage, product sense, execution speed, rapid learning, systems thinking, and agency. AI cannot replace taste or judgment; it is a vehicle for turning ideas into reality, lowering the cost of writing code without lowering the cost of deciding what is worth building. Typing code is no longer the bottleneck, and a high-agency &amp;ldquo;start doing, then figure it out&amp;rdquo; mindset is what sets people apart.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;iFlow CLI did a pretty good job on the first few articles, though toward the end it started leaving too many English words untranslated. A nice plus is that iFlow CLI can fetch many URLs by bypassing blocks through a proxy (though it&amp;rsquo;s a Chinese proxy, which feels a bit sketchy). While running it I also saw a bunch of log lines in Chinese, which was confusing and slightly unnerving :v I&amp;rsquo;ll try to refine &lt;code&gt;AGENTS.md&lt;/code&gt; and test it again later.&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #53</title><link>https://miti99.com/en/post/2025/09/09/</link><pubDate>Tue, 09 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/09/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;For this post, I experimented with consolidating all my previous coding agent rules into a single &lt;code&gt;AGENTS.md&lt;/code&gt; file, then pointing &lt;code&gt;CLAUDE.md&lt;/code&gt; to read that file.&lt;/del&gt; Enjoy Newsletter #53.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="anti-cheat-secure-boot--tpm"&gt;&lt;a href="https://andrewmoore.ca/blog/post/anticheat-secure-boot-tpm/" rel="noopener noreferrer"&gt;Anti-cheat, Secure Boot &amp;amp; TPM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Moore explains why anti-cheat systems like those in Battlefield 6 or Riot&amp;rsquo;s Vanguard have started requiring players to enable Secure Boot and TPM 2.0, while pushing back against claims that this is a pretext for harvesting player data. Secure Boot relies on a key hierarchy (Platform Key, Key Exchange Key, the DB allowlist of signatures, and the DBX blocklist) to ensure firmware only executes validly signed boot images. Combined with Windows only loading Microsoft-signed kernel drivers, cheat developers have a hard time injecting code into the kernel without an unpatched vulnerability.&lt;/p&gt;
&lt;p&gt;However, an anti-cheat client cannot simply trust the operating system when it reports that Secure Boot is enabled, which is where the TPM becomes the crucial link. The firmware TPM (fTPM) built into modern AMD and Intel CPUs holds a unique Endorsement Key backed by a manufacturer certificate, providing unforgeable hardware identification—meaning a hardware ban forces a cheater to buy a new CPU. In addition, the TPM&amp;rsquo;s PCR registers record a cryptographic hash chain of every event during the boot sequence, and through remote attestation via &lt;code&gt;TPM2_Quote&lt;/code&gt;, the anti-cheat server can verify that the boot environment has not been tampered with. The takeaway: this setup doesn&amp;rsquo;t eliminate cheating completely—especially hardware-based cheats—but it makes ban evasion far more expensive, doesn&amp;rsquo;t compromise user privacy, and forms an important layer of defense in depth.&lt;/p&gt;
&lt;h2 id="left-to-right-programming"&gt;&lt;a href="https://graic.net/p/left-to-right-programming" rel="noopener noreferrer"&gt;Left to Right Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that a program should remain syntactically valid while it is being typed from left to right, so the editor can offer autocomplete and type checking at every step. A classic counterexample is Python&amp;rsquo;s list comprehension: when writing &lt;code&gt;words_on_lines = [line.split() for line in text.splitlines()]&lt;/code&gt;, the variable &lt;code&gt;line&lt;/code&gt; is used before it is declared, so the editor doesn&amp;rsquo;t know its type when you type the dot and cannot suggest methods. By contrast, in Rust (&lt;code&gt;let words_on_lines = text.lines().map(|line| line.split_whitespace());&lt;/code&gt;) or JavaScript, expressions are built from left to right: the source is stated first, and the moment you type a dot, the editor can suggest relevant methods.&lt;/p&gt;
&lt;p&gt;The article connects this to the design principle of &amp;ldquo;progressive disclosure&amp;rdquo;: complexity should only surface when the user actually needs it. In C, because methods cannot be attached to structs, you have to know function names like &lt;code&gt;fread&lt;/code&gt; or &lt;code&gt;fclose&lt;/code&gt; ahead of time rather than discovering them through autocomplete after typing &lt;code&gt;file.&lt;/code&gt;. Python runs into a similar issue with global functions like &lt;code&gt;len&lt;/code&gt; or &lt;code&gt;map&lt;/code&gt;; as logic grows more complex, a single line of Python nesting multiple &lt;code&gt;filter&lt;/code&gt;, &lt;code&gt;lambda&lt;/code&gt;, and comprehension expressions becomes much harder to read than a method chain in JavaScript that reads sequentially from left to right. The closing message for language and library designers is simple: build discoverable APIs.&lt;/p&gt;
&lt;h2 id="big-o-notation"&gt;&lt;a href="https://samwho.dev/big-o/" rel="noopener noreferrer"&gt;Big O Notation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide on samwho.dev introduces Big O notation visually with live in-browser examples. Rather than measuring wall-clock time, Big O describes how execution time grows as input size increases. The author walks through four common complexity classes: summing numbers from 1 to &lt;code&gt;n&lt;/code&gt; with a loop is O(n) (linear), whereas using the formula &lt;code&gt;(n*(n+1))/2&lt;/code&gt; is O(1) (constant)—noting that O(1) does not mean &amp;ldquo;instant,&amp;rdquo; only that runtime does not depend on input size. Bubble sort illustrates O(n²) (quadratic), while guessing a number between 1 and 100 via binary search, halving the search space on each guess, illustrates O(log n) (logarithmic). Big O describes an asymptotic upper bound: O(2n) simplifies to O(n), keeping only the fastest-growing term. You can analyze best, average, or worst cases; the article focuses on the worst case.&lt;/p&gt;
&lt;p&gt;The final section shares practical performance tips: use a hash-table-backed &lt;code&gt;Set&lt;/code&gt; for average O(1) lookups instead of scanning an array (even though building the &lt;code&gt;Set&lt;/code&gt; costs O(n)), avoid calling &lt;code&gt;.indexOf&lt;/code&gt; inside a loop since that quietly turns the whole function into O(n²), and memoize intermediate results—as shown with factorials—to avoid redundant computation at the cost of extra memory. The most important advice: always benchmark before and after changing code, and don&amp;rsquo;t blindly trust performance claims you read online.&lt;/p&gt;
&lt;h2 id="personal-ai-evaluations-august-2025"&gt;&lt;a href="https://darkcoding.net/software/personal-ai-evals-aug-2025/" rel="noopener noreferrer"&gt;Personal AI Evaluations August 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Graham King evaluates large language models (LLMs) against his own day-to-day needs instead of relying on public leaderboards: he selected 12 questions out of 130 prompts from his bash history across four categories (coding, sysadmin, technical explanations, and general knowledge/creative), and ran them against 11 models via OpenRouter—including Claude Sonnet 4, DeepSeek, Gemini 2.5 Flash and Pro, Kimi K2, GPT-OSS-120B, Qwen3, and GLM 4.5. He wrote a custom Rust tool to anonymize the responses for blind grading while recording cost, latency, and throughput for each model.&lt;/p&gt;
&lt;p&gt;His main conclusion is that almost all current models give good answers, making cost and latency the deciding factors. Proprietary models like Gemini 2.5 Pro and Claude Sonnet did not stand out—in fact, they often scored lower than open-weight models while costing dramatically more. Gemini 2.5 Flash was the fastest; Kimi K2, Qwen3, and DeepSeek were among the cheapest; and two DeepSeek models alongside two Qwen3 models achieved the highest average accuracy. Reasoning mode rarely helped outside of a poetry prompt, and the entire evaluation produced only a single hallucination, when GPT-OSS-120B invented a nonexistent movie. Based on these results, the author now queries multiple models in parallel using &lt;code&gt;tmux&lt;/code&gt;: DeepSeek for everyday questions, adding Gemini Flash and Qwen3 when he wants a second opinion, and reserving reasoning models for particularly tough problems.&lt;/p&gt;
&lt;h2 id="how-to-keep-services-running-during-failures"&gt;&lt;a href="https://newsletter.scalablethread.com/p/how-to-keep-services-running-during" rel="noopener noreferrer"&gt;How to Keep Services Running During Failures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post from The Scalable Thread introduces graceful degradation, the design principle of keeping a system&amp;rsquo;s core functionality running when a component fails rather than letting the entire service go down. For example, if a video platform&amp;rsquo;s recommendation service fails, the homepage can fall back to showing trending videos while video playback continues working normally. The first group of strategies focuses on traffic control: rate limiting caps incoming requests during flash sales or DDoS attacks; request coalescing collapses thousands of identical concurrent queries into a single database hit; load shedding proactively drops non-essential requests (such as click tracking) to preserve capacity for checkout transactions; and retries with jitter add random backoff delays to prevent a &amp;ldquo;thundering herd problem&amp;rdquo; when a recovering service comes back online.&lt;/p&gt;
&lt;p&gt;The second group of strategies handles faults and improves observability. A circuit breaker acts like an electrical breaker: when a payment service repeatedly fails, the ordering service trips the breaker and fails fast for a cooldown period (say, 60 seconds) before letting a few probe requests through to check whether the downstream service has recovered. Request timeouts prevent upstream services from exhausting thread pools or connection limits waiting on a slow dependency. Finally, monitoring and alerting on metrics like error rates, latency, and message broker queue depth help engineers catch and contain incidents before they cascade.&lt;/p&gt;
&lt;h2 id="why-was-apache-kafka-created"&gt;&lt;a href="https://bigdata.2minutestreaming.com/p/why-was-apache-kafka-created" rel="noopener noreferrer"&gt;Why Was Apache Kafka Created?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from 2 Minute Streaming explains why Kafka was created in the first place. Around 2012, LinkedIn relied on user activity data to power many core features, but operated two separate data pipelines: an hourly batch system that pushed XML messages through HTTP servers into Oracle and Hadoop data warehouses, and a near-real-time monitoring pipeline built on Zenoss. Both required heavy manual operations, suffered from large backlogs, and consisted of fragile point-to-point connections that couldn&amp;rsquo;t be unified. Specific pain points included parsing hundreds of XML schemas, breaking downstream consumers whenever a schema changed, multi-hour latency, and clean data being locked inside the data warehouse.&lt;/p&gt;
&lt;p&gt;Kafka solved these problems with a distributed, replicated architecture that scales horizontally via partitions, an append-only log structure that supports multiple independent consumers, and disk persistence that decouples producers from consumers. LinkedIn also migrated from XML to Avro (roughly 7x smaller), built a schema versioning service—the precursor to Schema Registry—with backward-compatibility checks, enforced &amp;ldquo;schema on write&amp;rdquo; to validate data before it entered Kafka, and shifted schema ownership to the teams producing the data backed by mandatory review workflows. What surprised the author most is that LinkedIn&amp;rsquo;s original papers emphasized schemas over 13 years ago, whereas he considers the lack of native, built-in schema enforcement to be Kafka&amp;rsquo;s biggest design mistake.&lt;/p&gt;
&lt;h2 id="how-we-vibe-code-at-a-faang"&gt;&lt;a href="https://www.reddit.com/r/vibecoding/comments/1myakhd/how_we_vibe_code_at_a_faang/" rel="noopener noreferrer"&gt;How We Vibe Code at a FAANG&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A Reddit user who introduces himself as an AI engineer with over ten years of experience—roughly half of it at FAANG or similar companies—shares how his team integrates AI into a production software development workflow, pushing back against the claim that AI-assisted coding isn&amp;rsquo;t viable for real-world systems. Their process still starts with rigorous technical design docs: a proposal must win stakeholder alignment, followed by a full system design covering architecture and cross-team integrations, and then a design review where senior engineers tear it apart—what the author calls front-loading the pain. Next come subsystem documentation, task breakdowns, and sprint planning with PMs and TPMs.&lt;/p&gt;
&lt;p&gt;Only when it is time to write code does AI become a productivity &amp;ldquo;force multiplier&amp;rdquo;: the team practices Test-Driven Development, having AI agents write the tests first before implementing the feature. Every pull request still requires approval from two human engineers before merging (with AI also starting to assist in code reviews), followed by staging verification before production rollout. According to the poster, end-to-end delivery time from feature proposal to production is about 30% faster. Many commenters pointed out that this isn&amp;rsquo;t really &amp;ldquo;vibe coding&amp;rdquo; at all, but disciplined AI-assisted engineering inside a mature enterprise workflow—a distinction the author himself agreed with.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Verdict on &lt;code&gt;AGENTS.md&lt;/code&gt; effectiveness: Not great yet—it still left quite a lot of English terms untranslated. I&amp;rsquo;ll try to refine it further in upcoming posts. See you next time!&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #19</title><link>https://miti99.com/en/post/2025/05/06/</link><pubDate>Tue, 06 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #19.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-love-letter-to-the-csv-format"&gt;&lt;a href="https://github.com/medialab/xan/blob/master/docs/LOVE_LETTER.md" rel="noopener noreferrer"&gt;A love letter to the CSV format&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of &lt;code&gt;xan&lt;/code&gt; (a command-line CSV processing tool developed by medialab) wrote this &amp;ldquo;love letter&amp;rdquo; to push back against articles constantly declaring CSV obsolete in the face of Parquet, newline-delimited JSON, or MessagePack. CSV is no silver bullet, the author admits, but it has strengths that are routinely overlooked: a specification simple enough to explain in seconds (commas separate values, newlines separate rows, special values go in quotes), no corporate owner, and plain-text representation that humans can read and edit directly. CSV can also be streamed row by row with minimal memory and supports efficient append-only writes at the end of a file—things columnar formats like Parquet handle much worse, even if columnar formats excel when querying only a few columns.&lt;/p&gt;
&lt;p&gt;Beyond that, CSV is dynamically typed, leaving each language free to decide how to parse values (both flexible and error-prone if you&amp;rsquo;re careless), and remarkably compact since column names appear only once in the header rather than repeating keys on every record like JSON or XML. Even more uniquely, because escaping double quotes by doubling them is symmetrical, a CSV file reversed byte-for-byte is still valid CSV; this makes it possible to quickly read the last few rows of a massive file from the end, which is handy when resuming an interrupted job. The author jokes in closing that Excel hates CSV, which is probably a sign CSV is doing something right. For newer developers, the piece is a good reminder to pick data formats based on the actual problem rather than chasing trends.&lt;/p&gt;
&lt;h2 id="the-role-of-developer-skills-in-agentic-coding"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/13-role-of-developer-skills.html" rel="noopener noreferrer"&gt;The role of developer skills in agentic coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) reflects on months of using the agent modes of Cursor, Windsurf, and Cline to modify existing codebases. She appreciates how these tools can automatically run tests, fix compiler errors, and search the web, but notes that even in her most successful sessions, she constantly had to step in and steer. She categorizes AI mistakes into three &amp;ldquo;blast radii&amp;rdquo;: slowing down completion of a single commit (broken code or misdiagnosed problems, like blaming Docker&amp;rsquo;s architecture settings when the real issue was &lt;code&gt;node_modules&lt;/code&gt; built for the wrong architecture); creating friction for the team across development iterations (tackling too much at once instead of working in small vertical slices, treating symptoms by bumping memory limits instead of finding the root cause, or making the dev workflow messier); and most dangerously, degrading long-term maintainability (redundant tests, poor reuse, unnecessary verbosity). The wider the blast radius, the longer the feedback loop to catch the problem.&lt;/p&gt;
&lt;p&gt;In her view, we are nowhere near AI autonomously writing 90% of code within a year; right now, AI assists her roughly 80% of the time on a small ~15k-line project. To mitigate risks, individual developers should carefully review AI-generated code, stop sessions when cognitive load gets too high, stay wary of &amp;ldquo;good enough&amp;rdquo; solutions that appear too quickly, and practice pair programming. At the team level, she recommends maintaining code quality monitors like SonarQube or CodeScene, running checks in pre-commit hooks, curating custom rule files for AI assistants, and fostering a culture of trust and openness so nobody feels pressured to cut corners just to ship faster. For junior developers, the article clearly highlights the engineering skills that still matter in the AI era.&lt;/p&gt;
&lt;h2 id="cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes"&gt;&lt;a href="https://dev.to/prodevopsguytech/cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes-4fi2" rel="noopener noreferrer"&gt;CI/CD DevOps Pipeline Project: Deployment of Java Application on Kubernetes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community tutorial walks through building an end-to-end CI/CD pipeline from scratch to deploy a Java application onto Kubernetes, aiming to automate the entire software delivery lifecycle with minimal manual intervention. The infrastructure spans AWS EC2 instances for the Kubernetes master, worker nodes, Jenkins, SonarQube, Nexus, and a monitoring server. The author details setting up the cluster with Kubeadm (disabling swap, installing the CRI-O runtime and Kubernetes packages, initializing the control plane, and joining worker nodes), installing Jenkins, Docker, and Nexus, and setting up a private Git repository with a personal access token.&lt;/p&gt;
&lt;p&gt;At the heart of the guide is the &lt;code&gt;Jenkinsfile&lt;/code&gt;: the pipeline checks out the source code, compiles and runs tests with Maven, scans for vulnerabilities with Trivy, analyzes code quality via SonarQube, packages and uploads artifacts to Nexus, builds and pushes the Docker image, deploys to Kubernetes, and sends status notifications. The final section sets up real-time observability using Prometheus, Blackbox Exporter, and Grafana. It makes a solid hands-on project for developers who want to see how common DevOps tools fit together into a single cohesive workflow.&lt;/p&gt;
&lt;h2 id="road-to-jdk-25-over-engineering-tic-tac-toe-java-24"&gt;&lt;a href="https://briancorbinxyz.medium.com/road-to-jdk-25-over-engineering-tic-tac-toe-java-24-565c7f9b06d0" rel="noopener noreferrer"&gt;Road to JDK 25: Over-Engineering Tic-Tac-Toe (Java 24)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his &amp;ldquo;Road to JDK 25&amp;rdquo; series, Brian Corbin explores new Java features by deliberately over-engineering a simple tic-tac-toe game. This installment covers JDK 24—which includes 24 JEPs—focusing on finalized, non-preview features. The standout addition is Stream Gatherers: using &lt;code&gt;Stream::gather(Gatherer)&lt;/code&gt;, developers can define custom stateful or stateless intermediate Stream operations with one-to-one, one-to-many, many-to-one, or many-to-many semantics, alongside built-in gatherers like &lt;code&gt;fold&lt;/code&gt;, &lt;code&gt;scan&lt;/code&gt;, &lt;code&gt;windowFixed&lt;/code&gt;, and &lt;code&gt;windowSliding&lt;/code&gt;. The ZGC garbage collector is now exclusively generational, collecting short-lived objects more frequently and efficiently.&lt;/p&gt;
&lt;p&gt;Other highlights include a standard Class-File API for reading, generating, and transforming &lt;code&gt;.class&lt;/code&gt; files (foundational for bytecode tooling), Ahead-of-Time Class Loading &amp;amp; Linking to cut startup times, and two quantum-resistant lattice-based cryptographic algorithms for key encapsulation and digital signatures. Each feature is demonstrated directly inside the tic-tac-toe codebase, and Corbin notes that JDK 25, the next LTS release, arrives in September 2025.&lt;/p&gt;
&lt;h2 id="oracle-reveals-five-new-features-coming-to-java"&gt;&lt;a href="https://www.infoworld.com/article/3848288/oracle-reveals-five-new-features-coming-to-java.html" rel="noopener noreferrer"&gt;Oracle reveals five new features coming to Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Right on the heels of JDK 24&amp;rsquo;s general availability, Oracle previewed five features in the pipeline for upcoming Java releases; all have JEPs, though none are finalized yet (for instance, JEP 402 is still a Draft and JEP 468 is a Candidate). Enhanced primitive boxing makes primitive types behave more like reference types, such as calling methods directly on primitive values or using primitives as type arguments. Value classes and objects introduce identity-free objects with only &lt;code&gt;final&lt;/code&gt; fields, distinguished purely by their field values so the JVM can optimize memory layout, locality, and garbage collection. Paired with this are null-restricted value class types, allowing variables of value types to forbid &lt;code&gt;null&lt;/code&gt; for denser storage.&lt;/p&gt;
&lt;p&gt;Derived record creation provides concise syntax for creating a new record from an existing one without writing boilerplate &amp;ldquo;wither&amp;rdquo; methods (the immutable equivalent of setters). Finally, Stable Values—confirmed as a preview feature in JDK 25 (September 2025)—are objects holding immutable data that the JVM treats as constants, delivering &lt;code&gt;final&lt;/code&gt;-like performance optimizations with more flexible initialization timing to improve application startup. Together, these proposals show Java steadily modernizing both its object model and its runtime performance.&lt;/p&gt;
&lt;h2 id="java-bytecode-hacking-for-fun-and-profit"&gt;&lt;a href="https://cory.li/bytecode-hacking/" rel="noopener noreferrer"&gt;Java bytecode hacking for fun and profit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares Java bytecode optimization techniques learned from Battlecode, a programming competition where AI bots control virtual robots and each turn is capped by a strict bytecode execution limit (roughly 6,000–10,000 bytecodes) rather than wall-clock CPU time. While manual bytecode golfing has been rare in everyday Java ever since JIT compilers matured, it can decide wins and losses in Battlecode. The post explains that the JVM is a stack-based virtual machine where each bytecode is an atomic instruction akin to assembly, and Battlecode counts instructions regardless of byte width—so &lt;code&gt;iload_0&lt;/code&gt; and &lt;code&gt;iload #5&lt;/code&gt; each cost one instruction.&lt;/p&gt;
&lt;p&gt;By inspecting decompiled bytecode, the author demonstrates several concrete tricks: rewriting enhanced &lt;code&gt;for-each&lt;/code&gt; loops manually to shave a few instructions per iteration, copying instance fields into local variables because every field access costs an extra instruction, comparing against zero wherever possible since the JVM has dedicated zero-comparison opcodes, and using labeled &lt;code&gt;break&lt;/code&gt;/&lt;code&gt;continue&lt;/code&gt; statements to force the compiler to emit direct &lt;code&gt;goto&lt;/code&gt; jumps that skip unnecessary loop tails. The author stresses that you should only optimize at this level after finalizing your core AI framework and algorithms, as correctness and algorithmic efficiency always come first. Even if you rarely need this at work, it&amp;rsquo;s a fun way to see how Java actually executes under the hood.&lt;/p&gt;
&lt;h2 id="how-to-write-blog-posts-that-developers-read"&gt;&lt;a href="https://refactoringenglish.com/chapters/write-blog-posts-developers-read/" rel="noopener noreferrer"&gt;How to Write Blog Posts that Developers Read&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch, who has written a software blog for nine years reaching 300,000–500,000 readers annually, shares principles for writing technical blog posts developers actually read; the piece is a sample chapter from his upcoming book on writing for software developers. His first rule is to get straight to the point: your title and opening sentences should immediately tell readers who the post is for and what they will get out of it. Next is &amp;ldquo;think one level broader&amp;rdquo;: adding just a couple of sentences explaining background concepts or swapping niche jargon for plain language can open the article to a vastly larger audience. He also emphasizes having a realistic distribution path—such as Hacker News, Reddit, or Google search—rather than simply writing something good and hoping people find it.&lt;/p&gt;
&lt;p&gt;The remaining two rules focus on presentation. Adding visuals is the single highest-leverage improvement: screenshots, charts, diagrams—even a clumsy MS Paint drawing is far more engaging than AI-generated art. Finally, cater to skimmers, since many readers scan headings and images before deciding whether to read word for word; Lynch even provides a bookmarklet that blurs body text so you can preview your post through a skimmer&amp;rsquo;s eyes. Every principle is backed by examples from his own blog and applies just as well to internal design docs and workplace emails.&lt;/p&gt;
&lt;h2 id="the-new-look-and-feel-of-apache-kafka-40"&gt;&lt;a href="https://thenewstack.io/the-new-look-and-feel-of-apache-kafka-4-0/" rel="noopener noreferrer"&gt;The New Look and Feel of Apache Kafka 4.0&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Apache Kafka 4.0 brings upgrades across nearly every component of the distributed event streaming platform, but the headline change is running exclusively in KRaft (Raft-based) mode and removing ZooKeeper mode entirely. As Sandon Jacobs (Confluent) explains, this transition was prepared across multiple releases; operations teams no longer need to provision and manage a separate ZooKeeper cluster, configure TLS between two systems, or allocate dedicated compute for it—one less component means one less point of failure. The release also includes early access to Queues for Kafka (KIP-932), allowing the number of consumers to exceed a topic&amp;rsquo;s partition count so it behaves like traditional message queues such as Amazon SQS; the trade-off is that message ordering is not guaranteed, so ordered workloads should stick with traditional consumer groups.&lt;/p&gt;
&lt;p&gt;In addition, KIP-848 introduces a new consumer group protocol that eliminates stop-the-world rebalances; in Kafka 4.0, clients opt in via &lt;code&gt;group.protocol=consumer&lt;/code&gt;. KIP-1112 lets developers declare a processor wrapper applied across every processor in a Kafka Streams topology instead of manually duplicating cross-cutting logic like audit logging everywhere. Finally, KIP-1076 and KIP-1091 expand client and broker metrics that can be pushed over OpenTelemetry to observability tools like Datadog. For developers working with streaming data, Kafka 4.0 makes operations substantially simpler.&lt;/p&gt;
&lt;h2 id="five-things-ai-will-not-change"&gt;&lt;a href="https://metastable.org/five/" rel="noopener noreferrer"&gt;Five Things AI Will Not Change&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Inspired by how Jeff Bezos built Amazon around things customers will always want (low prices, fast delivery, vast selection) rather than trying to predict the future of the internet, the author outlines five things that won&amp;rsquo;t change even with powerful AI. First, there will be many AIs rather than a single superintelligence, because fierce competition prevents any one lab from holding a monopoly for long. Second, rogue or malicious AIs will always exist, created intentionally or accidentally by humans, much like the social media manipulation campaigns seen in the 2016 US election. Third, abundance will not be distributed equally: AI cannot manufacture more land or scarce physical resources, so money will still be needed to allocate them. Fourth, politics will remain deeply divided, because many disagreements stem from conflicting values rather than a lack of information. Fifth, humans will not become &amp;ldquo;ants&amp;rdquo; to AI, because AI is trained on human culture and will converse directly with us on every subject.&lt;/p&gt;
&lt;p&gt;In the closing section, the author explains why the 2023 open letter calling for a pause on giant AI experiments was never going to succeed: humanity is still fighting cancer, Alzheimer&amp;rsquo;s, pandemics, and poverty, and AI holds real promise for helping solve them. In the author&amp;rsquo;s view, both the AI doomers and the utopians are wrong; the future will be messy and occasionally dark, but also beautiful and inspiring.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5321bec2-0079-47e2-92e9-1cd9950227c8_2250x2624.png" alt="Object Oriented Programming Fundamentals"&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>