← Back to the catalogue

Level 2 · M.Sc

Advanced Python Programming

MSc syllabus · 42 phases · ~1 year

Every unit this programme teaches, in the order it is taught. Headlines only — the material itself opens once you are enrolled.

Dates, price and prerequisites

1. Phase 0 Foundations
2. Phase 1 What "advanced" means + the pyforge target
3. Phase 2 The CPython object model in depth
4. Phase 3 Bytecode & the dis module
5. Phase 4 The CPython evaluation loop (the ceval mental model)
6. Phase 5 Reference counting & the cyclic garbage collector
7. Phase 6 Memory: arenas, pools, __slots__, sys.getsizeof
8. Phase 7 The import system internals
9. Phase 8 Descriptors & how methods/properties really work
10. Phase 9 Metaclasses & class creation
11. Phase 10 Class-customization hooks: __init_subclass__, __set_name__
12. Phase 11 Attribute lookup, __getattr__/__getattribute__ & proxies
13. Phase 12 Abstract base classes & the collections.abc tower
14. Phase 13 Generators, coroutines & yield from
15. Phase 14 itertools & lazy pipelines at scale
16. Phase 15 Decorators with state & context managers
17. Phase 16 Generics, TypeVar, ParamSpec & variance
18. Phase 17 Protocols, structural typing & overloads
19. Phase 18 Typed plugin systems & runtime type introspection
20. Phase 19 Strict typing of dynamic code (the limits of mypy)
21. Phase 20 Threading in depth & the GIL (and the no-GIL future)
22. Phase 21 multiprocessing & shared memory
23. Phase 22 concurrent.futures & executor patterns
24. Phase 23 asyncio I — the event loop inside
25. Phase 24 asyncio II — synchronization, cancellation & structured concurrency
26. Phase 25 Async I/O at scale — streams & servers
27. Phase 26 Choosing a concurrency model — a measured comparison
28. Phase 27 Profiling & measurement
29. Phase 28 Optimization & the cost model of Python operations
30. Phase 29 The buffer protocol & memoryview
31. Phase 30 C extensions via the C-API
32. Phase 31 Cython & native acceleration
33. Phase 32 ctypes/cffi & calling shared libraries
34. Phase 33 Building wheels, sdists & native builds
35. Phase 34 API design, deprecation & semantic versioning
36. Phase 35 Plugin architecture & entry points
37. Phase 36 Publishing, supply-chain & reproducible builds
38. Phase 37 Developer tooling (an AST-based linter/codemod)
39. Phase 38 Documentation, examples & a stable public surface
40. Phase 39 Capstone
41. Phase 40 Hardening, postmortem, "What's Next"
42. Phase 41 Portal integration