Python 3.12 Environment Setup Mistake

The shortest agent framework tutorial ever written. Step 1: Install it. pip install definable Step 2: Build an agent. agent = Agent(model="openai/gpt-4o", instructions="You help with code reviews.") Step 3: Give it hands. @tool def search_code(query: str) -> str: return search_codebase(query) agent = Agent(model="openai/gpt-4o", tools=[search_code]) Step 4: Give it memory. agent = Agent(model="openai/gpt-4o", memory=True) Step 5: Give it knowledge. agent = Agent(model="openai/gpt-4o", knowledge="./docs/") Step 6: Give it guardrails. agent = Agent(model="openai/gpt-4o", security=True) Step 7: Run it. result = await agent.arun("Review my latest PR") That's the whole tutorial. You just learned an entire agent framework in one LinkedIn post. Every step adds one organ. Model (the brain), Tools (the hands), Memory (continuity), Knowledge (understanding), Security (immune system). Composition over configuration. Always. https://lnkd.in/g_fCTVfC #AIAgents #Tutorial #Python #ArtificialIntelligence #DeveloperTools #LLM #OpenSource #DefinableAI #LearnAI #BuildInPublic

DAY 40!!!! Designing an LRU Cache — thinking beyond “just code” Today’s learning pushed me to think about how systems remember — and more importantly, what they forget. In simple terms, a cache is just a memory shortcut. Instead of recalculating or refetching the same data over and over, we store it somewhere faster. But here’s the catch Memory is limited. So the real question becomes: When the cache is full… what do you remove? That’s where LRU (Least Recently Used) comes in. The idea is very human: If something hasn’t been used in a long time, it’s probably safe to let it go. If something was just used, it should stay. What fascinated me today is how Python (and many real systems) make this efficient: A dictionary gives instant access to data (O(1) lookup) A doubly linked list keeps track of what was used most recently Together, they allow fast reads and fast eviction — no scanning, no guessing This is why tools like OrderedDict exist… and also why engineers still learn how to build this from scratch — because real-world performance depends on these design choices. Caches power: Browsers Databases APIs Backend services Even things you interact with daily without noticing It’s less about memorizing syntax and more about learning how to think in systems. #LearningInPublic   #Python   #DataStructures   #SystemDesign   #Caching   #LRUCache   #SoftwareEngineering   #BackendDevelopment   #ComputerScience   #BuildInPublic

Day 12 — Error Handling: Writing Code That Doesn’t Crash Errors are not failures. They are signals. Real-world programs don’t stop just because something goes wrong — they handle it gracefully. That’s exactly what error handling is about. Today you learned: • Why errors happen at runtime • How try and except blocks prevent crashes • How to catch specific errors like ZeroDivisionError • How to keep programs running even when inputs are wrong This is where your code starts behaving like production code, not practice code. Error handling is used everywhere: • User input validation • File handling • Network requests • APIs and backend systems If your code can fail safely, it can scale confidently. Mini Challenge: Write a program that asks for two numbers and safely handles division by zero using try and except. Post your solution in the comments. I’m sharing Python fundamentals — one practical concept per day. Built to help beginners write reliable, real-world Python. Next up: List and Dictionary Comprehensions — writing clean one-line logic. Learning to debug and handle errors becomes much smoother in PyCharm by JetBrains, especially with clear error messages and stack traces. Follow for the full day Python series. Like • Save • Share with someone learning Python. #Python #LearnPython #PythonBeginners #ErrorHandling #Programming #CodingJourney #Developer #Tech #JetBrains #PyCharm

Another subtle Python quirk that silently breaks production… The logs showed empty lists where data should be. No errors. No crashes. Just… silence from a core function. After tracing through permissions, database calls, and network timeouts, I found this: (See screenshot for code snippet) The villain? Iterator exhaustion. zip returns an iterator. The first list comprehension consumed it entirely. The second got nothing. This pattern is everywhere: map, filter, csv.reader, generator expressions — they’re all one-time use. Key Insight for System Design: Treat iterators as streams, not containers. A stream flows once. If you need a container, materialize it: data = list(iterator) It’s a simple rule that prevents insidious bugs. What looks like harmless variable reuse can become a source of Heisenbugs — bugs that vanish when you add debug prints (which also consume the iterator!). Python backend issues that don’t throw errors, but break systems quietly. What’s your most memorable “silent failure” bug? #python #debugging #bestpractices #backend #engineering

Still using pip?! I recently switched to uv (a modern, high-performance package manager by Astral) — and for someone who codes heavily in Python, the upgrade feels practical and overdue. Why switching to uv? 1. Project initialization friction 𝐖𝐢𝐭𝐡 𝐩𝐢𝐩 (𝐭𝐲𝐩𝐢𝐜𝐚𝐥 𝐟𝐥𝐨𝐰): Create project folder → Manually create virtual environment (python -m venv venv) → Activate it (different commands per OS) → Upgrade pip (optional but common) → Install dependencies → Sometimes fix path or interpreter issues → Maintain separate requirements file It works — but it’s fragmented and repetitive. 𝐖𝐢𝐭𝐡 𝐮𝐯: Initialize project in one step -- That's it. The virtual environment handled automatically, Dependencies managed cleanly, Lockfile(UV's requirements.txt) generated for reproducibility Less ceremony. Fewer steps. Cleaner workflow. 2. Faster installs → pip installs packages sequentially. → uv performs parallel installation and dependency resolution. The difference becomes obvious in larger projects or fresh environment setups. 3. Shipping accuracy pip + requirements.txt often lists package names only conflicts when different python version is being used. uv generates a lockfile with exact resolved versions, ensuring consistent installs across machines and deployments. Better reproducibility. Fewer works on my machine issues. For anyone working in AI/ML, backend, automation, or tooling-heavy Python workflows, uv reduces overhead and speeds up iteration. Check out the Complete guide by Corey Schafer (one of the most respected educators in the Python community) to know more about it: https://lnkd.in/gN2BbbSy stay tuned for more updates✌️. #Python #PythonDevelopment #UV #PythonTools #DevTools #SoftwareDevelopment #BackendDevelopment #AIML #DataScienc #DeveloperProductivity #OpenSource #Programming #TechCommunity #BuildInPublic #ModernDevelopment

