Spring REST + DSA Practice Improves Backend Fundamentals

🚀 Day 2 — Debugging > Coding Today was less about writing code and more about understanding how things actually work. 🧠 DSA: - Started Sliding Window pattern - Practiced reducing brute force → O(n) using window techniques ⚙️ Backend (Spring + Caching): - Debugged a tricky issue with caching - Learned the difference between in-memory cache vs Redis cache - Faced a ClassCastException due to cache schema mismatch (String vs Object) - Understood how Spring caching works internally (proxy-based) 🛠️ Project (URL Shortener): - Fixed caching layer to correctly store shortCode → Url mapping - Ensured proper redirect behavior using cached data - Improved overall flow and reliability 📌 Key learning: It’s easy to write code when things work. Real growth happens when things break and you debug them. #Java #SpringBoot #BackendDevelopment #DSA #LearningInPublic

📘 OOPs… or “How Java made my life both easier and confusing” 😄 Initially, I thought: 👉 “OOPs means just writing code using objects instead of functions… simple!” Then I started digging deeper 👇 🚗 The example that clicked for me: Car = Object ✔ Properties → color, speed, fuel ✔ Behaviors → start(), accelerate(), brake() 💻 So in Java: 👉 We create a class (blueprint) 👉 Then create an object using the new keyword Simple understanding: 📄 Class = Plan 🚗 Object = Real thing 💡 Then came the famous 4 pillars (things got interesting 😅): ✔ Inheritance → Child class takes parent features ✔ Abstraction → Hide complexity, show only what's needed ✔ Polymorphism → One method, many forms ✔ Encapsulation → Protect data using getters/setters 😵 My realization: Before OOPs → Messy code After OOPs → Organized… but requires thinking 😄 🔥 Why OOPs actually matters: ✔ Easier to understand ✔ Code reuse (no need to rewrite logic) ✔ More secure ✔ Easy to scale (future features become manageable) 💭 Lesson learned: “OOPs is not just coding… it’s a way of thinking.” Still learning… but improving step by step 🚶♂️ #Java #OOP #Learning #BackendDeveloper #CodingLife

Day 2 of My 100‑Day DSA Challenge Today, I revisited and fully solved the Contains Duplicate (LeetCode 217) problem using Java. This time, I focused on optimizing the solution after understanding where my initial brute‑force approach fell short. - What I learned today: Time complexity matters: My first solution used nested loops (O(n²)), which passed smaller test cases but failed with Time Limit Exceeded (TLE) on large inputs. Hashing for efficiency: I learned how hashing converts values into consistent “indexes,” enabling O(1) average lookup using a HashSet. Collision handling: I explored how chaining (linked‑list buckets) is used in Java’s HashSet to handle collisions. Even when two keys hash to the same bucket, the structure remains efficient in practice. - How I solved the problem: Started with brute‑force: two nested loops to compare each element with every other. It worked for small arrays but TLE on 70+ / 77 test cases. Analyzed the bottleneck and realized that repeated lookups were the main cost. - Switched to a HashSet‑based solution: Iterate through the array once. For each number, check if it is already in the HashSet. If yes → return true (duplicate found). If no → add it to the HashSet and continue. This reduced the time complexity to O(n) and passed all 77 test cases. Moving forward Planning to solve 2–3 more easy‑medium DSA questions on LeetCode tomorrow. Still strengthening Java fundamentals side‑by‑side: syntax, data structures (HashSet, HashMap, arrays, etc.), and problem‑solving patterns. If you’d like to see the final optimized code or the list of 100 MAANG‑focused questions, feel free to DM me! #DSA #LeetCode #100DaysOfCode #Java #Hashing #Coding #SoftwareEngineering #MAANG #Developer #Google

🚀 #Day31/300 — Mastering DSA Challenge Continuing my 300-day journey to strengthen my Data Structures & Algorithms skills using Java. 📌 Daily Goals • Solve at least 1 problem every day • Focus on pattern recognition and optimized solutions • Share consistent learning updates along the journey 🧠 Today’s Problem: Smallest Range in K Lists Solved this problem using a Min Heap (Priority Queue) approach along with tracking the current maximum element. The idea is to always consider one element from each list and minimize the range between the minimum and maximum values. 💡 Key Takeaways: • Use Min Heap to track the smallest element among K lists • Keep updating the current maximum to calculate range • Helps in solving multi-pointer problems efficiently • Time Complexity: O(n log k) This problem strengthened my understanding of heap-based merging, range optimization, and handling multiple sorted lists. Staying consistent and improving every day in this 300-day DSA journey. 💪 #DSA #Java #ProblemSolving #BackendDeveloper #FullStackDeveloper #300DaysChallenge #LearningInPublic #Heap #PriorityQueue #Algorithms #SDE #React #ReactNative #JavaFullStack #SpringBoot

