Tiago Ferezin’s Post

One underrated feature of Java 17 is Sealed Classes, which allow you to define a closed set of implementations. Why is this important? - It enables stronger domain modeling. - It ensures safer refactoring. - It results in cleaner pattern matching. - It enhances maintainability. For example: public sealed interface Result permits Success, Failure {} With this approach, your system recognizes all possible outcomes. When combined with modern switch statements, the compiler can check for exhaustiveness. This development signifies Java's progression towards algebraic data types in a safe and incremental manner. Modern Java is no longer verbose; it is intentional. #Java #Java17 #BackendDevelopment #CleanCode #SoftwareArchitecture

Records in Java are used to create immutable data objects with minimal code. They automatically generate constructors, getters, equals(), hashCode(), and toString(). Unlike traditional bean classes, they eliminate boilerplate and improve readability.Records are best suited for DTOs and data carriers in modern applications. Java 14 → Preview Java 15 → Preview (second iteration) Java 16 → Official release #java #java16 #java17

🚀 Day 14/180 | #180DaysOfCode 📍 LeetCode | 💻 Java Solved: 3162. Find the Number of Good Pairs I Used a nested loop (brute-force) approach to check divisibility condition nums1[i] % (nums2[j] * k) == 0 for all possible pairs. ⏱️ Time Complexity: O(n × m) 📦 Space Complexity: O(1) Strengthening fundamentals by mastering basic logic and edge cases before jumping into optimizations. 💪 Consistency + clarity = long-term growth 🚀 #DSA #LeetCode #Java #CodingJourney #Consistency

Day 84/365 ✔️ Solved LeetCode 26 – Remove Duplicates from Sorted Array using Java. A classic two-pointer problem that looks simple but really tests how well you handle in-place updates. Key takeaways from today: • Leveraged the two-pointer technique • Modified the array in-place with O(1) extra space • Preserved the relative order of elements • Reinforced how sorted arrays simplify logic Consistency > intensity. One problem a day, building strong fundamentals. On to the next 🚀 #Day84 #365DaysOfCode #LeetCode #Java #DSA #TwoPointers #ProblemSolving #Consistency

Java 21+ Features Hack 🚀 Java devs, if you're still on Java 17 or earlier in 2026, you're missing game-changers from Java 21+! I just refactored a legacy Spring Boot microservice using Virtual Threads (Project Loom) and pattern matching in switch expressions — load times dropped 40%, and my code went from 200+ lines to under 100. Here's a quick breakdown: Virtual Threads: No more blocking I/O nightmares. Thread.ofVirtual().start(() -> { /* your async magic */ }); handles thousands of concurrent requests without thread pool exhaustion. Records + Pattern Matching: if (obj instanceof Point(int x, int y)) { return x + y; }—bye-bye verbose getters/setters! Sequenced Collections: List.of(1,2,3).getFirst() and getLast() for cleaner list ops. Pro tip: Pair this with Spring Boot 3.3 for auto-config magic. Who's experimenting with these? Drop your wins or gotchas below—I’m all ears! #Java21 #SpringBoot #BackendDev #java #knowledge #Features

🚀 Starting My Java Revision Journey Today I revisited Java fundamentals to strengthen my backend foundation. Topics covered: ✔ JDK vs JRE vs JVM (Compilation & Execution Flow) ✔ Primitive vs Non-Primitive Data Types ✔ Wrapper Classes & Autoboxing / Unboxing ✔ Variable Scope & Memory Basics (Stack vs Heap) ✔ Operators & Type Promotion ✔ Control Statements & Loop Execution Flow Understanding how Java actually works under the hood makes writing clean code easier. Strong fundamentals build scalable backend systems. Consistency > Motivation. Day 1 complete. On to deeper concepts next 💪 #Java #BackendDevelopment #SpringBoot #FullStack #JVM #SoftwareEngineering #DailyLearning

Day 18 of #100DaysOfLeetCode 💻✅ Solved #24. Swap Nodes in Pairs problem on LeetCode in Java. Approach: • Checked edge cases where list is empty or has only one node • Used pointer manipulation to swap adjacent nodes instead of modifying values • Maintained a previous pointer to connect swapped pairs correctly • Updated links step-by-step to ensure list continuity • Returned new head after first pair swap Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.41 MB Key Learning: ✓ Strengthened understanding of linked list pointer manipulation ✓ Learned how to safely swap nodes without changing node values ✓ Improved confidence in handling multi-pointer problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Day 20 of #100DaysOfLeetCode 💻✅ Solved #21. Merge Two Sorted Lists problem on LeetCode in Java. Approach: • Handled edge cases where either list is empty • Used a dummy node to simplify merging logic • Maintained a pointer current to build the new list step-by-step • Compared nodes from both lists and linked the smaller one • Connected any remaining nodes after one list ends • Returned dummy.next as the new head of the merged list Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 44.26 MB (Beats 75% submissions) Key Learning: ✓ Strengthened understanding of linked list pointer manipulation ✓ Learned to merge two lists without creating extra nodes ✓ Improved confidence in multi-pointer problems and list traversal Learning one problem every single day 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Multithreading sounds cool… until you debug it. When I first learned about threads in Java, it felt powerful. “Wow, my program can do multiple things at once!” Then I tried implementing it in a real scenario. And everything broke. 🔹 Random output order 🔹 Unexpected data changes 🔹 Sometimes it worked… sometimes it didn’t 🔹 No errors. Just wrong results. That’s when I understood: Multithreading isn’t about running code faster. It’s about managing shared resources safely. I learned the hard way about: • Race conditions • Synchronized blocks • Deadlocks • Thread lifecycle • ExecutorService The biggest realization? Concurrency bugs are the most dangerous because they don’t fail consistently. Now, whenever I write multithreaded code, I ask: 👉 What data is shared? 👉 Who can modify it? 👉 What happens if two threads access it together? Multithreading is powerful. But discipline makes it reliable. #Java #Multithreading #BackendDevelopment #LearningInPublic