Introduction

If you have worked with Python for more than five minutes, you have probably lived through this ritual: create a virtual environment with venv, install packages with pip, discover that you need pip-tools to generate a lockfile, use pyenv to switch Python versions, consider Poetry but give up because of its complexity, and eventually accept that dependency management in Python is an exercise in patience.

The Python ecosystem has always been like this — powerful, but fragmented. Each tool solves one piece of the problem. None of them solves everything. And the developer is stuck in the middle, gluing pieces together like an endless jigsaw puzzle.

That has changed. In February 2024, Astral — the same company behind Ruff, the fastest Python linter in the world — launched UV: a manager for packages, virtual environments and Python versions written in Rust, up to 100 times faster than pip. And it did not come to be just another piece of the puzzle. It came to be the whole puzzle.

In this article, we will explore:

  • The history of Python — who created it, when, and who maintains it today
  • Why Python gained so much prominence in recent years
  • The fragmentation problem that UV solves
  • What UV is, who created it, and how to use it in practice
  • And the question that will not go away: in complex applications, with architectural patterns and modularity, does Python compete with C#?

If you already use Python or are evaluating whether you should, this article is for you.


Python: A Brief History

Origins

Python was created by Guido van Rossum, a Dutch programmer who worked at CWI (Centrum Wiskunde & Informatica) in Amsterdam. Development began in late 1989, and the first public version — Python 0.9.0 — was released in February 1991.

The name has nothing to do with snakes. Guido was a fan of the British comedy group Monty Python, and he wanted a short, mysterious and slightly irreverent name. It worked.

Philosophy

From the start, Python was designed with a clear philosophy: readability above all. Where other languages use braces {} and semicolons ;, Python uses indentation. The idea was that code should be as easy to read as it is to write.

This philosophy was formalized in the Zen of Python (PEP 20), which you can see by running import this in the interpreter:

1
import this
1
2
3
4
5
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Readability counts.
There should be one -- and preferably only one -- obvious way to do it.

💡 The Zen of Python is not just poetry — it still guides the language’s design decisions today.

Guido and the BDFL

For almost three decades, Guido acted as BDFL — Benevolent Dictator For Life. He had the final word on any design decision in the language.

That changed in July 2018, when the controversial PEP 572 (which introduced the := operator, nicknamed the walrus operator) sparked such intense debate in the community that Guido decided to step away. He renounced the BDFL title and retired from direct leadership.

Who maintains Python today

Since 2019, Python has been governed by a Steering Council — an elected five-member committee that makes decisions on the language’s design and direction. The council is elected by the community of core developers for each release. Behind the Steering Council is the Python Software Foundation (PSF), a non-profit organization that looks after infrastructure, events, funding and the protection of the Python brand.

ℹ️ Guido van Rossum worked at Dropbox (2013–2019) and later at Microsoft (2020–2023), where he contributed significantly to the performance of CPython (the default interpreter). Today he remains an emeritus core developer, but without veto power.

Landmark versions

YearVersionMilestone
19910.9.0First public version
20002.0List comprehensions, garbage collector
20083.0Broke compatibility with Python 2 (a painful migration that lasted more than a decade)
20153.5Native async/await, type hints (PEP 484)
20163.6f-strings (f"Hello {name}") — changed how strings are formatted forever
20203.9Dictionary merge with |, native generic type hints
20223.11Performance improvements of 10-60% (Guido’s Faster CPython project at Microsoft)
20233.12Per-interpreter GIL (the start of the path to removing the GIL)
20243.13Experimental free-threaded mode (no GIL)

⚠️ The migration from Python 2 to Python 3 was one of the most painful in the history of computing. It took more than 12 years — Python 2 only reached its EOL (End of Life) in January 2020. That traumatic experience shaped the community: since then, Python avoids breaking compatibility at all costs.


Why Python Gained So Much Prominence

If someone had told you in 2010 that Python would be the most popular language in the world within a few years, you would probably have doubted it. Back then, Java, C and C++ reigned. Python was seen as a scripting language, good for automation and little else. What changed?

The data and AI revolution

