Benefits of Snake Case in Python Programming

Most developers use __init__ every day. But here’s the catch: We use it so often that we stop questioning how objects are actually created. And that’s where __new__ quietly gets ignored. The truth is: 👉 __𝐧𝐞𝐰__ creates the object 👉 __𝐢𝐧𝐢𝐭__ initializes the object Python doesn’t create objects in one step. It happens in two phases: 1️⃣ Memory is allocated → __new__ 2️⃣ Object is configured → __init__ A quick example: class Example: def __new__(cls): print("Creating instance") return super().__new__(cls) def __init__(self): print("Initializing instance") obj = Example() 𝘖𝘶𝘵𝘱𝘶𝘵: Creating instance Initializing instance Here’s the part most people never think about 👇 You’ve probably never written __new__. Yet your objects still get created perfectly. Why? Because Python is already doing this behind the scenes: obj = MyClass.__new__(MyClass) MyClass.__init__(obj) And if you don’t define __new__, Python uses: object.__new__() We treat __init__ like a constructor. But technically… it isn’t. 👉 𝑻𝒉𝒆 𝒓𝒆𝒂𝒍 𝒄𝒐𝒏𝒔𝒕𝒓𝒖𝒄𝒕𝒐𝒓 𝒊𝒔 __𝒏𝒆𝒘__. ⚡ Why __new__ matters: - Controls object creation - Used in Singleton patterns - Important for immutable types (int, str, tuple) - Can even return a different object ⚡ What __init__ actually does: - Just initializes the already-created object - Cannot create or return a new instance - Always returns None 💡 Real takeaway: We rely on __init__ so much that we rarely think about what happens before it. Understanding __new__ is what shifts you from: 👉 writing Python code to 👉 understanding how Python actually works Once you see it, you can’t unsee it 🙂 #Python #PythonProgramming #SoftwareDevelopment #BackendDevelopment #Coding #Programming #LearnToCode #DeveloperMindset #TechCareers #SoftwareEngineer #CleanCode #ProgrammingConcepts

