What to study for each PCPP2-32-202 domain
Environment, Tooling & Packaging
Covers professional environment and packaging practice, including venv, Poetry, uv and Conda, lockfiles and platform-aware dependency resolution with environment markers. It also addresses package builds, wheels and sdists, pyproject.toml build systems and release workflows.
Key skills
Creating isolated environments, pinning reproducible installs with lockfiles, building wheels and sdists, and managing platform-conditional dependencies.
Debugging, Memory and Performance Profiling
Covers systematic debugging and profiling, including pdb, breakpoint() and post-mortem debugging, call stacks and frames. It also addresses cProfile for CPU profiling and tracemalloc snapshot comparison for finding memory growth.
Key skills
Stepping through code with pdb, reading cProfile output, comparing tracemalloc snapshots, and choosing the right profiling tool for CPU versus memory problems.
Advanced Data Structures & Module Architecture
Covers data-model hooks such as __format__ and __bytes__, __slots__ and memory layout, and attribute lookup through __getattr__ and __getattribute__. It also addresses module namespaces, namespace packages, lazy imports with module __getattr__, and explicit public APIs via __all__.
Key skills
Using __slots__ and weak references effectively, implementing data-model hooks, designing lazy-importing packages, and choosing deque and other structures by complexity.
Object-Oriented Programming & Metaprogramming
Covers ABCs and abstract methods, structural Protocols and runtime checking, variance and the C3 method resolution order. It also addresses metaclasses, __init_subclass__, __set_name__ and class registries for controlled class creation.
Key skills
Defining interfaces with ABCs and Protocols, building registries with __init_subclass__, writing descriptors, and reasoning about MRO and variance.
Advanced Control Flow & Functional Constructs
Covers stateful generators, yield from delegation and generator send and close semantics. It also addresses itertools and functools composition, including groupby, tee, partial and lru_cache, and the memory and correctness trade-offs of memoization.
Key skills
Composing generators and itertools pipelines, delegating with yield from, applying functools tools, and managing caching trade-offs safely.
Operational Security
Covers operational secure coding, including the dangers of insecure deserialization with pickle and unsafe YAML loading, and SQL-injection prevention with parameterized queries. It also addresses constant-time comparison, salted password hashing, Bandit static analysis and dependency auditing.
Key skills
Preventing injection and deserialization attacks, hashing passwords correctly, generating tokens with secrets, and auditing code and dependencies for vulnerabilities.
Parallel and Asynchronous Processing
Covers choosing between concurrency and parallelism for CPU-bound and I/O-bound work, the GIL, threads, processes, synchronization, queues and worker pools. It also addresses asyncio tasks, event loops, gather, cancellation and executor use for blocking work.
Key skills
Selecting threads, processes or asyncio by workload, synchronising shared state, using concurrent.futures pools, and writing cancellable async code.
Web Frameworks & Observability
Covers WSGI and ASGI runtimes and middleware, and building services with FastAPI and Pydantic, including dependency injection and response models. It also addresses OpenTelemetry tracing and W3C context propagation, structured logging with request context, and production diagnostics such as health probes.
Key skills
Building validated FastAPI services, ordering middleware, propagating trace context, correlating structured logs, and operating services with liveness and readiness checks.