← Back to catalogue

Level 3 · Ph.D

Ph.D Advanced Python Programming

Software · Live · v0

Doctoral Python engineering — interpreter internals, performance, typing systems, and large-scale architecture.

Path type

Software

Requirements

MSc Advanced Python Programming

Enrollment

€19.95

Deadline

Next cohort starts 2027-09-06 (AY 2027/28)

Length

+1 year · 56 phases

Language

English · Español

Content freshness

Curriculum updated 2026-08-23 · content rev 694abd1b

Cortex Credits (CC)

280 CC · 364 CC across all tiers of this programme
What are Cortex Credits?

Syllabus

View the phase syllabus

0. Foundations
1. What "advanced" means + the pyforge target
2. The CPython object model in depth
3. Bytecode & the dis module
4. The CPython evaluation loop (the ceval mental model)
5. Reference counting & the cyclic garbage collector
6. Memory: arenas, pools, __slots__, sys.getsizeof
7. The import system internals
8. Descriptors & how methods/properties really work
9. Metaclasses & class creation
10. Class-customization hooks: __init_subclass__, __set_name__
11. Attribute lookup, __getattr__/__getattribute__ & proxies
12. Abstract base classes & the collections.abc tower
13. Generators, coroutines & yield from
14. itertools & lazy pipelines at scale
15. Decorators with state & context managers
16. Generics, TypeVar, ParamSpec & variance
17. Protocols, structural typing & overloads
18. Typed plugin systems & runtime type introspection
19. Strict typing of dynamic code (the limits of mypy)
20. Threading in depth & the GIL (and the no-GIL future)
21. multiprocessing & shared memory
22. concurrent.futures & executor patterns
23. asyncio I — the event loop inside
24. asyncio II — synchronization, cancellation & structured concurrency
25. Async I/O at scale — streams & servers
26. Choosing a concurrency model — a measured comparison
27. Profiling & measurement
28. Optimization & the cost model of Python operations
29. The buffer protocol & memoryview
30. C extensions via the C-API
31. Cython & native acceleration
32. ctypes/cffi & calling shared libraries
33. Building wheels, sdists & native builds
34. API design, deprecation & semantic versioning
35. Plugin architecture & entry points
36. Publishing, supply-chain & reproducible builds
37. Developer tooling (an AST-based linter/codemod)
38. Documentation, examples & a stable public surface
39. Capstone
40. Hardening, postmortem, "What's Next"
41. Portal integration
42. The specializing adaptive interpreter (PEP 659)
43. The tier-2 optimizer & the experimental JIT
44. Free-threading in depth (PEP 703) & thread-safe native code
45. Subinterpreters & the per-interpreter GIL (PEP 684/734)
46. Rust extensions with PyO3 & maturin
47. The stable ABI, limited API & extension portability
48. Embedding CPython & the initialization config (PEP 587)
49. CPython on WebAssembly (Emscripten / Pyodide)
50. Production observability: sys.monitoring (PEP 669) & tracing
51. Rigorous benchmarking & the CPython research literature
52. Proposing the doctoral capstone (research method)
53. Capstone I: execute the research
54. Capstone II: verified publication & hardening
55. Frontier, ethics & close; portal integration

Syllabus →

Enrolment prerequisites

• A verified account and admissions-committee approval.
• Completion of MSc Advanced Python Programming.