Java Singleton Approaches for Thread Safety

🤯 Yesterday I learned that ArrayList is dynamic… Today I explored how it actually grows internally in Java. Here’s the simple idea 👇 👉 ArrayList internally uses a normal array 👉 When the array becomes full, Java creates a new bigger array 👉 Old elements are copied into the new one 👉 Capacity usually increases by 1.5x Example: 10 → 15 → 22 → 33 This is what makes ArrayList flexible while still being fast. 💡 Key takeaway: ArrayList looks dynamic from outside, but internally it still depends on arrays + resizing logic. Small internal details like this make Java collections much more interesting. #Java #ArrayList #DSA #LearningInPublic

While Rustacions fight with the borrow checker at 2am, or Gophers try to figure out how to return or check those errors from every method, us Java people are sleeping soundly. During the day, we Java people try to figure out how to better serve the customer, deliver better features, and making our software more flexible. With #Java, we don't have to worry which CPU this is running on, or will be running in the future, whether to compile with debug or optimize, or wait for lengthy multi-platform native compilation.

🚀 Day 8/30 — LeetCode Challenge Solved "Swap Nodes in Pairs" on LeetCode using Java. This problem focuses on "rearranging node connections", not just swapping values — making pointer handling critical. Used a dummy node approach to simplify edge cases and ensure smooth pair-wise swapping. ✅ Key takeaway: Linked list problems are less about logic and more about **precise pointer management** — one wrong link can break the entire structure. #LeetCode #Java #LinkedList #DataStructures #ProblemSolving #Consistency

Day 94/100 – Consistency Journey Today’s focus: Strings in DSA + Java Multithreading Practiced string problems involving sliding window, two pointers, and pattern-based thinking. Realized how much efficiency improves when you move from brute force to optimized approaches. On the backend side, explored ExecutorService in Java — understanding how thread pools help manage multiple tasks efficiently instead of creating threads manually every time. Key takeaway: DSA builds problem-solving mindset, while backend concepts like multithreading show how things actually scale in real-world systems. Slowly connecting both worlds. Consistency > Motivation. #Day94 #100DaysOfCode #DSA #Java #BackendDevelopment #LearningInPublic

#Day88 of #100DaysOfCode Continued working on string manipulation in Java with a focus on problem-solving. Practiced: - Checking anagrams - Finding first non-repeating character - Implementing toggle case logic Focused on improving string handling and writing efficient solutions using loops and conditions. #Java #Strings #100DaysOfCode

Most Developers Use Java… But Few Understand Memory Layout In one interview, I was asked: “Explain Young Generation, Old Generation, and Eden Space.” I knew the terms. But explaining them clearly… was not easy. ** How JVM Memory Actually Works Java Heap is divided into: 🔹 Young Generation (where objects are born) This includes: 👉 Eden Space 👉 Survivor Spaces (S0, S1) Flow: New objects → created in Eden If they survive GC → move to Survivor Survive multiple cycles → move to Old Gen 🔹 Eden Space All new objects are created here Fills up quickly Triggers Minor GC 👉 Fast allocation 👉 Frequent cleanup 🔹 Survivor Spaces Objects that survive Eden GC Moved between S0 ↔ S1 👉 Helps track object age 👉 Decides promotion to Old Gen 🔹 Old Generation (Long-lived objects) Objects that survive multiple GC cycles Less frequent cleanup 👉 When full → Major GC (slow + expensive) 🔥 Why This Matters If you don’t understand this: You can’t debug memory issues You can’t understand GC pauses You can’t optimize performance 🧠 Simple Flow Eden → Survivor → Old Gen What happens when Old Generation becomes full? #Java #JVM #GarbageCollection #BackendEngineering #SoftwareEngineering #JavaDeveloper #Performance

Day 24 of Java Backend Journey 💻🔥 Built a Logger System using File Handling in Java! ✔️ Stored user input into files ✔️ Implemented append mode ✔️ Displayed logs dynamically Understanding how real backend systems store data step by step 🚀 #Java #BackendDevelopment #100DaysOfCode #LearningInPublic

Stop treating Thread states as a mystery. 🔍 We often talk about multithreading in Java, but how often do we really visualize the Thread lifecycle? When you understand the transition from NEW to TERMINATED, you’re not just memorizing states—you’re learning how to: ✅ Diagnose thread contention. ✅ Debug deadlocks effectively. ✅ Build more performant backend systems. In our latest "Backend Simplified" video, we break down the entire lifecycle. No fluff—just the core architecture you need to write production-grade concurrent code. If you are a student prepping for interviews or a dev looking to refine your concurrency skills, this one is for you. Watch it here: 👉 https://lnkd.in/gTQJVPRK What’s the most frustrating thread-state issue you’ve had to debug recently? Let’s discuss below! 👇 #Java #Concurrency #MultiThreading #BackendDevelopment #SoftwareEngineering #CareerGrowth #BackendSimplified

Java is called platform independent — but here’s what actually happens behind the scenes. When you compile Java code, it doesn’t turn into machine code. It becomes bytecode (.class file), which is not tied to any operating system. This bytecode runs on the JVM (Java Virtual Machine). Each OS has its own JVM, which converts the same bytecode into system-specific instructions. That’s why the same program runs everywhere without rewriting the code. Simple flow: Java Code → Bytecode → JVM → Machine Code It’s not magic — it’s smart design. #Java #JVM #Programming #SoftwareEngineering

Day 92 - LeetCode Journey Solved LeetCode 143: Reorder List in Java ✅ This problem looks tricky at first, but once you break it into steps, it becomes clean and elegant. The idea is simple: 1️⃣ Find the middle of the list (slow-fast pointers) 2️⃣ Reverse the second half 3️⃣ Merge both halves alternately That’s it. Three steps, one solid solution. Key takeaways: • Mastering slow & fast pointer technique • In-place reversal of linked list • Merging two lists efficiently • Breaking complex problems into smaller parts ✅ All test cases passed ⚡ O(n) time and O(1) space Problems like this build real confidence in linked lists 💯 #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney #InterviewPrep #Consistency #100DaysOfCode