Core Code
Core Code Modern Dev Handbook
PYTHON Contents
Python Fundamentals
Python Installation and venv Running Python Scripts (CLI, Modules, -m) Variables and Naming Conventions Strings and f-strings (Real-World Formatting) Numbers, Decimals, and Precision Lists vs Tuples vs Sets (When to Use Which) Dictionaries (Patterns and Gotchas) Conditionals and Truthiness Loops and Iteration Basics Functions Basics (Parameters, Defaults, Return) Modules Basics (Imports, Packages) Scope and Import Mechanics
Data Handling Basics
Paths and Files (pathlib, OS-safe) Reading and Writing Text Safely (Encoding) JSON Basics (Parse, Dump, Validation Mindset) CSV Basics (Reader/Writer, Dialects) datetime Basics (Timezones, Pitfalls) collections Module (deque, Counter, defaultdict) Iterators and Generators Intro Context Managers Intro (with-statement)
OOP Basics
Classes and Objects (Mental Model) __init__ and Instance State Class vs Instance (Attributes, Lookup) Inheritance Basics (Use Carefully) Composition Basics (Prefer Over Inheritance) Properties (@property) and Encapsulation Staticmethod vs Classmethod Special Methods (Dunder) Intro Dataclasses Intro (Less Boilerplate) Enums Intro (Safety and Readability)
Data Model & Advanced Patterns
Dunder Methods Deep Dive __eq__, __hash__, and Immutability Ordering and functools.total_ordering Descriptors Basics (How @property Works) Iterators and Generators (Advanced Patterns) Decorators Basics (Function Wrapping) Decorators Advanced (Args, Classes, Metadata) contextlib (contextmanager, ExitStack) __slots__ and Memory Footprint copy vs deepcopy (Safe Copies)
Typing & Code Quality
Type Hints Overview Typing Generics (TypeVar, Generic) Protocols and Structural Typing Literal, Union, Optional (Designing APIs) Typing with Dataclasses mypy Basics (Practical Workflow) Linting with Ruff (Fast and Modern) Formatting with Black (Consistency) Docstrings and Documentation Style Project Structure Conventions (src/, tests/)
Async & Concurrency
The GIL Explained (What It Means in Practice) Threading Basics (IO Concurrency) Multiprocessing Basics (CPU Parallelism) concurrent.futures (ThreadPool/ProcessPool) asyncio Intro (When to Use It) Event Loop and Tasks (Core Concepts) async/await Patterns (Fan-out, Gather, Limits) Cancellation and Timeouts (Correct Cleanup) asyncio Queues (Worker Pools) IO-bound vs CPU-bound (Choosing the Right Tool)
Reliability & Error Handling
Exceptions Best Practices (No Silent Failures) Custom Exceptions (Domain Errors) Error Boundaries and Containment Patterns Retries and Backoff (When Retries Are Harmful) Timeouts and Deadlines (Prevent Hanging) Idempotency Patterns (Safe Retries) Validation Patterns (What to Validate Where) Structured Logging (Fields, Correlation IDs)
Testing
pytest Intro (Assertions, Discovery) pytest Fixtures (Setup Without Pain) pytest Parametrize (Coverage with Less Code) Mocking Basics (unittest.mock) Mocking HTTP and Time (Deterministic Tests) Testing Async Code (pytest-asyncio) Coverage and Quality Gates (CI Mindset) Contract Tests Basics (Stable Interfaces)
Packaging & Delivery
Using venv in Production (Layouts and Pitfalls) Dependency Management with Poetry Build and Wheels (sdist, wheel) Versioning and SemVer (Release Discipline) Building a CLI with argparse Config Management (Env, Files, Defaults) Secrets Management Basics (No Secrets in Git)
Observability & Performance
Metrics Basics (What to Measure) Tracing Basics (Request Flow) Health Checks (Readiness/Liveness Basics) Profiling with cProfile (Find Hotspots) Performance Hotspots (I/O, Parsing, Loops) Memory Leaks Detection (tracemalloc, objgraph) Python Production Checklist

Tracing Basics (Request Flow)

Use tracing to follow a request across services, find latency hotspots, and debug distributed failures with correlation IDs.
On this page

Tracing Connects the Dots

Tracing helps you see where time is spent across boundaries (HTTP calls, DB queries). It is crucial when logs alone cannot explain latency.

Trace Context Basics

  • Every request gets a trace_id and spans for sub-operations.
  • Propagate trace context across service calls.
  • Correlate traces with logs using trace_id fields.

Operational Checklist

  • Ensure trace_id appears in logs for key events.
  • Sample intelligently (keep errors at higher sampling rates).
  • Instrument boundaries first: HTTP entry, DB calls, external APIs.

Failure Modes

  • Broken propagation: spans cannot be connected across services.
  • Over-instrumentation: tracing overhead becomes noticeable under load.
Health Checks (Readiness/Liveness Basics) →