Mastering Polymorphism in OOP

Coding agents generate code like there is no tomorrow. Soon enough, they struggle under the weight of what they created. AI writes a new helper instead of reusing an existing one. Old functions stay around because tests still call them, even though production does not. The codebase grows, but the agent's ability to reason about it does not. On bigger projects, especially ones that have been heavily vibe-coded, this turns into chaos. The problem is not just messy code. It is slower reviews, weaker trust in the codebase, and agents that get less reliable as the surface area grows. We have put a lot of energy into making code generation faster. I think the next thing to get right is safe code removal. There is a reason senior engineers get excited about deleting code. It is a bit like never throwing away clothes you no longer wear. It seems fine at first. Then one day, you have five versions of everything, and finding what you actually need means digging through closets you forgot existed. I built a Claude Code skill to help with this. It gives Claude a methodology for dead code removal: classify what you are looking at, verify the cases static tools miss, and avoid drifting into refactor territory while you are in there. It is tuned for Python and TypeScript, but should be easy to adapt. Clone it, fork it, open a PR if you improve it. https://lnkd.in/ds5AcC5U #CodingAgents #CodeQuality

14 hours of continuous coding, and I finally killed the final boss of my backend: child_process.spawn. Running heavy Python AI scripts directly inside a Node.js server seemed easy on Day 1. But it quickly turned into a nightmare of zombie processes, blocked event loops, and RAM crashes. The Fix: I completely ripped it out and built a dedicated FastAPI Microservice. The results? - Zero blocked event loops - True system decoupling - Blazing fast REST API communication If you're building AI applications, here's my biggest lesson: Let Node.js handle the WebSockets and I/O, and let Python handle the heavy AI lifting. Decouple from Day 1. Production is finally showing 🟢 200 OK, and the system is bulletproof!

Devlog Day 30 Today I revisited a question "Two Sum II" which is a very simple problem until you know the approach. The difference between Two Sum and Two Sum II is in Two Sum II the array is sorted and you have to solve the problem with O(n) TC and O(1) SC. Using two pointer approach you can solve this question. In brute force we use nested loops which loops through entire array to check if the sum of nums[i] and nums[j] equals to target. Else continue. It takes O(n2) TC and O(1) SC as we are not using any extra space for solution. In better approach we use two pointers by taking advantage of sorted order of array. We start from first and last pointer and check if the sum of them equals to target. If the sum is less we move left pointer else right. The problem in itself is not that hard but I am started analysing the pattern of such questions like if you have sorted array and want to find any element or perform any operation it is most likely targetting binary search and two pointers. Anyways later I continued my django course and today I learnt static files handling when your code is in production and even wrote a command script. Django lets you write your own command and you can access that command using python manage.py <command_name>. It really helps when you are containerizing your code and want to automate some processes like fetching static files from third party cdn and load it in locally so you dont have to request api for every reload. #DevLog #BuildInPublic #DSA #NeetCode #Stack #LearningInPublic #IndieHacker #WebDevelopment #Django #Coding #Development #Explore

OOP Isn't Magic — It's Just a Better Way to Think. Breaking down the four pillars, three models, and one mindset shift that changed how I see code. #ObjectOrientedProgramming #OOP #LearnToCode #SoftwareEngineering #RubyOnRails

Yesterday I asked: do you write tests before or after your code? Here’s why that matters — and how TDD fixes it. Most bugs aren’t a coding problem. They’re a thinking problem. You wrote the code first. Then you tested it. By then, you were already too attached to question your own logic. TDD fixes this at the root. Test-Driven Development means writing the test first — for code that doesn’t exist yet. The cycle is 3 steps: 🔴 Write a failing test 🟢 Write the minimum code to pass it 🔵 Refactor and clean it up That’s the core of the methodology. Simple to explain. Takes discipline to do. Tomorrow: why Django makes TDD easier than you think. Which step feels hardest for you: Red, Green, or Refactor? 👇 #TDD_Series_Django_2 #Python #Django #TDD #CleanCode #TDDWithDjango #Day2

Day 9/30 – Abstraction and Shortest Path in DAG Day 9 of the challenge focused on learning another important pillar of Object Oriented Programming and solving a graph problem based on shortest paths. Today’s learning was about hiding unnecessary complexity in code and using graph ordering to calculate minimum distances efficiently. MERN / OOP Concepts – Abstraction Today I learned about Abstraction, one of the core pillars of Object-Oriented Programming. What is Abstraction: • Abstraction means hiding internal implementation details and showing only essential functionality • It helps users interact with features without needing to know how everything works internally How it is achieved in Java: • Abstract classes • Interfaces Why it matters: • Reduces complexity • Improves code readability • Makes systems easier to maintain and extend • Focuses on what an object does instead of how it does it Real-world example: • When driving a car, we use steering, brakes, and accelerator • We do not need to understand the engine internals to drive it Key takeaway: • Show only what is necessary, hide the rest DSA – Shortest Path in DAG Today I solved Shortest Path in Directed Acyclic Graph (DAG). Approach: • Build graph using adjacency list with weights • Perform Topological Sort of all nodes • Initialize distance array with infinity • Start source node distance as 0 • Process nodes in topological order • Relax all outgoing edges to update shortest distances Key insight: • Since DAG has no cycles, topological order guarantees that each node is processed after its dependencies • This makes shortest path faster than Dijkstra in DAG cases Why this problem is important: • Combines Topological Sort with shortest path logic • Shows how graph structure can optimize solutions Time Complexity: O(V + E) Space Complexity: O(V + E) Takeaways • Abstraction helps simplify complex systems • Good software design hides unnecessary details • DAG problems often become easier using topological order • Choosing the right graph technique can greatly improve efficiency Day 9 completed. Concepts are getting deeper, and patterns are becoming more natural. #30DaysChallenge #OOP #Abstraction #Java #DSA #Graphs #ShortestPath #Consistency #LearningInPublic

