<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>JVM on miti99</title><link>https://miti99.com/en/tags/jvm/</link><description>Recent content in JVM 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/jvm/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 #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><item><title>Newsletter #3</title><link>https://miti99.com/en/post/2025/02/23/</link><pubDate>Sun, 23 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/23/</guid><description>&lt;i&gt;
Hello everyone, another weekend has rolled around—sit back, relax, and enjoy MiTi's Newsletter #3.
&lt;/i&gt;
&lt;h2 id="java"&gt;&lt;a href="https://www.youtube.com/watch?v=y26XGt8d_kI" rel="noopener noreferrer"&gt;Java&amp;rsquo;s Plans for 2025 - Inside Java Newscast #83&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #83 of the Inside Java Newscast from the official Java channel surveys Java&amp;rsquo;s roadmap for 2025 across the major OpenJDK projects: Babylon, Loom, Leyden, Lilliput, Panama, and Valhalla. For each project, the video recaps what has been accomplished so far and what is planned next, saving Project Amber for a dedicated follow-up episode. It is a quick way to get the big picture of where the Java language and platform are headed.&lt;/p&gt;
&lt;h2 id="why-you-should-learn-kotlin-in-2025"&gt;&lt;del&gt;&lt;a href="https://dev.to/empiree/why-you-should-learn-kotlin-in-2025-47g0" rel="noopener noreferrer"&gt;Why You Should Learn Kotlin in 2025&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This article on Dev.to encourages developers to learn Kotlin in 2025, highlighting its modern features, Java interoperability, and versatile applications. The post also discusses the job market and salary potential for Kotlin developers.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="mastering-java-logging-best-practices-for-effective-application-monitoring"&gt;&lt;a href="https://dev.to/nithinbharathwaj/mastering-java-logging-best-practices-for-effective-application-monitoring-20h7" rel="noopener noreferrer"&gt;Mastering Java Logging: Best Practices for Effective Application Monitoring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Dev.to article rounds up best practices for logging in Java applications. The author recommends pairing SLF4J as the logging facade with Logback as the underlying implementation so you can swap logging frameworks without touching application code, and explains how to choose appropriate log levels from TRACE to FATAL to avoid both missing critical errors and flooding alerting systems (the post mentions FATAL, though SLF4J and Logback only define TRACE, DEBUG, INFO, WARN, and ERROR). It also walks through structured JSON logging with &lt;code&gt;logstash-logback-encoder&lt;/code&gt; and using MDC (Mapped Diagnostic Context) to automatically attach contextual metadata like request IDs or user IDs to every log line.&lt;/p&gt;
&lt;p&gt;The second half focuses on performance and operations: using asynchronous appenders, avoiding expensive computations inside logging calls, and deferring message construction (in SLF4J 2, you can pass a &lt;code&gt;Supplier&lt;/code&gt; via the fluent logging API). On the security front, the author stresses masking sensitive data such as credit card numbers and passwords. Finally, the post covers centralized log aggregation with the ELK stack or Graylog, along with log rotation and retention policies to keep disks from filling up.&lt;/p&gt;
&lt;h2 id="fixed-window-counter-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/fixed-window-counter-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Fixed Window Counter Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io tutorial walks through building a Fixed Window Counter rate limiter using Redis and Java. The algorithm divides time into fixed intervals, counts requests within each interval, and rejects requests once the threshold is exceeded; its main advantage is simplicity, though bursts of traffic near the boundary between two windows can let twice the allowed rate through. The implementation uses Jedis with a dedicated key per client: it reads the current counter with &lt;code&gt;GET&lt;/code&gt;, and then inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction increments the counter with &lt;code&gt;INCR&lt;/code&gt; and sets the TTL using &lt;code&gt;EXPIRE&lt;/code&gt; with the &lt;code&gt;NX&lt;/code&gt; flag so the expiration is only set when the key is first created rather than extending the window on every request.&lt;/p&gt;
&lt;p&gt;The post also demonstrates how to test the rate limiter using Redis TestContainers, JUnit 5, and AssertJ, covering key scenarios: requests within the limit are allowed, requests exceeding the limit are rejected, the counter resets once the window expires, separate clients maintain independent counters, and rejected requests do not increment the counter. Note that because the initial &lt;code&gt;GET&lt;/code&gt; and threshold check happen outside the &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction, concurrent requests can still race past the limit; stricter enforcement requires a Lua script or &lt;code&gt;WATCH&lt;/code&gt; with retries.&lt;/p&gt;
&lt;h2 id="how-jvm-handles-exceptions"&gt;&lt;a href="https://foojay.io/today/how-jvm-handles-exceptions/" rel="noopener noreferrer"&gt;How JVM handles exceptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io article explains how the Java Virtual Machine (JVM) handles exceptions at the bytecode level. Each method can carry an exception table where every entry specifies a protected bytecode range (&lt;code&gt;from&lt;/code&gt;, &lt;code&gt;to&lt;/code&gt;), a handler jump target (&lt;code&gt;target&lt;/code&gt;), and the exception type to catch—or &lt;code&gt;any&lt;/code&gt; for handlers that catch all throwables. When an &lt;code&gt;athrow&lt;/code&gt; instruction executes, the JVM pops the exception object from the operand stack and searches the current method&amp;rsquo;s exception table for a matching handler; if none is found, it unwinds the call stack frame by frame. If the exception remains uncaught all the way up the call chain, the active thread terminates after running its uncaught exception handler.&lt;/p&gt;
&lt;p&gt;The author also dissects how the compiler translates &lt;code&gt;try-catch-finally&lt;/code&gt; blocks into bytecode. In the example, the &lt;code&gt;finally&lt;/code&gt; block&amp;rsquo;s bytecode is duplicated along the normal execution path, while &lt;code&gt;any&lt;/code&gt; entries in the exception table route control flow through the &lt;code&gt;finally&lt;/code&gt; block whenever an exception is thrown inside &lt;code&gt;try&lt;/code&gt; or &lt;code&gt;catch&lt;/code&gt;. It is a great read if you want to see what actually happens under the hood when an exception is thrown.&lt;/p&gt;
&lt;h2 id="database-sharding-explained"&gt;&lt;a href="https://architecturenotes.co/p/database-sharding-explained" rel="noopener noreferrer"&gt;Database Sharding Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Architecture Notes piece explains database sharding—the technique of partitioning data across multiple machines when a single database server can no longer handle the load. Before reaching for sharding, the author advises exhausting simpler alternatives: doing nothing if there isn&amp;rsquo;t a clear bottleneck yet, scaling vertically with bigger hardware, adding read replicas to offload read traffic, or moving specific workloads to specialized stores like Elasticsearch for search or S3 for large blobs.&lt;/p&gt;
&lt;p&gt;The article then covers three primary sharding strategies: hash-based sharding (distributes data evenly but makes resharding painful), range-based sharding (requires a lookup table and a well-distributed shard key to avoid hot spots), and relationship-based sharding (keeps related entities together on the same shard). The author clarifies the role of the shard key, distinguishes logical shards from physical shards, and introduces two-phase commit (2PC) as a way to coordinate atomic transactions across multiple shards—at the cost of extra write latency and significant complexity. The overarching message: sharding unlocks horizontal scale, but comes with a heavy operational burden.&lt;/p&gt;
&lt;h2 id="protecting-your-time-from-predators-in-large-tech-companies"&gt;&lt;a href="https://www.seangoedecke.com/predators/" rel="noopener noreferrer"&gt;Protecting your time from predators in large tech companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this post, Sean Goedecke warns high-performing engineers at large tech companies about people who constantly try to hijack their time—whom he calls &amp;ldquo;predators.&amp;rdquo; Two archetypes stand out: product managers from other teams who slide into DMs asking for a &amp;ldquo;quick fix&amp;rdquo; to bypass official prioritization channels, and underperforming engineers who lean on others as a substitute for learning on their own, claiming credit for the resulting work without acknowledging the help.&lt;/p&gt;
&lt;p&gt;To protect yourself, the author advises spotting asymmetric requests—where the requester puts in minimal effort while expecting hours of work from you—and matching their level of effort in your response. Move private requests into public channels so your contributions are visible and your manager stays in the loop. He also makes sure to distinguish legitimate demands on your time: helping your own manager, your reports, or junior teammates who are genuinely ramping up is part of the job. Above all, remember that shipping your own assigned projects is your primary responsibility.&lt;/p&gt;
&lt;h2 id="how-to-improve-your-wfh-lighting-to-reduce-eye-strain"&gt;&lt;a href="https://rustle.ca/posts/articles/work-from-home-lighting" rel="noopener noreferrer"&gt;How to improve your WFH lighting to reduce eye strain&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on rustle.ca shares practical ways to set up your work-from-home lighting to reduce eye strain. The author identifies three main culprits: imperceptible monitor flicker (PWM), especially when screen brightness is turned down and the monitor is the sole light source in the room; high-contrast environments such as harsh window glare or unevenly lit rooms; and focusing at a fixed distance for hours on end. For the last issue, the author recommends the 20/20/20 rule: every 20 minutes, look at something at least 20 feet (about 6 meters) away for at least 20 seconds.&lt;/p&gt;
&lt;p&gt;Concrete recommendations include making the most of natural daylight, using sheer curtains to diffuse direct sunlight rather than blocking it completely, placing multiple indirect light sources around the room to eliminate dark corners, choosing dimmable, flicker-free bulbs with a high Color Rendering Index (CRI) and a warm color temperature around 2700K, and adding a desk lamp or monitor bias lighting matched roughly to your screen&amp;rsquo;s brightness.&lt;/p&gt;
&lt;h2 id="working-fast-and-slow"&gt;&lt;a href="https://www.seangoedecke.com/working-fast-and-slow/" rel="noopener noreferrer"&gt;Working fast and slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that uneven productivity isn&amp;rsquo;t a flaw to be fixed; instead, he deliberately alternates between two working modes. During high-focus states, complex problems feel effortless, so he channels that energy into high-impact tasks, blocks out distractions, and works for hours at a stretch. However, this state burns through a finite internal reservoir of energy that takes time to recharge.&lt;/p&gt;
&lt;p&gt;When focus is low, he switches to lighter work such as knocking out easy tickets, reviewing pull requests, or unblocking other projects. Trying to force hard engineering work while unfocused, he notes, only introduces bugs that take longer to fix than simply waiting for focus to return—and usually gives you a headache to boot. This two-speed rhythm also aligns naturally with the cadence of large tech companies, where quiet maintenance periods alternate with high-stakes crunches that demand everything you&amp;rsquo;ve got.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="bonus-1-interesting-images-from-bytebytego"&gt;Bonus #1: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fe9062b4-fd0e-4530-8e20-eea854b8490e_2250x2814.png" alt="Top Strategies to Reduce Latency"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9c309ad3-78a8-4511-a6f2-e69c06d5c500_1280x1566.gif" alt="The Ultimate API Learning Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a44f9f4b-193d-484e-bbf1-169751104380_1280x1568.gif" alt="10 Essential Components of a Production Web Application"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d5155be3-163d-479c-a75e-632e0f98dd36_3006x3453.jpeg" alt="How do we design effective and safe APIs?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/aad520f5-00d9-4606-af4b-fdb5d1ac63c4_1600x1483.png" alt="Code First v.s. API First"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/bb375f63-bf06-4956-b3a3-914fd6aa2d91_1280x1664.jpeg" alt="Oauth 2.0 Explained With Simple Terms"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c1155e03-c3dc-4192-8e05-e6b87dc6a574_1280x1664.gif" alt="Session, Cookie, JWT, Token, SSO, and OAuth 2.0 Explained in One Diagram"&gt;&lt;/p&gt;
&lt;h3 id="bonus-2-other-interesting-links"&gt;Bonus #2: Other interesting links&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://openalternative.co/self-hosted" rel="noopener noreferrer"&gt;Self-hosted Alternatives to Popular Software&lt;/a&gt;&lt;/li&gt;
&lt;/ul&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 #1</title><link>https://miti99.com/en/post/2025/02/08/</link><pubDate>Sat, 08 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/08/</guid><description>&lt;i&gt;
Hello everyone, here I am returning to blogging after another long lazy streak :D
&lt;p&gt;One problem I&amp;rsquo;ve noticed about myself—but have been too lazy to fix—is that I read a lot of blog posts and tinker with plenty of tools, yet rarely dive seriously enough into any single topic to turn it into a high-quality standalone post. And even when I do find something I really like, I&amp;rsquo;m too lazy to write a full post about it.&lt;/p&gt;
&lt;p&gt;So I&amp;rsquo;m trying a different format: rounding up the interesting blog posts I&amp;rsquo;ve stumbled upon and read over the past week into a weekly newsletter. I hope you&amp;rsquo;ll support it.&lt;/p&gt;
&lt;p&gt;Without further ado, here is my Newsletter #1.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="seconds-since-the-epoch"&gt;&lt;a href="https://aphyr.com/posts/378-seconds-since-the-epoch" rel="noopener noreferrer"&gt;Seconds Since the Epoch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many people still believe that POSIX time (or Unix time) is the number of seconds elapsed since 00:00:00 on January 1, 1970. The author points out that this is not strictly true: the IEEE 1003.1 standard defines POSIX time in terms of UTC and assumes every day is exactly 86,400 seconds long. In reality, the length of a day varies over time, so astronomers periodically insert leap seconds into UTC to keep it from drifting too far from the solar day. As a result, at the time of writing (late 2024), the POSIX timestamp is 27 seconds behind the actual number of elapsed seconds, and every few years the POSIX clock jumps backward by a second—a quirk that has caused major outages across the Internet.&lt;/p&gt;
&lt;p&gt;The article quotes the standard&amp;rsquo;s rationale appendix, showing that the committee was well aware of this discrepancy yet deliberately ignored leap seconds to keep arithmetic simple. As for solutions, the author recommends using &lt;code&gt;CLOCK_MONOTONIC&lt;/code&gt; or &lt;code&gt;CLOCK_BOOTTIME&lt;/code&gt; when measuring intervals on a single machine; using TAI or GPS time if you don&amp;rsquo;t need to exchange timestamps with external systems; and smearing leap seconds over a longer window if you must stay compatible with POSIX-time systems. The post concludes by noting ongoing efforts to abolish leap seconds altogether, slated to take effect by 2035.&lt;/p&gt;
&lt;h2 id="b-trees-more-than-i-thought-i"&gt;&lt;a href="https://benjamincongdon.me/blog/2021/08/17/B-Trees-More-Than-I-Thought-Id-Want-to-Know/" rel="noopener noreferrer"&gt;B-Trees: More Than I Thought I&amp;rsquo;d Want to Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Drawing on Alex Petrov&amp;rsquo;s &lt;em&gt;Database Internals&lt;/em&gt;, the author revisits B-Trees from a practical engineering perspective rather than dry textbook formulas. The motivating question is straightforward: when a key-value dataset no longer fits in memory, how do you design a disk-friendly data structure? Because disk reads and writes are orders of magnitude slower than RAM and always operate on whole pages, an on-disk binary search tree (BST) costs roughly one disk seek per key comparison. B-Trees solve this by packing hundreds of keys into a single node (high fanout), allowing each disk read to cover many more key comparisons.&lt;/p&gt;
&lt;p&gt;The author then walks through concrete implementation details: slotted pages consisting of a header, data cells, and an offset pointer array so keys can be reordered without moving cell payloads; separator key truncation in internal nodes to pack more keys per page; overflow pages that keep prefixes of oversized keys in the main page so most queries avoid extra reads; and sibling pointers that allow range scans without traversing back up to parent nodes. The post wraps up with variants like Lazy B-Trees, FD-Trees, and Bw-Trees, concluding that while these implementation optimizations don&amp;rsquo;t change Big-O complexity, they make a massive difference to real-world database performance.&lt;/p&gt;
&lt;h2 id="sql-nulls-are-weird"&gt;&lt;a href="http://raymondtukpe.com/sql-nulls-are-weird.html" rel="noopener noreferrer"&gt;SQL NULLs are Weird!&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares a surprising behavior encountered while working on Convoy and LiteQueue: in SQL, &lt;code&gt;NULL = NULL&lt;/code&gt; evaluates to NULL rather than true, because NULL represents an unknown value. Consequently, under a UNIQUE constraint, every NULL is treated as distinct, meaning a column (or a composite constraint like &lt;code&gt;UNIQUE(email, deleted_at)&lt;/code&gt;) can still hold multiple &amp;ldquo;duplicate&amp;rdquo; rows whenever NULL is involved. This behavior is verified across SQLite, PostgreSQL, and MySQL, and SQLite&amp;rsquo;s own documentation acknowledges the inconsistency: NULL values are considered distinct in UNIQUE columns yet identical in &lt;code&gt;SELECT DISTINCT&lt;/code&gt; and &lt;code&gt;UNION&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;To enforce uniqueness properly, the post presents two approaches. The first adds a generated column using &lt;code&gt;COALESCE&lt;/code&gt; to replace NULL with a fixed sentinel value; however, this widens the table and still causes collisions if two rows share the same email and deletion timestamp. The second—recommended by the author—is a partial unique index on &lt;code&gt;email&lt;/code&gt; with &lt;code&gt;WHERE deleted_at IS NULL&lt;/code&gt;, which uses less space and is less error-prone because it constrains only active (non-deleted) rows. Additionally, modern relational databases support &lt;code&gt;IS [NOT] DISTINCT FROM&lt;/code&gt; for explicit NULL-safe comparisons.&lt;/p&gt;
&lt;h2 id="understanding-jvm-garbage-collector-performance"&gt;&lt;a href="https://mill-build.org/blog/6-garbage-collector-perf.html" rel="noopener noreferrer"&gt;Understanding JVM Garbage Collector Performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Li Haoyi&amp;rsquo;s post on the Mill blog explains JVM garbage collection (GC) from theoretical foundations to empirical benchmarks. The author starts with a simple copying GC: trace references from the roots to find live objects (the live-set), copy them to the empty half of the heap, and wipe the old half clean; this is contrasted with reference counting, which cannot compact the heap or reclaim cyclic references. Several key insights follow from this model: allocation is dirt cheap, pause times scale with the size of the live-set rather than the amount of garbage, and GC overhead shrinks as the total heap grows relative to the live-set.&lt;/p&gt;
&lt;p&gt;Benchmarks on Java 23 using G1 (the default GC) and ZGC confirm these takeaways. Adding more memory does not reduce individual pause times—it increases throughput by making collections less frequent; short-lived objects are collected much faster thanks to generational optimizations; and ZGC can bring pause times down to a few milliseconds if you are willing to provision roughly double the memory (with a heap at least four times the live-set, pauses drop to just a few milliseconds). The closing section offers practical advice: shrink the live-set by moving large datasets out of process (into SQLite, Redis, or Memcached), be careful with in-process LRU caches, and keep in mind that consolidating many small processes into one giant process can worsen GC pause times.&lt;/p&gt;
&lt;h2 id="a-deep-dive-into-jvm-start-up"&gt;&lt;a href="https://www.youtube.com/watch?v=ED1oc7gn5uY" rel="noopener noreferrer"&gt;A Deep Dive into JVM Start-Up&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Before the familiar &lt;code&gt;System.out.println(&amp;quot;Hello World&amp;quot;)&lt;/code&gt; line ever runs, the JVM has already done a tremendous amount of work behind the scenes. This presentation on the official Java YouTube channel walks through the entire JVM startup sequence: parsing command-line arguments, probing system resources, initializing the runtime environment, and then loading, linking, and initializing classes—everything the JVM must do to &amp;ldquo;create the universe&amp;rdquo; for your application.&lt;/p&gt;
&lt;p&gt;The final part of the video previews upcoming changes under Project Leyden, which promises substantial improvements to JVM startup time and warmup performance. It is a great reference for Java developers who want a deeper understanding of the core platform they rely on every day.&lt;/p&gt;
&lt;h2 id="parallel-processing-with-virtual-threads---a-comparative-analysis"&gt;&lt;a href="https://www.dhaval-shah.com/parallel-processing-virtual-threads-reactor-vs-jdk/" rel="noopener noreferrer"&gt;Parallel processing with Virtual Threads - A comparative analysis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Following up on an earlier post comparing parallel processing between Spring Core Reactor and JDK 21, the author evaluates both approaches when running on virtual threads. The article recaps the limitations of OS platform threads: heavy resource footprint, a bounded number of concurrent threads, reduced scalability under blocking operations, and expensive context switches. Virtual threads from Project Loom are managed by the JVM, making them cheap to create and block, capable of scaling to millions of threads, and ideal for I/O-heavy workloads. The author shares code for both implementations: one using JDK &lt;code&gt;CompletableFuture&lt;/code&gt; backed by a virtual-thread executor, and one using Reactor&amp;rsquo;s &lt;code&gt;Flux&lt;/code&gt; and &lt;code&gt;Mono&lt;/code&gt; scheduled on that same executor.&lt;/p&gt;
&lt;p&gt;Benchmarks over lists of 100,000, 250,000, and 500,000 objects show that the pure JDK version is dramatically faster than Reactor, with the gap widening as the dataset grows. In exchange, the JDK version consumes significantly more Old Gen memory and incurs higher GC pause times and GC CPU usage, though the author notes these do not meaningfully hurt application latency. The takeaway: with virtual threads, the standard JDK approach is the clear winner, whereas on traditional platform threads, Spring Core Reactor remains slightly faster.&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/2ae8b491-b794-446b-8ca5-25ac552161be_1417x1600.png" alt="A Cheatsheet On Message Queues"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/015e9750-7334-424b-b0c4-9c39bc5dd2d2_1600x1596.png" alt="From Monolith to Microservices: Key Transition Patterns"&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>