Eliminating Null Checks with Java's Optional Class

📌 Spring Boot Annotation Series ✅ @PropertySource The @PropertySource annotation is used to load external property files into the Spring environment 👇 🔹 Why do we use @PropertySource? To read properties from a custom .properties file To keep configuration separate from code To manage different configuration files easily 🔹 When do we need @PropertySource? When properties are not in application.properties When using multiple property files When working with legacy or external config files 🔹 Simple example custom.properties :- app.name=MySpringApp app.timeout=30 Java code :- @Configuration @PropertySource("classpath:custom.properties") public class AppConfig { } Now these values can be accessed using @Value 👇 @Value("${app.name}") private String appName; 🔹 In simple words @PropertySource tells Spring where to load additional property files from. 👉 🧠 Quick Understanding Used to load custom .properties files Works well with @Value Usually placed on a @Configuration class #SpringBoot #Java #PropertySource #BackendDevelopment #LearningInPublic

Understanding `Optional` the Right Way 🚀 > “NullPointerException: the most thrown (and hated) exception in Java history.” Let’s talk about how `Optional` helps us write safer, cleaner code — when used properly👇 ✅ Why `Optional` exists: - It represents a value that might be absent — no more random `null` checks. - Encourages clear, intentional handling using methods like `isPresent()` and `orElse()`. ✅ Pro tips for clean usage: - Use `Optional` in return types — not in entity fields or constructor parameters. - Chain with `map()` and `filter()` for elegant transformations. - Avoid misusing it inside DTOs or collections (it adds unnecessary complexity). 🤔 How do you prefer handling optional values — traditional null checks or functional style? #Java #SpringBoot #ReactJS #FullStack #Coding

📖 My journey into Java Full Stack Development started with pen and paper. I captured every concept — from Java fundamentals to Spring Boot, React, and database integration — in handwritten notes to build a strong foundation. Today, I’m sharing the complete PDF of my handwritten notes ✨ These notes reflect the raw effort and persistence behind my learning process, and they’ve been invaluable in helping me transition into building backend APIs and frontend projects. Sometimes the simplest tools — pen and paper — are the most powerful for building lasting knowledge. 📌 Full handwritten notes PDF attached below. #Java #SpringBoot #React #FullStackDevelopment #Notes #LearningJourney #HandwrittenNotes

Open LinkedIn. See posts about Java 21. Spring Boot developers discovering Go concurrency after writing a new novel in com/ └── spring/ └── java/ └── enterprise/ └── holy/ └── scripture/ └── Main.java Absolute cinema.

STOP choosing between "Readable Code" and "High Performance." Java 21+ just ended that debate. ☕️ For years, Java developers faced a frustrating trade-off: 1️⃣ 𝐓𝐡𝐞 𝐒𝐢𝐦𝐩𝐥𝐞 𝐖𝐚𝐲: Write standard blocking code. It’s easy to debug but hits a "memory wall" because OS threads are heavy (~1MB each). 2️⃣ 𝐓𝐡𝐞 𝐑𝐞𝐚𝐜𝐭𝐢𝐯𝐞 𝐖𝐚𝐲: Use WebFlux or CompletableFuture. It scales beautifully but turns your codebase into "Callback Hell." 𝐄𝐧𝐭𝐞𝐫: 𝐉𝐚𝐯𝐚 𝐕𝐢𝐫𝐭𝐮𝐚𝐥 𝐓𝐡𝐫𝐞𝐚𝐝𝐬 (𝐏𝐫𝐨𝐣𝐞𝐜𝐭 𝐋𝐨𝐨𝐦). After 6 years of working with traditional threading, I’m finally seeing the "Third Way." 𝐖𝐡𝐚𝐭 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐜𝐡𝐚𝐧𝐠𝐞𝐝?  Traditional threads are like 𝐒𝐞𝐦𝐢-𝐓𝐫𝐮𝐜𝐤𝐬 - they take up massive space on the highway. Virtual Threads are like 𝐁𝐢𝐜𝐲𝐜𝐥𝐞 𝐂𝐨𝐮𝐫𝐢𝐞𝐫𝐬. They are managed by the JVM, not the OS. You can literally spawn MILLIONS of them on a single laptop. 💻 𝐓𝐇𝐄 𝐈𝐌𝐏𝐋𝐄𝐌𝐄𝐍𝐓𝐀𝐓𝐈𝐎𝐍 (𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝟑.𝟐+) The best part? You don't even need to change your business logic. 𝐁𝐄𝐅𝐎𝐑𝐄 (𝐓𝐫𝐚𝐝𝐢𝐭𝐢𝐨𝐧𝐚𝐥 𝐏𝐨𝐨𝐥𝐢𝐧𝐠):  You had to carefully tune your thread pool to avoid crashing your server. server.tomcat.threads.max: 200 𝐍𝐎𝐖 (𝐕𝐢𝐫𝐭𝐮𝐚𝐥 𝐓𝐡𝐫𝐞𝐚𝐝𝐬): One line of config tells Spring Boot to run every request on a new Virtual Thread. spring.threads.virtual.enabled: true 𝐓𝐡𝐞 𝐫𝐞𝐬𝐮𝐥𝐭? Your standard, easy-to-read @RestController can now handle 10,000+ concurrent requests without breaking a sweat. 𝐌𝐲 𝐓𝐚𝐤𝐞 : We spent a decade making code more complex to gain performance. Now, the JVM is doing the heavy lifting so we can get back to solving business problems. Are you already migrating to Java 21, or sticking with the "Tried and True" for now? Let’s discuss below! 👇 #Java #SpringBoot #ProjectLoom #BackendDevelopment #SoftwareArchitecture #Scalability

