Programming Language
SQLAlchemy 2.0 #1 The Big Picture: Core, ORM, and the 2.0 Style
First post in a series covering SQLAlchemy, the de facto standard database library for Python, from the ground up: the two-layer structure of Core and ORM, why 1.x-era code and 2.0-style code look different, the unified select()-centric query style and type hint support, installation and the first connection, and running raw SQL with text().
Python Packaging #7 Team Conventions and Tool Choice: uv, poetry, pip
The series finale: tool choice and team conventions. uv, poetry, and pip+venv on one table with criteria that decide between them, the real cost of migration, caching and frozen verification in CI, the standard pattern for uv in Docker images, and a team convention checklist that survives new teammates — closing with a look back at the whole series.
Rust Basics #1 What Rust Is: Why Learn It, Installing rustup, First Steps with cargo
Starting from what "memory safety without GC" actually means — the reason Rust has spread so quickly from kernels to CLI tools. The difference from languages where safety and performance were a trade-off, the one-line rustup install, the basic cycle of creating and running a project with cargo, how to read your first compile error message, and a map of the whole course.
Python Packaging #6 Publishing: Building Wheels and Uploading to PyPI
Switching from the receiving side to the making side: the workflow that turns your code into an installable package. The src layout and the role of build backends, the difference between sdist and wheel, building with uv build and rehearsing on TestPyPI before the real upload, tokenless deployment with GitHub Actions Trusted Publishing as the modern standard, and internal-only distribution alternatives.
Python Packaging #5 Dependency Locking: Lock Files and Reproducibility
Starting from why declaration and lock are separate, we read the contents of uv.lock directly: the resolution result that pins every transitive dependency, the supply-chain risks hash verification blocks, reproducing the lock exactly in CI with --frozen, a strategy that turns upgrades into routine work, and pylock.toml (PEP 751), the standard that opens movement between tools.
Python Packaging #4 uv: The Standard Workflow of 2026
The daily uv workflow that folds virtual environments, dependency installation, locking, and Python version management into one tool: how init, add, sync, and run replace the manual work of earlier posts, uv installing Python interpreters themselves, isolated global tools via uvx and uv tool, and migrating existing requirements.txt projects.
Python Packaging #3 pyproject.toml: The Standard for Project Configuration
How the era of setup.py and scattered config files converged into the single pyproject.toml: metadata and dependency declarations in the project table, separating optional features and dev tooling with extras and dependency-groups, the role of build-system, and the practical layout that gathers ruff and pytest settings under the tool table.
Python Packaging #2 pip and requirements.txt: The Limits of the Traditional Workflow
How pip works and the requirements.txt workflow — and where the approach falls apart. Reading version specifiers, pip freeze's inability to distinguish direct from transitive dependencies, the reproducibility hole where unpinned installs differ by the day, and constraints files, building the case for why the next generation of tools exists.
Python Packaging #1 Virtual Environments: Why Environments Break, and venv
Starting from the structural cause of broken Python environments: the path import searches and the conflicts born from having a single site-packages, why the system Python must be left alone and what the PEP 668 error means, isolating each project with venv, and the fact that activate is nothing more than PATH manipulation.
When Your Python Server Is Slow — Finding the Bottleneck in 5 Minutes with py-spy
Using py-spy, the sampling profiler that attaches to a running Python process with no code changes or restarts: dump to identify a hung process, top for live bottleneck watching, record and flame graphs, --idle for off-CPU waits, reading the GIL numbers, and running it in containers.
Python's JIT Compiler: From the 3.13 Experiment to Realistic Expectations
A look at the experimental copy-and-patch JIT compiler that landed in CPython 3.13. How it works, how to enable it, what changed in 3.14, and what you can realistically expect from it today.
Python Without the GIL Is Here: Where Free-Threading Stands and When to Use It
The current state of free-threading, from the experimental build in Python 3.13 to official support in 3.14. Installation and verification, single-thread overhead, C extension compatibility, and the criteria for deciding whether it belongs in production today.