<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Vibe Coding on miti99</title><link>https://miti99.com/en/tags/vibe-coding/</link><description>Recent content in Vibe Coding 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/vibe-coding/index.xml" rel="self" type="application/rss+xml"/><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 #41</title><link>https://miti99.com/en/post/2025/07/31/</link><pubDate>Thu, 31 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/31/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #41.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-fastest-way-to-detect-a-vowel-in-a-string"&gt;&lt;a href="https://austinhenley.com/blog/vowels.html" rel="noopener noreferrer"&gt;The Fastest Way to Detect a Vowel in a String&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Austin Henley benchmarks 11 different ways to check whether a string contains a vowel in Python—ranging from a simple &lt;code&gt;for&lt;/code&gt; loop, a C-style loop with chained &lt;code&gt;or&lt;/code&gt; conditions, nested loops, set intersection, a generator expression with &lt;code&gt;any()&lt;/code&gt;, recursion, and &lt;code&gt;filter&lt;/code&gt;/&lt;code&gt;map&lt;/code&gt; with a lambda, all the way to regular expressions and a &amp;ldquo;just for fun&amp;rdquo; prime-number character encoding. The initial results are surprising: on short strings (length 10), a simple loop wins, but from length 100 upward, regex takes the lead while the C-style loop falls far behind. The reason is that Python&amp;rsquo;s regex engine is written in C and uses a bitmap lookup table to match characters instead of interpreting Python bytecode one character at a time.&lt;/p&gt;
&lt;p&gt;The post-publication update is even better: readers pointed out that Python&amp;rsquo;s built-in &lt;code&gt;str.find()&lt;/code&gt; beats regex thanks to CPython&amp;rsquo;s optimized substring search, and simply flipping the loop order—iterating over the vowel string and checking &lt;code&gt;if v in s&lt;/code&gt; against the input—beats both regex and &lt;code&gt;find()&lt;/code&gt;, running roughly 16x faster than regex on long strings. The takeaway is that performance differences in Python mostly come down to the CPython interpreter boundary: whichever approach pushes more of the loop into C wins. In practice, write the readable version unless you are processing millions of strings.&lt;/p&gt;
&lt;h2 id="writing-toy-software-is-a-joy"&gt;&lt;a href="https://blog.jsbarretto.com/post/software-is-joy" rel="noopener noreferrer"&gt;Writing Toy Software Is A Joy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joshua Barretto encourages programmers to build &amp;ldquo;toy software&amp;rdquo;—small, from-scratch projects—to deeply understand how systems work under the hood and rediscover the joy of programming. Starting from Richard Feynman&amp;rsquo;s line, &amp;ldquo;What I cannot create, I do not understand,&amp;rdquo; Barretto argues that building a simplified version of a familiar tool teaches you its core constraints far better than reading theory alone. The guiding rule is the 80:20 principle: spend 20% of the effort to get the 80% of functionality that is actually interesting, implement only what you need, and let the program crash until you are forced to handle an edge case. That mindset turns intimidating systems into approachable weekend projects.&lt;/p&gt;
&lt;p&gt;The post lists 23 project ideas with difficulty ratings (from 3 to 8 out of 10), time estimates, and reference links: easier picks include a regex engine, a CHIP-8 emulator, a hash table, and an interpreter; medium ones cover a physics engine, a text editor, a voxel engine, and an orbital simulator; the hardest are an x86 OS kernel and a compiler for a C-like language. Barretto strongly advises leaving large language models (LLMs) out of these projects, because understanding shouldn&amp;rsquo;t be &amp;ldquo;served on a platter&amp;rdquo;: struggling through the problem yourself is the entire point, especially as everyday software work becomes increasingly commoditized and AI-assisted.&lt;/p&gt;
&lt;h2 id="field-notes-from-shipping-real-code-with-claude"&gt;&lt;a href="https://diwank.space/field-notes-from-shipping-real-code-with-claude" rel="noopener noreferrer"&gt;Field Notes From Shipping Real Code With Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diwank shares battle-tested lessons from shipping production code with Claude. He divides AI-assisted work into three distinct modes: &amp;ldquo;playground&amp;rdquo; mode for weekend hacks and prototypes where Claude writes 80–90% of the code with minimal guardrails; pair-programming mode for codebases under roughly 5,000 lines; and production/monorepo scale with real users, where every step requires deliberate orchestration. The anchor of the workflow is &lt;code&gt;CLAUDE.md&lt;/code&gt;, which acts as the codebase&amp;rsquo;s &amp;ldquo;constitution&amp;rdquo;—recording the reasoning behind architectural decisions, coding standards, test commands, repository conventions, and hard off-limits rules. Complementing it are inline &amp;ldquo;anchor comments&amp;rdquo; like &lt;code&gt;AIDEV-NOTE:&lt;/code&gt;—short, greppable markers that guide both AI agents and human readers.&lt;/p&gt;
&lt;p&gt;His non-negotiable rule is that humans write the tests, because tests encode business requirements and edge cases that AI doesn&amp;rsquo;t truly understand; he illustrates this with an AI-generated test suite that passed green while completely missing a memory leak. AI is strictly forbidden from modifying test files, changing API contracts, touching database migrations, committing secrets, or guessing at domain logic. He also recommends using &lt;code&gt;git worktree&lt;/code&gt; for parallel AI experiments, prefixing AI-assisted commits with &lt;code&gt;[AI]&lt;/code&gt;, and being transparent across the team by agreeing on shared rules upfront—because strong engineering discipline is what separates AI as a force multiplier from AI as a chaos generator.&lt;/p&gt;
&lt;h2 id="why-generative-ai-coding-tools-and-agents-do-not-work-for-me"&gt;&lt;a href="https://blog.miguelgrinberg.com/post/why-generative-ai-coding-tools-and-agents-do-not-work-for-me" rel="noopener noreferrer"&gt;Why Generative AI Coding Tools and Agents Do Not Work For Me&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Miguel Grinberg, author of Flask-SocketIO and several widely used Python libraries, explains why generative AI coding tools and agents don&amp;rsquo;t fit his workflow. His central argument is that they don&amp;rsquo;t actually save him time: because he is personally accountable for every line of code he ships to production, with or without AI, he has to read and fully understand every line before committing. Reviewing AI-generated code takes him just as long as—or longer than—writing it himself, wiping out any time &amp;ldquo;saved&amp;rdquo; during generation.&lt;/p&gt;
&lt;p&gt;Grinberg also pushes back on comparing AI to an intern: a human intern learns and grows more autonomous over time, whereas in his view AI tools have no durable memory across sessions, resetting to square one on every task like an intern with amnesia. He views learning new languages and frameworks firsthand as both a joy and a long-term career investment, not a chore to offload to a machine. And while reviewing open-source community contributions also takes effort, it brings rewards AI never provides: genuine human connection, thoughtful feedback, and fresh ideas that make the project better.&lt;/p&gt;
&lt;h2 id="ai-coding-assistants-aren"&gt;&lt;a href="https://leaddev.com/velocity/ai-coding-assistants-arent-really-making-devs-feel-more-productive" rel="noopener noreferrer"&gt;AI coding assistants aren&amp;rsquo;t really making devs feel more productive&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;LeadDev reporter Chantal Kapani examines data from the 2025 Engineering Leadership Report (surveying 617 engineering leaders in March) on perceived productivity gains from AI coding assistants, finding that the impact so far is much more modest than the hype suggests. Only 6% of respondents reported a significant productivity boost, while 39% saw minor improvements in the 1–10% range. Teams primarily use AI for code generation (47%), refactoring (45%), documentation (44%), internal communication (28%), and bug fixing (22%). Those numbers contrast sharply with upbeat vendor and enterprise claims like GitHub&amp;rsquo;s report that 88% of users feel more productive or JPMorgan Chase citing 10–20% efficiency gains, though the studies differ in sample and methodology.&lt;/p&gt;
&lt;p&gt;Industry experts quoted in the piece point to several reasons for the gap: current AI tools focus narrowly on typing code while ignoring deeper workflow bottlenecks; many rollouts are driven top-down by executive excitement rather than validated bottom-up; real delivery latency sits in test runtimes and deployment pipelines rather than keystrokes; and developers are rarely consulted before tools are mandated. The takeaway is to diagnose a team&amp;rsquo;s actual bottlenecks first before assuming AI is the fix.&lt;/p&gt;
&lt;h2 id="how-to-vibe-code-as-a-senior-engineer"&gt;&lt;a href="https://blog.alexmaccaw.com/how-to-vibe-code-as-a-senior-engineer" rel="noopener noreferrer"&gt;How to Vibe Code as a Senior Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex MacCaw shares how to &amp;ldquo;vibe code&amp;rdquo; effectively as a senior engineer: letting AI models write the bulk of the code while the human steers through crisp prompts and architectural oversight. In his experience, the prerequisites are a rock-solid project scaffold—such as &lt;code&gt;ai-monorepo-scaffold&lt;/code&gt;—with clear examples of migrations, routes, and schemas for the AI to mimic; &lt;code&gt;.cursor/rules&lt;/code&gt; files that instruct the agent to plan first, preserve type safety, and run tests so it behaves like &amp;ldquo;a clean, responsible junior engineer&amp;rdquo;; pulling every relevant file (including type definitions) into context; using Cursor for near-instant lint and typecheck feedback; and picking frontier models like Claude Opus 4 or Gemini 2.5 Pro in &amp;ldquo;thinking&amp;rdquo; mode, prioritizing output quality over token cost.&lt;/p&gt;
&lt;p&gt;On prompting technique, MacCaw advises always asking the model for a plan to approve before it writes code, specifying exact outcomes and target file paths, providing concrete examples, setting explicit constraints (like &amp;ldquo;avoid &lt;code&gt;any&lt;/code&gt;&amp;rdquo;), keeping scope tight, and switching to longer conversational prompts when stuck. He also catalogs AI&amp;rsquo;s recurring blind spots: not knowing what context it is missing, reaching for TypeScript&amp;rsquo;s &lt;code&gt;any&lt;/code&gt; instead of proper types, jumping straight into code without confirming direction, and lacking architectural taste for a project&amp;rsquo;s conventions. MacCaw suggests we may be witnessing &amp;ldquo;the final chapter of human-led programming&amp;rdquo; before AI closes those remaining gaps.&lt;/p&gt;
&lt;h2 id="sql-noir---interactive-sql-game"&gt;&lt;a href="https://www.sqlnoir.com/blog/games-to-learn-sql" rel="noopener noreferrer"&gt;SQL Noir - Interactive SQL Game&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hristo Bogoev, creator of SQL Noir, rounds up five interactive games that teach SQL through hands-on problem-solving rather than dry textbooks. First is his own SQL Noir, a detective game where you solve crimes by writing SQL queries across six progressively harder cases with realistic schemas, instant feedback, and both free and paid cases. Next is SQL Island, a castaway survival game that works well for beginners despite its dated interface; Northwestern University&amp;rsquo;s SQL Murder Mystery, a single self-contained case that is great for practicing &lt;code&gt;JOIN&lt;/code&gt;s; and SQL Police Department (SQLPD), a paid platform featuring multiple cases, guided hints, and strong storytelling.&lt;/p&gt;
&lt;p&gt;Rounding out the list is SQLZoo, a free interactive tutorial site over 20 years old that systematically covers everything from basic &lt;code&gt;SELECT&lt;/code&gt;s to advanced topics like window functions, albeit without a story wrapper. Together they make a fun practice list for junior developers: newcomers can start with SQL Island or SQL Noir for narrative momentum, then solidify their fundamentals on SQLZoo.&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 #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><item><title>Newsletter #29</title><link>https://miti99.com/en/post/2025/05/16/</link><pubDate>Fri, 16 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/16/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #29 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-clean-approach-to-process-optimization"&gt;&lt;a href="https://queue.acm.org/detail.cfm?id=3722546" rel="noopener noreferrer"&gt;A Clean Approach to Process Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas A. Limoncelli opens with an everyday example: how he reorganized doing the dishes at home. Instead of waiting until the start of a wash cycle to add detergent to the dishwasher, he does it right after unloading the clean dishes. Simply reordering the steps made the chore smoother without any extra effort. He then applied this exact mindset to customer onboarding at his company, cutting wait times from several days down to just a few minutes.&lt;/p&gt;
&lt;p&gt;The core idea is to split a process into two phases. The slow phase covers generic tasks that can be done in advance before an order arrives; the fast phase handles only the specific customization after the order comes in. Alongside this, review optional tasks, since they are often unnecessary or can be done more efficiently. For junior developers, this is a practical lesson: the same approach applies to software deployment pipelines, infrastructure provisioning, and many other areas, improving both performance and service quality.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="microsoft"&gt;&lt;a href="https://www.gatesnotes.com/microsoft-original-source-code" rel="noopener noreferrer"&gt;Microsoft&amp;rsquo;s Original Source Code Released for 50th Anniversary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;To mark Microsoft&amp;rsquo;s 50th anniversary, Bill Gates released the original source code for Altair BASIC, the company&amp;rsquo;s first product, calling it the &amp;ldquo;coolest&amp;rdquo; code he has ever written. The story began with the January 1975 cover of Popular Electronics featuring the Altair 8800 computer from MITS. Gates and Paul Allen contacted founder Ed Roberts and told him they already had a version of BASIC for the Altair&amp;rsquo;s chip, even though they hadn&amp;rsquo;t written a single line yet. The pair chose to build an interpreter rather than a compiler because running code line by line gave beginners immediate feedback and made debugging easier.&lt;/p&gt;
&lt;p&gt;Since they didn&amp;rsquo;t have an Intel 8080 chip, Allen wrote a simulator for it on Harvard&amp;rsquo;s PDP-10 mainframe, Gates wrote the core interpreter, and Monte Davidoff handled the math package. After about two months of working day and night, they squeezed the entire interpreter into just 4 KB of memory using compact data structures and efficient algorithms, because memory at the time cost more than the computer itself. The demo succeeded, MITS licensed the software, and Micro-Soft was born. For developers today, it is a vivid example of optimizing under extreme hardware constraints; Gates tells the fuller story in his memoir &amp;ldquo;Source Code.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="no-code-is-dead-long-live-vibe-coding"&gt;&lt;a href="https://kenneth.io/post/no-code-is-dead-long-live-vibe-coding" rel="noopener noreferrer"&gt;No code is dead. Long live vibe coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kenneth Auchenberg makes a blunt call: in 2025, no-code is dead. For a decade, no-code and low-code platforms promised to democratize software creation, yet none truly broke through or replaced traditional programming. Instead, a new generation of tools powered by AI and large language models is emerging, known as &amp;ldquo;vibe coding.&amp;rdquo; Tools like Bolt, Lovable, and v0 show that generating real, production-grade code from natural-language descriptions is not only viable, but better than drag-and-drop WYSIWYG editors.&lt;/p&gt;
&lt;p&gt;According to the author, users turned out not to want &amp;ldquo;less code&amp;rdquo;—they wanted a better way to write code. They don&amp;rsquo;t want to be locked into proprietary runtimes; they want real source code, full control, and the freedom to edit and deploy anywhere. The previous generation, such as Webflow and Retool, bundled the editor, hosting, runtime, and UI components into a closed system. Now, large language models can generate clean React code that follows open standards and industry best practices, ready to deploy onto open infrastructure. The author calls this the &amp;ldquo;unbundling&amp;rdquo; of no-code.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="simple-scalable-and-global-containers-are-coming-to-cloudflare-workers-in-june-2025"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-containers-coming-2025/" rel="noopener noreferrer"&gt;Simple, scalable, and global: Containers are coming to Cloudflare Workers in June 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced that Containers will enter open beta in late June 2025. Workers are already the simplest way to deploy software globally, but there are workloads they cannot handle: running user-generated code in arbitrary languages, executing CLI tools that require a full Linux environment, using multiple gigabytes of memory or multiple CPU cores, or lifting and shifting applications from AWS, GCP, or Azure without a rewrite. Containers fill that gap. With just a few lines of Wrangler configuration and &lt;code&gt;wrangler deploy&lt;/code&gt;, containers spin up on demand near the user, go to sleep after a configurable timeout, and support autoscaling based on CPU usage.&lt;/p&gt;
&lt;p&gt;What sets them apart is the architecture: each container is backed by a Durable Object acting as a programmable &amp;ldquo;sidecar,&amp;rdquo; letting you start, stop, run commands, and monitor container state directly from code. That allows Workers to act as an API gateway, service mesh, or orchestrator for containers without writing Kubernetes operators or configuring a complex control plane. On pricing, users pay only for the time a container actually runs, billed per vCPU, memory, and disk at rates Cloudflare says are competitive with Google Cloud Run. The takeaway: handle the bulk of requests with lightweight, inexpensive Workers, and reach for containers only for heavy workloads that truly need them.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-types-of-companies-you-can-work-for-and-what-they-do-for-your-career"&gt;&lt;a href="https://www.elenaverna.com/p/the-types-of-companies-you-can-work" rel="noopener noreferrer"&gt;The types of companies you can work for and what they do for your career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elena Verna advises choosing where you work intentionally rather than chasing titles or compensation. She breaks companies into six archetypes. &amp;ldquo;Unicorns&amp;rdquo; grow around 100% year over year, like early Miro or Figma: the pace is breakneck and burnout is a real risk, but experience there opens many doors. &amp;ldquo;Tankers&amp;rdquo; like Google, Apple, and Microsoft run with mature processes, high pay, and abundant training resources—great for starting a career, though roles are highly specialized and progress is slow. &amp;ldquo;Declining Giants&amp;rdquo; are in constant reorganization; pressure for results is intense, but advancement can be fast. &amp;ldquo;Survival Mode&amp;rdquo; startups haven&amp;rsquo;t found product-market fit yet: autonomy is high and skills broaden quickly, but the risk is steep and the author advises newcomers to avoid them.&lt;/p&gt;
&lt;p&gt;The remaining two are &amp;ldquo;Lifestyle Boats,&amp;rdquo; often bootstrapped, profitable, and sustainably growing like Basecamp, which are great for beginners thanks to a supportive environment; and &amp;ldquo;Social Good Seekers,&amp;rdquo; where social impact comes before revenue—pay may be lower, but fulfillment is high. To identify which type a company is, ask about headcount, revenue growth over the past three years, and how much runway remains before the next fundraise. At the same time, ask yourself how much change and pressure you can tolerate, whether you need a clearly defined role, and what your current financial priorities are.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-to-create-a-chain-reaction-of-good-habits"&gt;&lt;a href="https://jamesclear.com/domino-effect" rel="noopener noreferrer"&gt;How to Create a Chain Reaction of Good Habits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Clear, author of &amp;ldquo;Atomic Habits,&amp;rdquo; explains the Domino Effect: when you change one behavior, it sets off a chain reaction that shifts related behaviors too. He shares the story of Jennifer Dukes Lee, who didn&amp;rsquo;t make her bed for over twenty years; after doing it four days in a row, she found herself folding laundry, washing the dishes, and organizing the kitchen cabinets. A 2012 Northwestern University study similarly found that when people cut down their sedentary time, they naturally ate less fat even though nobody asked them to. The effect works for bad habits as well—checking your phone leads to scrolling social media, which turns into twenty more minutes of procrastination.&lt;/p&gt;
&lt;p&gt;Clear argues this happens because daily habits are tightly interconnected and because of the principle of commitment and consistency: once we make even a tiny commitment, we tend to follow through because it aligns with our self-image. To deliberately trigger a positive domino chain, start with the small habit you feel most motivated to do and practice it consistently, ride the momentum of finishing one task straight into the next, and when things get hard, break them into smaller pieces and focus on consistency rather than outcomes. Remarkably, the effect doesn&amp;rsquo;t just create new behaviors—it shifts beliefs: each falling domino helps you believe in a new version of yourself and build identity-based habits.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-post-developer-era"&gt;&lt;a href="https://www.joshwcomeau.com/blog/the-post-developer-era/" rel="noopener noreferrer"&gt;The Post-Developer Era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Two years after writing &amp;ldquo;The End of Front-End Development&amp;rdquo; when GPT-4 launched, Josh W. Comeau revisits whether we have entered a &amp;ldquo;post-developer era.&amp;rdquo; His answer is no. The headline figure that &amp;ldquo;AI writes over 25% of code at Google&amp;rdquo; is easy to misread, because AI isn&amp;rsquo;t working autonomously—skilled developers are always at the wheel, steering and editing. Meanwhile Devin, pitched as an autonomous replacement for software engineers, completed only 3 out of 20 tasks in an independent team&amp;rsquo;s real-world evaluation. Comeau uses Cursor with Claude Sonnet and finds it impressive, but compares it to cruise control: take your hands off the wheel and the car slowly drifts out of its lane. Non-programmers won&amp;rsquo;t spot subtle bugs and eventually end up stuck with an unmaintainable mess.&lt;/p&gt;
&lt;p&gt;The job market remains tough, but Comeau attributes that primarily to high interest rates, waves of layoffs at large tech companies, and the mistaken belief among executives that AI is about to make developers redundant—not to AI actually replacing people. He also worries that newcomers will fall into &amp;ldquo;vibe coding,&amp;rdquo; endlessly clicking accept without understanding the code. Conversely, if you use AI actively as a personal tutor, there has never been a better time to learn programming, and a &amp;ldquo;developer renaissance&amp;rdquo; may follow once companies realize AI is a force multiplier rather than a replacement.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="everything-wrong-with-model-context-protocol-mcp"&gt;&lt;a href="https://blog.sshh.io/p/everything-wrong-with-mcp" rel="noopener noreferrer"&gt;Everything Wrong With Model Context Protocol (MCP)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar examines the flaws and limitations of the Model Context Protocol, the standard for connecting third-party tools and data to AI assistants like Claude, ChatGPT, and Cursor. On protocol security, the initial version didn&amp;rsquo;t define an authentication mechanism and the subsequent specification drew criticism for its complexity; running MCP servers locally over stdio creates a shortcut for less experienced users to download and execute malware; and many servers trust inputs and execute them directly. On user experience, MCP doesn&amp;rsquo;t distinguish risk levels between a tool that reads logs and one that deletes files, offers no token-cost controls, and at the time of writing only returned unstructured text—something later specs addressed.&lt;/p&gt;
&lt;p&gt;More serious is the security of the language models themselves. Tool descriptions are typically injected into the system prompt, giving them outsized influence over the agent; a server can silently rename or rewrite tool descriptions after the user has approved them, and data pulled from fourth-party sources—such as a database row—can carry prompt injections. Easy data aggregation also lets employees infer sensitive information from data they are individually permitted to view. Finally, model reliability drops when too many tools are exposed, and simple primitives like listing or reading files fall short of the queries users expect. Shankar concludes that safe adoption requires a secure-by-default protocol, applications that protect users, and users who understand the trade-offs of their choices.&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 #20</title><link>https://miti99.com/en/post/2025/05/07/</link><pubDate>Wed, 07 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #20.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="performance-improvements-in-jdk-24"&gt;&lt;a href="https://inside.java/2025/03/19/performance-improvements-in-jdk24/" rel="noopener noreferrer"&gt;Performance Improvements in JDK 24&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Inside.java article rounds up the most notable performance improvements in JDK 24 over JDK 23, organized by JDK bug tracker issue. In the core libraries, bulk operations in the Foreign Function &amp;amp; Memory API such as &lt;code&gt;MemorySegment::fill&lt;/code&gt;, &lt;code&gt;copy&lt;/code&gt;, and &lt;code&gt;mismatch&lt;/code&gt; are now handled in pure Java when memory segments are small enough, avoiding the overhead of transitioning to native code via &lt;code&gt;Unsafe&lt;/code&gt;. String concatenation now uses cacheable, reusable hidden classes instead of constructing chains of intermediate &lt;code&gt;MethodHandle&lt;/code&gt; combinators; SHA3 digests are up to 27% faster by reducing conversions between &lt;code&gt;byte&lt;/code&gt; and &lt;code&gt;long&lt;/code&gt; arrays; and internal migrations to the new Class-File API have been tuned to minimize startup overhead.&lt;/p&gt;
&lt;p&gt;At the runtime layer, JEP 491 allows virtual threads blocked inside a &lt;code&gt;synchronized&lt;/code&gt; block to unmount from their carrier thread rather than pinning it, significantly improving scalability for code that uses &lt;code&gt;synchronized&lt;/code&gt;. &lt;code&gt;String::indexOf&lt;/code&gt; is roughly 1.3x faster on x64 platforms with AVX2. JEP 483 (Ahead-of-Time Class Loading &amp;amp; Linking), the first deliverable from Project Leyden, uses an AOT cache to cut startup time by around 42% in the article&amp;rsquo;s benchmark. JEP 450 introduces experimental 8-byte compact object headers, reducing memory footprint by 10–20% on typical workloads. Finally, the RISC-V port gained several new intrinsics including CRC32, Adler32, string comparison optimizations, and byte-reversal operations.&lt;/p&gt;
&lt;h2 id="clean-your-memory-from-finalize-to-cleaner"&gt;&lt;a href="https://blog.frankel.ch/java-cleaner/" rel="noopener noreferrer"&gt;Clean your Memory: From Finalize to Cleaner&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stefano Fago explains that Java&amp;rsquo;s garbage collector (GC) only manages heap memory and does not automatically release external resources like sockets or file handles; mismanaging them can lead to resource leaks, gradual slowdowns, or crashes. The old approach was overriding &lt;code&gt;finalize()&lt;/code&gt;, which has been deprecated because its execution timing is unpredictable, objects require at least one extra GC cycle to be reclaimed, accidental object resurrection can cause leaks, and the dedicated Finalizer thread is prone to contention. Its replacement is the &lt;code&gt;Cleaner&lt;/code&gt; API, introduced in Java 9: under the hood, it uses &lt;code&gt;PhantomReference&lt;/code&gt; and a background daemon thread while hiding the complexity of raw reference queues. You register an object alongside a cleanup action, and once the object becomes phantom-reachable, that action is enqueued to run on the background thread.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Cleaner&lt;/code&gt; pairs well with &lt;code&gt;AutoCloseable&lt;/code&gt;: the &lt;code&gt;close()&lt;/code&gt; method invokes &lt;code&gt;clean()&lt;/code&gt; for immediate deterministic cleanup, while the &lt;code&gt;Cleaner&lt;/code&gt; acts as a safety net. Even so, Fago stresses that &lt;code&gt;Cleaner&lt;/code&gt; should only be a fallback when resources cannot be released via &lt;code&gt;try-with-resources&lt;/code&gt; or an explicit &lt;code&gt;close()&lt;/code&gt; call, since cleanup is asynchronous and carries background-thread overhead. When writing a cleanup action, avoid lambdas that capture fields through &lt;code&gt;this&lt;/code&gt;, as doing so accidentally keeps a strong reference to the very object you want collected; cleanup logic should also be short and non-blocking, since multiple actions may share the same &lt;code&gt;Cleaner&lt;/code&gt; thread pool.&lt;/p&gt;
&lt;h2 id="5-hidden-git-tips-for-java-developers"&gt;&lt;a href="https://www.azul.com/blog/5-hidden-git-tips-for-java-developers/" rel="noopener noreferrer"&gt;5 Hidden Git Tips for Java Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On the Azul blog, Luqman Saeed walks through five underappreciated Git features beyond the everyday &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; trio, with examples tailored to Java projects. First is &lt;code&gt;git bisect&lt;/code&gt;: when you don&amp;rsquo;t know which commit introduced a bug, you mark the current commit as bad (&lt;code&gt;git bisect bad&lt;/code&gt;) and an older working commit as good (&lt;code&gt;git bisect good &amp;lt;commit-hash&amp;gt;&lt;/code&gt;), and Git performs a binary search by checking out midpoint commits for you to test until the culprit is found, finishing with &lt;code&gt;git bisect reset&lt;/code&gt;. Next, &lt;code&gt;git blame &amp;lt;file&amp;gt;&lt;/code&gt; shows who last modified each line and when (pass &lt;code&gt;-L 50,60&lt;/code&gt; to inspect a specific line range), giving you helpful context before debugging or refactoring. When you need to switch tasks mid-flight, &lt;code&gt;git stash&lt;/code&gt; shelves uncommitted changes and &lt;code&gt;git stash pop&lt;/code&gt; restores them; &lt;code&gt;git stash list&lt;/code&gt; and &lt;code&gt;git stash apply &amp;lt;stash-id&amp;gt;&lt;/code&gt; let you manage multiple stashes.&lt;/p&gt;
&lt;p&gt;For temporary build artifacts generated by Maven or Gradle like &lt;code&gt;.class&lt;/code&gt; files or the &lt;code&gt;target/&lt;/code&gt; directory, &lt;code&gt;git clean -n&lt;/code&gt; previews what would be deleted, &lt;code&gt;-f&lt;/code&gt; removes untracked files, &lt;code&gt;-fd&lt;/code&gt; removes untracked directories as well, and &lt;code&gt;-x&lt;/code&gt; also deletes ignored files such as &lt;code&gt;.idea/&lt;/code&gt;. Finally, Git hooks are scripts that run automatically before or after events like commits, pushes, or merges—for example, a &lt;code&gt;pre-commit&lt;/code&gt; hook in &lt;code&gt;.git/hooks&lt;/code&gt; can run &lt;code&gt;mvn test&lt;/code&gt; and abort the commit if tests fail. As a bonus tip, &lt;code&gt;git checkout -&lt;/code&gt; jumps straight back to the previous branch you were working on without retyping its name, saving time and avoiding typos.&lt;/p&gt;
&lt;h2 id="simplify-your-system-by-challenging-the-status-quo-and-learning-from-other-ecosystems"&gt;&lt;a href="https://www.infoq.com/podcasts/simplify-system-learning-ecosystems/" rel="noopener noreferrer"&gt;Simplify Your System by Challenging the Status-Quo and Learning from Other Ecosystems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this InfoQ podcast, Max Rydahl Andersen—Distinguished Engineer at Red Hat and creator of JBang—recounts how taking a year away from Java helped him see upon returning that the ecosystem had accumulated too much accidental complexity, like &amp;ldquo;a thousand paper cuts&amp;rdquo;: each small feature is useful on its own, but together they become a burden. Quarkus, which he works on, flips traditional Java conventions by shifting most framework processing from runtime to build time, enabling near-instant startup. That speed unlocks a much better developer experience: live reload, continuous testing, Dev Services that automatically spin up containers like PostgreSQL or Kafka, and an interactive chat UI for testing AI services via LangChain4j right inside the Dev UI.&lt;/p&gt;
&lt;p&gt;With JBang, he drew inspiration from Python and Node.js to let developers run Java from a single source file—even downloading a JDK automatically if none is installed; he jokes that if you find any development environment easier to set up, that&amp;rsquo;s a bug in JBang. Andersen also argues that AI cannot replace core software engineering fundamentals and systems thinking, and warns that AI will accelerate CVE exploitation, meaning legacy systems will need much more frequent patching. The overarching takeaway: challenge the status quo and borrow good ideas from other ecosystems to keep systems simple.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/03/24/about-vibe-coding/" rel="noopener noreferrer"&gt;About &amp;ldquo;vibe coding&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea writes a brief reflection on &amp;ldquo;vibe coding&amp;rdquo;—the trend of letting AI write code in place of the developer. After reading &amp;ldquo;Vibe Coding vs Reality,&amp;rdquo; he was relieved to see he wasn&amp;rsquo;t the only skeptic, recounting his own attempt to use Cursor on a Java Maven project where the tool couldn&amp;rsquo;t even rename a class properly: first it renamed the class declaration without renaming the file, and when asked to fix it, it created an empty file with the new name—twice in a row.&lt;/p&gt;
&lt;p&gt;When he shared the experience on Hacker News, the replies were mostly along the lines of &amp;ldquo;haha Java,&amp;rdquo; leaving him wondering whether Cursor was only trained on trendy frontend frameworks or whether its vocal fans simply don&amp;rsquo;t care about real-world enterprise codebases. He ended up uninstalling Cursor and feeling even more skeptical of &amp;ldquo;magical&amp;rdquo; AI coding tools, though he leaves the door open: &amp;ldquo;Next year though? Next year we&amp;rsquo;ll see.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="visual-focused-algorithms-cheat-sheet"&gt;&lt;a href="https://photonlines.substack.com/p/visual-focused-algorithms-cheat-sheet" rel="noopener noreferrer"&gt;Visual-Focused Algorithms Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nick M compiles a visual-first cheat sheet of essential algorithms used in practice, following up on his earlier data structures cheat sheet; each algorithm is explained through everyday analogies and diagrams. The sorting section progresses from Selection Sort and Insertion Sort—simple but O(n²)—to Heap Sort and Merge Sort at O(n log n), Quick Sort with an O(n log n) average case and O(n²) worst case, and Tim Sort, the hybrid of Insertion Sort and Merge Sort used in Python and Java. Searching covers Binary Search at O(log n) alongside DFS and BFS for depth-first and breadth-first graph traversal. The graph section walks through Prim&amp;rsquo;s and Kruskal&amp;rsquo;s algorithms for minimum spanning trees, Dijkstra&amp;rsquo;s and Bellman-Ford for shortest paths (with Bellman-Ford handling negative edge weights), A* using heuristics, plus Union-Find and Ford-Fulkerson.&lt;/p&gt;
&lt;p&gt;Later sections cover string search, data compression and encoding (Huffman coding, LZ compression, Fourier transforms, JPEG compression), optimization (Simplex, Simulated Annealing), machine learning and data science, and security and cryptography algorithms. The post wraps up with coding interview resources like &amp;ldquo;14 Patterns to Ace Any Coding Interview&amp;rdquo; and &amp;ldquo;5 Simple Steps for Solving Dynamic Programming Problems,&amp;rdquo; making it a handy reference for junior developers preparing for interviews.&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/81074d22-5821-4aec-bb2d-0a099d06b6ac_1600x840.png" alt="3 Steps to Master Your Software"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/67c39b9a-9a91-4e57-9e24-7714b4f806dd_1280x1349.gif" alt="The Ultimate Software Architect Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fb1b1cd1-eac3-4b66-a391-9ec73f6c37f3_1280x1502.gif" alt="How Two-factor Authentication (2FA) Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/3efae3ad-8c45-4fb2-a79f-6b3387b0751e_1280x1601.gif" alt="How Amazon S3 Works?"&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 #17</title><link>https://miti99.com/en/post/2025/05/04/</link><pubDate>Sun, 04 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #17.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="to-fork-or-not-to-fork"&gt;&lt;a href="https://www.augmentcode.com/blog/to-fork-or-not-to-fork" rel="noopener noreferrer"&gt;To fork or not to fork?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Dietzen, CEO of Augment Code (and former CEO of Pure Storage), discusses a key architectural decision facing AI coding assistants: running as a plugin inside standard IDEs versus forking VS Code outright. GitHub Copilot and Augment chose the former, operating as plugins in VS Code, JetBrains, or Vim. Cursor and Windsurf (by Codeium) chose the latter, modifying the VS Code source directly for deeper AI integration.&lt;/p&gt;
&lt;p&gt;According to Dietzen, forking yields short-term advantages, but users pay the price: they are forced out of their familiar IDEs (especially painful for JetBrains users), lose official Microsoft support, run into issues with official plugins like Python, C++, Docker, or Jupyter, lose access to the official VS Code extension marketplace, and have to wait for the fork maintainers to port upstream features. For the long-term benefit of customers, Augment chose the plugin route and focused on its core strength of supporting large, complex codebases. Dietzen also notes that Cursor is the third most popular IDE among users trialing Augment, showing that the two products can complement each other.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://blog.container-solutions.com/why-im-no-longer-talking-to-architects-about-microservices" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m No Longer Talking to Architects About Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ian Miell explains why he no longer wants to debate microservices with software architects. The first problem is that nobody agrees on what &amp;ldquo;microservices&amp;rdquo; actually means: some measure it by lines of code, others tie it to team structure, and others equate it with container deployments. Like DevOps or Agile, the term has lost much of its original meaning through overuse.&lt;/p&gt;
&lt;p&gt;The second problem is that discussions are typically abstract and disconnected from business goals: promises of scalability, agility, or reduced cognitive load rarely go tested. The third problem is that microservices only pay off when the organization changes alongside them—requiring cross-functional teams, decentralized decision-making, and a mature DevOps culture—and changing organizational structure is far harder than changing software architecture. Even Sam Newman advises that most organizations shouldn&amp;rsquo;t adopt microservices without a compelling reason. Miell suggests starting from concrete problems like shortening release cycles, improving reliability, or removing bottlenecks, and only then asking whether microservices are the right solution.&lt;/p&gt;
&lt;h2 id="not-all-ai-assisted-programming-is-vibe-coding-but-vibe-coding-rocks"&gt;&lt;a href="https://simonwillison.net/2025/Mar/19/vibe-coding/" rel="noopener noreferrer"&gt;Not all AI-assisted programming is vibe coding (but vibe coding rocks)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison argues that the term &amp;ldquo;vibe coding,&amp;rdquo; coined by Andrej Karpathy in February 2025, is being misused as a catch-all for any AI-assisted programming. By Karpathy&amp;rsquo;s original definition, vibe coding means &amp;ldquo;forgetting that the code even exists&amp;rdquo;: accepting every change generated by an LLM without reading it. Responsible AI-assisted programming, by contrast, still involves reviewing, testing, and understanding every implementation detail. Willison&amp;rsquo;s golden rule: never commit code to a repository if you couldn&amp;rsquo;t explain exactly what it does to someone else.&lt;/p&gt;
&lt;p&gt;Even so, Willison is a fan of vibe coding. It lowers the barrier for beginners, helps them build useful tools on their own, and is a great way for experienced developers to build intuition for what LLMs can and cannot do. The key is restricting it to low-stakes, disposable projects—ideally inside a sandbox like Claude Artifacts—and avoiding anything involving security, privacy, or financial risk. He also hopes to see safer tools emerge so newcomers can experiment without causing harm.&lt;/p&gt;
&lt;h2 id="career-advice-in-2025"&gt;&lt;a href="https://lethain.com/career-advice-2025" rel="noopener noreferrer"&gt;Career advice in 2025.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson surveys the 2025 tech job market and identifies four major shifts. First, managers who advanced between 2010 and 2020 through strong hiring and team morale now face new expectations: getting into the details, driving faster execution, and leading the transition to AI. Second, the wave of foundation models has invalidated many old playbooks; products now need to be designed around progressive validation with human-in-the-loop verification for critical data, while staying prepared for models either making massive leaps forward or plateauing right where they are.&lt;/p&gt;
&lt;p&gt;Third, non-AI companies are struggling to raise funding, leading to fewer promotions and raises, while equity at AI startups is far from a guaranteed payout. Fourth, companies are pushing existing teams harder to find growth, turning once-comfortable roles into high-pressure ones. Today it is rare to find great colleagues, prestige, and learning opportunities all in the same job. Larson&amp;rsquo;s advice: don&amp;rsquo;t sit on the sidelines waiting for the market to recover—make your current work count, and remember that these headwinds are industry-wide, not a reflection of your personal ability.&lt;/p&gt;
&lt;h2 id="tips-for-better-interactions"&gt;&lt;a href="https://staysaasy.com/saas/2025/03/17/interactions.html" rel="noopener noreferrer"&gt;Tips For Better Interactions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy shares six practical tips for more effective workplace meetings and interactions. When someone says you seem &amp;ldquo;frustrated,&amp;rdquo; don&amp;rsquo;t accept that framing—restate calmly that you are escalating an issue or need more information so you aren&amp;rsquo;t dismissed as acting out of emotion. Volunteer to take notes in meetings: it signals humility, lets you help steer the discussion, gives you a natural pause to stay composed, and shows people their points are being heard. Avoid pushing back with extreme slippery-slope hypotheticals like &amp;ldquo;if we let everyone choose their own project, it&amp;rsquo;ll be chaos,&amp;rdquo; which implicitly insults the proposer&amp;rsquo;s judgment and wastes time.&lt;/p&gt;
&lt;p&gt;Don&amp;rsquo;t interrupt someone mid-thought just to correct an immaterial detail; follow up privately afterward if needed. Schedule important meetings thoughtfully—avoid Mondays, Fridays, lunch hours, and the end of the day—and keep a consistent weekly slot for 1:1s. Finally, order meeting agendas by priority: thoroughly resolving two important topics is far better than rushing through five without reaching a conclusion.&lt;/p&gt;
&lt;h2 id="code-is-the-new-no-code"&gt;&lt;a href="https://lumberjack.so/code-is-the-new-no-code/" rel="noopener noreferrer"&gt;Code is the new no-code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Szabo-Stuban and Evan Boyle (CEO of GenSX) argue that the promise of the no-code movement is finally being realized in an unexpected way: through code itself. Visual programming tools are easy at first, but complexity balloons rapidly—a marketing automation workflow in n8n can easily sprawl into a spiderweb of 47 interconnected nodes. Abstractions inevitably leak, forcing users to learn technical concepts anyway, and power users usually end up migrating back to code.&lt;/p&gt;
&lt;p&gt;According to the authors, AI coding assistants like Claude, ChatGPT, and GitHub Copilot have flipped the script: users describe their goal in plain language, the AI generates working code and explains each piece, and learning happens gradually instead of hitting a wall. Combined with familiar component models like React, code becomes even more intuitive than node-based visual editors. The post illustrates this with GenSX, where a workflow that fetches CRM data, filters it, and generates a report is written as readable JavaScript components, arguing that because most workflows are sequential, the tree structure of code is naturally easier to follow than a graph.&lt;/p&gt;
&lt;h2 id="how-to-improve-jvm-based-application-startup-time"&gt;&lt;a href="https://softwaremill.com/how-to-improve-jvm-based-application-startup-time/" rel="noopener noreferrer"&gt;How to Improve JVM-Based Application Startup Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michał Zyga (SoftwareMill) compares five approaches to shortening JVM application startup time, a critical metric for serverless and microservices. The JVM starts slowly because it has to load, verify, and initialize a large number of classes. Class Data Sharing (CDS) pre-packages core JDK classes and has been enabled by default since JDK 12; Application Class Data Sharing (AppCDS) extends this to application classes and became easier to use in JDK 19. GraalVM compiles ahead-of-time (AOT) into a native binary, CRaC snapshots a running JVM process using CRIU (Linux-only) for fast restore, and Project Leyden is a newer JDK effort that caches additional optimization data.&lt;/p&gt;
&lt;p&gt;Benchmarks on a sample Netty application across two machines (a personal Intel i5 laptop and a Google Cloud Xeon instance, 50 runs per configuration) show that AppCDS more than doubles startup speed over the default, CRaC and GraalVM are the fastest overall, and Project Leyden sits in the middle while still under active development. Zyga recommends choosing based on context: AppCDS is an easy win with moderate gains, CRaC suits long-running services since it retains full runtime JIT optimizations, and GraalVM fits short-lived workloads that need near-instant startup.&lt;/p&gt;
&lt;h2 id="domain-driven-design"&gt;&lt;a href="https://dev.to/lovestaco/domain-driven-design-3i2j" rel="noopener noreferrer"&gt;Domain Driven Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Athreya (Maneshwar) introduces Domain-Driven Design (DDD), an approach to software design that puts the business domain at the center rather than focusing purely on technical concerns. The article walks through core DDD building blocks: domains and subdomains; Bounded Contexts that draw clear boundaries so models stay independent; Entities with distinct identities versus immutable Value Objects defined by their attributes; Aggregates that group related objects under an Aggregate Root; Domain Events that decouple system components; Repositories, Services, and Factories for persistence, domain operations, and object creation; and Ubiquitous Language, a shared vocabulary between developers and domain experts.&lt;/p&gt;
&lt;p&gt;These concepts are illustrated through an e-commerce platform where order management is separated from the product catalog, accompanied by TypeScript examples of an &lt;code&gt;Order&lt;/code&gt; class managing state and an &lt;code&gt;OrderRepository&lt;/code&gt; handling persistence. The author notes that DDD shines in complex, long-lived projects requiring close collaboration between engineering and business teams, but can easily lead to over-engineering for simple CRUD apps; applying it well requires a solid grasp of design patterns and object-oriented principles.&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/66d12ddc-2abe-4a98-82d5-ee177e80487c_1470x1600.png" alt="Monolith vs Microservices vs Modular Monoliths"&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>