python

Why CPython has a Global Interpreter Lock, what it does and does not protect, and how the three concurrency models differ. Then how PEP 703 free-threading removes the GIL using per-object locks and biased, deferred, and immortal reference counting, plus the tradeoffs that keep it opt-in.

How CPython reclaims memory: immediate reference counting for the common case, plus a generational cyclic garbage collector that catches the reference cycles counting cannot. Covers what changes a refcount, generations and thresholds, the gc module, __del__ and weakref, and why a process's memory does not always shrink.

What actually runs when you run Python: the compiler turns source into a code object of bytecode, and a single C evaluation loop executes it on a stack machine, one frame per call. Covers code objects, the dis module, the value stack, frames, and the adaptive specializing interpreter.

How Python values really work under the hood: every value is a heap object with a type and a reference count, names are references not boxes, and behavior comes from the data model's dunder methods. Covers identity versus equality, attribute lookup order, descriptors, and __slots__.

SQLAlchemy 2.0 from the production angle. The engine/session/transaction layering, the typed declarative, the identity map, the N+1 query problem, async-only gotchas (no lazy loading), savepoint nesting, and the connection-pool knobs that decide whether the backend survives load.

Dependency injection as a pattern, FastAPI's Depends as one concrete implementation. Sub-dependencies and per-request caching, yield-based cleanup, where Pydantic v2 validation runs, lifespan-scoped resources, BackgroundTasks vs real queues, and the override trick that makes the whole thing testable.

Python's type system has two audiences — static checkers and runtime frameworks. Generics, Protocol, TypedDict, ParamSpec, type narrowing, and runtime introspection, framed as the spec that Pydantic, FastAPI, and SQLAlchemy actually execute.

Async Python from the bytecode up. Coroutines vs return values, how the event loop schedules tasks, when async beats threading or multiprocessing, structured concurrency with TaskGroup, and the cancellation rules that production backends live or die by.

Move beyond toy ReAct loops. Learn how to build a production-grade agent harness with a robust control loop, tool registry, schema validation, retry logic, token budgets, abort signals, and a persistent journal that survives crashes.

Learn to build Model Context Protocol servers from scratch using the official Python and TypeScript SDKs. Cover tool schemas, resource URIs, prompt templates, and how Claude Code, Claude.ai, and Cursor consume them.

A beginner's guide to LangChain, the popular framework for composing applications with Large Language Models. Learn the core concepts of Models, Prompts, and Chains, and build a simple application using the LangChain Expression Language (LCEL).

Dive into Apache Airflow, the powerful platform for programmatically authoring, scheduling, and monitoring complex data workflows. Learn about DAGs, operators, and how to build robust, scalable pipelines for modern data engineering.