Just wrapped my talk at ArcOfAI in Austin yesterday. 75 minutes on AI coding agents for full-stack Java dev in IntelliJ IDEA. Here's what we covered... AI coding agents aren't autocomplete anymore. They write entire features, generate tests, and produce docs. The shift is real and it's fast. We did a live head-to-head: GitHub Copilot vs JetBrains Junie, running Claude, GPT, Gemini, and Grok side-by-side inside IntelliJ IDEA 2026.1. And then topped it off with an OpenCode demo.  The stack I used: Spring Boot + The Apache Grails Framework. Why Grails? Groovy gives you ~30-40% better token efficiency vs pure Java. That matters a lot when you're hitting context limits. We also got real about the pitfalls: ↳ Hallucinations inventing fake methods and plugins ↳ Context loss mid-session on large codebases ↳ Security risks from unreviewed AI commits ↳ Over-reliance leading to hidden tech debt And I showed my GitHub contribution graph: 7,744 contributions in the last year. Agentic engineering acceleration is not theoretical. The audience brought great energy and sharp questions. Austin did not disappoint. 🚀 Slides link in the comments 👇

Been spending some time revisiting fundamentals lately — and honestly, nothing beats clean, simple code. In a world full of frameworks and shortcuts, it’s easy to forget that strong basics still do most of the heavy lifting. A few small snippets I’ve been reflecting on: Python # Clean and readable always wins def find_max(numbers): return max(numbers) if numbers else None JavaScript // Simplicity > over-engineering const uniqueItems = arr => [...new Set(arr)]; SQL -- Good queries save hours later SELECT customer_id, COUNT(*) AS total_orders FROM orders GROUP BY customer_id ORDER BY total_orders DESC; Nothing fancy here — but that’s the point. The real difference often comes from writing code that: someone else can understand quickly you can debug without frustration actually scales without breaking everything Tech keeps evolving, but clarity, structure, and logic never go out of style. Curious — what’s one coding principle you always stick to, no matter the language or stack? #Coding #Technology #SoftwareDevelopment #CleanCode #Programming #Developers

Day 44- Ever wondered how one class can use another class without inheriting it? That’s exactly what the Has-A relationship is all about. Instead of making one class do everything, we let classes work together. 🔹 What is Has-A relationship? Has-A means: One class contains another class as a part of it. It doesn’t inherit behavior, it simply uses another object to perform tasks. This helps in building clean and modular code. 🔹 Let’s understand with a simple example class Test { void play() { System.out.println("Executing play()......"); } } class Example { Test ref; Example(Test ref) { this.ref = ref; } } public class MainClass2 { public static void main(String[] args) { Test t1 = new Test(); Example e1 = new Example(t1); e1.ref.play(); } } 🔹 What’s happening here? • A Test object is created • That object is passed into Example • Example stores it using a reference (ref) • Then Example uses it to call play() 🔹 Why this is Has-A? Because: 👉 Example HAS-A Test object 👉 It is not extending Test 👉 It is simply using Test’s functionality 🔹 Type of relationship here This is Aggregation (Weak Has-A) ✔ The Test object exists independently ✔ It is created outside and passed into Example ✔ Both classes are loosely connected 🔹 Why this matters Using Has-A relationship helps in: • Better code structure • Reusability of classes • Loose coupling • Real-world modelling Instead of writing one big class, we design systems where objects collaborate. #Java #OOP #ObjectOrientedProgramming #JavaProgramming #Coding #Programming #SoftwareDevelopment #Developer #LearningInPublic #TechLearning #ComputerScience #CodingJourney #CodeNewbie #JavaDeveloper

Longer autonomous coding runs lead to longer reviews. This is how you make them fast again. Your bug count may be infinite but your threat model is finite. If you build a TypeScript and Python app you likely have SSRF (when your server makes HTTP requests on behalf of the user) and missing/incorrect authorization bugs. The road to asurance AND velocity is paved with ”define and conquer”. Define an input filter for URLs and scan for fetch and request lib calls that don't use it. This can be a lint rule. Your app roles have purposes and flows. Define these to make an allowed calls definition. Peak into the tests/ directory for playwright tests that you can use to reach all features with lower than expected roles. Clear definitions and types are what makes things verifiable at speed.