Tom Cools’ Post

You can now optionally use Timefold Solver with java's modulepath, instead of the classpath (which is also still supported). This enables smaller builds.

✅ Java Features – Step 20: Sealed Classes (Java 17) 🔒 Java 17 introduced Sealed Classes, which allow you to control which classes can extend or implement a class/interface. Before this, any class could extend a public class. Example: public sealed class Shape permits Circle, Rectangle { } Only the permitted classes can extend Shape. final class Circle extends Shape { } final class Rectangle extends Shape { } Why this matters Gives better control over inheritance Improves code safety and design Useful for domain models with limited variations Real-world idea Imagine a payment system: sealed interface Payment permits CardPayment, UpiPayment, NetBanking { } Now only these payment types are allowed. Key takeaway Sealed classes help developers define strict class hierarchies and prevent unintended extensions. Next up: Pattern Matching for instanceof (Java 17) ⚡

Java 25 pattern matching in instanceof and switch With every new release in java numerous interesting features are being added.  Latest LTS java 25 has included pattern matching for primitive types in instanceof and switch(This feature is also available in non LTS versions 23 and 24). The biggest benefit a developer gets from this update is guarantee that there will not be any lossy conversion. A lossy conversion can lead to numerous bugs in the application. This makes a developers life easier. Example: int i = 1000; if (i instanceof byte) {   // false -- i cannot be converted exactly to byte   byte b = (byte)i;    // potentially lossy   ... b ... } can be written as if (i instanceof byte b) {   ... b ...        // no loss of information } because i instanceof byte b means "test if i instanceof byte and, if so, cast i to byte and bind that value to b". This is similar to reference type variable pattern matching. In the above example we can add a default condition in else when the type does not match any condition in if or in switch.  We will be seeing more changes in switch and instanceof in upcoming releases. The above being the latest one.

✅ Java Features – Step 22: Java 8 → Java 17 Recap 🚀 Over the past few posts, I’ve been revisiting some key Java features introduced from Java 8 to Java 17. A quick recap of the highlights: 🔹 Java 8 Streams API Optional Functional Interfaces Lambda Expressions 🔹 Java 9–11 Factory methods (List.of, Set.of, Map.of) var for local variable type inference New String methods (isBlank, strip, repeat) Modern HttpClient API 🔹 Java 14–15 Switch expressions Text blocks 🔹 Java 16–17 Records Sealed classes Pattern matching for instanceof Key takeaway Java has evolved significantly to: Reduce boilerplate Improve readability Support modern programming patterns Understanding these features helps write cleaner and more maintainable backend code. Next up: Practical examples of modern Java features in real backend applications ⚙️

💻 Starting My Spring Framework Learning Journey After learning Java web technologies and Hibernate, I recently started exploring the Spring Framework. Spring is one of the most popular frameworks in Java used to build robust and scalable applications. Before Spring, developing Java applications often involved writing tightly coupled code and managing objects manually. Spring helps solve this by providing a more structured and flexible way to build applications. In simple terms, Spring helps developers: ✔ Reduce complex and repetitive code ✔ Build loosely coupled applications ✔ Manage objects efficiently ✔ Improve application maintainability One of the key features of Spring is Dependency Injection, which allows objects to be provided from outside instead of creating them manually. Starting with Spring is helping me understand how modern Java applications are built in a cleaner and more scalable way. Looking forward to exploring more concepts like IoC, Beans, and Spring Boot. Beginning a new learning journey 🚀 Github link:- https://lnkd.in/dKrcejQw #Java #SpringFramework #BackendDevelopment #LearningJourney #SoftwareDevelopment

Java 26 update — simple but impactful (HTTP/3 support) Java 26 has introduced support for HTTP/3 — a small change on the surface, but important behind the scenes. 💡 In simple words: When apps talk to each other (APIs), they use HTTP. Earlier Java supported: 👉 HTTP/1.1 & HTTP/2 (TCP-based) Now Java 26 supports: 👉 HTTP/3 (QUIC-based) → faster & more stable communication 📱 Real-life example: Earlier → API calls could slow down under heavy load Now → faster, smoother, and more reliable responses 💻 Code difference (simple view): 👉 Earlier (Java ≤25): HttpClient client = HttpClient.newHttpClient(); 👉 Now (Java 26 — conceptually HTTP/3 supported): HttpClient client = HttpClient.newBuilder() .build(); 💡 Same code, but better performance with HTTP/3 under the hood. 💭 My takeaway: No major code change… but a big improvement in performance and reliability Good to see Java evolving with modern needs 👍 Have you explored Java 26 yet? #Java #Java26 #HTTP3 #BackendDevelopment #Microservices #Programming

Java 26 will be supported for just six months, until the release of Java 27 later this year. The next LTS (long-term support) Java release is expected to be Java 29 in September 2027. https://lnkd.in/g-TERN6m

Major Java changes vs minor updates Java 8 → Java 11 → Java 17 brought long-term support (LTS), modular system, var, records, sealed classes, pattern matching, etc. These changes are great for new projects or major refactoring. But for most backend systems, business apps, or microservices: the core APls and performance are stable across versions. • When it actually matters Starting a new project that can leverage modern syntax and APIs. Using features like virtual threads or new memory models in high-concurrency apps. Migrating off old versions due to security or support end-of-life. • Bottom line: For 90% of existing projects, upgrading Java version is optional. Stability, proven libraries, and team familiarity often outweigh shiny new features. So next time someone asks "Do we really need Java 21?" think: do we benefit from new features, or just chasing the version number?

𝗘𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗼𝗳 𝗝𝗮𝘃𝗮: Key Features Across Versions 🔹 Java 8 (2014) – LTS A revolutionary release that introduced Lambda Expressions and the Streams API, enabling functional-style programming in Java. Added Optional to reduce null-related errors, a modern Date-Time API, and default & static methods in interfaces for better flexibility. 🔹 Java 11 (2018) – LTS Focused on long-term stability and performance. Introduced a modern HttpClient API, var in lambda parameters, and new String utility methods like isBlank(), lines(). Also removed outdated modules (like Java EE), making the JDK more lightweight. 🔹 Java 15 (2020) Improved developer productivity with Text Blocks for cleaner multi-line strings. Introduced Sealed Classes (preview) to better control class hierarchies and Hidden Classes for frameworks. Enhanced Z Garbage Collector (ZGC) for low-latency applications. 🔹 Java 17 (2021) – LTS A major LTS release bringing Sealed Classes to standard, Pattern Matching for instanceof, and improved switch expressions (preview). Also enhanced security, performance, and long-term maintainability for enterprise systems. 🔹 Java 21 (2023) – LTS One of the most impactful releases with Virtual Threads (Project Loom), enabling scalable and lightweight concurrency. Added Record Patterns and Pattern Matching for switch, along with Sequenced Collections for more consistent data structures. 🔹 Java 25 (2025) – LTS Continues to evolve with refinements in concurrency, pattern matching, and performance optimizations. Focuses on improving developer experience, scalability, and modern application needs, building on features like virtual threads and structured concurrency. #Java #JavaDeveloper #Programming #SoftwareDevelopment #Coding #BackendDevelopment #LearnToCode

Want to create a Java object? You need a Constructor. A Constructor is the very first function that runs when an object is born. One simple line of code and your object is ready. If Java concepts confuse you, start here. This explanation makes it all make sense!