📌 Spring Boot Annotation Series – Part 7 ✅ @PropertySource The @PropertySource annotation is used to load external property files into the Spring environment 👇 🔹 Why do we use @PropertySource? To read properties from a custom .properties file To keep configuration separate from code To manage different configuration files easily 🔹 When do we need @PropertySource? When properties are not in application.properties When using multiple property files When working with legacy or external config files 🔹 Simple example custom.properties :- app.name=MySpringApp app.timeout=30 Java code :- @Configuration @PropertySource("classpath:custom.properties") public class AppConfig { } Now these values can be accessed using @Value 👇 @Value("${app.name}") private String appName; 🔹 In simple words @PropertySource tells Spring where to load additional property files from. 👉 🧠 Quick Understanding Used to load custom .properties files Works well with @Value Usually placed on a @Configuration class #SpringBoot #Java #PropertySource #BackendDevelopment #LearningInPublic

Many people write Java code without really understanding 𝘄𝗵𝗲𝗿𝗲 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗯𝗲𝗴𝗶𝗻𝘀. They know the line. They don’t know the reason. The 𝚖𝚊𝚒𝚗 method isn’t special because of magic. It’s special because the 𝗝𝗩𝗠 𝗻𝗲𝗲𝗱𝘀 𝗮 𝗰𝗹𝗲𝗮𝗿 𝗲𝗻𝘁𝗿𝘆 𝗽𝗼𝗶𝗻𝘁. When a Java program starts, the JVM looks for: • A class • A method with an exact signature • A predictable way to pass arguments That strictness isn’t accidental. It allows Java programs to: • Start consistently on any machine • Accept external inputs cleanly • Be managed by tools, frameworks, and servers The 𝚂𝚝𝚛𝚒𝚗𝚐[] 𝚊𝚛𝚐𝚜 part is often ignored, but it represents something important : your program doesn’t live in isolation. It can receive data from outside — commands, environments, systems. Understanding this changes how you see programs not as scripts, but as 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀 𝗶𝗻 𝗮 𝗹𝗮𝗿𝗴𝗲𝗿 𝘀𝘆𝘀𝘁𝗲𝗺. Today was about: • How the JVM locates the entry point • Why the 𝚖𝚊𝚒𝚗 method signature must be exact • How arguments connect your program to the outside world Once you know how a program starts, you write code with more intention. #Java #JVM #ProgrammingConcepts #SoftwareEngineering #DeveloperJourney #LearningInPublic

Java☕ — Reflection made frameworks less magical🪞 I used to wonder how Spring creates objects automatically. Then I discovered Reflection API. 📝Reflection allows Java to: ✅Inspect classes at runtime ✅Access fields & methods dynamically ✅Create objects without new #Java_Code Class<?> clazz = Class.forName("com.example.User"); Object obj = clazz.getDeclaredConstructor().newInstance(); That blew my mind. Realization for me: Frameworks use reflection to reduce boilerplate. 📝But also: ✅Slower than normal calls ✅Breaks encapsulation ✅Should be used carefully Reflection isn’t for daily coding. It’s for building libraries and frameworks. #Java #Reflection #AdvancedJava #BackendDevelopment

Hard truth: most Java teams waste weeks post-launch fighting startup time, memory bloat, and unpredictable latency. With Java 21 and Spring Boot 3, a focused checklist reduces cold-start by tens of percent and prevents the post-deploy scramble. Start with the problem: long cold starts, noisy GC, and thread contention. Practical first moves: adopt virtual threads for high-concurrency endpoints, trim the classpath, enable introspective native-image experimentation, and profile allocations during integration tests. These changes buy immediate operational wins without risky rewrites. Core Java — Focus on OOP design, immutable data, streams, exception handling, generics, collections, concurrency

While working with Java Streams, I came across this code: List<Integer> list = Arrays.asList(1, 3, 5, 7); Optional<Integer> max = list.stream().max((x, y) -> x > y ? x : y); At first glance, it looks like this should return 7. But this code is logically wrong, even though it compiles. ❌ What’s the real problem? The max() method expects a Comparator. A valid comparator must: return positive → first element is greater return 0 → both are equal return negative → second element is greater But this comparator: (x, y) -> x > y ? x : y returns actual values (x or y), not a comparison result. This violates the comparator contract. 🤯 What happens in reality? With the same input: [1, 3, 5, 7] Instead of always returning 7, this code may return: 1 3 5 or 7 (by coincidence) ⚠️ The result is unpredictable and JVM-dependent. ✅ Correct way to write it list.stream().max(Integer::compareTo); or list.stream().max(Comparator.naturalOrder()); Now the output is guaranteed: Optional[7] Code that compiles is not necessarily correct. Understanding method contracts matters more than clever one-liners. Small mistakes like this often decide interview outcomes. #Java #Streams #DSA #BackendDevelopment #CleanCode #LearningInPublic