Java's _ Variable: From Invalid to Intentional

Something weird happened while I was debugging a Java program today. I had a simple program running with multiple threads, and I printed the thread names just to see what was happening. The output looked something like this: main http-nio-8080-exec-1 http-nio-8080-exec-2 ForkJoinPool.commonPool-worker-3 At first I ignored it. But then I started wondering… Where are all these threads actually coming from? I didn’t create them. After digging a bit deeper, I realized something interesting. Modern Java applications are constantly using different thread pools behind the scenes. For example: • The web server creates request threads • "CompletableFuture" uses the ForkJoinPool • Some frameworks create background worker threads • The JVM itself runs internal service threads Which means even a “simple” backend service may actually be running dozens of threads at the same time. It made me realize something: A lot of complexity in backend systems isn’t in the code we write — it’s in the systems running around our code. Now I’m a lot more curious about what’s actually happening inside the JVM when our apps run. #Java #BackendEngineering #SpringBoot #SoftwareEngineering #LearningInPublic

Day 1/100 — What is Java? ☕ Most beginners start writing Java code without understanding what actually runs their program. Let’s fix that today. When you write Java code, it doesn’t directly talk to Windows or Mac. First, the code is compiled into a bytecode (.class file) . This bytecode is then executed by the JVM (Java Virtual Machine). The JVM acts like a translator between your program and the operating system. That's the reason Java follows the famous principle: “Write Once, Run Anywhere.” JVM vs JRE vs JDK • JVM → Executes Java bytecode • JRE → JVM + standard libraries (String, Math, Collections, etc.) • JDK → JRE + developer tools like javac compiler 👉 If you're a developer, always install the JDK because it includes everything needed to build and run Java programs. Today's Challenge 1. Install the JDK 2. Create a file HelloWorld.java 3. Compile using: → javac HelloWorld.java 4. Run using: → java HelloWorld For More Clarity Check Out this Vedio:- https://lnkd.in/g4Tp5UMp Post your output screenshot in the comments — I’ll check it! 👇 hashtag #Java #100DaysOfJava #CoreJava #JavaDeveloper #Programming #LearnInPublic

🚨 Java is finally fixing “final” — and it’s a BIG deal for backend devs For years, we trusted this: final String name = "Alok"; 👉 Meaning: this value will never change But under the hood… that wasn’t always true 😶 Using reflection: Field f = User.class.getDeclaredField("name"); f.setAccessible(true); f.set(user, "Hacked"); 💥 Your "final" field could still be modified No error. No warning. (Yes, since JDK 5!) --- 🤯 Why was this allowed? Because popular frameworks relied on it: • Jackson / Gson → deserialization • Hibernate → entity hydration • Mockito → mocking • Old DI → field injection 👉 Reflection made it possible to break immutability --- 🚨 What’s changing now? With Java 26 (JEP 500): ➡️ “Prepare to Make Final Mean Final” ✔️ Today: You’ll see warnings ❌ Tomorrow: It will be blocked (error) --- ⚠️ Why this matters This is not just syntax — it impacts: 🔹 Thread safety (immutability = safe concurrency) 🔹 JVM optimizations (compiler trusts "final") 🔹 Security (no hidden mutation) --- 🛠️ What you should do NOW ✅ Prefer constructor injection private final Service service; public MyClass(Service service) { this.service = service; } ✅ Use immutable DTOs (Java Records) public record UserDTO(String name, int age) {} ✅ Update libraries (Jackson, Hibernate, Mockito) ✅ Run your app on newer Java & check warnings --- 💡 Final Thought 👉 “final” was never truly final… until now. And honestly — it’s about time. --- #Java #SpringBoot #Backend #JavaDeveloper #CleanCode #JVM #Programming #SoftwareEngineering

🧠 JVM Memory & Garbage Collection Let me explain Java memory using your HOUSE as an example 🏠👇 🏠 JVM = Your House Your Java app lives here. Different rooms, different purposes. 📦 Heap = The Storeroom All objects go here. Never clean it? It crashes → OutOfMemoryError 💥 Heap has sections: 👶 Young Gen → new stuff (dies fast) 🧓 Old Gen → stuff you kept for years 🏷️ Metaspace → labels about your stuff 🪑 Stack = Your Desk Small, fast. Holds current work (method calls, local variables). Cleans itself when work is done. No GC needed! 🧹 Garbage Collection = Mom Cleaning Your Room “Do you still need this? No? GONE.” Java finds unused objects and removes them automatically. But sometimes GC yells: “EVERYBODY FREEZE while I clean!” ⏸️ These Stop-the-World pauses make apps laggy. 🔧 Choose Your Cleaner: 🟢 G1 → good all-rounder 🔵 ZGC → almost zero pauses 🟡 Shenandoah → low-latency beast 🔴 Serial → tiny apps only 📝 String Pool = Shared Notebook String a = “Hello”; String b = “Hello”; Java keeps ONE copy. Both point to it. Memory saved! 🎯 ⚡ Make Your App Faster: → Create only objects you need → Set unused objects to null → Close DB connections always → Remove unused listeners → Tune heap with -Xms and -Xmx → Profile with VisualVM or JConsole 🚨 Memory Leak Culprits: ❌ Unclosed DB connections ❌ Static lists that grow forever ❌ Listeners never unsubscribed ❌ Huge data in user sessions 🎯 Recap: 🏠 JVM = House 📦 Heap = Storeroom 🪑 Stack = Desk 🧹 GC = Auto cleaner 📝 String Pool = Shared notebook 🚨 Leaks = Stuff you forgot to toss Clean heap = Fast app 🏃💨 #Java #JVM #GarbageCollection #HeapMemory #JavaDeveloper #Programming #CodingTips #SoftwareEngineering #LearnJava #DevCommunity #100DaysOfCode #JavaPerformance #MemoryManagement #CleanCode #JavaInterview #BackendDevelopment

