Refactoring for Ego and Clean Code

update from previous post[https://lnkd.in/dVx_NrDQ] From "Arrow Code" to Clean Architecture. 🏹 ➡️ 🧱 I’ve hit a major turning point in my Python journey. I realized my code was starting to look like an arrow—layers upon layers of if statements and while loops pushing my logic further and further to the right. In professional dev circles, they call this Arrow Code, and it's a nightmare to maintain. Here’s how I "flattened" my latest project: ✅ Decomposition: I broke down massive, nested blocks into small, dedicated functions. Each function now does one thing well, making the main logic readable at a single glance. ✅ The "Gatekeeper" Pattern: Instead of scattered validation, I built a centralized handler to act as a security guard for all user inputs. ✅ State Management: I’m now mastering the "Baton Pass"—using return values and arguments to move data (like budgets) safely through the app instead of relying on global variables. ✅ Professional Workflow: I’m officially using Git branches and Pull Requests on GitHub to review my own work and track my architectural improvements. The goal isn't just to write code that the computer understands; it’s to write code that other humans can read. 🚀 #CleanCode #Python #SoftwareEngineering #Refactoring #CodingJourney #BuildInPublic

Most beginner backend projects die in refactoring. Here's the structure I use to prevent that. When I built my Task Manager CLI, I learned this the hard way — a monolithic file that worked until it very much didn't. After refactoring, here's the structure I now start with: Before writing a single line: → Define your data model first → Identify all operations (CRUD) you'll need → Map inputs, outputs, and error states While building: → One module per concern (routes, models, utils, exceptions) → Validate inputs at the boundary — not deep inside logic → Handle errors explicitly — no silent failures Before shipping: → Test the unhappy paths, not just the happy ones → Read your own code like a stranger would This approach reduced my debugging effort by 40% on a real project. It works at any scale — from a CLI tool to a FastAPI service. What's the first thing you do when starting a new backend project? #BackendDevelopment #Python #FastAPI #SoftwareEngineering #CodingTips

Building this trading bot taught me how powerful clean architecture, modular design, and API‑driven automation can be. My goal wasn’t to create a complex system — but a simple, reliable, and transparent bot that anyone can understand. This project helped me sharpen my Python fundamentals, improve my debugging discipline, and design a structure that scales. Excited to keep improving it with strategies, risk checks, and backtesting. - Drafted with the help from Copilot. #Python #TradingBot #AlgorithmicTrading #PythonProjects #Automation #APIDevelopment #CodingJourney #LearningInPublic GIT hub link for code: https://lnkd.in/d_cCwG-r

Tackling my first HARD tree problem! 🧗♂️🌲 Binary Tree Maximum Path Sum - LeetCode 124 - Hard (Blind 75) Moving from Easy/Medium to a Hard problem is always intimidating, but breaking it down to its core logic makes it manageable. This problem asks us to find the maximum sum of any path in a tree. The catch? A path can start and end anywhere, and it can go up and down, but it cannot branch twice. (The Split Decision): When standing at any node, we have to make two distinct calculations: 1. The Local curved path (The closed loop): What is the maximum sum if the path curves *through* this current node? This is `left_sum + right_sum + node.val`. We check if this curved path is the biggest sum we've seen so far and store it in our global tracker (`self.max_sum`). 2. The Straight path (Reporting to the boss): When returning a value back up to the parent node, we CANNOT return the curved path (because a path can't fork). We must choose the most profitable single straight line: `node.val + max(left_sum, right_sum)`. Key Learnings: 1) Ignoring Toxicity: If a child subtree returns a negative sum, it will only drag our total down. We can simply ignore it by using `max(dfs(...), 0)`. If it's negative, we just pretend the path stops there. 2) Dual-Purpose Recursion: Our recursive function does two things simultaneously—it continuously updates the global maximum path found anywhere, while returning the max straight path to keep the recursion flowing. Time and Space Complexity: Time Complexity: O(N) — We visit every single node exactly once. Space Complexity: O(H) — Where H is the height of the tree (for the recursion stack). Reaching the "Hard" level in the Blind 75 journey feels like a huge milestone. To anyone else practicing DSA right now—keep pushing, the logic eventually clicks! 💡 #LeetCode #BinaryTrees #Blind75 #DataStructures #Python #Recursion #Algorithms #TechInterviews #SoftwareEngineering #CodingJourney #ProblemSolving

My CLAUDE.md was 281 lines. Claude loaded all of it every session - whether I was writing a post or debugging a Python script. Post rules. Format guides. Note conventions. Voice guidelines. All in context, all the time. Even when none of it was relevant. Longer context = lower adherence. The docs say it plainly. I ignored it until I ran this prompt: --- *Review my CLAUDE.md against https://lnkd.in/g6UNtsC7 and suggest specific improvements - what to add, what to move to .claude/rules/ files, and what to cut.* --- Claude read the official docs, compared them against my file, and came back with a diagnosis. The biggest one was `.claude/rules/` - a directory most people don't know exists. Here's what it told me to do: Rules in `.claude/rules/` load just like CLAUDE.md - but you can scope them to specific file paths. ``` paths: - "posts/**" ``` That one frontmatter block means post rules only enter context when Claude is working inside that folder. Format guides, note conventions - same thing. Zero tokens wasted when they don't apply. After the restructure: - CLAUDE.md: 281 lines → 69 lines - Always-loaded context: ~180 lines total - 3 rule files load on demand, only when relevant The path-scoped rules are in the official docs at https://lnkd.in/g6UNtsC7. Almost nobody uses them. Run `/memory` in Claude Code to see exactly what's loaded in your current session. If it's over 200 lines, that's where the drift is coming from. What rule do you keep repeating to Claude because it keeps forgetting? #ClaudeAI #AITools #BuildInPublic #ProductManagement #DeveloperTools

