Learn to Code in 7 days
Intermediate Pilot

Writing Reliable Python

Make programs that survive bad input and stay easy to change.

7 days · About 2 hours a day

Start Day 1

This course is in its pilot. All seven days are ready to work through. How long each lesson took you, and where you got stuck, decides what changes before it's final.

How it works

  • Seven days is a pace, not a deadline. Each day is a module; taking one over two sittings costs nothing.
  • Core first. A day's Optional topics — sections headed Going further, and asides — are extras nothing later depends on. Skip them on a first pass.
  • Help comes in steps. Every exercise has hints — the idea, then a first step — before its solution.
  • Then on your own. The course ends with a fresh brief to build without a plan, and review challenges to come back to a week and a month later.

The seven days

  1. 1

    Refactoring with a Safety Net

    By the end you can: Split a messy working script into small, well-defined functions, with tests locking in its behaviour before anything changes.

    1. 1.1 Read Before You Change
    2. 1.2 A Safety Net for a Script
    3. 1.3 Extract Functions, One Step at a Time
    4. 1.4 Modules, Defaults and the Day 1 Checkpoint
  2. 2

    Parsing Text

    By the end you can: Turn raw log lines into dataclass records — string methods where they're enough, a regex where the format needs one — stream the file lazily, and reject malformed lines with clear errors.

    Optional: Pattern matching on parsed records

    1. 2.1 From Lines to Records
    2. 2.2 When a Regex Is the Right Tool
    3. 2.3 Streaming a Big Log
    4. 2.4 Rejecting Bad Input
  3. 3

    Storing Data

    By the end you can: Store records in SQLite with parameterized queries, test against an in-memory database, and save a summary as JSON.

    Optional: Custom JSON encoders

    1. 3.1 Records into SQLite
    2. 3.2 Queries You Can Trust
    3. 3.3 Testing with a Throwaway Database
    4. 3.4 Summaries as JSON
  4. 4

    Functions & Resources

    By the end you can: Make the analyzer configurable by passing functions, and guarantee cleanup with `with` — proven by a test. A decorator only if something genuinely repeats.

    Optional: Decorators and decorator factories · functools.partial and singledispatch

    1. 4.1 Functions as Arguments
    2. 4.2 Functions That Build Functions
    3. 4.3 Cleanup You Can Count On
    4. 4.4 Checkpoint: A Configurable Analyzer
  5. 5

    Composition & Practical Typing

    Optional part needs local Python

    By the end you can: Compose records into reports, type-hint the public functions, and fix a silent miscount — deciding yourself whether an Enum is the right cure.

    Optional: Protocols · Running mypy

    1. 5.1 Reports Made of Parts
    2. 5.2 Type Hints That Help
    3. 5.3 The Silent Miscount
    4. 5.4 Checkpoint: Levels Everywhere
  6. 6

    Async Fundamentals

    Standalone exercise Optional part needs local Python

    By the end you can: Fetch several simulated sources at once with asyncio, handling a timeout and one failing source.

    Optional: Threads and processes · Real HTTP requests

    1. 6.1 Waiting Without Blocking
    2. 6.2 Tasks and the Event Loop
    3. 6.3 Timeouts and Failures
    4. 6.4 Checkpoint: Four Sources at Once
  7. 7

    Finish & Ship

    Optional part needs local Python

    By the end you can: Finish the analyzer: tests for the week's edge cases, logging, a README and an argparse command line.

    Optional: Packaging and installing it

    1. 7.1 Edge Cases, on Purpose
    2. 7.2 Logging, Not Printing
    3. 7.3 A Command Line with argparse
    4. 7.4 Ship It
    5. 7.5 On Your Own: A Fresh Brief
    6. 7.6 Come Back Later: Review Challenges