Srikant Kumar’s Post

🚀✨ Sharing something I’ve been building — Code Crawler 🕷️ Ever joined a large Python codebase and spent days 😵💫 figuring out what calls what? Yeah… that frustration led me to build this 👇 💡 Code Crawler helps you understand any Python codebase visually and instantly. Just point it to a GitHub repo (or even a local folder 📂), and it parses everything using AST to generate a function & class-level lineage graph 🧬 🔍 What makes it powerful: ⚙️ Resilient crawl pipeline (Temporal) — survives restarts & scales smoothly 🔗 Cross-repo lineage — track relationships across repos + inheritance chains 🌿 Branch comparison — see what changed & what it impacts downstream ▶️ Run functions from UI — no test setup needed 🧪 Smart mocking — auto-detect dependencies & stub them easily 📊 Batch testing — run multiple test cases together with instant results 📂 Local support — drag & drop projects, no GitHub required 🏢 Multi-tenant architecture — full isolation + invites + admin panel 💭 Why I built this: Understanding a new codebase shouldn’t feel like solving a puzzle 🧩 Instead of jumping across hundreds of files: 👉 Visualize relationships 📈 👉 Trace flows instantly 🔄 👉 Run functions with real inputs ⚡ All in one place. 🚧 Still building, but already super useful for exploring codebases I didn’t write Would love feedback from folks who’ve struggled with large Python projects 🙌🔥 🔗 https://lnkd.in/gtD-5juu #Python 🐍 #SoftwareEngineering 💻 #DevTools 🛠️ #OpenSource 🌍 #FastAPI ⚡ #React ⚛️

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

#The_most_expensive_comma_I’ve_ever_typed. 💸 I recently spent way too long debugging a background task that was "failing successfully." No errors in the frontend, no crashes in the logs—just... silence. The culprit? A single trailing comma at the end of a string: #email_body = "Hello there...", In Python, that tiny comma turns your intended String into a Tuple. So, instead of sending a block of text to the email handler, I was sending ("Hello there...",). Because we had fail_silently=True enabled in our background thread (standard practice to keep the UI snappy), the system was quietly choking on the Tuple and dying without a word. #The Lesson: Syntax Matters: Even in a "readable" language like Python, one character changes the entire data structure. The Danger of Silence: fail_silently is a double-edged sword. It keeps the user experience smooth, but it can bury the "why" during development. Log Everything: If it’s failing silently, make sure your logger isn’t! Has a single character ever brought down your entire workflow? Let’s commiserate in the comments. 👇 #Python #SoftwareEngineering #CodingLife #Debugging #Django #WebDevelopment

Writing tests felt like extra work when I started. Now I think of it differently: Tests aren't for checking your code works. Tests are for changing code confidently. I was refactoring a payment processing module in Rails that touched 6 other parts. With RSpec tests: refactored in 90 minutes, caught 2 regressions immediately. What I test: Business logic, API endpoints, edge cases that have broken things before, anything involving money/permissions/data integrity. What I don't test: Framework code, simple getters/setters, anything that changes with every UI change. My setup: Rails: RSpec + FactoryBot + Shoulda Matchers. Python: PyTest + factory_boy. The goal isn't 100% coverage. The goal is confidence that critical paths work. What's your testing philosophy? Follow Sachin Shah - backend engineering practices learned the hard way. #SoftwareTesting #RSpec #PyTest #BackendDevelopment #SoftwareEngineering #BuildInPublic #RubyOnRails #Python #CleanCode #TechTips

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

The Secret to Clean Code: Snake Case 🐍 Have you heard about snake variable 🐍? If you are diving into Python or working within a team of developers, you’ve likely seen variable names like 'user_login_count' or 'total_price_usd' This specific style—where words are written in lowercase and joined by underscores is known as snake_case. Why does it even matter? In the world of coding, readability is just as important as functionality. Here is why snake case is a standard for many: Readability—It mimics natural spacing, making it easy for the human eye to distinguish separate words at a glance. Context— Instead of vague abbreviations like ua, using "user_age" tells anyone reading your code exactly what data is being stored. Consistency— Following naming conventions ensures that a large codebase remains professional and maintainable, whether you're working solo or with a global team. Writing clean code is a form of professional etiquette. It respects the time of your future self and your colleagues. What’s your preferred naming convention? Let’s discuss below! 👇 #Python #CleanCode #ProgrammingTips #DataScience #WebDevelopment #TechCommunity

