Day 12: Backend Journey Continues with LeetCode Challenge and Spring Boot Learning

🚀 Day 10: Classes & Objects – The Core of Object-Oriented Programming 💎🏗️ Today marks a significant step in my Java journey. I moved beyond writing simple logic and started understanding how to represent real-world entities in code using Classes and Objects. Here’s how I structured my learning: 🔹 1. Class – The Blueprint 📋 A class is a logical structure—a blueprint that defines what an object will look like. It contains: • Properties (State): Variables like name, age, etc. • Behaviors (Actions): Methods that define functionality 👉 Think of it as an architect’s design—you can’t live in it, but it guides construction. 🔹 2. Object – The Real Entity 🏠 An object is an instance of a class. It exists in memory and represents a real-world entity. Created using the new keyword: Car myCar = new Car(); 👉 If the class is the design, the object is the actual building. 🔹 3. Class–Object Relationship 🔗 • A class is defined once • Multiple objects can be created from it • Each object holds its own unique data 💡 Key Takeaway: Programming is not just about writing instructions—it’s about modeling the real world digitally using structured and reusable designs. I’m starting to see how powerful Object-Oriented Programming is in building scalable and maintainable applications. This feels like the foundation for becoming a strong backend developer. 💻 #JavaFullStack #OOP #ObjectOrientedProgramming #JavaDeveloper #CodingJourney #Day10 #BackendDev2026

🚀 Stop blindly using @Autowired on fields. It works… but it’s NOT the best way. Let’s understand why 👇 👉 There are 3 ways to inject dependencies in Spring: 1️⃣ Field Injection 2️⃣ Setter Injection 3️⃣ Constructor Injection ✅ (Recommended) --- 💡 Most beginners do this: @Service public class OrderService { @Autowired private PaymentService paymentService; } ❌ Problems: - Hard to test (no control over dependency) - Hidden dependencies - Breaks immutability --- ✅ Better approach → Constructor Injection: @Service public class OrderService { private final PaymentService paymentService; public OrderService(PaymentService paymentService) { this.paymentService = paymentService; } } ✔ Dependencies are explicit ✔ Easy to write unit tests ✔ Ensures immutability --- 🔥 Bonus (Spring Boot magic): If a class has ONLY ONE constructor → You don’t even need @Autowired 😮 Spring automatically injects it! --- ⚡ Real-world impact: In large projects: - Field injection → messy & hard to debug - Constructor injection → clean & maintainable --- ❌ Common mistake: Using @Autowired everywhere just because it’s easy --- 📌 Key Takeaway: “Convenience is not always best practice.” Always prefer Constructor Injection for clean and testable code. --- Follow for more real backend learnings 🚀 #SpringBoot #Java #CleanCode #BackendDevelopment #SoftwareEngineer

💡 Copilot feels faster… but Codex made me rethink AI coding in IntelliJ IDEA... I tested both on a real Spring Boot project with external JARs, Nexus dependencies, and internal SDKs. At first glance, they feel almost identical. Both speed up development. Both reduce boilerplate. But once you work with real complexity, especially external libraries, the difference becomes obvious. ⚡ Copilot = speed layer It works great for: boilerplate code quick methods inline suggestions But it mostly relies on visible context. With external dependencies, it doesn’t really “understand” what’s inside the libraries, you guide it more than it interprets them. 🧠 Codex = context layer On complex projects, it starts to: follow patterns across the codebase respect architecture and structure infer how external libraries are actually used reason across multiple files It doesn’t read JARs directl, but it reconstructs intent from how you use them. 💡 My takeaway: -Copilot helps you code faster. -Codex helps you think deeper. And the real insight is this: 👉 The cleaner your architecture and library usage, the more powerful both tools become. Curious how others see it: In real Spring Boot/enterprise projects, do you feel Copilot is enough, or does Codex add another layer of understanding? #AI #Java #SpringBoot #IntelliJIDEA #SoftwareEngineering #AI_Agent