The rise of data science, machine learning and artificial intelligence put Python at the center of the map. Not because Python was the fastest or most robust language — but because the ecosystem formed around it:

AreaDominant Python libraries
Numerical computingNumPy, SciPy
Data analysisPandas, Polars
Machine Learningscikit-learn, XGBoost, LightGBM
Deep LearningTensorFlow, PyTorch, Keras
Generative AILangChain, Hugging Face Transformers, OpenAI SDK
VisualizationMatplotlib, Seaborn, Plotly
NotebooksJupyter, Google Colab

When TensorFlow (Google, 2015) and PyTorch (Meta, 2016) chose Python as their main interface, the outcome was sealed. Researchers, data scientists and ML engineers concentrated on Python, and the network effect did the rest.

Academic adoption

Universities around the world started teaching programming with Python instead of Java or C. MIT switched its introductory course to Python in 2009. Stanford followed. The consequence: an entire generation of developers grew up with Python as their first language.

Versatility

Python is not only for AI. It has a significant presence in:

  • Web: Django (full-stack), FastAPI (modern APIs), Flask (microframework)
  • Automation and DevOps: Ansible, infrastructure scripts, CI/CD
  • Scripting: replacing Bash for complex tasks
  • APIs and microservices: with FastAPI + Pydantic
  • Education: thanks to its clean syntax and low barrier to entry

Python in numbers (2025–2026)

IndicatorPosition / Metric
TIOBE Index#1 (leader since 2021)
Stack Overflow Survey 2025Top 3 most used languages
GitHub Octoverse 2025#1 in new repositories
PyPI (official repository)600,000+ published packages
Monthly downloads (PyPI)15+ billion

💡 Python is not necessarily the best language for every problem. But it is the language with the least friction to get started — and that counts for a lot when the goal is to validate ideas, prototype or iterate quickly.


The Problem UV Solves

Now that we understand why Python is so popular, let’s get to the point every Python developer knows well: the chaos of package and environment management.

The ecosystem before UV

The history of dependency management in Python is a history of fragmentation. Each tool solves one piece of the problem, but none of them solves everything:

ToolWhat it doesWhat it does NOT doProblem
pipInstalls packagesDoes not manage environments, no native lockfileSlow (resolution in pure Python), no reproducibility
virtualenv / venvCreates virtual environmentsDoes not install packages, does not manage Python versionsIt is just one piece of the puzzle
pip-toolsGenerates a lockfile (pinned requirements.txt)Does not manage environments or Python versionsRequires manual combination with pip + venv
PipenvCombines pip + virtualenv + lockfilePoor performance, unstable maintenancePractically abandoned by the community
PoetryManages packages, venv, lockfile, buildDoes not manage Python versionsComplex, slow, solves everything but at a cost
CondaManages packages + environments + Python + C/FortranA world parallel to PyPIConflicts with pip, isolated ecosystem
pyenvManages Python versionsDoes not install packages, does not manage environmentsOne more tool to learn
pipxRuns isolated Python toolsNot meant for projectsLimited scope

The typical workflow before UV

To set up a Python project “properly” before UV, developers had to combine multiple tools:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# ❌ Fragmented workflow (before UV)

# 1. Install the right Python version
pyenv install 3.12.1
pyenv local 3.12.1

# 2. Create a virtual environment
python -m venv .venv
source .venv/bin/activate    # Linux/macOS
# .venv\Scripts\Activate.ps1 # Windows

# 3. Install dependencies
pip install fastapi uvicorn

# 4. Generate a lockfile (if using pip-tools)
pip install pip-tools
pip-compile requirements.in -o requirements.txt

# 5. Run linting tools (if using pipx)
pipx install ruff
ruff check .

Five different tools. Five install commands. Five things to document and explain to anyone joining the project. That is the problem UV solves.

⚠️ Poetry tried to unify part of this workflow, and for many projects it works well. But dependency resolution is slow (written in Python), its pyproject.toml has its own conventions that diverge from PEP standards, and it still requires a separate pyenv to manage Python versions.


UV: What It Is and Who Created It

Astral and Charlie Marsh

