Alex C.’s Post

Built Zetten - a Rust-powered task runner for Python backends. I was tired of glue code (venvs, env vars, duplicated CI scripts), so I built a tool to make running and orchestrating tasks boring again. One cool surprise: standardized task definitions make AI coding much more reliable. No guessing - it just reads the config and runs correctly. I wrote more about the journey, tradeoffs, and lessons on Substack: https://lnkd.in/gitWHmfJ If you’re into Rust, Python, or developer tooling, I’d love your feedback. Repo: https://lnkd.in/gTrzzkn4 #Rust #Python #OpenSource #BuildInPublic #DevTools

Most Python code works. Very little Python code scales. The difference? 👉 Object-Oriented Programming (OOPS). As part of rebuilding my Python foundations for Data, ML, and AI, I’m now focusing on OOPS — the layer that turns scripts into maintainable systems. Below are short, practical notes on OOPS — explained the way I wish I learned it 👇 (No theory overload, only what actually matters) 🧠 Python OOPS — Short Notes (Practical First) 🔹 1. Class & Object A class is a blueprint. An object is a real instance. class User: def __init__(self, name): self.name = name u = User("Anurag") Used to model real-world entities (User, File, Model, Pipeline) 🔹 2. __init__ (Constructor) Runs automatically when an object is created. Used to initialize data. def __init__(self, x, y): self.x = x self.y = y 🔹 3. Encapsulation Keep data + logic together. Control access using methods. class Account: def get_balance(self): return self.__balance Improves safety & maintainability 🔹 4. Inheritance Reuse existing code instead of rewriting. class Admin(User): pass Used heavily in frameworks & libraries 🔹 5. Polymorphism Same method name, different behavior. obj.process() Makes systems flexible and extensible 🔹 6. Abstraction Expose what a class does, hide how it does it. from abc import ABC, abstractmethod Critical for large codebases & APIs OOPS isn’t about syntax. It’s about thinking in systems, not scripts. #Python #OOPS #DataEngineering #LearningInPublic #SoftwareEngineering #AIJourney

“Why are you looking at Rust 🦀 ?” 🤔 I get that question a lot. Python 🐍 is still the dominant language in network automation — and for good reason. But when you start building long-running, scalable automation systems, the runtime matters just as much as the logic. That’s why I’ve been looking at how Rust and Python work together, not in competition, but as complementary strengths. I wrote an article on how Rust can act as a safe, high-performance automation runtime, while Python remains the language for intent, logic, and extensibility — connected cleanly using PyO3. 👉 Python as a plugin, not a process 👉 Rust for safety, performance, and control If you’re curious why more Python tooling is powered by Rust — and what that means for automation platforms — have a read 👇 🔗 https://lnkd.in/eh5herY4

How to Build an MCP Server in Python — Step by Step Everyone’s talking about Agentic AI. Very few explain how the plumbing actually works. So I wrote a practical, end-to-end guide on building an MCP (Model Context Protocol) server in Python — no hand-waving, no vendor fluff. In this post, I walk through: - What an MCP server really is (beyond the buzzwords) - How tools, resources, and prompts actually fit together - A minimal but production-ready Python MCP server - The mental model you need to extend it for real systems (Redmine, legacy APIs, internal platforms) If you’re serious about moving from RAG → agentic workflows, this is the missing piece. #AgenticAI #MCP #LLM #Python #AIEngineering #DeveloperTools

Python 3.14 keeps raising the bar for developer productivity : clearer errors, smarter templates(t-strings) and serious progress toward parallel execution. Small changes, big long-term impact.

Python doesn’t just run code — it decides what to run next… just like we do. When you first learn to code, it feels magical: you write a few lines, hit run, and something happens. But a real program doesn’t just go top to bottom — it needs to think, react, and choose based on conditions, just like human decision making in everyday life. In my latest article, I break down how Python “thinks” with control flow, showing how constructs like if, else, and logical conditions let your code behave intelligently — not just sequentially. 👇 Here’s what you’ll learn: 🔹 What control flow really means It’s not just syntax — it’s how Python evaluates conditions and chooses actions like humans do. 🔹 Why programs need decision logic Without it, your code would just follow instructions blindly — and that’s not very useful for dynamic tasks. 🔹 How if, else, and chained conditions work together These are the structures that allow your Python programs to adapt to different scenarios and inputs. 🔹 Real-life analogy to human thinking Just like carrying an umbrella if it’s raining, Python evaluates “conditions” and chooses what to do next — making your programs flexible and responsive. Whether you’re just starting your Python journey or building data pipelines, ML systems, or automation tools, understanding how Python decides is foundational to writing smarter code. 👉 I’ll drop the article link in the first comment — check it out and let me know this: What’s one decision your code has to make often? Is it based on user input, data values, or something else? 👇 #Python #Programming #ControlFlow #DecisionMaking #Coding #DataScience #TechLearning