Understanding OOPS is not just about theory—it’s the foundation of writing clean, scalable, and maintainable code. While revisiting core concepts in Java, I realized how powerful these principles are in real-world development: • Objects & Classes help us model real-world problems into code • Encapsulation keeps data secure and structured • Abstraction hides complexity and improves usability • Inheritance promotes code reusability • Polymorphism makes systems flexible and dynamic What stood out the most is how these concepts simplify complex systems and make code easier to maintain over time. For example, just like an ATM hides internal operations from users, abstraction allows developers to focus only on what’s necessary—improving both usability and design. Mastering OOPS is not optional if you want to build real-world applications—it’s essential. Still learning, still building 🚀 #Java #OOPS #Programming #SoftwareDevelopment #CodingJourney

Resharing this as I recently revised OOPS during my placement preparation. I used to think OOPS was just theoretical, but now I see how it actually helps in writing clean and structured code. Concepts like Encapsulation and Abstraction made a big difference in how I understand problems, while Inheritance and Polymorphism help in writing reusable code. Currently focusing on strengthening my fundamentals along with DSA. What OOPS concept do you find most useful? #Java #OOPS #Placements #CodingJourney

# Day 1 of My Journey: Multithreading → Reactive Programming → WebFlux → Rate Limiter If you want to truly understand Reactive Programming, you cannot skip Multithreading. So I decided to start from the basics instead of jumping directly into frameworks  @ Phase 1: Multithreading (Current Focus) Today, I started learning: What is a thread and why it’s expensive How blocking operations waste threads Thread pools & Executor Framework Why thread-per-request model fails under high load @Reality Check Reactive programming is not magic. If you don’t understand: How threads work How thread pools get exhausted Why blocking kills performance  You will never truly understand WebFlux. @ Why I’m doing this? Because I want to understand:  Why applications crash under high concurrency  How modern systems handle millions of requests  How to design scalable backend systems @ What’s next? After multithreading, I’ll move to:  Reactive Programming (non-blocking mindset)  WebFlux & Event Loop Model  Reactive Redis  Build a Production-Level Rate Limiter @ End Goal To build high-performance systems that can: Handle massive traffic Avoid thread bottlenecks Implement smart control using Rate Limiting  I’ll share this journey step by step. If you're learning backend, scalability, or system design — follow along. #Day1 #Multithreading #ReactiveProgramming #WebFlux #RateLimiter #Java #BackendDevelopment #LearningInPublic

📘 DSA Journey — Day 37 Today’s focus: Binary Search with APIs / decision functions. Problems solved: • Guess Number Higher or Lower (LeetCode 374) • First Bad Version (LeetCode 278) Concepts used: • Binary Search • Decision-based search (using API feedback) • Search space reduction Key takeaway: Both problems are classic examples of binary search on answers using an external API. In Guess Number Higher or Lower, we use the guess() API: • If guess is too high → move left • If too low → move right • If correct → return mid In First Bad Version, we use the isBadVersion() API: • If current version is bad → search left to find the first occurrence • Else → search right The key idea is: We don’t know the exact value, but we can narrow down the search space based on feedback. This pattern is useful in problems where: • A condition is monotonic (false → true transition) • We need to find the first/last occurrence of a condition Time complexity remains O(log n). Continuing to strengthen binary search intuition and consistency in problem solving. #DSA #Java #LeetCode #CodingJourney

💡 Understanding the 4 Pillars of OOPS in Java In my previous post, I introduced OOPS. Now let’s dive into its core concepts that make Java powerful and scalable 🚀 🔹 1. Encapsulation Encapsulation means wrapping data (variables) and code (methods) together in a single unit (class). 👉 It helps in data hiding and protecting sensitive information. Example: Using private variables with getters & setters. 🔹 2. Inheritance Inheritance allows one class to acquire properties and behavior of another class. 👉 Promotes code reuse and reduces duplication. Example: class Dog extends Animal 🔹 3. Polymorphism Polymorphism means “many forms.” 👉 The same method can behave differently based on the context. Types: ✔ Method Overloading (Compile-time) ✔ Method Overriding (Runtime) 🔹 4. Abstraction Abstraction means hiding implementation details and showing only essential features. 👉 Focus on what an object does, not how it does it. Example: Abstract classes & interfaces. 💭 Mastering these concepts helps you write clean, scalable, and maintainable code—especially in real-world applications like Spring Boot & Microservices. #Java #OOPS #ObjectOrientedProgramming #Programming #Coding #SoftwareDevelopment #BackendDevelopment #LearnJava #CodeBetter #TechLearning #DeveloperLife #ProgrammingConcepts #JavaDevelopment

After one month in the Web Development + AI Bootcamp at @TuwaiqAcademy, we moved from Java basics into Spring Boot — and one thing became clear: Validation is not optional. It’s fundamental. At first, I was writing manual checks like: if(name.isEmpty()) { ... } That works… but it doesn’t scale and quickly turns messy. Now using annotation-based validation in Spring Boot: - @NotNull - @Size(max = 100) - @Min / @Max The difference is obvious: Cleaner code, better structure, and proper separation of concerns. Instead of mixing validation with business logic, everything becomes more maintainable. Next step: Handling validation errors properly and returning meaningful API responses instead of generic 400 errors. This is where backend development starts to feel real. #TuwaiqAcademy #Java #SpringBoot #BackendDevelopment #SoftwareEngineering