<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Spring Boot on miti99</title><link>https://miti99.com/en/tags/spring-boot/</link><description>Recent content in Spring Boot 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/spring-boot/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #21</title><link>https://miti99.com/en/post/2025/05/08/</link><pubDate>Thu, 08 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #21.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-to-monitor-jvm"&gt;&lt;a href="https://www.baeldung.com/java-jvm-monitor-non-heap-memory-usage" rel="noopener noreferrer"&gt;How to Monitor JVM&amp;rsquo;s Non-Heap Memory Usage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Baeldung article surveys tools for monitoring JVM non-heap memory usage—the memory regions outside the heap such as Metaspace, JIT code cache, GC structures, and direct buffers. The simplest option is &lt;code&gt;jcmd&lt;/code&gt;: once Native Memory Tracking is enabled, running &lt;code&gt;jcmd &amp;lt;pid&amp;gt; VM.native_memory&lt;/code&gt; prints the reserved and committed memory for each region. If you prefer a GUI, &lt;code&gt;jconsole&lt;/code&gt; includes a built-in non-heap chart under the Memory tab, while VisualVM displays Metaspace out of the box and can be extended with the MBeans and Buffer Pools plugins to inspect individual regions and direct buffers.&lt;/p&gt;
&lt;p&gt;For deeper analysis, Java Mission Control (JMC) lets you inspect total non-heap memory via the MBean Browser (note that this figure excludes direct buffers), and starting in Java 20 you can continuously record Native Memory Tracking events via JFR to track consumption by memory category over time. Finally, the JMX Exporter exposes &lt;code&gt;MemoryMXBean&lt;/code&gt; metrics at a Prometheus-compatible &lt;code&gt;/metrics&lt;/code&gt; endpoint, integrating non-heap monitoring into existing observability stacks. The author&amp;rsquo;s rule of thumb: use &lt;code&gt;jcmd&lt;/code&gt; or &lt;code&gt;jconsole&lt;/code&gt; for quick checks, pair JFR with JMC when you need fine-grained detail, and always account for the resource overhead of the monitoring tools themselves.&lt;/p&gt;
&lt;h2 id="unlocking-the-power-of-interfaces-creative-approaches-in-java"&gt;&lt;a href="https://gainjavaknowledge.medium.com/unlocking-the-power-of-interfaces-creative-approaches-in-java-635f390a1e0d" rel="noopener noreferrer"&gt;Unlocking the Power of Interfaces: Creative Approaches in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Medium post by Real World Java (Gain Java Knowledge) shows that Java interfaces are more than just contracts for classes to implement—they are powerful tools for decoupling components and making code extensible, reusable, and maintainable. The author walks through eight creative uses of interfaces, starting with the Strategy pattern: defining an interface like &lt;code&gt;PaymentStrategy&lt;/code&gt; for a family of algorithms and swapping concrete implementations (credit card, PayPal, etc.) at runtime. Next are callback interfaces that allow called code to invoke caller-supplied logic, functional interfaces paired with Java 8 lambda expressions, and mixin interfaces—where a class combines behavior from multiple interfaces to achieve multiple inheritance of behavior.&lt;/p&gt;
&lt;p&gt;The remaining sections cover dependency injection through interfaces to reduce tight coupling between classes, the Observer pattern, polymorphism when storing heterogeneous objects in a single collection typed to a shared interface, and default methods that add new functionality to interfaces without breaking existing implementations. For newer Java developers, the post serves as a concise collection of examples showing how interfaces underpin many classic design patterns.&lt;/p&gt;
&lt;h2 id="how-java-manages-thread-synchronization-with-locks-and-monitors"&gt;&lt;a href="https://medium.com/@AlexanderObregon/how-java-manages-thread-synchronization-with-locks-and-monitors-541ce7c7a0b2" rel="noopener noreferrer"&gt;How Java Manages Thread Synchronization with Locks and Monitors&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon explains how Java handles thread synchronization at the JVM level. Every object is associated with an intrinsic lock and a monitor; when a thread enters a &lt;code&gt;synchronized&lt;/code&gt; method or block, it must acquire ownership of the monitor while other contending threads wait (the JVM may spin briefly or park the thread depending on contention). The monitor tracks which thread holds the lock, which threads are waiting in the entry set, and which threads are waiting for a signal via &lt;code&gt;wait()&lt;/code&gt;, &lt;code&gt;notify()&lt;/code&gt;, or &lt;code&gt;notifyAll()&lt;/code&gt;—methods that may only be called while holding the lock, or else an &lt;code&gt;IllegalMonitorStateException&lt;/code&gt; is thrown. Intrinsic locks are reentrant: a thread that already holds a lock can acquire it again thanks to a recursion counter inside the monitor. To reduce overhead, the JVM uses lightweight locking first and only &amp;ldquo;inflates&amp;rdquo; to a full monitor under sustained contention; biased locking was used historically but has been disabled by default since JDK 15.&lt;/p&gt;
&lt;p&gt;The second half introduces &lt;code&gt;ReentrantLock&lt;/code&gt; in &lt;code&gt;java.util.concurrent.locks&lt;/code&gt;, which offers more flexibility than &lt;code&gt;synchronized&lt;/code&gt; via &lt;code&gt;tryLock()&lt;/code&gt; for non-blocking acquisition attempts, &lt;code&gt;lockInterruptibly()&lt;/code&gt; so waiting threads can respond to interrupts, and multiple &lt;code&gt;Condition&lt;/code&gt; objects to maintain separate wait queues per condition, such as in a bounded producer-consumer buffer. Under the hood sits &lt;code&gt;AbstractQueuedSynchronizer&lt;/code&gt; (AQS), which manages waiting threads using a doubly linked FIFO queue and &lt;code&gt;LockSupport.park()&lt;/code&gt;. The article also notes fair locks, which grant access to the longest-waiting thread at the cost of lower throughput, which is why most systems stick with the non-fair default.&lt;/p&gt;
&lt;h2 id="building-a-custom-spring-boot-starter-for-shared-logic"&gt;&lt;a href="https://medium.com/@AlexanderObregon/building-a-custom-spring-boot-starter-for-shared-logic-9be5699aff18" rel="noopener noreferrer"&gt;Building a Custom Spring Boot Starter for Shared Logic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon walks through packaging shared cross-cutting logic—such as logging setup, exception handling, or database configuration—into a custom Spring Boot starter instead of copy-pasting it across projects. At the core of a starter is auto-configuration: a class annotated with &lt;code&gt;@AutoConfiguration&lt;/code&gt; declares beans alongside conditional annotations like &lt;code&gt;@ConditionalOnMissingBean&lt;/code&gt; (backing off if the application defines its own bean) or &lt;code&gt;@ConditionalOnClass&lt;/code&gt; (activating only when required classes are on the classpath). Starting in Spring Boot 3, auto-configuration classes are registered in &lt;code&gt;META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports&lt;/code&gt; rather than the legacy &lt;code&gt;spring.factories&lt;/code&gt;, while &lt;code&gt;@ConfigurationProperties&lt;/code&gt; and &lt;code&gt;@EnableConfigurationProperties&lt;/code&gt; let consumers customize behavior via &lt;code&gt;application.properties&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The second half covers packaging and publishing. For third-party starters, Spring&amp;rsquo;s documentation recommends naming modules &lt;code&gt;&amp;lt;name&amp;gt;-spring-boot-starter&lt;/code&gt;, reserving the &lt;code&gt;spring-boot&lt;/code&gt; prefix for official Spring artifacts. The remaining steps include adding &lt;code&gt;spring-boot-autoconfigure&lt;/code&gt; and the configuration metadata annotation processor for IDE autocomplete, running &lt;code&gt;mvn clean install&lt;/code&gt; to test locally, and publishing to an internal or public Maven repository. Obregon also advises keeping starters lean and marking non-essential dependencies as &lt;code&gt;optional&lt;/code&gt; to avoid version conflicts in consuming applications. Once structured properly, Spring Boot automatically wires everything up on startup.&lt;/p&gt;
&lt;h2 id="real-world-garbage-collection-solutions"&gt;&lt;a href="https://dzone.com/articles/real-world-garbage-collection-solutions" rel="noopener noreferrer"&gt;Real-World Garbage Collection Solutions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DZone article presents real-world case studies showing how tuning garbage collection (GC) can deliver major performance gains at minimal cost. First, the author outlines the key metrics to watch: throughput (the percentage of time the application spends doing real work, which should be around 99% for critical systems), GC pause latency, CPU time spent in GC, and overall response time. To gather data, enable GC logging with &lt;code&gt;-Xlog:gc*:file=&amp;lt;path&amp;gt;&lt;/code&gt; (Java 9+) or &lt;code&gt;-XX:+PrintGCDetails -Xloggc:&amp;lt;path&amp;gt;&lt;/code&gt; (Java 8 and earlier) and analyze the logs with a tool like GCeasy.&lt;/p&gt;
&lt;p&gt;Three case studies illustrate the impact. An insurance company suffered back-to-back Full GCs during peak hours; adding memory and resizing the heap boosted throughput by 23% and cut GC CPU usage in half. A warehouse robotics control application running CMS on a 126 GB heap experienced occasional pauses lasting up to 5 minutes; switching to G1 brought the worst-case pause down to about 2 seconds with an average of 198 ms. Finally, a cloud service provider running Parallel GC with a 40 GB heap split evenly between young and old generations shrank the young generation to 1 GB, raising throughput to 99% and dropping average pause time from 12 seconds to 139 ms. Takeaway: when a Java application slows down, GC analysis should be your first stop.&lt;/p&gt;
&lt;h2 id="java-naming-conventions"&gt;&lt;a href="https://www.baeldung.com/java-naming-conventions" rel="noopener noreferrer"&gt;Java Naming Conventions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Baeldung summarizes the foundational Java naming conventions that keep codebases readable, consistent, and easy to collaborate on. Classes use &lt;code&gt;UpperCamelCase&lt;/code&gt; with nouns or noun phrases that clearly describe their role, like &lt;code&gt;CustomerAccount&lt;/code&gt;, avoiding abbreviations or vague names; interfaces also use &lt;code&gt;UpperCamelCase&lt;/code&gt; and express the capability implementing classes commit to, such as &lt;code&gt;Printable&lt;/code&gt;. Variables use &lt;code&gt;lowerCamelCase&lt;/code&gt;, while &lt;code&gt;static final&lt;/code&gt; constants use &lt;code&gt;UPPER_SNAKE_CASE&lt;/code&gt; like &lt;code&gt;MAX_BALANCE&lt;/code&gt;; methods use &lt;code&gt;lowerCamelCase&lt;/code&gt; starting with a verb that describes the action, such as &lt;code&gt;deposit()&lt;/code&gt; or &lt;code&gt;print()&lt;/code&gt;. Variables or methods holding or returning multiple elements should use plural names.&lt;/p&gt;
&lt;p&gt;Packages are written in all lowercase using reverse domain name notation—for example, &lt;code&gt;com.baeldung.namingconventions&lt;/code&gt;—to organize code cleanly and prevent namespace collisions. Enums use &lt;code&gt;UpperCamelCase&lt;/code&gt; for the type name and &lt;code&gt;UPPER_SNAKE_CASE&lt;/code&gt; for their constants (such as &lt;code&gt;DayOfWeek.MONDAY&lt;/code&gt;), and annotations follow &lt;code&gt;UpperCamelCase&lt;/code&gt; just like classes, e.g., &lt;code&gt;@Auditable&lt;/code&gt;. While simple, these conventions are essential habits for new Java developers to build early on.&lt;/p&gt;
&lt;h2 id="vibe-coding-vs-reality"&gt;&lt;a href="https://cendyne.dev/posts/2025-03-19-vibe-coding-vs-reality.html" rel="noopener noreferrer"&gt;Vibe Coding vs Reality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cendyne pushes back against the &amp;ldquo;vibe coding&amp;rdquo; hype—the viral idea sparked by Andrej Karpathy of &amp;ldquo;giving in to the vibes&amp;rdquo; and forgetting the code exists while letting LLMs write everything. The author admits that AI coding agents like Cursor or GitHub Copilot in agent mode look magical when scaffolding a greenfield project from an empty folder, but that excitement quickly fades once the codebase grows. Working with Claude 3.7 Sonnet, Cendyne catalogs a long list of recurring blunders: duplicating TypeScript interfaces instead of importing them, recreating components that already exist, putting security-sensitive trust logic on the client side, mutating production code to match broken tests instead of fixing the tests, refactoring only one instance of duplicated code while leaving the rest untouched, and degenerating into gibberish once the context window fills up.&lt;/p&gt;
&lt;p&gt;According to the author, the core limitation is that models cannot genuinely learn new project knowledge on the fly, cannot monitor multiple real-time feedback streams simultaneously (such as server logs alongside end-to-end test output), and lack both short- and long-term organizational memory. The &amp;ldquo;Claude Plays Pokémon&amp;rdquo; experiment illustrates how even with handoff notes across context resets, the model keeps repeating the exact same mistakes. The verdict: vibe coding might get you 80% of the way to a prototype, but building reliable, secure software worth paying for still requires experienced humans.&lt;/p&gt;
&lt;h2 id="sell-yourself-sell-your-work"&gt;&lt;a href="https://www.solipsys.co.uk/new/SellYourselfSellYourWork.html" rel="noopener noreferrer"&gt;Sell Yourself, Sell Your Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short piece on &lt;code&gt;solipsys.co.uk&lt;/code&gt; reminds engineers that doing great technical work is not enough on its own: if you lock yourself in a room, produce brilliant work, and never tell anyone about it, nobody knows, nobody benefits, and the effort is effectively wasted. The author has met many talented engineers who avoid writing reports because they find it boring, difficult, and beside the point. In reality, writing and presenting clearly and concisely—since typos or sloppy prose are enough to lose a chunk of your audience—is how your work saves other people time and builds your own credibility.&lt;/p&gt;
&lt;p&gt;The post quotes Richard Hamming&amp;rsquo;s famous 1986 talk &amp;ldquo;You and Your Research&amp;rdquo;: finishing a piece of work is not enough—you have to &amp;ldquo;sell&amp;rdquo; it, because everyone is busy with their own problems; you must present it well enough that others are willing to set their own work aside to read yours, honing your skills in writing, formal talks, and informal hallway conversations alike. Even if you start your own company, you still have to sell your products and services. The closing message: let the world benefit from the work you do.&lt;/p&gt;
&lt;h2 id="building-resilient-payment-systems-at-ssense-our-journey-towards-asynchronous-processing"&gt;&lt;a href="https://medium.com/ssense-tech/building-resilient-payment-systems-at-ssense-our-journey-towards-asynchronous-processing-56d46dc2b348" rel="noopener noreferrer"&gt;Building Resilient Payment Systems at SSENSE: Our Journey Towards Asynchronous Processing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The engineering team at fashion e-commerce platform SSENSE shares how they migrated their payment system from synchronous to asynchronous processing. Their legacy architecture tightly coupled payment execution to the order lifecycle: certain payment service providers (PSPs) processed transactions in batches that left payment status unresolved for hours or even days, flash-sale traffic spikes strained the system, and refunds required complex manual intervention. Their solution was decoupling payment confirmation from order placement—moving orders into a pending state so checkout could proceed—while diversifying across multiple PSPs to reduce single-provider risk.&lt;/p&gt;
&lt;p&gt;In the new architecture, the payment service and its cron jobs (written in TypeScript and running on Kubernetes) share a database, receive PSP updates via webhooks, and publish domain events onto an event bus so the order service and financial integration layer can react asynchronously. Every transaction moves through explicit states: &lt;code&gt;Queued&lt;/code&gt;, &lt;code&gt;Pending&lt;/code&gt;, &lt;code&gt;Complete&lt;/code&gt;, &lt;code&gt;Declined&lt;/code&gt;, or &lt;code&gt;Failed&lt;/code&gt;. When an outbound request fails, the system retries immediately a few times before placing the transaction into &lt;code&gt;Queued&lt;/code&gt; for a cron job to replay later, using idempotency keys to prevent duplicate charges. Failed transactions automatically open customer support tickets, and a separate cron job detects transactions stuck in &lt;code&gt;Pending&lt;/code&gt;. The result is a smoother checkout experience, greater resilience during peak sales, and consistent data across downstream systems.&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 #15</title><link>https://miti99.com/en/post/2025/05/02/</link><pubDate>Fri, 02 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/02/</guid><description>&lt;p&gt;&lt;em&gt;Normally I follow a one-post-per-day format, but lately I&amp;rsquo;ve been too lazy to write and have accumulated way too many interesting articles. So for the near future I&amp;rsquo;ll pull a little trick by backdating posts and writing more to catch up on my backlog. For example, today is May 10th, but I&amp;rsquo;m writing this for May 2nd—just check the git history and you&amp;rsquo;ll see, hehe. Enjoy Newsletter #15.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="heres-how-i-use-llms-to-help-me-write-code"&gt;&lt;a href="https://simonwillison.net/2025/Mar/11/using-llms-for-code/" rel="noopener noreferrer"&gt;Here’s how I use LLMs to help me write code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison reflects on more than two years of using large language models (LLMs) to assist with coding and argues that using LLMs effectively is a skill that takes practice, not something that comes naturally. According to him, you should treat an LLM as an advanced autocomplete tool: it fills in knowledge gaps but can still make unpredictable mistakes, so the human must always stay in control. He also notes the training data cutoff limitation: for libraries that have changed significantly since the cutoff date, you need to include fresh examples directly in your prompt. Conversation context is everything, so proactively provide existing source code, sample examples, or use tools that can load your entire project.&lt;/p&gt;
&lt;p&gt;In practice, he uses LLMs to explore library options and implementation approaches early on; when writing actual code, he gives detailed instructions such as function signatures and clear requirements, then iteratively asks for edits and refactoring across multiple turns rather than throwing away the first result. Running and testing the code yourself is non-negotiable. The article shares an example of building a commit history aggregation page with Claude Code in about 17 minutes at a cost of $0.61, though he still had to configure GitHub Actions by hand. The biggest benefit is speed: LLMs make projects feasible that previously weren&amp;rsquo;t worth the effort, while amplifying a developer&amp;rsquo;s existing expertise.&lt;/p&gt;
&lt;h2 id="i-use-cursor-daily---here"&gt;&lt;del&gt;&lt;a href="https://www.nickcraux.com/blog/cursor-tips" rel="noopener noreferrer"&gt;I use Cursor daily - here&amp;rsquo;s how I avoid the garbage parts&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical tips from daily use of Cursor, a code editor built on VS Code with deep integration of large language models like GPT-4. The author covers essential keyboard shortcuts, how to write prompts for more accurate AI responses, how to leverage codebase-wide chat, and strategies for optimizing workflows and configuring Cursor to fit individual developers and projects.&lt;/p&gt;
&lt;p&gt;Notably, the author emphasizes harmonious collaboration between humans and AI rather than blindly leaving everything to the tool, resulting in higher-quality code in less time. It is a useful reference for both newcomers and experienced Cursor users looking to get more out of the editor.&lt;/p&gt;
&lt;h2 id="why-java-endures-the-foundation-of-modern-enterprise-development"&gt;&lt;a href="https://github.blog/developer-skills/why-java-endures-the-foundation-of-modern-enterprise-development/" rel="noopener noreferrer"&gt;Why Java endures: The foundation of modern enterprise development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub Blog article explains why Java, created in 1995 at Sun Microsystems, remains the foundation of enterprise software development nearly 30 years later. At the root of Java&amp;rsquo;s strength is the &amp;ldquo;write once, run anywhere&amp;rdquo; principle: code written once can run across multiple operating systems without recompilation. The language continues to modernize—for instance, Java 23 (September 2024) simplifies syntax for beginners, while pattern matching and record classes help keep code concise and maintainable.&lt;/p&gt;
&lt;p&gt;Furthermore, Java&amp;rsquo;s ecosystem is massive, spanning the standard library and frameworks like Spring Boot and Hibernate so developers don&amp;rsquo;t have to reinvent common solutions; Minecraft, Netflix, and LinkedIn are prime examples. In AI, while Python dominates research, Java excels at large-scale deployment—such as Uber&amp;rsquo;s Michelangelo platform—and libraries like Deeplearning4j and LangChain4j make it straightforward to add AI capabilities to existing Java systems. The article concludes that Java remains a highly sought-after skill on the job market and will retain its position thanks to its commitment to durable, scalable, and maintainable code.&lt;/p&gt;
&lt;h2 id="part-5-implementing-a-web-ui-using-vaadin-and-github-copilot-agent-mode"&gt;&lt;a href="https://itnext.io/part-5-implementing-a-web-ui-using-vaadin-and-github-copilot-agent-mode-563e74f131aa" rel="noopener noreferrer"&gt;Part 5: Implementing a Web UI using Vaadin and GitHub Copilot Agent Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the fifth installment in Saeed Zarinfam&amp;rsquo;s series on using AI-powered IDEs for Java development. Here, the author uses VS Code with GitHub Copilot Agent Mode and Claude 3.5 Sonnet to build a web UI with Vaadin Flow—a niche framework for writing web interfaces entirely in Java—for a sample Employee Assistance Chatbot project built with Spring AI. He documents the exact steps and prompts used to see Copilot Agent Mode in action, while comparing it against Windsurf&amp;rsquo;s Cascade agent, which he had previously used smoothly to build a cached REST service with Spring Boot.&lt;/p&gt;
&lt;p&gt;The key difference this time is that the author is not very familiar with Vaadin Flow, making the post a test of whether LLMs truly help when working with a less popular framework. As the article&amp;rsquo;s subtitle hints, the answer is fairly cautious: LLMs are not yet well suited to niche programming languages and frameworks, so developers cannot rely entirely on AI when stepping into unfamiliar technology.&lt;/p&gt;
&lt;h2 id="microservices-vs-monoliths-how-to-choose-the-right-architecture-for-your-project"&gt;&lt;a href="https://dev.to/jhonifaber/microservices-vs-monoliths-how-to-choose-the-right-architecture-for-your-project-2bep" rel="noopener noreferrer"&gt;Microservices vs. Monoliths: How to Choose the Right Architecture for Your Project&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two common architectures—monoliths and microservices—to help engineering teams choose the right approach. In a monolith, the UI, business logic, and database operations live together in a single deployment unit, making it easy to build, test, debug, and operate. In exchange, scaling requires replicating the entire system rather than just the bottlenecked parts, large teams frequently run into merge conflicts, the tech stack is locked in across the whole application, and every small change forces a full redeployment, increasing risk.&lt;/p&gt;
&lt;p&gt;Microservices split an application into independent services, each owning a specific business capability and communicating over APIs. This allows selective scaling, autonomous teams, and per-service technology choices. Service isolation can help contain failures, though it does not guarantee that a failure in one service won&amp;rsquo;t cascade to dependent ones. The trade-off is high complexity: you need orchestration, monitoring, and service discovery tools while dealing with network latency and data consistency. The article introduces the SAGA pattern—a sequence of local transactions with compensating actions—and its two implementation styles: choreography (event-driven, decentralized) and orchestration (centrally coordinated). Choosing the right architecture depends on your application&amp;rsquo;s needs, team size, and long-term goals.&lt;/p&gt;
&lt;h2 id="designing-a-scalable-architecture---with-some-spring-boot-examples"&gt;&lt;a href="https://dev.to/jhonifaber/designing-a-scalable-architecture-with-some-spring-boot-examples-340o" rel="noopener noreferrer"&gt;Designing a Scalable Architecture - with Some Spring Boot Examples&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post outlines core principles for designing scalable systems, complete with Spring Boot examples. The author distinguishes vertical scaling (adding power to a single machine) from horizontal scaling (adding more instances), then walks through key building blocks: breaking applications into microservices for independent scaling, managing configuration with Spring Cloud Config and packaging with Docker, and designing stateless services—such as using JWT authentication so servers don&amp;rsquo;t need to store and look up session state.&lt;/p&gt;
&lt;p&gt;At the data layer, the article covers sharding, read replicas to offload the primary database, and NoSQL options like MongoDB with their trade-offs between consistency and availability. For asynchronous processing, it introduces message brokers like Kafka and RabbitMQ alongside Spring Boot&amp;rsquo;s &lt;code&gt;@Async&lt;/code&gt; annotation to run methods on separate threads. It also discusses caching with &lt;code&gt;@Cacheable&lt;/code&gt; and &lt;code&gt;@CacheEvict&lt;/code&gt;, plus an API Gateway handling routing, authentication, rate limiting, and circuit breaking. Finally, the author reminds readers that logging, security, monitoring, and error handling are essential to keeping a system resilient as it grows.&lt;/p&gt;
&lt;h2 id="java-is-very-fast-if-you-dont-create-many-objects"&gt;&lt;a href="https://blog.vanillajava.blog/2022/09/java-is-very-fast-if-you-dont-create.html" rel="noopener noreferrer"&gt;Java is Very Fast, If You Don’t Create Many Objects&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;High-performance Java specialist Peter Lawrey demonstrates that object allocation heavily impacts Java performance in high-throughput systems, even when garbage collection (GC) itself is cheap. In a Chronicle Wire benchmark on a Ryzen 5950X CPU, with zero object allocations, the system processed around 60–68 million events per second at a latency of 467–528 nanoseconds; allocating just a single 44-byte object per event dropped throughput to roughly 37–50 million events per second—about a 25% reduction—and added roughly 166 nanoseconds of latency.&lt;/p&gt;
&lt;p&gt;Interestingly, GC took only about 170 milliseconds per minute (0.3% of runtime), showing that the bottleneck lies not in cleanup, but in pressure on the CPU&amp;rsquo;s L1/L2/L3 caches when multiple cores allocate memory simultaneously. In multi-threaded tests, the allocation rate plateaued around 220 million objects per second, and latency spiked sharply beyond eight threads. Chronicle Wire solves this by reusing the same object per event type by default during deserialization, eliminating allocations while keeping the code simple. The takeaway: for latency-sensitive systems like finance, reducing object allocation yields far bigger gains than tuning GC.&lt;/p&gt;
&lt;h2 id="microbenchmarks-java-locks-vs-atomic"&gt;&lt;del&gt;&lt;a href="https://blog.tombert.com/posts/2025-03-04-lock-benchmark/" rel="noopener noreferrer"&gt;Microbenchmarks: Java Locks vs Atomic&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This article presents a detailed analysis of the performance of various synchronization mechanisms in multithreaded programming. The author benchmarked different lock types—including mutexes, spin locks, read-write locks, and lock-free solutions—evaluating them under varying load scenarios.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The benchmark results show significant differences across lock types, with several interesting findings:&lt;/del&gt;
&lt;del&gt;1. Spin locks are generally more efficient than mutexes for short tasks with low contention&lt;/del&gt;
&lt;del&gt;2. Read-write locks offer major benefits in read-heavy, write-light workloads&lt;/del&gt;
&lt;del&gt;3. Lock-free solutions can deliver superior performance in certain cases, but are significantly more complex to implement and maintain&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The article also discusses factors affecting lock performance such as latency, throughput, thread scalability, and the impact of cache coherence. The author provides practical guidelines for choosing the right synchronization mechanism based on application characteristics and data access patterns.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;This is a valuable reference for developers working on high-performance multithreaded systems, helping them make informed decisions when selecting synchronization mechanisms for their specific project requirements.&lt;/del&gt;&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/ad16adef-3082-42bd-ac99-9a569ad2e33b_2250x2624.png" alt="API Protocols 101"&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 #13</title><link>https://miti99.com/en/post/2025/04/22/</link><pubDate>Tue, 22 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/22/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #13.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="designing-a-distributed-id-generator"&gt;&lt;a href="https://siddharthsabron.in/blog/id-generator/" rel="noopener noreferrer"&gt;Designing a Distributed ID Generator&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through building a 64-bit Snowflake-style distributed ID generator that produces unique IDs across nodes without relying on a centralized coordinator like a database &lt;code&gt;AUTO_INCREMENT&lt;/code&gt; sequence. First, the author explains why random strings (like UUIDv4) make poor primary keys in relational databases: string comparisons are slower than integer comparisons, indexes take up much more memory, and inserting random keys into a B-Tree causes frequent page splits, fragmentation, and poor cache locality. By contrast, time-ordered 64-bit integers keep indexes compact and append new rows cleanly near the right edge of the B-Tree.&lt;/p&gt;
&lt;p&gt;The core design packs three fields into a 64-bit integer: 41 bits for a millisecond timestamp relative to a custom epoch (good for ~69 years), 10 bits for the shard/machine ID (supporting up to 1,024 shards), and 12 bits for a per-millisecond sequence counter (allowing 4,096 IDs per millisecond per shard), combined using bitwise shifts and &lt;code&gt;OR&lt;/code&gt; operations. The author also candidly notes what needs to be hardened before taking the toy code to production, including handling sequence rollovers within the same millisecond, NTP clock drift, and automated shard ID assignment. It is a clear, practical read on why primary-key layout directly impacts database performance.&lt;/p&gt;
&lt;h2 id="3200-cpu-utilization"&gt;&lt;a href="https://josephmate.github.io/2025-02-26-3200p-cpu-util/" rel="noopener noreferrer"&gt;3,200% CPU Utilization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joseph Mate recounts a production war story where a Java server spiked so hard that he could barely SSH into the box: CPU utilization hit 3,200%, pegging all 32 cores at 100%. Pulling a Java 17 thread dump—which includes per-thread CPU time—revealed dozens of threads stuck endlessly inside &lt;code&gt;TreeMap.put()&lt;/code&gt;. The culprit was an unsynchronized &lt;code&gt;TreeMap&lt;/code&gt; being mutated concurrently by multiple threads. Under a race condition during tree rebalancing, the internal red-black tree&amp;rsquo;s pointers became corrupted and formed a cycle, causing subsequent lookups and inserts to spin in an infinite loop. Crucially, the bug stayed hidden until &lt;code&gt;NullPointerException&lt;/code&gt;s thrown during concurrent corruption were silently swallowed by an executor thread pool without an uncaught exception handler (or inside a gRPC request handler), leaving the corrupted map live in memory with zero stack traces in the logs.&lt;/p&gt;
&lt;p&gt;The author reproduces the bug in a standalone test, compares how other languages handle concurrent map mutation, and outlines fixes—the simplest being wrapping the map in &lt;code&gt;Collections.synchronizedMap&lt;/code&gt; or switching to &lt;code&gt;ConcurrentSkipListMap&lt;/code&gt;. Beyond the immediate fix, he advocates defense-in-depth: alerting on unexpected NPEs, monitoring sustained CPU anomalies, always registering an &lt;code&gt;UncaughtExceptionHandler&lt;/code&gt; on thread pools, thorough code review, static analysis, and multithreaded stress tests. It&amp;rsquo;s a vivid reminder that data races don&amp;rsquo;t just corrupt state—they can take down an entire server.&lt;/p&gt;
&lt;h2 id="a-map-metaphor-for-architectural-diagrams"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/maps-metaphor-for-architectural-diagrams.html" rel="noopener noreferrer"&gt;A map metaphor for architectural diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi suggests thinking of software architecture diagrams as maps: the map is not the territory, and every model is &amp;ldquo;wrong&amp;rdquo; because it leaves out detail, yet it becomes useful precisely by highlighting the specific dimension needed for a given task. Just like a topographic map versus a subway map, each architectural diagram should focus on a single slice of concern. If a diagram constantly falls out of sync with the code, it is probably drawn at too low a level of abstraction.&lt;/p&gt;
&lt;p&gt;Sironi shares his experience maintaining a lightweight set of living &amp;ldquo;maps&amp;rdquo; on a digital whiteboard like Miro, using nothing more than boxes, arrows, sticky notes for open decisions, and color-coding for status. These living boards replace sprawling lists of Architectural Decision Records (ADRs)—which become hard to navigate once you have dozens of them—and differ from ADRs by being edited in place as the system evolves. His core set of maps covers system context (inspired by the C4 model), bounded contexts and their ubiquitous language, static module dependencies, testing strategy, observability pipelines, and technology radar choices. Crucially, the whole team owns and updates these maps together rather than treating them as the tech lead&amp;rsquo;s private artifact, consulting them whenever kicking off a new initiative.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/02/28/about-developer-philosophy/" rel="noopener noreferrer"&gt;About &amp;ldquo;Developer philosophy&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea shares his reflections on reading qntm&amp;rsquo;s &amp;ldquo;Developer philosophy&amp;rdquo; essay. He starts by asking whether there is still room for junior developers in the age of AI, empathizing with new grads struggling to land their first role and drawing parallels to the offshoring wave of the 2000s. On the topic of big-bang rewrites, while he agrees with qntm that the rot leading to a rewrite builds up over years, he argues that accumulated gaps can usually still be paid down incrementally. Full rewrites, he warns, are massive projects that inevitably slip their schedules—at which point &amp;ldquo;non-essential&amp;rdquo; requirements get cut to hit the deadline, birthing a brand-new pile of technical debt in the replacement system.&lt;/p&gt;
&lt;p&gt;In the second half, Costea offers pragmatic caveats on qntm&amp;rsquo;s other rules: automating best practices via linters only works once you have buy-in from the influential voices on the team; edge cases often only reveal themselves late in the game following the 80/20 rule; don&amp;rsquo;t expect a V2 rewrite to stay clean and simple for long; and even code that looks modular, testable, and &amp;ldquo;obviously correct&amp;rdquo; can still surprise you in production. It&amp;rsquo;s a grounded, slightly battle-weary counterpoint to the original essay.&lt;/p&gt;
&lt;h2 id="team-learning-session-surviving-legacy-code-by-jb-rainsberger"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/team-learning-session-surviving-legacy.html" rel="noopener noreferrer"&gt;Team learning session: surviving legacy code by J.B. Rainsberger&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi describes how he runs a recurring team learning session built around J.B. Rainsberger&amp;rsquo;s &amp;ldquo;Surviving Legacy Code&amp;rdquo; kata. The fictional premise puts a TypeScript team in charge of maintaining a newly acquired, business-critical PHP codebase with no tests, cryptic logic, and nobody left who knows where the landmines are buried. The exercise targets three learning goals: characterizing and understanding unfamiliar legacy code, writing tests at multiple levels of granularity, and refactoring safely behind a safety net of tests—while also getting comfortable picking up an unfamiliar language and its ecosystem tooling (&lt;code&gt;Composer&lt;/code&gt;, &lt;code&gt;PHPUnit&lt;/code&gt;, &lt;code&gt;PHPStan&lt;/code&gt;, &lt;code&gt;PHP-CS-Fixer&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The team works together in an ensemble (mob programming) format for an hour a week on a single shared screen against a deliberately awful toy repository. Their progression starts with running the code to see what it does, locking down existing behavior with a &lt;strong&gt;Golden Master&lt;/strong&gt; characterization test (controlling the random number generator seed so outputs are deterministic), and only then extracting smaller seams and writing fine-grained unit tests. Because the codebase is fictional and there is no delivery deadline, teammates feel safe saying &amp;ldquo;I don&amp;rsquo;t know&amp;rdquo; and experimenting aloud. Each session wraps up with a quick retrospective to capture takeaways and pick the next thread to pull.&lt;/p&gt;
&lt;h2 id="trimodal-nature-of-tech-compensation-in-the-us-uk-and-india"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/trimodal" rel="noopener noreferrer"&gt;Trimodal Nature of Tech Compensation in the US, UK and India&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, author of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt;, analyzes more than 20,000 compensation data points from Levels.fyi to test his &lt;strong&gt;trimodal compensation model&lt;/strong&gt; across the US, the UK, and India. Under this model, tech employers cluster into three distinct pay bands: &lt;strong&gt;Tier 1&lt;/strong&gt; (local market rate—the vast majority of companies), &lt;strong&gt;Tier 2&lt;/strong&gt; (Big Tech and regional leaders), and &lt;strong&gt;Tier 3&lt;/strong&gt; (top scaleups, elite quant trading firms, and hedge funds). In the US, Tier 2 and Tier 3 typically pay roughly double Tier 1 at both the median and 75th percentile for both entry-level and senior engineers, with significant overlap between Tier 2 and Tier 3 packages.&lt;/p&gt;
&lt;p&gt;The post breaks down top-paying companies in each tier by country and surfaces several striking patterns: hedge funds and quant firms don&amp;rsquo;t grant equity, but pay massive year-end cash bonuses that make them the only group paying higher pure cash compensation than Big Tech; in the UK, hedge funds and financial institutions dominate the very top of the market; and in India, top Tier 3 employers pay over ₹1 crore ($120K+) for senior engineers. Orosz also reminds readers that private &amp;ldquo;paper money&amp;rdquo; equity at pre-IPO scaleups can inflate headline numbers while carrying real liquidity risk. It is an essential read for calibrating your market value and career strategy.&lt;/p&gt;
&lt;h2 id="9-software-architecture-patterns-for-distributed-systems"&gt;&lt;a href="https://dev.to/somadevtoo/9-software-architecture-patterns-for-distributed-systems-2o86" rel="noopener noreferrer"&gt;9 Software Architecture Patterns for Distributed Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Soma provides a visual overview of nine fundamental architectural patterns for managing data flow and communication in distributed systems—topics that also come up constantly in system design interviews. The first five cover communication and state: &lt;strong&gt;Peer-to-Peer&lt;/strong&gt;, where nodes communicate directly without a central coordinator; &lt;strong&gt;API Gateway&lt;/strong&gt;, a single entry point handling authentication, rate limiting, and routing to backend services; &lt;strong&gt;Pub-Sub&lt;/strong&gt;, decoupling producers and consumers asynchronously through topics; &lt;strong&gt;Request-Response&lt;/strong&gt;, the classic synchronous client-server model; and &lt;strong&gt;Event Sourcing&lt;/strong&gt;, persisting every state transition as an immutable append-only log of events.&lt;/p&gt;
&lt;p&gt;The remaining four focus on data processing and workflow coordination: &lt;strong&gt;ETL&lt;/strong&gt; (Extract, Transform, Load) for moving data into analytical stores; &lt;strong&gt;Batching&lt;/strong&gt; for high-throughput periodic processing; &lt;strong&gt;Stream Processing&lt;/strong&gt; for continuous real-time event pipelines; and &lt;strong&gt;Orchestration&lt;/strong&gt;, where a central controller coordinates multi-step workflows across services. Each pattern is paired with a clear diagram and real-world use cases, making the post a handy quick-reference refresher before diving deeper into individual patterns.&lt;/p&gt;
&lt;h2 id="extending-java-apis---add-missing-features-without-the-hassle"&gt;&lt;a href="https://foojay.io/today/extending-java-apis-add-missing-features-without-the-hassle/" rel="noopener noreferrer"&gt;Extending Java APIs - Add Missing Features Without the Hassle&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shai Almog introduces the &lt;strong&gt;extension methods&lt;/strong&gt; feature of the Manifold compiler plugin, which lets you add missing methods to existing Java classes (like &lt;code&gt;String&lt;/code&gt; or &lt;code&gt;Collection&lt;/code&gt;) without waiting years for the JDK to add them. You simply create a class annotated with &lt;code&gt;@Extension&lt;/code&gt; inside a package whose name ends with the fully qualified name of the target class, and write &lt;code&gt;static&lt;/code&gt; methods whose first parameter is annotated with &lt;code&gt;@This&lt;/code&gt;. For example, you can add a &lt;code&gt;.map()&lt;/code&gt; method directly onto &lt;code&gt;Collection&lt;/code&gt; to skip the ceremony of calling &lt;code&gt;.stream().map(...).toList()&lt;/code&gt;. Under the hood, Manifold does not modify the bytecode of the target JDK class—instead, it rewrites call sites into static method calls at compile time with zero runtime wrapper overhead. And if a future JDK release adds a native method with the exact same signature, the real JDK method automatically takes precedence, keeping upgrades smooth.&lt;/p&gt;
&lt;p&gt;Manifold also ships with ready-made extension libraries for collections, &lt;code&gt;String&lt;/code&gt;, I/O, and JSON—bringing Kotlin-style helpers like &lt;code&gt;removePrefix()&lt;/code&gt;, &lt;code&gt;padStart()&lt;/code&gt;, and &lt;code&gt;isEmpty()&lt;/code&gt; on arrays straight to Java. Finally, the post showcases &lt;code&gt;@Structural&lt;/code&gt; interfaces, which bring TypeScript/Go-style structural typing to Java so unrelated classes like &lt;code&gt;String&lt;/code&gt; and &lt;code&gt;Collection&lt;/code&gt; can be treated polymorphically through a shared interface without modifying their class declarations.&lt;/p&gt;
&lt;h2 id="how-spring-boot-reloads-configuration-without-restart"&gt;&lt;a href="https://medium.com/@AlexanderObregon/how-spring-boot-reloads-configuration-without-restart-4d9dc9e8b926" rel="noopener noreferrer"&gt;How Spring Boot Reloads Configuration Without Restart&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon explains how Spring Boot reloads configuration properties dynamically at runtime without restarting the JVM. By default, &lt;code&gt;@Value&lt;/code&gt; and &lt;code&gt;@ConfigurationProperties&lt;/code&gt; bindings are evaluated once at startup. To make them dynamic, applications typically pull configuration from Spring Cloud Config Server, annotate dynamic beans with &lt;code&gt;@RefreshScope&lt;/code&gt;, and trigger a reload by sending a POST request to Spring Boot Actuator&amp;rsquo;s &lt;code&gt;/actuator/refresh&lt;/code&gt; endpoint.&lt;/p&gt;
&lt;p&gt;The article looks under the hood at what happens when &lt;code&gt;/actuator/refresh&lt;/code&gt; is called: Spring publishes a &lt;code&gt;RefreshEvent&lt;/code&gt;; the &lt;code&gt;ConfigurableEnvironment&lt;/code&gt; re-fetches property sources from the external config server and diffs the changes; and any bean marked with &lt;code&gt;@RefreshScope&lt;/code&gt;—which Spring wraps in a CGLIB proxy at startup—has its cached target instance invalidated in the scope cache, forcing Spring to lazily re-instantiate the bean with the fresh property values on the very next method call. Properties injected into regular singleton beans outside &lt;code&gt;@RefreshScope&lt;/code&gt;, the author notes, will not update until a full restart. For multi-instance deployments, pairing Config Server with &lt;strong&gt;Spring Cloud Bus&lt;/strong&gt; over RabbitMQ or Kafka broadcasts the refresh event across every running instance simultaneously via &lt;code&gt;/actuator/bus-refresh&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="building-high-performance-rpc-services-with-grpc-and-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/2025/03/building-high-performance-rpc-services-with-grpc-and-spring-boot.html" rel="noopener noreferrer"&gt;Building High-Performance RPC Services with gRPC and Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eleftheria Drosopoulou walks through integrating gRPC into a Spring Boot application to build high-performance RPC services. Created by Google, gRPC uses HTTP/2 for transport and Protocol Buffers (Protobuf) as its interface definition language and binary serialization format. Thanks to compact binary payloads, HTTP/2 connection multiplexing, native bidirectional streaming, and strongly typed client/server code generation from &lt;code&gt;.proto&lt;/code&gt; schemas, gRPC is a strong fit for internal microservice-to-microservice communication. The article opens with a comparison table pitting gRPC against REST and WebSockets across transport protocol, payload format, performance, streaming support, and browser compatibility.&lt;/p&gt;
&lt;p&gt;The hands-on tutorial steps through adding &lt;code&gt;grpc-spring-boot-starter&lt;/code&gt;, defining a service contract in a &lt;code&gt;.proto&lt;/code&gt; file, configuring the Maven Protobuf plugin to generate Java stubs, implementing the server-side service class, and wiring up the gRPC server port. It wraps up with clear guidance on when to pick each protocol: gRPC for low-latency polyglot microservices and streaming RPCs, REST for public-facing CRUD APIs and direct browser clients, and WebSockets for stateful real-time browser push.&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/39f5b04d-ad39-4bbe-a32f-f47792d4ef62_2250x2682.png" alt="Latency and Partition Tolerance in Distributed Systems"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Lis4w4_bBc" rel="noopener noreferrer"&gt;8 Most Important Tips for Designing Fault-Tolerant System&lt;/a&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>