UV was created by Astral, a company founded by Charlie Marsh in 2023. Charlie is an American software engineer who, before founding Astral, worked on Python infrastructure and realized that the ecosystem’s fundamental tools were decades behind what other languages offered.

Astral was already known for Ruff — a linter and formatter for Python written in Rust that is 100 to 300 times faster than equivalent tools such as Flake8 and Black. Ruff’s success proved that rewriting Python tooling in Rust produced real and immense gains.

In February 2024, Astral launched UV with the same premise: take what the Python ecosystem did slowly and in a fragmented way and rewrite it in Rust, fast and unified.

💡 Astral received a US$ 4 million investment from Accel to develop UV and Ruff. Charlie Marsh is a former engineer at Spring Health and Khan Academy.

What UV does

UV is a unified toolkit for Python, written in Rust. On its own, it replaces the following tools:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
┌─────────────────────────────────────────────────────────┐
│                         UV                              │
│                                                         │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│   │ Gerenciador  │  │  Ambientes   │  │  Versões do  │  │
│   │ de pacotes   │  │  virtuais    │  │  Python      │  │
│   │ (pip,        │  │ (virtualenv, │  │ (pyenv)      │  │
│   │  pip-tools)  │  │  venv)       │  │              │  │
│   └──────────────┘  └──────────────┘  └──────────────┘  │
│                                                         │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│   │ Gerenciador  │  │  Execução    │  │  Lockfile    │  │
│   │ de projetos  │  │  de scripts  │  │  nativo      │  │
│   │ (poetry)     │  │  e tools     │  │  (uv.lock)   │  │
│   │              │  │  (pipx)      │  │              │  │
│   └──────────────┘  └──────────────┘  └──────────────┘  │
│                                                         │
└─────────────────────────────────────────────────────────┘

In concrete terms:

CapabilityTool it replacesUV command
Install packagespip installuv add / uv pip install
Create a virtual environmentpython -m venvuv venv (automatic)
Generate a lockfilepip-compile (pip-tools)uv lock (automatic)
Manage Python versionspyenv installuv python install
Create a projectpoetry inituv init
Run toolspipx runuvx
Run scriptspython script.pyuv run script.py

Speed

The speed difference is not incremental — it is a different order of magnitude:

OperationpipUVFactor
Install dependencies (cold cache)~22s~1.2s18x faster
Install dependencies (warm cache)~5s~0.06s80x faster
Dependency resolutionseconds to minutesmilliseconds10-100x faster
Create a virtual environment~1.5s~0.01s150x faster

📌 These numbers vary by project and environment, but the order of magnitude is consistent. UV does in milliseconds what pip does in seconds — and in seconds what pip does in minutes.

This speed is no accident. UV is written in Rust, with dependency resolution implemented in an optimized SAT solver (PubGrub), aggressive caching, parallel downloads and zero Python interpreter overhead.


UV in Practice

Enough theory. Let’s see UV in action.

Installation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Linux / macOS
curl -LsSf https://astral.sh/uv/install.sh | sh

# Via pip (if you prefer — but you lose part of the fun)
pip install uv

# Via Homebrew (macOS)
brew install uv

After installing, check:

1
uv --version
1
uv 0.6.x

Create a new project

1
2
uv init meu-projeto-api
cd meu-projeto-api

UV generates the following structure:

1
2
3
4
5
meu-projeto-api/
├── .python-version      # Pinned Python version
├── pyproject.toml        # Project metadata and dependencies
├── README.md
└── main.py               # Basic entrypoint

The generated pyproject.toml follows the PEP standards (621, 517):

1
2
3
4
5
6
7
[project]
name = "meu-projeto-api"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12"
dependencies = []

💡 Unlike Poetry, which uses proprietary keys such as [tool.poetry], UV follows the official PEP standards. This means your pyproject.toml is compatible with any tool that follows the PEPs.

Add dependencies

1
2
3
4
5
# Add production dependencies
uv add fastapi uvicorn[standard]

# Add development dependencies
uv add --dev pytest ruff mypy

