Balanced Brackets: The Power of Stacks in Programming

Today seems like a good day to mention we’ve built our own litellm-esque model library, and that its completely open source. It provides one Python SDK to access any provider. It's simple, fully typed, and modular by design. At a glance: - Simple, modular design (easy to read + contribute to) - Fully typed, LLM-agnostic Pydantic I/O - Built-in model metadata + granular cost tracking (cache read/write, reasoning tokens, per-turn totals) - Agent loop with tool execution + hooks - Image + file support across providers - Retry strategies, including token-aware retries It’s built for simplicity and transparency — with a built-in agent loop + tool hooks, image/file support, and granular cost tracking. It is intentionally small and modular - we wanted it to be easy to understand, verify, and extend. 🔗 Link in the comments!

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

I often see Excel used extensively among scientists, and for good reasons. It's accessible, visual, and fast to get started with. But as analyses grow, a few things start to bite: - Debugging is hard. Logic is scattered across cells and sheets, with no easy way to write a test to catch when something breaks. - Change tracking is limited (and optional!). Who changed what, and when? - Data and logic live in the same file. One accidental keystroke can silently corrupt the underlying data, and it's up to the user to set up protections (i.e., lock cells) every time. A Python or R workflow with Git handles all of this pretty naturally. Code is testable, every change is tracked and reversible, and raw data stays separate from analysis logic. Not the right fit for every situation, but worth considering as projects get more complex. #ResearchSoftware #Reproducibility #ScientificComputing

I often see Excel used extensively among scientists, and for good reasons. It's accessible, visual, and fast to get started with. But as analyses grow, a few things start to bite: - Debugging is hard. Logic is scattered across cells and sheets, with no easy way to write a test to catch when something breaks. - Change tracking is limited (and optional!). Who changed what, and when? - Data and logic live in the same file. One accidental keystroke can silently corrupt the underlying data, and it's up to the user to set up protections (i.e., lock cells) every time. A Python or R workflow with Git handles all of this pretty naturally. Code is testable, every change is tracked and reversible, and raw data stays separate from analysis logic. Not the right fit for every situation, but worth considering as projects get more complex. #ResearchSoftware #Reproducibility #ScientificComputing

I wrote a CLI tool to help your teams catch "slop" code before it creates a mountain of tech debt. Runs for any python projects 3.10 -> 3.13. Drop it in your CI/CD pipelines to act as a last linter for AI specific slop patterns like vague comments, util functions, and more. Check it out! https://lnkd.in/e5xNUwH2 https://lnkd.in/eT6psfZS

I just learned something that no LeetCode problem ever taught me. How do you sort 200 GB of data when your RAM is only 5 GB? 🤯 I came across this in a real interview question today — and honestly, I had no clue. The answer? External Merge Sort. Here's how it works in simple terms 👇 📦 Phase 1 — Break it down: • Read 5 GB of data into RAM • Sort it using QuickSort • Write it back to disk as a sorted "chunk" • Repeat 40 times → now you have 40 sorted files 🔀 Phase 2 — Merge using a Min-Heap: • Open all 40 files at once • Push the first element of each file into a Min-Heap (size = just 40!) • Pop the minimum → write to output → push next element from that file • Repeat until all 200 GB are merged The genius part? The heap never holds more than 40 elements at a time. Not 200 GB. Just 40. All those Heap and Merge Sort problems on LeetCode? This is exactly what they're preparing you for — just at a massive scale. This is why Big Tech companies ask System Design questions. Real-world data doesn't fit in an array. 🌍 📸 Attached the full Python implementation above — Phase 1 (Run Creation) + Phase 2 (K-Way Merge) with comments explaining every step. Drop a 🙋 if you had no idea this concept existed before today! And tell me — what's the most surprising DSA concept YOU'VE come across recently? 👇 #DSA #LeetCode #SystemDesign #SoftwareEngineering #Python #CodingInterview #ExternalSorting

Topic 5/100 🚀 🧠 Topic 5 — Iterators Ever wondered how a for loop actually works behind the scenes? 🤔 This is the concept powering it. 👉 What is it? Iterators are objects that allow you to traverse through data step-by-step using __iter__() and __next__() methods. 👉 Use Case: Used in real-world applications for: Custom data pipelines Streaming data Building your own iterable objects 👉 Why it’s Helpful: Gives full control over iteration Enables custom looping logic Foundation for generators 💻 Example: class Counter: def __init__(self, max): self.max = max self.current = 0 def __iter__(self): return self def __next__(self): if self.current < self.max: self.current += 1 return self.current raise StopIteration for num in Counter(3): print(num) 🧠 What’s happening here? We created a custom object that behaves like a loop by controlling how values are returned one by one. ⚡ Pro Tip: If you understand iterators, you’ll unlock how Python handles loops internally. 💬 Follow this series for more Topics #Python #BackendDevelopment #100TopicOfCode #SoftwareEngineering #LearnInPublic

Built a simple Linked List from scratch in Python to strengthen core DSA fundamentals. Key operations implemented: • Insert at beginning • Insert at end • Insert at specific position Clean and minimal implementation 👇 💡 Tips & insights from this implementation: • Always handle edge cases first (especially position == 0 and empty list) • Use position - 1 when inserting → you need the previous node, not the exact index • Traversal safety matters → always check temp is None to avoid crashes • Keep functions single responsibility (traverse_to_position makes insertion cleaner and reusable) • Don’t break links accidentally → Always connect new_node.next before changing temp.next • Naming matters → insert_behind can be clearer as insert_end • Remember: Linked Lists are about pointer management, not index access like arrays Simple idea, powerful foundation #DSA #SoftwareEngineering

Have you ever heard of "Duck Typing"? 🦆 "I don't care who you are—I only care what you can do." 🦆 That is the soul of Duck Typing. In many programming languages, you have to show an "ID card" (a specific Class or Type) to get the job done. If the system expects a Duck, it will reject a Goose, even if the Goose behaves exactly the same. Python plays by different rules. It follows a simple philosophy: "If it walks like a duck and quacks like a duck, then for all intents and purposes, it’s a duck." The Big Picture: Old School— "Are you officially a 'Payment' object?" Duck Typing— "Do you have a 'process()' method? Great, let's go." Why this matters: Flexibility: You can swap components in and out without rewriting your whole logic. Speed: You spend less time defining strict hierarchies and more time building features. Testing: It’s why mocking and fakes are so seamless in Python. The Trade-off: You trade the safety of strict rules for the freedom of behavior. If your "duck" forgets how to quack halfway through, you’ll hit an error. #Python #Data Science #Insights #TechStrategy #Coding #CleanCode