How much does zuzu.codes cost?

The starter track is free — read all lessons and practice for free. Full access to every track (current and future) is $14.99/month. Cancel anytime.

How long does each track take?

Each track is designed as a 30-day challenge — one lesson per day, about 15 minutes each. Go at your own pace, but the structure is built around daily consistency.

What's the lesson format?

Each lesson is a student-teacher dialogue with code examples, followed by a hands-on code challenge in an in-browser editor. You read, you understand, then you write real code.

Do I need prior coding experience?

Our beginner track starts from absolute zero — no prior experience needed. Advanced tracks build on earlier ones, and the platform tells you exactly where to start.

How is zuzu.codes different from freeCodeCamp or Codecademy?

zuzu.codes uses a structured 30-day track format with dialogue-based teaching, an in-browser code editor, and gamification (XP, streaks, progress tracking). The format builds genuine understanding through daily practice.

Pipeline: Emails to Tasks With Per-Item Guards — Automation For Explorers

Day 26 · ~12 min●

A loop with a write call inside. If one write fails, the loop should keep going — you don't want a single broken task to block the other nine. Where does the try/except go in that loop?

Around the write call itself, not around the whole loop? So a failure on one item just skips it and moves on?

Exactly. The try/except lives inside the loop body, wrapping only the risky write. The loop continues to the next item on failure:

python

for m in messages:
    title = m.get("snippet", "")
    try:
        toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title})
        created.append(title)
    except Exception:
        continue

And continue is optional — the except body is empty so it falls through anyway. Adding continue just makes the intent explicit?

Explicit is better than implicit when the loop keeps going is the important behaviour. The explicit version reads more clearly. Full pipeline:

python

def pipeline_emails_to_tasks(max_results: int) -> list:
    emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_results})
    messages = emails.get("messages", [])
    created = []
    for m in messages:
        title = m.get("snippet", "")
        try:
            toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title})
            created.append(title)
        except Exception:
            continue
    return created

The return is the list of successes — so a run of 10 emails might return 8 titles if 2 writes failed. Should the function also report the failures?

Two-list return is the next refinement — {"created": [...], "failed": [...]}. For now the single list is the minimum useful contract: the caller knows exactly what was written and can infer failures from the difference against the input count.

So a pipeline is just this shape — fetch, loop, guard, accumulate, return. Any bulk write I write from now on uses the same three lines of defence?

Fetch, guard, accumulate. The per-item try/except is the cheapest defence you can add to any loop — three lines turn a fragile pipeline into a resilient one.

Per-Item Guard

TL;DR: try/except inside the loop body, not around the loop — one failure skips one item.

Fetch once — single read outside the loop
Guard the write — try/except wraps only the execute_action call
Accumulate successes — append inside the try, after the write returns

Outer vs inner try

Placement	Effect
Around the loop	One failure aborts the rest
Inside the loop body	One failure skips one item

Inner wins every time for bulk pipelines. Outer is a legitimate pattern only when you want the whole batch to abort on any failure.

Day 26 · ~12 min●

A loop with a write call inside. If one write fails, the loop should keep going — you don't want a single broken task to block the other nine. Where does the try/except go in that loop?

Around the write call itself, not around the whole loop? So a failure on one item just skips it and moves on?

Exactly. The try/except lives inside the loop body, wrapping only the risky write. The loop continues to the next item on failure:

python

for m in messages:
    title = m.get("snippet", "")
    try:
        toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title})
        created.append(title)
    except Exception:
        continue

And continue is optional — the except body is empty so it falls through anyway. Adding continue just makes the intent explicit?

Explicit is better than implicit when the loop keeps going is the important behaviour. The explicit version reads more clearly. Full pipeline:

python

def pipeline_emails_to_tasks(max_results: int) -> list:
    emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_results})
    messages = emails.get("messages", [])
    created = []
    for m in messages:
        title = m.get("snippet", "")
        try:
            toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title})
            created.append(title)
        except Exception:
            continue
    return created

The return is the list of successes — so a run of 10 emails might return 8 titles if 2 writes failed. Should the function also report the failures?

So a pipeline is just this shape — fetch, loop, guard, accumulate, return. Any bulk write I write from now on uses the same three lines of defence?

Fetch, guard, accumulate. The per-item try/except is the cheapest defence you can add to any loop — three lines turn a fragile pipeline into a resilient one.

Per-Item Guard

TL;DR: try/except inside the loop body, not around the loop — one failure skips one item.

Fetch once — single read outside the loop
Guard the write — try/except wraps only the execute_action call
Accumulate successes — append inside the try, after the write returns

Outer vs inner try

Placement	Effect
Around the loop	One failure aborts the rest
Inside the loop body	One failure skips one item

Inner wins every time for bulk pipelines. Outer is a legitimate pattern only when you want the whole batch to abort on any failure.

for m in messages: title = m.get("snippet", "") try: toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title}) created.append(title) except Exception: continue

def pipeline_emails_to_tasks(max_results: int) -> list: emails = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, {"max_results": max_results}) messages = emails.get("messages", []) created = [] for m in messages: title = m.get("snippet", "") try: toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title}) created.append(title) except Exception: continue return created

Per-Item Guard

TL;DR: try/except inside the loop body, not around the loop — one failure skips one item.

Fetch once — single read outside the loop

Guard the write — try/except wraps only the execute_action call

Accumulate successes — append inside the try, after the write returns

Outer vs inner try

Placement	Effect
Around the loop	One failure aborts the rest
Inside the loop body	One failure skips one item

Inner wins every time for bulk pipelines. Outer is a legitimate pattern only when you want the whole batch to abort on any failure.

for m in messages: title = m.get("snippet", "") try: toolset.execute_action(Action.GOOGLETASKS_CREATE_TASK, {"title": title}) created.append(title) except Exception: continue

Per-Item Guard

TL;DR: try/except inside the loop body, not around the loop — one failure skips one item.

Fetch once — single read outside the loop

Guard the write — try/except wraps only the execute_action call

Accumulate successes — append inside the try, after the write returns

Outer vs inner try

Placement	Effect
Around the loop	One failure aborts the rest
Inside the loop body	One failure skips one item

Inner wins every time for bulk pipelines. Outer is a legitimate pattern only when you want the whole batch to abort on any failure.

Per-Item Guard

Outer vs inner try

Per-Item Guard

Outer vs inner try

Per-Item Guard

Outer vs inner try

Sign up to practice

Per-Item Guard

Outer vs inner try

Sign up to practice