Hi Java fellows 👋 and Spring enthusiasts 🌿, The releases of Spring Framework 7 (November 13th) and Spring Boot 4 (November 20th) are just around the corner, and here's what you should know: Spring Framework 7: ✅ Resilience features: RetryTemplate, @Retryable, @ConcurrencyLimit ✅ API Versioning ✅ Null Safety with JSpecify ✅ Programmatic Bean Registration ✅ HTTP Interface Client configuration .... Release note:🔗 https://lnkd.in/g7SfnbBk Spring Boot 4: ✅ HTTP Service Clients ✅ OpenTelemetry starter ✅ Improved Observability ✅ Native Image Improvements ... Release note: 🔗https://lnkd.in/gDcGR3KJ (Draft version) For a deeper dive into what's coming, check out the official "Road to GA Introduction" blog post here: https://lnkd.in/g3gXyEn6 Happy learning! 👨💻🎉 #SpringFramework #SpringBoot #Java #SpringFramework7 #SpringBoot4

Big news for the Java ecosystem! Spring applications are now officially null-safe, leveraging NullAway and JSpecify to eliminate what Tony Hoare called “the Billion Dollar Mistake” - the NullPointerException. Spring blog post by Sébastien Deleuze: https://lnkd.in/dnh5Qmc2 I’ve been actively contributing to NullAway (https://lnkd.in/dWUjYVdv) under Professor Manu Sridharan’s guidance, helping improve it's support for generics, strengthening NullAway's ability to better handle generics in large, production-grade codebases. Exciting times for the Java community! #Java #Spring

Are we finally fixing the billion dollar mistake? 👀 Spring Boot 4's null safety improvements might be the most underrated feature in the upcoming release. NonNull and Nullable annotations are now first-class citizens across the entire framework. Spring is migrating its entire codebase to use these consistently. No more guessing if that service method might return null. Your IDE catches NPEs at compile time, not runtime. Is this the correction Tony Hoare wished for? Not entirely, but it's a significant step toward safer Java code. The best part? You don't need to adopt it all at once. You can migrate incrementally, making your codebase safer and giving you more confidence with each step. #SpringBoot4 #Java #SpringFramework https://lnkd.in/g_xe72Jr

Don't miss my new blog post in the Road to GA series to learn how the Spring team empowers Spring developers to make their Spring Boot 4 application null-safe, to reduce or remove the risk of NullPointerException and to solve "the billion dollar mistake"! https://lnkd.in/dZ-Tj4FP #spring #java

🔥 Spring Boot 4: Real Null-Safety at Last! 🚀 For years, null in Java has been a guessing game. When you see a method like: User findUserByEmail(String email) Can it return null? Maybe. Maybe not. You guess, you hope, and sometimes… 💥 boom — a NullPointerException in production. With Spring Boot 4, that uncertainty is finally over. 👉 Thanks to @NullMarked, powered by JSpecify and NullAway, null-safety becomes explicit. Here’s what it means in practice: Add @NullMarked once at the package level Your IDE instantly shows you where nulls are risky The compiler helps you fix issues before they ever hit runtime No more gray areas. Every parameter, return type, and variable clearly tells you whether it can be null or not. Your code becomes more predictable, more readable, and above all — safer. 💡 Daily benefits: ✅ Fewer bugs and production surprises ✅ Clearer method contracts ✅ Self-documenting code ✅ Easier reviews and maintenance It’s a small change in syntax, but a huge leap for Java’s ecosystem. Finally, safety and clarity take the spotlight. Bonus: modern IDEs (IntelliJ, Eclipse, VS Code) already integrate perfectly with JSpecify and NullAway. You see warnings as you type — fix issues before they exist. In short, Spring Boot 4 doesn’t just add features — it upgrades the developer experience and makes your codebase trustworthy again. 💪 If you’re tired of endless Optionals, manual null checks, and unpredictable NPEs… #SpringBoot #Java #CleanCode #NullSafety #DeveloperExperience #SpringBoot4 #JSpecify #NullAway

