Upgrading Java 8 to 17 and Spring Boot 3.5.4 for cleaner code and better defaults

Just wrapped up creating a presentation on REST APIs and revisited some key fundamentals: What REST really means HTTP methods (GET, POST, PUT, DELETE) Status codes & best practices Real-world API examples REST APIs are the backbone of modern web and mobile applications, especially in Java & Spring Boot ecosystems. Always feels good to strengthen the basics 💪 #RESTAPI #BackendDevelopment #Java #SpringBoot #WebDevelopment #Learning

☕ Why Using var Everywhere Can Hurt Java + Spring Boot Readability var makes Java code shorter but not always clearer. In Spring Boot projects, I’ve seen code like: 🔹 var data = service.process(input); 🔹 var result = repository.findById(id); Now the reader has to guess the type 😅 What this leads to: "Harder code reviews" "Slower onboarding" "Less readable business logic" What works better: ✅ Use var when the type is obvious ✅ Avoid var in public APIs and method returns ✅ Prefer explicit types for domain objects Shorter code is nice — understandable code is better. 👉 Readability always beats cleverness. #CoreJava #SpringBoot #CleanCode #BackendDevelopment #SoftwareEngineering

Automate the boring stuff: Seamless Maven & Java switching. If you are a Java developer, you know the struggle. You spend the morning working on a modern Spring Boot 3 application (Java 21 + Latest Maven). In the afternoon, you have to patch a legacy service (Java 8 + Maven 3.8). You switch the Java version using jEnv. You run the build. 💥 FAILURE. “Source option 5 is no longer supported.” “Class file version mismatch.” You forgot to downgrade Maven. Again. Context switching is expensive enough without our tools fighting us. I got tired of manually swapping paths every time I changed projects, so I wrote a bash script to do it for me. How it works: It hooks into my shell environment. Whenever jEnv detects a Java version change: It checks if I’m on a legacy version (JDK 1.8 or lower). If yes, it automatically points PATH to Maven 3.8.8 If I’m on a modern JDK, it swaps to Maven 3.9.12 No aliases. No manual exports. Just seamless switching. Here is the script. Save your brain cycles for the code, not the config. 👇 https://lnkd.in/g-WXpqNa #DevOps #Java #Productivity #Bash #DeveloperExperience #CodingLife

Recently, I integrated Java Virtual Threads (Project Loom) into my backend project to handle high-concurrency I/O operations more efficiently. 🔧 What I changed: • Replaced traditional thread pools with Virtual Threads • Used Executors.newVirtualThreadPerTaskExecutor() for async processing • Kept the code synchronous and clean, without reactive complexity 📈 Impact: • Better scalability for concurrent API calls • Reduced thread management overhead • Improved performance for I/O-heavy flows • Cleaner and more maintainable code 💡 Virtual Threads allowed me to scale without rewriting logic into complex async/reactive patterns. A simple change with powerful results! #Java #VirtualThreads #ProjectLoom #SpringBoot #BackendEngineering #Microservices

☕ A Core Java Habit That Improves Spring Boot Code Instantly One simple Core Java habit that quietly improves Spring Boot applications: Coding to interfaces, not implementations. Yet, many codebases still look like: 🔹 ArrayList everywhere instead of List 🔹 HashMap injected directly instead of Map 🔹 Concrete classes tightly wired into services This creates: 1 "Rigid code" 2 "Harder testing" 3 "Painful refactoring later" What works better: ✅ Depend on List, Set, Map in method signatures ✅ Let Spring decide the concrete implementation ✅ Swap implementations without touching business logic It’s basic Java but Spring Boot rewards it heavily. 👉 Flexibility starts with interfaces. #CoreJava #JavaInterfaces #SpringBoot #BackendDevelopment #CleanCode #SoftwareEngineering

While revisiting Java fundamentals, I bumped into javafx.util.Pair again ☕ A simple utility to hold two related values without creating a separate class. It’s straightforward and works well for: - Quick return values - Temporary grouping of data - Prototyping or internal utilities But it also made me pause and think, - getKey() and getValue() don’t convey domain meaning - JavaFX dependency just for Pair feels heavy in backend projects - A small, named class often reads better in business logic So while javafx.util.Pair is convenient, it’s not always the best design choice — especially in long-lived codebases. Re-learning these small details reminds me that good Java code is often about clarity, not shortcuts. Curious how others handle this — do you use Pair, or prefer explicit domain objects? #Java #JavaFX #CleanCode #BackendDevelopment #LearningInPublic

Day 17 / 100 Days of Java Today was about treating errors as first-class citizens, not afterthoughts. I implemented custom exception handling to enforce domain rules instead of letting invalid state silently pass through the system. Rather than relying only on built-in exceptions, I defined a meaningful custom exception and used it to validate inputs explicitly. The result is code that communicates intent, not just failure. This exercise reinforced an important principle: exceptions are not just for crashes — they are for protecting invariants. When validation logic is expressed through well-named exceptions, the code becomes easier to reason about, safer to extend, and harder to misuse. That’s the difference between defensive programming and disciplined design. I’m deliberately spending time here because robust systems fail in predictable ways — and Java gives you the tools if you use them correctly. On to Day 18. Still focused on foundations that scale. #Java #100DaysOfJava #ExceptionHandling #CleanCode #SoftwareEngineering #BuildInPublic

Loose Coupling in Spring — No Source Code Change Implemented true loose coupling in Spring where the injected bean is controlled externally, not hard-coded. ✔ Bean selection done via properties file ✔ Dynamic alias mapping in XML ✔ Dependency injected using @Qualifier ✔ Switched engine implementation without touching Java code 💡 Just update the property value → restart → different bean gets injected. This cleanly separates configuration from logic and makes the app flexible and maintainable. #Spring #Java #DependencyInjection #LooseCoupling #BackendDevelopment #LearningInPublic #GeeksForGeeks160Days #Day103

Your SDKs are more brittle than you think. We treat forward compatibility as an API versioning problem. But what happens when an API evolves faster than consumers can update their SDKs? The client breaks. At Speakeasy, we maintain that SDKs aren't just thin clients. They're products that deserve the same engineering rigor as the APIs they wrap. I've been working with Java SDKs, so I'll speak to the two common failure points in them, which are evolving enums and polymorphic responses (unions). A new enum value from the server shouldn't crash a client that hasn't updated yet. I wrote about the patterns we use: 1. Open Enums in Java: A class-based pattern for handling unknown enum values gracefully. 2. Java Unions with Jackson: Techniques for deserializing evolving union types without breaking. Links in the comment below. #Java #SDK #APIDesign #DeveloperExperience