Most Python developers learned packaging the same way: Install Python → create a virtual environment → install dependencies with pip. The core of this workflow has always been pip, the package installer that pulls libraries from the Python Package Index (PyPI). pip does its job well, but it was never designed to manage the broader concerns of a Python project. Things like Python version management, environment isolation, dependency locking, and reproducible setups have traditionally been handled by a collection of separate tools layered around it. Over time, this led to a fairly fragmented developer experience. Setting up a project often meant juggling multiple utilities and expecting every developer (or user) to configure them correctly before running even a simple script. Recently I’ve been exploring uv, a newer tool that approaches this problem from a different angle. Instead of focusing purely on package installation, uv acts as a broader project and environment manager. It can automatically handle Python versions, create isolated environments, resolve dependencies, and run scripts—all from a single interface, and significantly faster than the traditional stack. The interesting part isn’t that uv replaces pip entirely, but that it collapses several layers of the traditional Python tooling ecosystem into something much simpler to work with. I wrote a short article breaking down how pip fits into the traditional workflow and where uv changes the model. If you work with Python or manage Python environments across teams, it might be a useful read. https://lnkd.in/g2s3wpEN This post is part of my Tech101 series, where I explore fundamental developer tools and concepts. If you found this useful, follow along for future posts. I'm curious how others are approaching this. Are you sticking with the classic pip + virtualenv setup, or starting to experiment with tools like uv? #python #softwaredevelopment #latest #softwareengineer #bestpractices #tech101

The new inline comprehensions unpacking is a really cool feature, avoiding nested comprehensions... #Python $ python3.15 Python 3.15.0a6+ (heads/main:3f37b94c737, Feb 19 2026, 17:29:52) [GCC 12.2.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> L=[list(range(i,i+5)) for i in range(5)] # Earlier >>> [x for item in L for x in item] [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8] # Now >>> [*x for x in L] [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]

🚨Exception Handling Philosophy: JavaScript vs Python When working across multiple languages, we’ll notice that error handling isn’t just about syntax — it’s about philosophy. JavaScript and Python approach exceptions with slightly different mindsets. 🟨 JavaScript — LBYL (Look Before You Leap): Developers often check conditions before performing an operation. The idea is to validate inputs or states first to avoid runtime errors. 🟦 Python — EAFP (Easier to Ask Forgiveness than Permission): Python encourages trying the operation first and handling the exception if it occurs. This keeps the main logic concise and more Pythonic. ⚖️ Core Difference JavaScript: Check first, then act. Python: Act first, handle failure if needed. Examples in the image below 👇 #Python #JavaScript #WebDevelopment #BackendDevelopment #SoftwareEngineering #Programming #Developers #ErrorHandling #TechCommunity #LearningInPublic #SoftwareDevelopment #CleanCode 

UV is great for python package management, but I shot myself in the foot with it. At work I developed the release process of our python backend microservices monorepo and I came up with a release branch strategy that when fired, automatically creates a release branch and bumps versions of the updated services. Then multiple release candidate versions can be pushed to pre-prod, before a release is finalized and a new prod version is pushed. Version bumps work by changing the semantic version in the pyproject.toml file which with uv also syncs in the uv.lock file - then these 2 files are used inside each container to build the python dependencies. The problem is that the COPY of the uv files is almost at the beginning of the dockerfile, which invalidates all cached layers below. Even if dependencies are not changed for the particular service, we still rebuild everything. This is not a big problem for all services, but there is one in particular that builds for 15 minutes which makes everything slow. I still need to figure out a way to mitigate that, so if you have any suggestion 😁 probably the only thing I can think of is to split out the dependencies or the version but its not ideal.

For anyone that migrated from #TwosApp to #Obsidian or just wants to include their TwosApp notes in Obsidian, I created this #Python utility to export a TwosApp markdown export into individual markdown files that follow the standard YYYY-MM-DD date format filename convention. You can find the repo for this at... https://lnkd.in/ep9E8xCF You don't have to download the entire repo, just the Python file. I strongly recommend exporting the files into their own subfolder, not your Daily Notes folder. But that's up to you. #OpenSource #GitHub

Why the Python Pass Statement Is Useful The `pass` statement serves as a useful placeholder in your code. It allows you to define functions, loops, or conditionals without having to implement any logic just yet. This keeps your code free from syntax errors, giving you a valid structure while you ponder the final implementation. Using `pass` is particularly beneficial during incremental development. When you are drafting a function or a control structure, you might not have the complete logic ready. By utilizing `pass`, you ensure that your code remains executable, making it easier to iterate. This is especially advantageous during rapid prototyping, where you may want to present the intended structure to teammates or stakeholders without all the details ironed out. Additionally, `pass` can enhance code readability. Rather than leaving an empty block, it signifies to anyone reading the code that there’s an intention behind the vacant structure. It acts as an effective communication tool within the codebase, helping maintain clarity and context without cluttering the area with comments about what's missing. Quick challenge: How would you modify the `placeholder_function` to include a simple return statement while still using `pass` in a meaningful way? #WhatImReadingToday #Python #PythonProgramming #CodeQuality #PythonTips #Programming

Perhaps you've seen that uvx command in your MCP server configs and wondered what it does. It's shorthand for uv tool run. uv is a single Rust binary that replaces your entire Python toolchain — pyenv, virtualenv, pip-tools, Poetry, all of it. uvx runs any package in its own throwaway environment, which is exactly why MCP configs use it. Since I switched, versioning issues are gone and my Python setup is simpler than it's ever been. Here's the full story: 👉 https://lnkd.in/epFEYRBC

I once spent 3 hours debugging a Python script. The logic was right. The data was right. The tests were passing. But the output was wrong. Every. Single. Time. Turns out? A variable I thought was local was leaking from an outer scope. One line. Three hours. A lesson I never forgot. Scope bugs are brutal because Python doesn't yell at you, it just silently uses the wrong value. So I put together a free guide that breaks down exactly how Python scope works: → The LEGB rule, explained simply → The most common scope bugs (and why they're so sneaky) → How to read your own code the way Python reads it → global and nonlocal, when to use them, when to avoid them If you've ever been confused by a variable that "shouldn't" have that value... this guide is for you. Get it free here: https://lnkd.in/dY8az6hc Save this post. Your future self will thank you. #Python #SoftwareDevelopment #Programming #PythonTips #ChiefOfCode