🎯𝗗𝗮𝘆 𝟮/𝟯𝟬 – 𝟯𝟬-𝗗𝗮𝘆𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲🔥 Day 2 complete.📝 Today was less about syntax… and more about thinking logically. I focused on Control Flow and Functions in Python — basically how programs make decisions and how we avoid repeating code. Here’s what I learned (and revised) today 𝟭. 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗙𝗹𝗼𝘄 – Teaching Code to Think Programming isn’t just writing instructions. It’s teaching the system how to decide. -Conditional Statements (if, elif, else) This is where logic begins. if condition: # execute this elif another_condition: # execute this else: # fallback Python checks conditions from top to bottom. Only the first true condition runs. It reminded me that order matters — 𝗶𝗻 𝗰𝗼𝗱𝗲 𝗮𝗻𝗱 𝗶𝗻 𝗹𝗶𝗳𝗲. Loops help us repeat tasks efficiently. 𝗳𝗼𝗿 𝗹𝗼𝗼𝗽 → when we know how many times to run. for i in range(5): print(i) 𝘄𝗵𝗶𝗹𝗲 𝗹𝗼𝗼𝗽 → when execution depends on a condition. while condition: # keep running 𝗯𝗿𝗲𝗮𝗸 → stops the loop immediately 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲 → skips current iteration 𝗽𝗮𝘀𝘀 → placeholder 𝟮. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 – Write Once, Use Many Times This was my favorite part today. Instead of repeating code again and again, we define functions. def greet(name): return f"Hello {name}" *𝗮𝗿𝗴𝘀 → accepts multiple positional arguments (stored as tuple) **𝗸𝘄𝗮𝗿𝗴𝘀 → accepts multiple keyword arguments (stored as dictionary) 𝗟𝗘𝗚𝗕 𝗥𝘂𝗹𝗲 (𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗦𝗰𝗼𝗽𝗲) Python searches variables in this order: 𝗟𝗼𝗰𝗮𝗹 → 𝗘𝗻𝗰𝗹𝗼𝘀𝗶𝗻𝗴 → 𝗚𝗹𝗼𝗯𝗮𝗹 → 𝗕𝘂𝗶𝗹𝘁-𝗶𝗻 Scope clarity = fewer debugging headaches. 𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻 A function calling itself. Powerful, but must have a base condition, otherwise it runs forever. 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (𝘆𝗶𝗲𝗹𝗱) Unlike return, which ends a function, yield pauses it and resumes later. Generators don’t store all values in memory — they generate values one by one. 𝗹𝗮𝗺𝗯𝗱𝗮 → small anonymous functions 𝗺𝗮𝗽() → transform data 𝗳𝗶𝗹𝘁𝗲𝗿() → filter data 𝗿𝗲𝗱𝘂𝗰𝗲() → reduce list to single value It showed me there are multiple ways to solve the same problem — and choosing the right one matters. 𝗛𝗶𝗴𝗵𝗲𝗿-𝗢𝗿𝗱𝗲𝗿 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀, 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 & 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 Today I learned that in Python: Functions can accept other functions. Functions can return functions. Inner functions can remember outer variables (Closures). We can pre-fill arguments using partial(). This made Python feel powerful and elegant. 📝 𝗥𝗲𝗳𝗹𝗲𝗰𝘁𝗶𝗼𝗻 – 𝗗𝗮𝘆 𝟮 Today wasn’t about writing long programs. It was about: - Understanding flow - Structuring logic -Writing smarter code - Thinking like a programmer I’m realizing something: The more I learn fundamentals deeply, the more confident I feel moving forward. Consistency > Motivation. 28 days to go. #𝟯𝟬𝗗𝗮𝘆𝘀𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 #𝗣𝘆𝘁𝗵𝗼𝗻 #𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗜𝗻𝗣𝘂𝗯𝗹𝗶𝗰 #𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 #𝗦𝗮𝗵𝗮𝗻𝗮.𝗕𝘂𝗶𝗹𝗱s #𝗗𝗮𝘆𝟮