Day 29: The Anatomy of a Bug — Three Types of Errors 🐞 In programming, not all "crashes" are created equal. We categorize errors into three levels of severity, ranging from "The computer doesn't understand you" to "The computer does exactly what you said, but you said the wrong thing." 1. Syntax Errors (The "Grammar" Mistake) These happen before the code even starts running. Python’s "Parser" looks at your script and realizes it violates the rules of the language. The Cause: Missing colons :, unclosed parentheses (, or incorrect indentation. The Result: The program won't start at all. 💡 The Engineering Lens: These are the "cheapest" errors to fix. Your code editor (IDE) will usually highlight these with a red squiggly line as you type. 2. Runtime Errors (The "Panic" Mistake) The syntax is perfect, and the program starts running—but then it hits a situation it can't handle. The Cause: Dividing by zero, trying to open a file that doesn't exist, or calling a variable that hasn't been defined yet (NameError). The Result: The program "crashes" in the middle of execution. 💡 The Engineering Lens: We handle these using Exception Handling (try/except). Professional code assumes things will go wrong (like the internet cutting out) and builds "safety nets" to keep the program alive. 3. Semantic Errors (The "Logic" Mistake) These are the most dangerous and difficult to find. The program runs perfectly from start to finish. There are no crashes and no red text. But the output is wrong. The Cause: You used + when you meant -, or your loop stops one item too early. The Result: The program gives you the wrong answer (e.g., a calculator saying $2 + 2 = 22$). 💡 The Engineering Lens: The computer is doing exactly what you told it to do; the "error" is in your logic. We find these using Unit Testing and Debugging tools. If you don't test your code, you might not even know a semantic error exists until a customer reports it. #Python #SoftwareEngineering #Debugging #ProgrammingTips #LearnToCode #TechCommunity #PythonDev #CleanCode #BugHunting

🚀✨ 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 ⚛️

🚀 𝗕𝘂𝗶𝗹𝘁 𝗮 𝗖𝗹𝗲𝗮𝗻 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻 𝗼𝗳 𝗟𝗼𝗻𝗴𝗲𝘀𝘁 𝗖𝗼𝗺𝗺𝗼𝗻 𝗣𝗿𝗲𝗳𝗶𝘅 (𝗟𝗖𝗣) 𝗶𝗻 𝗣𝘆𝘁𝗵𝗼𝗻 As part of improving my problem-solving skills, I explored multiple approaches to solve the Longest Common Prefix problem. 🔍 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Given a list of strings, find the longest common prefix among them. 💡 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵𝗲𝘀 𝗜 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗲𝗱: 🔴 𝗕𝗿𝘂𝘁𝗲 𝗙𝗼𝗿𝗰𝗲 (𝗩𝗲𝗿𝘁𝗶𝗰𝗮𝗹 𝗦𝗰𝗮𝗻𝗻𝗶𝗻𝗴) Compare characters column-wise across all strings ⏱ Time: O(N × M) 🟡 𝗛𝗼𝗿𝗶𝘇𝗼𝗻𝘁𝗮𝗹 𝗦𝗰𝗮𝗻𝗻𝗶𝗻𝗴 Start with first string and shrink prefix step by step ⏱ Time: O(N × M) 🟢 𝗢𝗽𝘁𝗶𝗺𝗮𝗹 (𝗦𝗼𝗿𝘁𝗶𝗻𝗴 𝗧𝗿𝗶𝗰𝗸) Sort strings and compare only first & last ⏱ Time: O(N log N + M) ⚡ 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀: Early exit conditions improve performance significantly Choosing the right approach depends on input size and use case Clean code > complex code 🧠 𝗥𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗨𝘀𝗲 𝗖𝗮𝘀𝗲𝘀: Search suggestions (Autocomplete) Text processing systems Data normalization 📂 𝗖𝗼𝗱𝗲 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗼𝗻 𝗚𝗶𝘁𝗛𝘂𝗯: 👉 https://lnkd.in/gJQ-KgRP #Python #DataStructures #Algorithms #Coding #SoftwareDevelopment #ProblemSolving #Developers #GitHub #LearningJourney

🚀 Day 9 of My Coding Journey — Valid Parentheses Problem Today’s challenge looked simple at first: Check if a string of brackets like ()[]{} is valid. 🔍 The Twist It’s not about counting brackets. It’s about order and pairing. "([])" ✅ Valid "([)]" ❌ Invalid 🧠 What Actually Works? → Stack Instead of counting, I used a stack: Push opening brackets When a closing bracket appears → check the last opening If it doesn’t match → invalid ⚙️ Python Solution def isValid(s): stack = [] mapping = {')': '(', '}': '{', ']': '['} for char in s: if char in mapping: if not stack or stack[-1] != mapping[char]: return False stack.pop() else: stack.append(char) return len(stack) == 0 💡 Key Takeaways Order > Count Stack is powerful for pattern-based problems Small problems can hide tricky logic 📈 Getting better every day by solving and understanding—not just coding. #Day9 #100DaysOfCode #Python #DataStructures #ProblemSolving #CodingJourney

🐍 Exploring NumPy Operations in Python Today I practiced different operations on NumPy arrays, which are essential for Data Science and Machine Learning 🚀 🔹 Created arrays using np.arange() 🔹 Performed element-wise operations: ✔ Addition (arr + arr) ✔ Subtraction (arr - arr) ✔ Multiplication (arr * arr) ✔ Division (arr / arr) 🔹 Applied scalar operations: ✔ arr + 4, arr * 3 🔹 Explored mathematical functions: ✔ Square root (np.sqrt) ✔ Exponential (np.exp) ✔ Trigonometric functions (np.sin) 🔹 Found useful statistics: ✔ Maximum (np.max) ✔ Minimum (np.min) ⚠️ Important Observation: Dividing by zero gives inf or nan values Example: 1/0 → inf, 0/0 → nan 💡 Key Takeaway: NumPy allows fast and efficient element-wise operations, but handling edge cases like division by zero is very important in real-world data. 📌 Full code available here: 👉 https://lnkd.in/dCMhYQey #Python #NumPy #DataScience #MachineLearning #100DaysOfCode #LearningJourney

🐍 Exploring NumPy Indexing & Slicing in Python Today I practiced how to access and manipulate data inside NumPy arrays. This is a very important step for Data Science and Machine Learning 🚀 ✔ Accessed elements using indexing (arr[9]) ✔ Used slicing to get parts of arrays (arr[:9], arr[8:]) ✔ Learned that slicing creates a view (changes affect original array!) ✔ Used .copy() to avoid modifying original data ✔ Worked with 2D arrays (matrix indexing) ✔ Applied conditional filtering (arr[arr > 3]) ✔ Explored slicing in 2D arrays (rows & columns selection) 💡 Key takeaway: NumPy slicing returns a view, not a copy. So changing a slice can change the original array — this is very important to remember! 📌 Full code available here: 👉 https://lnkd.in/dCMhYQey #Python #NumPy #DataScience #MachineLearning #100DaysOfCode #LearningJourney

From the leaked Claude source code, people are porting the architecture and logic to a different language (python) to avoid legal issues. One example is this one: https://lnkd.in/eVpnWN-n I remember using claude code to reverse engineering it itself, the intention? to enable a custom llm proxy, and it worked! The llm proxy didn't follow the regular authentication mechanism (required extra headers, custom url pattern) plus a custom change in the response. It was the opencode before opencode 😅🤣

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