Blog: Some Benefits of Enabling Compact Object Headers in Java 25 for Streams There are signs. You just have to learn how to look for and read them. https://lnkd.in/e4ARCGbQ

"extends" vs "implements" in Dart — explained with my Java understanding Coming from Java, I used to think: → extends = class/abstract class → implements = interface class But in Dart, things are a bit different— in Dart ↓ extends → reuse + inherit behavior Just like Java: Child class gets all properties & methods You can override if needed Example: Dog extends Animal → Dog already has eat() and sleep() from Animal ✔️ Using this when I want code reuse ***But for "implements", here’s the twist in Dart ↓ In Java, we implement interfaces. But in Dart, there is no interface keyword to create a interface class. Here we can implement any class. When we use implements, we get no code and we must override everything manually It’s like saying: “I agree with your structure, but I’ll write my own logic.” Simple way to remember: extends → reuse code (like Java class inheritance) implements → follow rules (like Java interface) _____ Real-world use (Flutter thinking): extends → when building base classes or reusable logic like, extends "ChangeNotifier" for provider pkg. implements → when you want strict control or custom behavior like, when applying Dependency Inversion Principle or repository pattern. Once I connected this with Java, Dart OOP inheritance started making much more sense. #Flutter #Dart #Java #OOP #LearningInPublic

Remember a time when we all agreed that blocking JDBC couldn't possibly scale? Java 25 just changed the game. Between Virtual Threads and the latest JVM optimizations, the "simple" blocking pattern has been vindicated. We can finally have both i.e. our application scalability and our readable code, too. I just posted another update to my series on Non-Blocking vs. Blocking JDBC. After many years of tracking this, the answer seems to be Java 25. Check it out: https://lnkd.in/daW7aWrM #Java #Programming #Backend #TechTrends

🚀 Sealed Classes + Records in Java — Clean Code or Just Hype? Java 17+ introduced Sealed Classes and Records, and honestly, together they solve two very real problems we’ve all faced: 👉 Uncontrolled inheritance 👉 Boilerplate-heavy data classes 🔒 Sealed Classes — Finally, Control Over Who Can Extend public sealed interface Payment permits CardPayment, UpiPayment {} This ensures: ✔️ Only defined types can implement your interface ✔️ No unexpected extensions ✔️ Safer and more predictable domain models 📦 Records — Say Goodbye to Boilerplate public record CardPayment(String cardNumber) implements Payment {} public record UpiPayment(String upiId) implements Payment {} ✔️ Immutable by default ✔️ No getters / constructors / equals / hashCode needed ✔️ Perfect for DTOs, APIs, event-driven systems ⚡ Together — This is Where It Gets Interesting Sealed → controlled hierarchy Record → immutable data switch(payment) { case CardPayment c -> System.out.println(c.cardNumber()); case UpiPayment u -> System.out.println(u.upiId()); } 💡 The compiler knows all possible types → fewer bugs, cleaner logic 🤔 Now I’m curious… Are you using sealed classes in your projects? Where exactly? Have records replaced your DTOs, or are you still relying on Lombok/classes? Any real-world challenges with Spring Boot, JPA, or serialization? 👇 Would love to hear how you’re using these features in production #Java #Java17 #SealedClasses #Records #CleanCode #JavaDeveloper #BackendDevelopment #SoftwareEngineering #Microservices #APIDesign #CodingBestPractices #TechDiscussion

Day 7 of #100DaysOfCode — Java is getting interesting ☕ Today I explored the Java Collections Framework. Before this, I was using arrays for everything. But arrays have one limitation — fixed size. 👉 What if we need to add more data later? That’s where Collections come in. 🔹 Key Learnings: ArrayList grows dynamically — no size worries Easy operations: add(), remove(), get(), size() More flexible than arrays 🔹 Iterator (Game changer) A clean way to loop through collections: hasNext() → checks next element next() → returns next element remove() → safely removes element 🔹 Concept that clicked today: Iterable → Collection → List → ArrayList This small hierarchy made everything much clearer. ⚡ Array vs ArrayList Array → fixed size ArrayList → dynamic size Array → stores primitives ArrayList → stores objects Still exploring: Set, Map, Queue next 🔥 Consistency is the only plan. Showing up every day 💪 If you’re also learning Java or working with Collections — let’s connect 🤝 #Java #Collections #ArrayList #100DaysOfCode #JavaDeveloper #LearningInPublic

🚀 **Day 4/30 – LeetCode Java Challenge** Today’s problem pushed me to think beyond basic comparisons and focus on **pattern-based validation**. Worked on a string problem where the key insight was separating characters based on **even and odd indices**, then comparing frequency distributions instead of direct string matching. 📊 **Result:** ✔️ Accepted (752/752 test cases) ⚡ Runtime: 5 ms (Beats 93.81%) 💾 Memory: Efficient (Beats 86.60%) 💡 **What actually mattered today:** * Brute force thinking won’t scale — pattern recognition does * Breaking a problem into smaller logical groups simplifies everything * Frequency arrays can outperform more complex data structures when used correctly Let’s be real: This wasn’t a hard problem, but the approach matters. If you miss the pattern, you overcomplicate it. If you see it early, the solution becomes clean and efficient. Day 4 done. Still building consistency, still sharpening fundamentals. Archana J E Bavani k Deepika Kannan Divya Suresh Hari priya B Devipriya R Harini B Bhavya B Kezia H Vaishnavi Janaki #LeetCode #Java #DSA #ProblemSolving #Consistency #30DaysOfCode