🌶️ Python is NOT ready for the agentic era of software engineering. And that's an existential risk for teams who ship Python in production. Why so? It's all about... 👏 FEEDBACK LOOPS 👏 FEEDBACK LOOPS 👏 FEEDBACK LOOPS 👏 The #AgenticAI workflows of today heavily rely on strong feedback loops to steer agents in the right direction. Formatters, linters, type checkers, LSP diagnostics, test runners... All of these tools play a critical role in repelling code slop. 💡 Yet, type safety in Python remains an afterthought. In practice you get `dict[str, Any]`, `Unknown` return types, or no type stubs at all even among the mainstream packages in the ecosystem. The preference for defensive duck typing over robust type safety is culturally pervasive. 💡 Many modern typing features feel bolted-on and inconsistent. A far cry from the Zen of Python: `if TYPE_CHECKING`, quoted "type expressions", and runtime typing incantations are fragile and non-cohesive. 💡 Worse, many of these type-safety features aren’t reliably in current model knowledge cut-offs. Agents burn context web-searching for the latest PEPs instead of reasoning about the problem. That is, if you're lucky that the model even decides to do that... 💡 Static analysis and control-flow narrowing are also primitive compared to their TypeScript counterparts. Tools like Pyright struggle to collapse unions without blunt tools like `isinstance` and `assert`. Agents burn precious context looping on `Unknown`, retrying type trickery, and spending tokens web-searching PEPs for edge-case features. 💡 TypeScript, by contrast, offers a far stricter and more intelligent harness for coding agents. When coupled with an ecosystem that cares about end-to-end type safety, the difference in developer (and agent!) experience is night and day! If you must use Python in production, the only defensible exception is ecosystem lock-in. But even then, we should treat that as technical debt, not a default. Moving forward, new greenfield projects should *strongly* reconsider using Python. To say the least, there are far more productive options nowadays. #Python #TypeScript #SoftwareEngineering #TypeSafety

uv... There’s this moment in Python when you try a tool and it just… clicks. Feels like one of those rare upgrades to the Python ecosystem that fixes fundamentals instead of adding another layer on top. No ceremony, no "read the docs for two days", no mental overhead. You install it, run one or two commands, and suddenly your whole workflow feels cleaner and faster. That’s how uv feels right now. It’s a new-generation package manager and environment manager in one. You create virtual environments, install packages, lock dependencies, run tools, even inspect dependency graphs, all from one fast, minimal CLI. No more juggling pip, venv, poetry, pip-tools, pyenv and a small zoo of shell scripts. What makes it special is how organic it feels. It doesn’t try to reinvent Python packaging. It just takes the existing ecosystem (pip, wheels, pyproject.toml, lock files) and makes it pleasant to use. You type uv add, uv run, uv venv and things just work. Tooling around it is growing fast, it works nicely in Docker and CI, and many Python projects are quietly switching because once you try it, going back to the old stack feels like using a modem after fiber. This is one of those tools that doesn’t need much evangelism. You use it once, and it’s hard not to keep using it. Have you adopted it already? https://lnkd.in/gh56pAbw https://docs.astral.sh/uv/ https://astral.sh/blog/uv #python #DataEngineering

Announcing yaml12: High-Performance YAML 1.2 Parsing for R and Python We are pleased to announce the release of yaml12 (for R) and py-yaml12 (for Python), two new packages designed to provide predictable, high-performance YAML 1.2 parsing and emitting. These packages are specifically designed for those who use YAML for configuration files, front matter, or data interchange. While the existing yaml package in R remains maintained for those who rely on it, yaml12 offers a modernized alternative built on a shared Rust-based core. • Built with Rust, the R package is approximately 2x faster than the original yaml package, while the Python version (py-yaml12) has demonstrated speeds over 50x faster than default PyYAML in common benchmarks. • By following the YAML 1.2 specification, the packages provide stricter implicit conversions. • Both the R and Python packages share a consistent API and design philosophy, making it easier for teams working in multi-language environments to maintain the same YAML behavior. The library is designed to preserve mapping order and handle unhandled tags gracefully, ensuring that data written back to YAML retains its original structure and intent. Learn more about the release and its technical capabilities on the Tidyverse blog: https://lnkd.in/gXMBxzdU