← Back to the catalogue

Level 3 · Ph.D

Advanced Python Programming

Ph.D syllabus · 56 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
43. Phase 42 The specializing adaptive interpreter (PEP 659)
44. Phase 43 The tier-2 optimizer & the experimental JIT
45. Phase 44 Free-threading in depth (PEP 703) & thread-safe native code
46. Phase 45 Subinterpreters & the per-interpreter GIL (PEP 684/734)
47. Phase 46 Rust extensions with PyO3 & maturin
48. Phase 47 The stable ABI, limited API & extension portability
49. Phase 48 Embedding CPython & the initialization config (PEP 587)
50. Phase 49 CPython on WebAssembly (Emscripten / Pyodide)
51. Phase 50 Production observability: sys.monitoring (PEP 669) & tracing
52. Phase 51 Rigorous benchmarking & the CPython research literature
53. Phase 52 Proposing the doctoral capstone (research method)
54. Phase 53 Capstone I: execute the research
55. Phase 54 Capstone II: verified publication & hardening
56. Phase 55 Frontier, ethics & close; portal integration