🚀 #100DaysOfCode – Day 17 Consistency is turning into confidence. Showing up daily 🔥 ✅ What I accomplished today: 🧠 LeetCode Daily Challenge – XOR After Queries 📌 Problem Overview: You are given an array and a list of queries. Each query contains: left, right → range k → step increment value → multiplier 👉 For each query: ✔ Update elements from left to right with step k ✔ Multiply each selected element by value Finally, compute the XOR of the entire array 💡 My Approach (Simulation): 🔹 Iterated through each query 🔹 For every query: ✔ Started from left ✔ Jumped with step k until right ✔ Applied multiplication with modulo (10^9 + 7) 🔹 After processing all queries: ✔ Calculated final XOR of array ⚡ Time Complexity: 👉 O(Q * (N / K)) in worst case ⚡ Space Complexity: 👉 O(1) 🧩 Key Insights: ✔ Step-based traversal reduces unnecessary operations ✔ Careful handling of large numbers using modulo ✔ XOR aggregation at the end is straightforward but important ✔ Simulation works, but optimization scope exists (future improvement 🚀) 🔗 LeetCode Submission Link: https://lnkd.in/gZKCZf87 ☕ Spring Boot Learning – Lambda & Stream API Today I explored one of the most powerful features in modern Java 💡 📌 Key Concepts Covered: ✔ Introduction to Lambda Expressions ✔ Writing concise and readable functional code ✔ Using Stream API for data processing ✔ Performing operations like: filter() map() forEach() collect() ✔ Converting collections into streams for clean transformations 🌍 Why This Matters: ✔ Reduces boilerplate code ✔ Improves readability and maintainability ✔ Encourages functional programming style ✔ Makes data processing more expressive and efficient 🧠 Big Learning: Writing less code doesn’t mean doing less— it means writing smarter, cleaner, and more expressive code. 🔥 Learning Streak: Day 17/100 Discipline today → Results tomorrow 🚀 #100DaysOfCode #Java #SpringBoot #BackendDevelopment #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #LearningInPublic #Developers #Consistency #BuildInPublic

From user story → working Spring Boot API in minutes 🚀 No boilerplate. No manual setup. No repetitive coding. In this demo I’m using DevJAI CLI to generate a full backend from a simple user story: 👉 Paste a user story 👉 Select Codgen 👉 Let the engine generate everything 💥 Output includes: Controllers Services Repositories Models DTOs Mappers pom.xml Database + sample data And the best part 👇 👉 Import into IntelliJ 👉 Run 👉 Test instantly in Postman No manual wiring. No scaffolding. Just business logic → working API. This is how backend development should feel. Example user story used: "As a dealership manager, I want to manage cars, purchases and sales so that I can track inventory and transactions efficiently." ⚡ Result: fully functional REST API ready to use. #AI #SpringBoot #Java #BackendDevelopment #DeveloperTools #DevTools #Automation #Postman #IntelliJ #SoftwareEngineering #Startups #BuildInPublic