The first version of my Task Manager CLI was a mess. One big file. Everything tangled together. It worked — barely. Then I refactored it into modular components. Debugging effort dropped by 40%. Not because I became smarter, but because I could finally isolate problems instead of hunting through 300 lines of spaghetti code. That refactor taught me something no tutorial spells out clearly: Clean code isn't about aesthetics. It's about reducing the cost of being wrong. When you write modular code: → Bugs are easier to find → Features are easier to add → Other people (or future you) can actually understand it I now think about modularity before I write a single function. It's the difference between a project that grows and one that collapses under its own weight. What's a coding habit you wish you'd developed earlier in your journey? #CleanCode #SoftwareEngineering #Python #BackendDevelopment #CodingBestPractices

Stop wasting time on manual tasks. 🐍⚡ I’ve put together a 12-slide Python Automation Roadmap to help you turn repetitive work into clean, scalable scripts. No fluff—just the core libraries and patterns you actually need. What’s inside: ✅ File Ops: Mastering os, shutil, and pathlib. ✅ Web & APIs: Scraping with Selenium and robust requests handling. ✅ Production Ready: Scheduling, Logging, and CLI design. ✅ Advanced: Asyncio, decorators, and a full real-world project. Whether you're looking to clean up your filesystem or build a headless web bot, this guide has you covered. 👇 Download the PDF below and start automating. #Python #Automation #Programming #SoftwareEngineering #PythonRoadmap

🔍 Analyzed my own code with SonarQube — here's what I found. As part of my Software Engineering course (4th Semester) at Dawood University of Engineering & Technology, I applied SonarQube to ResumRank-AI, my AI-powered resume screening app built with Python, Flask, spaCy, and pdfplumber. Instead of a textbook demo, I ran it on real production-intended code. The results were eye-opening: 🔴 8 Security Hotspots — CSRF vulnerabilities & sensitive data exposure in Flask routes 🟠 58 Maintainability violations — Cognitive Complexity exceeding threshold in ranking logic 🟡 60 Total issues — consistency, reliability & maintainability across 3.7k lines ⚡ 11 Reliability issues — unhandled edge cases in backend processing 📊 7 hours of Technical Debt estimated ✅ Quality Gate: Passed The biggest takeaway: code that works is not the same as code that's secure and maintainable. SonarQube flagged real vulnerabilities in my own codebase that I hadn't noticed — proving why static analysis belongs in every developer's workflow. 🔗 GitHub Repo: https://lnkd.in/d6MKMhU4 📄 Full Analysis Report: https://lnkd.in/gMgW-avE #SonarQube #Python #SoftwareEngineering #CodeQuality #StaticAnalysis #DUET #ArtificialIntelligence #Flask #OpenSource

Built a Python-based Directory Sync Tool to compare and synchronize files between two directories with reliability and control. Instead of relying only on file names or timestamps, the tool uses a combination of metadata and SHA-256 hashing to accurately detect new, modified, and missing files. Key highlights: • Recursive directory scanning with structured metadata (name, extensions, size, hash) • Efficient change detection using size-first filtering followed by hash comparison • Memory-efficient hashing using chunk-based file reading (handles large files) • Synchronization support with metadata preservation using shutil.copy2 • Safe cleanup by optionally removing extra files from the destination While building this, I focused on moving beyond a basic script and treating it like a real tool, structuring the code into clear components, improving output readability, and adding validation and error handling to make it more reliable in real use. GitHub:https://lnkd.in/gt-Ec3rF #Python #CLI #GitHubProjects #SoftwareDevelopment #LearningByBuilding #SystemsThinking

🔥 Day 8/100 of My LeetCode Challenge — 0 ms (100%) 🔥 Hook: Most people fail this “easy” problem because they ignore one tiny detail — can you spot it? 💭 Problem: Add 1 to a number represented as an array of digits. Sounds simple, right? But here’s the catch 👇 👉 What if the last digit is 9? 👉 What if ALL digits are 9? Example: [9,9,9] → [1,0,0,0] 💥 🧠 What I learned today: Always think about edge cases Simple problems can hide tricky logic Traversing backwards can simplify carry problems ⚡ My Approach: Start from the end If digit < 9 → add 1 and return If digit == 9 → make it 0 and continue If all become 0 → add 1 at front 💻 Result: ✅ Runtime: 0 ms (100%) ✅ Clean & optimized solution 📈 Consistency Check Day 8 complete. No excuses. No breaks. Small wins daily → Big results later 🚀 #LeetCode #Day8 #CodingJourney #Python #ProblemSolving #100DaysOfCode