Learning path / 15 published lessons
Python and software engineering
Build a reliable Python workflow: environments, Git, language semantics, data modelling, packaging, tests and types. Follow values and side effects through a program before reaching for abstraction.
What you’ll work toward
- Virtual environments isolate Python packages, not the OS or native libraries
- Git snapshots, the index and working tree are distinct
- Pipelines connect stdout to stdin but stderr remains separate unless redirected
- Match installed version, documentation and a minimal reproduction
Completion is stored on this device only. Nothing is locked; start where it makes sense.
Start this pathBefore the first lesson
- Read the prerequisite section and complete its exercises
These are the starting lesson’s prerequisites, not requirements for every advanced topic below.
How to practise this subject
Use a disposable local project. Explain aliasing and exceptions, add an edge-case test, then make the smallest change that satisfies the contract without hiding a failure.
- 01
Dev Environment — Linux/WSL, Terminal, VS Code
The 90 minutes that saves you 90 hours. Real environment, real editor, real terminal — no ‘works on my machine’ for the next six months.
- 02
Git & GitHub — Commits, Branches, PRs
The 90 minutes that turns Git from a scary black box into a save-point machine you trust with your career. Real commits, real branches, real PRs — the muscle memory every senior engineer runs on.
- 03
The Command Line — bash, pipes, grep, jq
Live in the terminal without fear. The pipes, filters, and text-crunching muscle memory that separates an engineer from a button-clicker — and the 20 commands you'll use every single day for the rest of your career.
- 04
Reading Docs & Effective Googling — the Meta-Skill
The single skill that separates a 10× engineer from a 1× engineer: knowing how to find the answer, fast, without asking a human. Man pages, official docs, GitHub source-diving, and search queries that actually work.
- 05
Python Variables & Types — Mental Model of Memory
Not ‘what is a variable’ — the actual model of what happens in memory when you write `x = [1, 2, 3]`. References, mutability, boxes, arrows. The mental picture every senior Python dev has that every junior doesn't.
- 06
Control Flow — if/else, loops, comprehensions
The three shapes of Python control flow every dev needs to reach for on reflex — branches, loops, comprehensions — with the rules for when each one is right and when it silently becomes unreadable.
- 07
Functions — arguments, scope, closures
Functions are the atom of Python. This session covers the four kinds of arguments, the LEGB scope rule, closures, decorators as functions, and the classic tricks that trip up devs who thought they knew Python.
- 08
Data Structures — list, tuple, dict, set (when to use what)
The one-page decision matrix that separates senior Python devs from the rest: given a data shape and a query pattern, know within 5 seconds which built-in structure to reach for — and its Big-O cost.
- 09
Classes & Objects — the OOP Mental Model
Classes in Python are not what they are in Java. Everything is public, `self` is explicit, dunder methods are the interface. This session installs the mental model of what a class actually IS in Python — plus the three patterns you'll use daily.
- 10
Inheritance, Composition & Polymorphism
The single most-abused feature in OOP is inheritance. This session teaches the ‘composition first’ rule every senior codebase uses, plus the MRO, super() rules, ABCs, protocols, and how Python's duck typing makes half of Java's ceremony unnecessary.
- 11
Errors, Exceptions & Debugging with pdb
The mindset shift that turns ‘print statement warrior’ into ‘engineer who kills bugs in minutes’. Try/except done right, custom exceptions, tracebacks decoded, pdb keystrokes memorised, and the modern replacements (icecream, ipdb, structlog).
- 12
Modules, Packages, Virtualenvs, pip & uv
How Python code is organised, versioned, and shipped — from a single script to an installable package, with reproducible envs on every machine.
- 13
Testing with pytest — TDD Workflow
Turn code from hope into evidence: real pytest patterns — parametrize, fixtures, mocks, coverage — plus the TDD loop that makes refactoring safe.
- 14
Type Hints, mypy, dataclasses & pydantic
Modern Python that scales past 1000 lines: gradual typing with mypy, immutable value objects with dataclasses, and runtime-validated boundaries with pydantic v2.
- 15
Big-O Notation — Reasoning About Scale
How to talk about performance without measuring: growth rates, worst/avg/amortised cost, and the constant-factor traps that make theory disagree with reality.