🧠 Python Feature That Makes Error Handling Elegant: contextlib.suppress 💫 No noisy try/except. 💫 No empty except: pass. 💫 Just clean intent ❌ Old Way try: os.remove("temp.txt") except FileNotFoundError: pass Works… but feels messy 😬 ✅ Pythonic Way from contextlib import suppress with suppress(FileNotFoundError): os.remove("temp.txt") Readable. Explicit. Clean. 🧒 Simple Explanation Imagine wearing noise-canceling headphones 🎧 You choose which noise to ignore. Python ignores only that error — nothing else. 💡 Why This Is Powerful ✔ Cleaner error handling ✔ Avoids swallowing real bugs ✔ Very expressive code ✔ Used in production-grade code ⚠️ Important Rule Only suppress errors you truly expect (never hide bugs blindly ❌) 💻 Clean code isn’t about removing errors. 💻 It’s about handling them intentionally 🐍✨ 💻 contextlib.suppress is Python being elegant again. #Python #PythonTips #PythonTricks #AdvancedPython #CleanCode #LearnPython #Programming #DeveloperLife #DailyCoding #100DaysOfCode

Me: can we use #claudecode? Nobody: we have Claude Code at home! Claude Code at home: (see while-loop below) As magical as code assistants feel today, the core agent loop fits in ~100 lines of Python for my “From LLMs to Agents” lecture at Columbia University. The intuition: LLMs are text→text functions, so you need a layer that does text→tool→text. Run a Python interpreter and pipe logs back, call an API and parse JSON, etc. The rest is "just" scaffolding and optimizations! So where’s the magic? In the model and in the tools. You can swap Claude Code for another agent in a minute, but not every #lakehouse plays nicely with agentic patterns (i.e., we argued before that only one fits the bill 👉 https://lnkd.in/g7p5htZg) Should you rebuild Claude Code? Definitely not, but it is worth demystifying what’s “presentation layer” vs what’s the sticky backend. If you want to play with this idea, the repo includes the lecture slides and an open-source implementation: https://lnkd.in/gT3ZzSEv And if it’s useful, consider leaving a ⭐️: it helps others find it! See you, #agentic cowboys!

🚀 Project Showcase: Real-Time EMA Crossover Stock Monitoring & Prediction System I’m excited to share my latest project built using Django and Python. This system monitors live stock market data, detects EMA crossovers across multiple timeframes, and provides real-time trading signals. It also includes a machine learning module that predicts future stock trends using historical CSV data. 🔹 Key Highlights: 🔐 OTP-based secure authentication   📈 Real-time EMA crossover detection   ⏱ Multi-timeframe analysis (15m, 30m, 1h, 1d)   🤖 Background stock monitoring bot   📊 Live dashboard with AJAX updates   🧠 ML-based trend prediction  This project helped me gain hands-on experience with real-time systems, background processing, and AI-based decision support. 🔗 GitHub Repository: https://lnkd.in/d9in7qck 🎥 Demo video below 👇 I’d love to hear your feedback! #Django #Python #MachineLearning #StockMarket #WebDevelopment #StudentProject #FinalYearProject #GitHub

Whoa … Amazing how much faster #Rust is on so many tasks than #Python. There’s a lot of philosophical discussion around Rust vs. Python. So I ran a simple benchmark instead. Test setup: - Generate 5 million records - Hash each record (SHA-256) - Group by hash prefix - Measure execution time + peak memory No I/O. No tricks. Just CPU + memory pressure. Results on my machine (M2 MacBook Air, 24 GB RAM): 🐍 Python: ~8–12 seconds, ~800–1200 MB peak memory 🦀 Rust (release build): ~0.7–1.5 seconds, ~250–350 MB peak memory That’s not “a bit faster.” That’s an order of magnitude difference in speed — and significantly tighter memory behavior!!! Why? Python: - Interpreter overhead per loop - Boxed objects - Heavy dictionaries - GC + ref counting Rust: - Zero-cost abstractions - Tight memory layout - No GC - Native compiled code But raw performance is only one axis. If I’m building: - API orchestration - AI workflows - Rapid prototypes - Business logic Python wins on time-to-value. If I’m building: - High-volume data pipelines - Graph ingestion engines - Hash-heavy processing - Systems-level infrastructure Rust is in a different league. The real answer isn’t “Rust or Python?” It’s: Where does performance actually matter in your architecture? Curious how others decide where to draw that boundary. What do you think?