Cursos en esta ruta
Python Oop And Data Modeling
A plain dictionary with the right keys can look like an object, but it doesn't protect its invariants, doesn't expose behavior, and breaks silently the moment someone puts an invalid value in it. This guide teaches you to design a clean, correct, "Pythonic" object model starting from that exact problem. You work by modeling a single domain end to end — Reservo, a coworking room-booking system — and build it with classes from scratch: first the move from loose data to an object that bundles data and behavior, then encapsulation with properties that validate invariants, `@dataclass` for modeling immutable data without boilerplate, composition to assemble the domain's object graph, inheritance and polymorphism for the different member types, protocols and abstract classes to design against interfaces instead of concrete implementations, and the dunder methods that make an object feel native to Python (comparison, ordering, iteration, context managers). All the code actually runs on Python 3.14 and is checked against anchor numbers from the domain (a 3-hour booking in the Focus room costs 7500 cents, with a 20% discount for the pro tier). The final project models the complete Reservo domain with all eight pieces integrated and a runnable demo.
64 lecciones
Modern Python Tooling Guide
A Python project's toolchain — which interpreter runs it, where dependencies live, who checks style and types, who builds and publishes the package — gets decided once and paid for every day after. This guide takes you through operating that toolchain with the tools the industry settled on in 2026: `uv` for interpreters, environments, and reproducible-lockfile dependency management; Ruff as the single linter and formatter that replaces flake8, isort, pyupgrade, and black; a type checker (mypy, pyright, or ty) wired into `pyproject.toml`; automation with pre-commit hooks and GitHub Actions; and packaging and publishing to PyPI with trusted publishing. The differentiator isn't the list of commands — it's the judgment: every tool is presented with its strongest argument for and its most serious objection, including when NOT to adopt it and how to evaluate an open-source project's governance health before betting your stack on it. The whole path builds a single project — `pkgpeek`, a CLI that queries PyPI — that ends up published from CI with nine verifiable deliverables and a decisions document defending every choice.
48 lecciones
Python Typing And Pydantic
A type annotation in Python is a label, not a lock: the interpreter reads it, stores it, and keeps running without checking anything. This guide corrects that misunderstanding at the root and builds, on top of it, a complete system of static typing and runtime validation with Pydantic v2. You work through a single realistic case study — Cosecha, a platform that connects small farm producers with restaurants, where every piece of data comes from outside (a messy per-producer CSV, a payments webhook, a weather API, a web form) and none of it can be trusted — and take it from forty unannotated functions to a system where invalid data simply cannot exist. You'll learn to install and read a type checker (mypy) without getting frustrated by the first 300 errors, to describe the real shape of your data with the full `typing` vocabulary, to turn those descriptions into real validation with Pydantic, to express business rules as code instead of scattered `if` statements, and to design boundaries where data gets validated exactly once so the rest of the system can stop defending itself. The guide closes with real-world hard cases — untyped libraries, variable-shape JSON, environment-variable configuration, migrating from Pydantic v1 to v2 — and with an explicit framework for knowing when typing gets in the way and when to concede with a written reason.
64 lecciones
Building with LLMs in Code
Integrate an LLM into a real product from code, not from an experimentation notebook. This guide works directly against the provider's SDK — on purpose, so you understand what a framework abstracts away before you adopt one — across eight modules: treating the LLM as just another dependency of your software (non-deterministic, billed by token), building your first serious integration with your own client, keeping prompts as versioned code, getting structured, validated outputs instead of parsing free text, giving the model tools through tool calling controlled by your code, streaming responses, hardening the integration against real provider failures, and evaluating and shipping with an eval suite that tells you whether a change made the system better or worse. The final project is a production-ready support-ticket triage service: Pydantic-validated classification, streaming responses, real tools, retries, caching, cost control, and evals running in CI.
64 lecciones
Debugging and Troubleshooting
Take an unknown failure — a thirty-line traceback, a silently wrong result, a regression buried under two hundred commits, or a test that fails once every thirty runs — and learn to reproduce it, corner it down to the exact line, and explain it with evidence, before asking a model anything; and when you do ask, learn to verify whether the answer is correct. The six modules move from reading the failure (what a traceback is already telling you) to the method that goes from symptom to root cause, to the debugger for stopping the program and looking inside, to logging for diagnosing what already happened, to bisection for cornering regressions and intermittent failures, and close with AI in the loop: using it after you understand the error, not instead of understanding it. The final project is a debugging dossier on a repository with five failures of different natures — including a regression that requires `git bisect run` — resolved with protocol, evidence, and a regression test.
48 lecciones
Working with Coding Agents
Learn to direct coding agents as a professional craft, not improvisation. This guide covers the six pieces that separate amateur use from professional use: the craft of directing instead of writing code directly, spec-driven development, harness engineering — the environment, context, and permissions you set up so the agent can verify itself — verifying and reviewing what the agent generates, budgeting and controlling token and time cost, and governing AI-generated code within a team. By the end, you can write executable specifications, prepare an agent-ready repository, review — not just accept — what an agent produces, control how much you spend in tokens and human attention, and write the playbook that governs how your team works with agents.
48 lecciones
PostgreSQL & SQLAlchemy Guide
Learn PostgreSQL from installation to optimized queries, model your data with the SQLAlchemy ORM, manage your schema with Alembic, and integrate everything asynchronously with FastAPI. This guide replaces in-memory data with real, professional persistence, exactly as it is used in production. Built for developers who have already built APIs with FastAPI and need to take the next step: a well-designed relational database that scales.
48 lecciones
Git & GitHub Guide
Master version control with Git and collaborative development with GitHub, from your first commit to production CI/CD pipelines. This guide walks you step by step through everything you need to work professionally with Git: local workflow, branches, conflict resolution, Pull Requests, team workflows, automation with hooks and GitHub Actions, and error recovery. Built for developers of any language who want to stop fearing Git and start using it with confidence on real teams.
104 lecciones
Security for AI-Generated Code
45% of AI-generated code contains security flaws (Veracode 2025). Java: 72% failure rate. JavaScript: 43%. Python: 38%. XSS: 86% of AI code fails. Larger models don't generate more secure code. This guide teaches you to detect, prevent, and fix vulnerabilities in code produced by any AI tool — OWASP Top 10 applied to AI code, vulnerability patterns by language, detection tools, security review checklists, hardening techniques, and secrets management.
32 lecciones
Python Async And Concurrency
Concurrency doesn't make work faster: it eliminates the time your program spent not working. That distinction between waiting (network, disk, an external service) and computing (processor at 100%) is what this whole guide hinges on, and it's the thing almost nobody has straight before starting. You work through a single realistic case — Faro, a service that watches the price of 300 products across 12 online stores and today takes 40 minutes because it does everything sequentially — and take it, module by module, to a concurrent collector running in about 2 minutes. You'll learn the real mental model behind `async`/`await` (why `async def` on its own doesn't speed up anything), how to launch and control hundreds of tasks with courtesy limits so you don't overwhelm the other side, how to handle partial failures and cancellation, when to use threads for blocking code that's someone else's and can't be rewritten (a third-party library, say), and when to use processes for pure computation that no amount of `async` or threading will speed up because of the GIL. The guide closes with the problems that only show up in production under real volume and time — memory, connections, graceful shutdown, debugging intermittent bugs — and with a final project where you defend, with numbers, which tool you used for each layer and what you deliberately left sequential.
64 lecciones
Python Packaging And Cli Tools
A script that "works on my machine" and an installable package someone else can actually use are two very different things, and this guide walks you from one to the other step by step. You work by packaging a single realistic case — `reservo`, a coworking room-booking system whose object model already exists — and turn it into an installable library with its own command-line tool. You'll learn what a module and a package are, how `import` and `sys.path` resolve, the modern `pyproject.toml` standard (PEP 621) and how to build a real wheel and sdist with `uv build`, how to isolate a project in virtual environments and manage dependencies with `pip` and `uv`, how to build a complete CLI with `argparse` (no external dependencies), how to expose it as an installed command via an entry point in `[project.scripts]`, how to structure a real package with submodules, relative imports, and a deliberate public API, and how to configure a quality toolchain (`ruff`, `mypy`, `pytest`, `pre-commit`). Everything runnable actually runs — the `reservo price --tier basic --hours 3` command prints `7500` from your terminal — the only thing taught as content without execution is publishing to PyPI, because that's a public, irreversible action. The final project integrates all seven pieces into a complete package, built, installed, and running end to end.
64 lecciones
Python Performance and Profiling
Intuition about what makes a program slow is almost always wrong, and optimizing without measuring is the most common way to waste time fixing the part that was never the problem. This guide teaches the complete optimization process under the one rule that matters: measure first, change second. You work through a single realistic case — Nómada, a command-line tool that processes trip logs for a vehicle fleet and takes four minutes to generate a monthly report — and take it down to a few seconds using the real method: timing with the correct clock, profiling with `cProfile` to find where the time actually goes (almost never where the team thinks), measuring memory cost, choosing the right data structure for the problem, and applying the specific optimization that fits each real bottleneck. The guide also teaches you to recognize when pure Python no longer cuts it and work needs to be pushed to vectorized code, and how to document and protect an optimization so it doesn't get lost in the next refactor. The final project requires an honest report of what changed, how much each change gained, and what was deliberately NOT optimized and why.
64 lecciones