What happens under the hood:

  1. UV updates pyproject.toml with the new dependencies
  2. It resolves all dependencies (in milliseconds)
  3. It generates/updates uv.lock — a lockfile with hashes and exact versions
  4. It creates the virtual environment (.venv/) automatically, if it does not exist
  5. It installs everything in the virtual environment

All in a single command. In less than two seconds.

Run the project

1
2
3
4
5
# Run directly (UV activates the venv automatically)
uv run uvicorn main:app --reload

# Or run any Python script
uv run python main.py

💡 There is no need to activate the virtual environment manually. uv run does it for you. No more source .venv/bin/activate.

Manage Python versions

1
2
3
4
5
6
7
8
# List available versions
uv python list

# Install a specific version
uv python install 3.12

# Pin the project version
uv python pin 3.12

UV downloads and manages Python versions without needing pyenv. It works on Windows, Linux and macOS.

Run tools without installing them

1
2
3
4
5
6
7
8
# Run Ruff without installing it in the project
uvx ruff check .

# Run Black without installing it
uvx black --check .

# Run any tool from PyPI
uvx httpie https://api.github.com

uvx is the equivalent of Node.js’s npx — it runs Python tools in temporary environments, without polluting your project.

Complete workflow with UV

Remember the fragmented workflow with five tools? Now with UV:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
# ✅ Unified workflow with UV

# 1. Create the project (already pins the Python version)
uv init meu-projeto
cd meu-projeto

# 2. Install dependencies (creates venv + lockfile automatically)
uv add fastapi uvicorn[standard]
uv add --dev pytest ruff

# 3. Run (activates the venv automatically)
uv run uvicorn main:app --reload

# 4. Run tests
uv run pytest

# 5. Linting (without installing it in the project)
uvx ruff check .

One tool. Five lines. Zero friction.


When to Use UV

Ideal scenarios

UV is the right choice when you:

  • Are starting a new Python project — uv init provides the perfect standard structure
  • Want speed in CI/CD — installing dependencies in 1 second instead of 30 makes a difference in pipelines
  • Work with multiple Python versions — uv python install replaces pyenv without friction
  • Want reproducibility — uv.lock guarantees that everyone on the team uses exactly the same versions
  • Need something simple — one command for everything, without complex configuration
  • Maintain Python monorepos — UV supports Cargo/npm-style workspaces
  • Want to standardize the toolchain — one tool to manage everything, from venv to lockfile

Scenarios still worth evaluating

ScenarioRecommendation
Projects with Conda/AnacondaUV does not replace Conda for C/Fortran dependencies (BLAS, LAPACK, etc.). If your project depends heavily on the Conda ecosystem, evaluate the migration carefully
Very large legacy projectsMigrating a large project from Poetry or Pipenv may require adjustments. It works, but test it in separate branches
Restricted corporate environmentsIf your company blocks external binaries, UV (which is a Rust binary) may need security approval

💡 UV is compatible with pip. You can use uv pip install -r requirements.txt as a direct replacement for pip — same interface, Rust speed. This is the safest way to experiment without changing anything in the project.


Python vs C# in Complex Applications

Comparative diagram of Python vs C# — complementary domains

This is the question that motivated half of this article: when the application needs to be modular, with architectural patterns such as Clean Architecture, CQRS or Hexagonal — is it worth using Python instead of C#? Is there a real gain?

The honest answer is: it depends on what you call a “gain”.

Full comparison

DimensionPythonC#
TypingDynamic (with optional hints via mypy, Pydantic)Strong static typing (guaranteed by the compiler)
CompilationInterpreted — errors appear at runtimeCompiled — errors appear before deployment
Dependency InjectionThird-party: dependency-injector, python-inject, manualNative in the framework (IServiceCollection)
Interfaces / ContractsABC (Abstract Base Class) — not strong enforcementinterface — a real contract, verified by the compiler
Architectural PatternsPossible, but requires manual discipline. No opinionated framework for Clean ArchitectureMature ecosystem: MediatR (CQRS), Clean Architecture templates, Minimal APIs
ORMSQLAlchemy, Django ORM, TortoiseEntity Framework Core — superior in migrations, Fluent API and integration
Testspytest (excellent, mature)xUnit, NUnit, MSTest (all mature)
PerformanceThe GIL limits real parallelism (improving with 3.13+), I/O-bound work is good with asyncioReal parallelism, Tasks, mature async/await, high performance
Tooling / IDEPyCharm, VS Code (good, but refactoring is limited by dynamic typing)Visual Studio, Rider, VS Code (robust refactoring with static typing)
Enterprise EcosystemAzure SDK, AWS SDK — functional, but less integratedNative Azure, integrated Microsoft tools, complete enterprise ecosystem
ModularityPython modules and packages are flexible, but boundaries are not enforcedAssemblies, namespaces, separate projects with explicit references
Documentation / APISwagger via FastAPI (automatic), SphinxNative Swagger, XML docs, source generators