🧠 Real-world lesson as a junior Java developer After a month of running perfectly, my Spring Boot app suddenly stopped working. The logs showed: java.sql.SQLNonTransientConnectionException: Socket fail to connect to host: localhost:3307 After hours of debugging, I realized the real issue wasn’t the database — it was Docker networking. Inside a container, localhost doesn’t point to the VM — it points to the container itself. 😅 💡 What I learned and fixed: Connected Spring Boot container to the correct Docker network Changed DB URL from localhost to db: jdbc:mariadb://db:3306/insurance_app Split configs into: application-properties application-local-properties application-prod-properties Used spring.profiles.active=prod for the right environment 🚀 Result: The app is up again — and I learned how critical Spring profiles, Docker networks, and environment separation are. A small crash turned into a big lesson. 💪 #Java #SpringBoot #Docker #Backend #LearningByDoing #DeveloperJourney

🚀 Spring Boot 4: Real Null-Safety at Last! For years in Java we’ve played the guessing game around null. When you see a method like: User findUserByEmail(String email) Can it return null? Maybe. Maybe not. You hope it won’t… and sometimes — 💥 boom — a NullPointerException in production. With Spring Boot 4, that uncertainty is finally over. Thanks to the @NullMarked support (via JSpecify & NullAway) the nullability of your APIs becomes explicit. Here’s what it means in practice: Add @NullMarked at the package level → by default, types are non-null unless annotated otherwise. The IDE (IntelliJ, Eclipse, VS Code) immediately shows where nulls are risky. The compiler and build tools (via NullAway) help you fix issues before runtime. Every parameter, return type and field clearly tells you whether it can be null or cannot. Your code becomes more predictable, more readable, and above all — safer. 💡 Daily benefits: ✅ Fewer bugs and production surprises ✅ Clearer method and API contracts ✅ Self-documenting code for teammates and reviewers ✅ Easier code reviews and maintainability ✅ Better interoperability (especially with Kotlin, which understands nullability) But null-safety isn’t the only upgrade in Spring Boot 4.0. Among other improvements: Baseline requirement of Java 17+ — unlocking records, sealed classes, pattern-matching, better performance. Enhanced native image and ahead-of-time (AOT) compilation support, making microservices start faster and use fewer resources. Improved API versioning support, so evolving REST-APIs become easier to maintain side-by-side. In short: Spring Boot 4 doesn’t just add features — it upgrades the developer experience and makes your entire codebase more trustworthy. 💪 If you’re tired of endless Optionals, manual null checks, and unpredictable NPEs — it’s time to take the leap. #SpringBoot #Java #CleanCode #NullSafety #DeveloperExperience #JSpecify #NullAway

Say goodbye to NullPointerException? Spring Boot 4 and JSpecify are changing the game. With the move to Spring Boot 4 (and Spring Framework 7), we're seeing a massive, deliberate shift towards compile-time null-safety. This isn't just about using Optional anymore. Spring is embracing JSpecify annotations (@NullMarked and @Nullable). This allows the framework and just as importantly, our own code to explicitly declare nullability contracts. What this means for developers: 1. Catching NPEs at Compile-Time: By integrating tools like NullAway, we can find and fix potential NullPointerExceptionsduring the build, not in production at 2 AM. 2. Cleaner, More Expressive APIs: Your code's public API now clearly states what's allowed to be null and what isn't. No more guessing. 3. IDE Superpowers: IDEs like IntelliJ IDEA can provide instant, accurate feedback, guiding us to write safer, more robust code from the first line. This is a huge step forward for production-grade Java applications. The "billion-dollar mistake" is finally getting a proper fix in the Spring ecosystem. What are your thoughts on this new approach to null-safety? #SpringBoot #Java #SpringFramework #NullSafety #JSpecify #Developer

𝗝𝗮𝘃𝗮 𝟮𝟭 – 𝗔 𝗡𝗲𝘄 𝗘𝗿𝗮 𝗕𝗲𝗴𝗶𝗻𝘀 Java 21 is redefining backend development! With Virtual Threads (Project Loom), we can now handle thousands of concurrent requests effortlessly. Add in Record Patterns and Pattern Matching, and your code becomes more elegant and readable. Developers can finally achieve scalability without complex async code. If you haven’t tried Java 21 yet, now’s the time! New features, virtual threads, record patterns “Have you tried Java 21 yet? Share your thoughts!” #Java21 #ModernJava #FullStackDevelopment #BackendEngineering