"TypeScript advanced generics and type inference are revolutionizing code reliability. Yet, many developers struggle to harness their full potential." When was the last time you reconsidered how you use generics in TypeScript? Many of us stick to the basics but miss out on the depth they offer. Type-level programming, especially with advanced generics and inference, can lead to more robust and maintainable code. After diving deep into some real-world projects, I've seen how leveraging these features transforms codebases. For instance, applying default generic values and using conditional types together can enable a highly flexible API design. Types become self-documenting, reducing the need for extensive documentation. Consider the power of leveraging type inference in complex type transformations. I've prototyped solutions using what I call "vibe coding," allowing the flow of development to guide the typing process, resulting in efficient workflows. Here's a quick demonstration with a simple utility type using TypeScript's conditional types and inference: ```typescript type FunctionReturnTypeT = T extends

🚀 I built an open-source library of Claude Code rules & skills to keep AI-assisted development consistent across all my projects. The problem: every time I started a new project, I was re-explaining the same conventions to Claude — Clean Architecture, SOLID, idiomatic Go, PEP 8, React hooks rules… over and over. The solution: my-rules-skills — a single .claude/ folder you drop (or symlink) into any project. Claude Code automatically picks up the rules and skills from there. What's inside: 📐 Shared rules (apply to every language) Clean Code (Uncle Bob) SOLID principles enforcer Object Calisthenics ⚙️ .NET — Clean Architecture with Brighter/Darker, Minimal API, C# conventions 🐹 Go — Effective Go + Google Style Guide: naming, concurrency, error handling, project structure 🐍 Python — PEP 8/257/20, type hints, logging, src layout, pyproject.toml + uv ⚛️ React — Component purity, hooks rules, feature-slice architecture, React Query, TypeScript Each language also ships with a skill — a step-by-step workflow Claude follows when you say "add a new feature", automatically covering domain → service → repository → handler → tests. How it works: # Drop it into any project (or symlink to keep rules in sync) ln -s ~/my-rules-skills/.claude ./. claude Rules activate automatically based on file type. Skills are invoked by name or by describing what you want to do. It's agnostic, extensible, and completely free. Add your own rules in Markdown — no config, no build step. 👉 https://lnkd.in/d-3uNxaf Would love to hear how others are managing Claude Code conventions across projects. Are you doing something similar? #ClaudeCode #AI #DeveloperTools #SoftwareEngineering #CleanCode #SOLID #dotnet #golang #Python #React #OpenSource

Solved LeetCode #237 – Delete Node in a Linked List Today I worked on an interesting linked list problem that challenges the usual way we think about deletion. Problem Insight : Normally, to delete a node in a linked list, we need access to the previous node. But in this problem, we are only given the node to be deleted, not the head or the previous node. Key Idea (Trick) : Instead of deleting the node directly, we: Copy the value of the next node into the current node Skip the next node Delete the next node This effectively removes the given node from the list. Code Explanation (Simple Way) void deleteNode(ListNode* node) { node->val = node->next->val; // Step 1: Copy next node's value ListNode* temp = node->next; // Step 2: Store next node node->next = temp->next; // Step 3: Skip next node delete temp; // Step 4: Delete it } Dry Run Example Linked List: 10 → 20 → 30 → 40 Given node: 20 After the operation: 10 → 30 → 40 We didn’t delete 20 directly. We replaced it with 30 and removed the original 30-node. Learning Outcome : This problem improves understanding of: Pointer manipulation In-place operations Thinking beyond traditional approaches “Focus on progress, not perfection — every solved problem counts.” #LeetCode #DataStructures #LinkedList #Cpp #CodingJourney #ProblemSolving #SoftwareDevelopment #TechLearning #CodingPractice #Developers #100DaysOfCode

🚀 #100DaysOfCode – Day 14 Consistency is turning into discipline. Small steps, every day 💯 ✅ What I accomplished today: 🧠 LeetCode Daily Challenge – Judge Route Circle 📌 Problem Overview: Given a string of moves consisting of U, D, L, R, determine: The robot starts at origin (0,0) Each move changes its position Goal → Check if it returns back to origin 💡 My Approach (Counting Logic): 🔹 Counted frequency of each move 🔹 Compared: ✔ Up vs Down ✔ Left vs Right 🔹 If both are equal → robot returns to origin ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(1) 🧩 Key Insight: This problem helped me understand: ✔ How simple counting can replace simulation ✔ Importance of balance conditions ✔ Writing clean and optimized logic ✔ Avoiding unnecessary computations 🔗 LeetCode Submission Link: https://lnkd.in/gvBucvjB ☕ Spring Boot Learning – Exception Handling 🔹 Today I learned how to handle errors effectively in Spring Boot 📌 Key Concepts Covered: ✔ Using @ExceptionHandler for handling specific exceptions ✔ Handling scenarios like Employee Not Found gracefully ✔ Returning proper HTTP status codes (404, etc.) ✔ Understanding how Optional can throw exceptions 🌍 Global Exception Handling: ✔ Learned @RestControllerAdvice for centralized handling ✔ Created a global exception layer ✔ Kept controllers clean and focused ✔ Explored validation annotations like @AssertTrue, @AssertFalse 🧠 Big Learning: A good backend is not just about success responses— it’s about how well you handle failures and edge cases. 📝 Spring Boot Notes: https://lnkd.in/gakX9V-X 🔥 Learning Streak: Day 14/100 Discipline > Motivation. Let’s keep building 🚀 #100DaysOfCode #Java #SpringBoot #BackendDevelopment #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #LearningInPublic #Developers #Consistency #BuildInPublic

Have you ever felt confused about how to represent a fixed collection of values? Tuple types in TypeScript can help you organize data more effectively! Labeled tuples take this a step further, allowing for better readability and understanding when working with multiple data points. ────────────────────────────── Mastering Tuple Types and Labeled Tuples in TypeScript Ever wondered how to use tuples effectively in TypeScript? Let's dive into the power of tuple types and how labeled tuples can enhance your code. #typescript #tuples #programming #coding #webdevelopment ────────────────────────────── Key Rules • A tuple type is defined by an array with fixed size and known types for each index. • Labeled tuples allow you to assign names to elements, improving code clarity. • Use tuples when you want a lightweight alternative to objects for structured data. 💡 Try This type User = [string, number]; const user: User = ['Alice', 30]; type LabeledUser = [name: string, age: number]; const labeledUser: LabeledUser = ['Bob', 25]; ❓ Quick Quiz Q: What is the main advantage of using labeled tuples? A: They enhance code readability by providing names for tuple elements. 🔑 Key Takeaway Embrace tuples and labeled tuples in TypeScript to make your data structures clearer and more manageable! ────────────────────────────── Small JavaScript bugs keep escaping to production and breaking critical user flows. Debugging inconsistent runtime behavior steals time from feature delivery.