Python for architectural applications: possible, but…

Yes, you can implement Clean Architecture, Hexagonal, CQRS and any pattern in Python. Frameworks such as Django (opinionated, MTV) and FastAPI (modern, async, Pydantic) offer solid foundations. There are libraries for dependency injection, type validation and layer separation.

However, there are fundamental differences in the development experience:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# Python: Dependency injection with dependency-injector
from dependency_injector import containers, providers
from dependency_injector.wiring import Provide, inject

class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    user_repository = providers.Singleton(
        UserRepository,
        connection_string=config.db.connection_string,
    )
    user_service = providers.Factory(
        UserService,
        repository=user_repository,
    )

@inject
def create_user(
    service: UserService = Provide[Container.user_service],
):
    service.create(name="Lincoln")
1
2
3
4
5
6
7
8
9
// C#: Native dependency injection in .NET
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IUserService, UserService>();

// In the controller or endpoint, the framework injects automatically
app.MapPost("/users", (IUserService service) =>
{
    service.Create(name: "Lincoln");
});

The difference is not just syntax — it is philosophy:

  • In C#, DI is part of the framework. You do not need to choose a library, configure wiring or decorate methods. It works out of the box
  • In Python, DI is a third-party library. It works, but it adds complexity, requires configuration and has no native framework support

This difference repeats itself in almost every pattern:

PatternIn C#In Python
Interfacesinterface IService — a strong contract, verified at compile timeclass IService(ABC) — a convention, not real enforcement
RepositoryA mature pattern with EF Core, typed genericsImplementable, but without strong type safety
CQRSMediatR (an established library), clear separationManual implementation, no dominant library
MediatorMediatRNo consolidated equivalent
Options PatternNative IOptions<T>Manual configuration or Pydantic Settings

Where Python wins — no contest

There are domains where Python simply has no real competitor:

  • AI and Machine Learning: TensorFlow, PyTorch, Hugging Face — the entire ecosystem is Python-first
  • Data science: Pandas, NumPy, Jupyter — C# does not even enter the conversation
  • Rapid prototyping: from zero to a working API in minutes with FastAPI
  • Scripts and automation: replacing Bash, processing files, interacting with APIs
  • DevOps: Ansible, infrastructure scripts, CLI tools

Where C# wins — when complexity matters

For applications that require long-term maintenance by large teams, with rigorous architectural patterns, C# (and, more broadly, .NET) offers real advantages:

  • Safe refactoring: strong static typing lets you rename, extract and move code with confidence
  • The compiler as a gatekeeper: type errors, unimplemented interfaces and missing dependencies are detected before any code runs
  • Native DI and middleware: the ASP.NET Core pipeline is mature, testable and extensible
  • Enforced boundaries: separate assemblies and projects create real architectural boundaries, not just conventions
  • Enterprise ecosystem: native integration with Azure, SQL Server, Identity and the entire Microsoft ecosystem

The verdict

📌 Python and C# are not competitors — they are complementary.

ScenarioRecommended language
AI, ML, Deep LearningPython
Data science, analyticsPython
Scripts, automation, DevOpsPython
Rapid API prototypingPython (FastAPI)
Enterprise applications with rigorous patternsC# (.NET)
Clean Architecture, Hexagonal, CQRSC# (more mature ecosystem)
Applications with large teams and long maintenanceC# (static typing = safety)
High-performance APIs with intensive I/OC# (mature async/await, Kestrel)
Microservices with complex orchestrationBoth (depends on the company’s ecosystem)

