Indexes Can Hurt Performance: A Cautionary Tale

🚀 Day 7 – Exception Handling: More Than Just try-catch Today I focused on how exception handling should be used in real applications—not just syntax. try { int result = 10 / 0; } catch (Exception e) { System.out.println("Error occurred"); } This works… but is it the right approach? 🤔 👉 Catching generic "Exception" is usually a bad practice 💡 Better approach: ✔ Catch specific exceptions (like "ArithmeticException") ✔ Helps in debugging and handling issues more precisely ⚠️ Another insight: Avoid using exceptions for normal flow control Example: if (value != null) { value.process(); } 👉 is better than relying on exceptions 💡 Key takeaway: - Exceptions are for unexpected scenarios, not regular logic - Proper handling improves readability, debugging, and reliability Small changes here can make a big difference in production code. #Java #BackendDevelopment #ExceptionHandling #CleanCode #LearningInPublic

👉Arrays vs ArrayLists. Looks similar. But difference matters! Many people start with Arrays. Fixed size. Simple syntax. Everything feels under control. Then comes ArrayList. Dynamic size. Easy to use. No need to worry about capacity. Sounds like ArrayList is better, right? Not always. That’s where the realisation comes in. 👉Arrays are faster. They use fixed memory. Better when size is known. 👉ArrayLists are flexible. They resize automatically. But come with slight overhead. Same data. Different behavior. And that difference shows up in performance. The real takeaway is simple. ✨Use Arrays when size is fixed and performance matters. ✨Use ArrayList when flexibility is needed. Don’t just learn syntax — understand use cases. 👉Because in the end, choosing the right structure > writing more code. 👉 When do you prefer Arrays over ArrayList? #DSA #Java #CodingJourney #SoftwareDevelopment #CareerGrowth

🚀 Day 60 of #100DaysOfCode Solved 100. Same Tree on LeetCode 🔗 🧠 Key Insight: Two trees are the same if: 👉 Their structure is identical 👉 Corresponding nodes have equal values ⚙️ Approach (Recursive DFS): 1️⃣ If both nodes are null → ✅ return true 2️⃣ If one is null and other is not → ❌ return false 3️⃣ If values are different → ❌ return false 4️⃣ Recursively check: 🔹 Left subtree → isSame(p.left, q.left) 🔹 Right subtree → isSame(p.right, q.right) 5️⃣ Return: 👉 leftCheck && rightCheck ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursive stack) #100DaysOfCode #LeetCode #DSA #BinaryTree #Recursion #DFS #Java #InterviewPrep #CodingJourney

What actually happens when you hit a REST API? 🤔 Let’s break it down step by step 👇 1️⃣ Client sends HTTP request 2️⃣ Request hits DispatcherServlet 3️⃣ HandlerMapping finds the correct controller 4️⃣ Controller processes request 5️⃣ Service layer applies business logic 6️⃣ Repository interacts with DB 7️⃣ Response is returned as JSON 💡 Behind the scenes: - Jackson converts Java → JSON - Spring handles dependency injection - Exception handling via @ControllerAdvice ⚡ Real benefit: Understanding this flow helps you: ✔ Debug faster ✔ Write better APIs ✔ Optimize performance Next time you call an API, remember — a lot is happening inside 🔥 Follow for more backend deep dives 🚀 #SpringBoot #Java #RestAPI #BackendDeveloper

𝐍+𝟏 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐢𝐧 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 – 𝐓𝐡𝐞 𝐇𝐢𝐝𝐝𝐞𝐧 𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐓𝐫𝐚𝐩 Fetching records looks easy… until Hibernate executes N+1 queries instead of one. • 1 query to fetch orders • N extra queries to fetch related data (like customers) Result? Slow performance & unnecessary DB load 𝐇𝐨𝐰 𝐭𝐨 𝐟𝐢𝐱 𝐢𝐭: Use JOIN FETCH Use @EntityGraph Use DTO projections Optimize your queries, not just your code! #SpringBoot #Java #Backend #Hibernate #PerformanceOptimization #CodingTips

Day 73 - Merge K Sorted Lists Understanding how to merge multiple sorted lists using an optimized approach. Approach: • Use a priority queue (min-heap) • Add the head of each list • Extract the smallest node • Add its next node back to heap • Repeat until heap is empty Key Insight: Heap helps always pick the smallest element among k lists efficiently Time Complexity: O(N log k) Space Complexity: O(k) #Day73 #LeetCode #Java #CodingPractice #TechJourney #DSA #LinkedList

🚀 Day 19 – map() vs flatMap() in Java Streams While working with Streams, I came across a subtle but important difference: "map()" vs "flatMap()". --- 👉 map() Transforms each element individually List<String> names = Arrays.asList("java", "spring"); names.stream() .map(String::toUpperCase) .forEach(System.out::println); ✔ Output: JAVA, SPRING --- 👉 flatMap() Flattens nested structures List<List<Integer>> list = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4) ); list.stream() .flatMap(Collection::stream) .forEach(System.out::println); ✔ Output: 1, 2, 3, 4 --- 💡 Key insight: - "map()" → 1-to-1 transformation - "flatMap()" → 1-to-many (and then flatten) --- ⚠️ Real-world use: "flatMap()" is very useful when dealing with: - Nested collections - API responses - Complex data transformations --- 💡 Takeaway: Understanding when to use "flatMap()" can make your stream operations much cleaner and more powerful. #Java #BackendDevelopment #Java8 #Streams #LearningInPublic

Some linked list problems go beyond simple pointers — they test how you handle multiple relationships between nodes. 🚀 Day 117/365 — DSA Challenge Solved: Copy List with Random Pointer Problem idea: We need to create a deep copy of a linked list where each node has an additional random pointer. Efficient approach: Use a HashMap to map original nodes to copied nodes. Steps: 1. Traverse the list and create a copy of each node 2. Store mapping: original → copy 3. Traverse again to assign next and random pointers 4. Return the copied head This ensures all pointers in the new list correctly reference copied nodes. ⏱ Time: O(n) 📦 Space: O(n) Day 117/365 complete. 💻 248 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #HashMap #LeetCode #LearningInPublic

I had an API that was “working fine”. But under load, response time spiked. Turned out I was fetching full entities when I only needed 3 fields. Switched to DTO projection. Same logic, much faster response. Lesson: don’t fetch what you don’t need. #Backend #SpringBoot #Performance #Java

Is REST really enough for everything… or are we just used to it? I’ve been working with GraphQL lately and spent some time exploring it in detail — and it definitely changed how I think about APIs. So I put together a PDF with what I learned, practical insights, and a few things that made me pause and rethink. Sharing it here — curious to know what you think: Is GraphQL actually better, or just another hype? #GraphQL #APIs #BackendDevelopment #TechDiscussion #Java #RestAPI