Day 28/90 I solved one LeetCode in four different ways, but my Django project stayed at zero today. I took April 2nd off for personal reasons. Yesterday, Day 28, I finished my DSA session, but I couldn't get started on the development work. I am converting my Sunday rest day into a working day again to make up for the lost time. DSA & LeetCode: • Solved LeetCode 268 (Missing Number). • I deliberately started with a Sorting approach. By sorting the array, I could see exactly where the index and the value stopped matching. It’s a simple way to find the gap, but the O(n log n) time complexity is slow for bigger arrays. • Next, I optimized it by using a Set for hashing. Turning the list into a Set gave me O(1) lookups and dropped the total time to O(n). It’s faster, but it still carries an O(n) space cost. • Then, I tried the Summation (Gauss Formula) method. I calculated the expected sum using (n * (n + 1)) // 2, where n is the length of the nums array, and subtracted the actual sum. This hit a 0ms runtime and O(1) space. • Finally, I used the Bitwise Exclusive OR method. Since any number XORed with itself cancels out (a ^ a = 0), I XORed every index from 0 to n with every value in the array. The pairs cancelled each other out, leaving only the missing number. It’s O(n) time and a perfect O(1) space, and unlike the math formula, it doesn't risk an integer overflow. Do you find value in solving the same problem multiple ways to understand trade-offs, or do you prefer moving quickly to the next challenge? #python #django #backenddevelopment #leetcode #dsa #90daysofcode #softwareengineering #bitwise #refactoring #consistency

My first version of the Task Manager CLI was embarrassing. Everything in one file. No error handling. Variables named x, temp, data2. It worked — until it didn't. And when it broke, I had no idea where to start debugging. That moment of staring at my own code and not understanding it was one of the most important moments in my development as an engineer. I refactored the entire project. Broke it into modules. Added structured exception handling. Rewrote the validation logic. Debugging effort dropped by 40%. More importantly, I could actually read my own code. The lesson wasn't technical. It was about ego. Bad code is often the result of being in a hurry to "finish" — instead of being willing to do it right. I now build slower and ship cleaner. And I'm better for it. Have you ever looked back at old code and learned something important about yourself? #Refactoring #CleanCode #Python #SoftwareEngineering #LessonsLearned

🚫 I spent hours debugging my API… just because I didn’t understand this one thing in Django REST Framework. I thought Function-Based Views were enough… until my code started getting messy, repetitive, and hard to scale. That’s when I finally understood the real difference between FBVs and CBVs 👇 🔹 What I Learned FBVs feel easy in the beginning. But as soon as your API grows → logic becomes cluttered. CBVs (especially Generic Views & ViewSets) completely changed the game for me: ✔ Cleaner structure ✔ Reusable logic ✔ Scalable architecture 🔹 Example Function-Based View 👇 @api_view(['GET', 'POST']) def product_list(request): if request.method == 'GET': ... elif request.method == 'POST': ... Class-Based View 👇 class ProductView(ListCreateAPIView): queryset = Product.objects.all() serializer_class = ProductSerializer 👉 Same result… but CBVs remove a LOT of manual work. 🔹 What’s Actually Happening? CBVs use: Mixins → handle logic (list, create, update) Generic views → combine mixins ViewSets → full CRUD with routers 👉 You focus on what to build, DRF handles how it works 🔹 Mistakes I Made (and learned from) ❌ Forgot queryset in ViewSet → basename error ❌ Passed Model instead of ViewSet to router ❌ Wrong URL (case-sensitive → 404) ❌ Imported NestedSimpleRouter from wrong module ❌ Didn’t understand router → action mapping 👉 These mistakes actually helped me understand DRF deeply. 🔹 Final Take 👉 FBVs = Good for learning basics 👉 CBVs = Essential for real-world APIs Now I use ViewSets + Routers by default — less code, more clarity 🚀 #Django #Python #BackendDevelopment  #SoftwareEngineering #API #Programming #LearnPython #TechTips  #100DaysOfCode #TechCommunity

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