The right question is not “Python or C#?” — it is “what problem am I solving?”

If the problem is AI, data or prototyping: Python, without a second thought.

If the problem is a modular application, with layers, patterns and a team that needs safe refactoring two years from now: C# will give you fewer headaches.

And what if the problem requires both? Use both. An AI microservice in Python, orchestration and the main API in C# — that is not heresy, it is pragmatism.


Important Considerations

UV Is Still Pre-1.0

UV is at version 0.6.x (March 2026). Although it is stable for production use and adopted by thousands of projects, the pre-1.0 version means that breaking changes may happen between minor releases. Astral mitigates this with detailed changelogs and assisted migration, but it is a point to consider before adopting it in conservative corporate environments. Follow the releases on GitHub to know when 1.0 arrives.

pyproject.toml as the Source of Truth

UV adopts pyproject.toml following PEPs 517, 518 and 621 — Python’s official standards for project metadata. This means your UV project is not locked into UV: any tool compatible with these PEPs (including pip and poetry) can read and use your pyproject.toml. If you ever need to migrate, the exit path is guaranteed.

UV and Docker

For projects that run in containers, UV shines especially at the build stage. An optimized Dockerfile with UV:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
FROM python:3.12-slim

# Install UV as a static binary (no dependencies)
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

WORKDIR /app
COPY pyproject.toml uv.lock ./

# Install dependencies (separate layer for caching)
RUN uv sync --frozen --no-dev

COPY src/ ./src/

CMD ["uv", "run", "uvicorn", "meu_api.main:app", "--host", "0.0.0.0"]

The gain in build time is huge — especially in CI/CD pipelines where every second of execution has a real cost.

UV vs Cargo vs dotnet CLI

If you come from Rust or .NET, you will notice that UV follows the same unified CLI philosophy:

AspectUV (Python)Cargo (Rust)dotnet CLI (C#)
Create a projectuv initcargo newdotnet new
Add a dependencyuv addcargo adddotnet add package
Runuv runcargo rundotnet run
Lockfileuv.lockCargo.lockpackages.lock.json
Build— (interpreted)cargo builddotnet build
Testsuv run pytestcargo testdotnet test

UV is, for Python, what cargo is for Rust: the tool the community waited decades for.

On Adoption and Community

Numbers that show UV’s traction:

  • 40,000+ stars on GitHub (March 2026)
  • Adopted by FastAPI as the recommended package manager in its official documentation
  • Integrated into GitHub Actions as an official option for setting up Python
  • Officially supported in VS Code and PyCharm
  • Weekly releases with detailed changelogs and strict semver

When to Migrate and When to Wait

If you are on a project with plain pip and feel the pain of slowness and the lack of a lockfile: migrate now. The cost is low — uv pip install -r requirements.txt works as a drop-in replacement for pip.

If you are on Poetry and the workflow works without pain: evaluate calmly. The migration is worth it, but it is not urgent if the project is already stable.

If your company requires audited and versioned tools (1.0+): wait for UV 1.0. But keep a close eye on it — it is near.


Conclusion

UV is, without exaggeration, the biggest advance in Python tooling in recent years. It solves a problem the community had been dragging along for more than a decade — the absurd fragmentation of tools for something that should be simple: installing packages, creating an environment and running code.

With UV, you have one tool that replaces pip, virtualenv, pyenv, pip-tools, pipx and part of Poetry. Written in Rust, with absurd speed and adherence to PEP standards. If you are starting a new Python project, there is no reason not to use UV.

As for the comparison with C#: Python is an extraordinary language for prototyping, AI, data and automation. But when the conversation is about complex enterprise applications with rigorous architectural patterns and long-term maintenance, C# (and .NET) offers structural advantages that are hard to ignore — strong static typing, native DI, the compiler as a gatekeeper, and superior refactoring tooling.

The maturity of a technical choice lies in recognizing that there is no perfect language for everything. There is the right language for the right problem. And having UV in the arsenal makes Python significantly more viable for serious projects — because the part that was always bad (package management) has finally become excellent.


References