👋 Java Devs! Welcome to this weeks edition. We are closer to complete 100th edition.
This week we have packed agenda with covering variety of curated articles, videos. Engineers are talking about topics that are directly or indirectly related to AI + Java/Spring, along with some clean architecture and internals of JDK.
But before we dive in, quick news to share and an announcement. This week we crossed 8000 subscribers mark and feel like big achievement to reach here and able to build a community of 8000+ like minded engineers. Thank you so much for being so kind and supporting my articles.
If you are new here, i keep writing about Java & Spring Boot via articles or Interview Questions. If this interests you, consider becoming free or paid subscribers. Currently Founding member plan is active and you can become paid subscriber at $4/mo (with annual subscription).
Testimonials
This article explores how virtual threads have evolved since JDK 21 and explains why JDK 24's fix for thread pinning doesn't eliminate all production risks. Instead, the bottleneck shifts from thread pools to downstream resources like database connections, file descriptors, and rate limits. It also highlights why common ThreadLocal patterns become ineffective with virtual threads and recommends adopting Scoped Values for request context. The key takeaway is that virtual threads simplify concurrency, but production systems still need explicit resource limits, proper context propagation, and careful migration planning.
This talk demonstrates how to build serverless applications that can run across multiple cloud providers without changing business logic. Using Spring Cloud Function, Clean Architecture, and Gradle modules, the speaker isolates domain logic from cloud-specific services so the same application can be deployed to both AWS and Azure. The key takeaway is that portability comes from architectural boundaries and dependency injection—not avoiding cloud services altogether.
This tutorial explores Java's Ahead-of-Time (AOT) Cache, introduced in JDK 24 as part of Project Leyden to reduce JVM startup time by precomputing and storing class metadata. It explains how JDK 25 simplifies cache generation, while JDK 26 improves compatibility by removing earlier garbage collector limitations. The key takeaway is that AOT Cache can significantly improve startup and warmup times, but only when integrated thoughtfully into the build and deployment process.
This tutorial demonstrates how to build a fraud detection service entirely in Java using Deep Netts and Spring Boot, eliminating the need for a separate Python inference service. It covers training and serving the model in the same application, highlights why metrics like precision and recall matter more than accuracy for imbalanced datasets, and explains common production pitfalls such as deploying a model without its corresponding feature scaler.
This article explains how Spring Data JPA Specifications simplify building dynamic database queries without creating dozens of repository methods for every filter combination. By encapsulating each filter into small, reusable specifications, developers can compose queries at runtime using .and() and .or(), making search functionality far more flexible and maintainable. The article also covers joins, pagination, keyword search, and common pitfalls to avoid.
This article introduces Spring MockMvc, a testing framework that lets us verify Spring MVC controllers without starting a web server. By executing requests through the real DispatcherServlet while mocking the servlet container, MockMvc provides fast, reliable tests that cover request mapping, validation, serialization, and error handling.
This case study shows how a legacy SOAP middleware evolved to support both SOAP and REST without splitting into multiple services. Instead of hardcoding protocol-specific logic, the team made transport and authentication configurable, allowing the same application to communicate with different customers based on configuration alone. They also preserved their existing XSLT transformation pipeline by adding JSON conversion for REST integrations, avoiding a costly rewrite.
This article explains how to profile and analyze Spring application's startup process using the Spring Boot Actuator /startup endpoint. By enabling BufferingApplicationStartup, Spring records detailed startup events, bean initialization, and application lifecycle steps, making it easier to identify slow components and optimize startup performance. The article also demonstrates how to expose and inspect this data through Actuator, making it a valuable tool for diagnosing startup bottlenecks in complex Spring Boot applications.
📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.
Dan Vega demonstrates a practical workflow for using AI to perform dependency upgrades safely. Using Claude to upgrade a Nuxt application, he emphasizes reviewing release notes first, letting the AI generate a migration plan, working in a separate branch, and validating every step with local builds and preview deployments before merging. The key takeaway is that AI can significantly speed up low-risk upgrades, but for large enterprise codebases, deterministic tools like OpenRewrite remain a better choice due to their predictable, repeatable results.
This talk introduces HAT (Heterogeneous Accelerator Toolkit), an experimental Java project that enables developers to offload compute-intensive workloads to GPUs while writing only Java. Built on Project Babylon and Project Panama, HAT uses Java's reflection capabilities to generate optimized GPU code for backends like CUDA and OpenCL.
This Inside Java Podcast explores how HotSpot's Just-In-Time (JIT) compiler turns Java bytecode into highly optimized native machine code. Oracle compiler engineer Roberto Lozano explains core concepts including tiered compilation (C1 and C2), profiling, speculative optimizations, deoptimization, inlining, escape analysis, and scalar replacement. The discussion also highlights how techniques like fuzz testing, hardware-specific intrinsics, and upcoming projects such as Valhalla continue to push JVM performance forward, making it a great deep dive into the internals of Java execution.
In this episode, Josh Long reflects on Spring's evolution, from its early days to Spring Boot, cloud-native development, and now AI. He shares how developer advocacy, great documentation, and continuous community engagement played a major role in Spring's success, while explaining how Spring Boot simplified dependency management and developer productivity. Josh also discusses AI's impact on software engineering, arguing that frameworks like Spring become even more valuable as developers remain responsible for reviewing, integrating, and maintaining AI-generated code.
Spring Boot Interview: The Event That Lied About Being Saved
Spring Boot Interview Quiz : Why Is CPU Low but Latency High?
Spring Boot Interview Quiz: The Hidden Order of Your Beans
Spring Data JPA Interview Quiz : Why did Hibernate execute an UPDATE without calling save()?
Thats all for this week friends! Thanks for reading this far. If you liked it please like and share with your network.
📢 If you have a product or services that you like to present in front of 8000+ Java and Spring Developers , considering sponsoring this newsletter.
Happy Coding 🚀
Suraj
Subscribe | Sponsor us | LinkedIn | Twitter | Youtube
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.