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.

Streaming-style read+process — Automation Patterns

Day 24 · ~12 min●

Yesterday: collect items across pages, then process. Two failure modes at scale: (1) memory grows linearly with total items, (2) a crash on page 17 of 20 loses everything you collected.

The streaming alternative — process each page as it arrives. Memory stays at one-page-worth. A crash on page 17 means pages 1-16 are already done.

python

processed = 0
page_token = None

for page_num in range(5):                            # MAX_PAGES
    args = {"max_results": 5}
    if page_token:
        args["page_token"] = page_token
    
    result = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, args)
    page = result.get("messages", [])
    
    # process this page immediately — don't collect
    for item in page:
        # ... do work for `item` here ...
        processed += 1
    
    page_token = result.get("nextPageToken")
    if not page_token:
        break

print(f"streamed {processed} items")

No all_items list. Each page is processed and discarded before the next fetch.

When does this matter?

Three signals. (1) Memory — at 100K items × 5KB each, the collect-all list is 500MB; streaming stays small. (2) Recovery — combine streaming with state-across-runs (day 12) and a crash mid-pagination doesn't lose the work that already happened. (3) Latency — first item processed in seconds vs minutes (you don't wait for all pages to download before starting).

Are there downsides?

Yes. Aggregation is harder — if you need a total at the end, you have to count as you go. Sorting across pages is harder — items from different pages are interleaved. For "do something to each item" tasks, streaming wins. For "compute a property of the whole set" tasks, collect-all is simpler.

Streaming-style read+process

Two patterns side-by-side

Collect, then process (yesterday):

python

all_items = []
for page in pages:
    all_items.extend(page)

for item in all_items:
    process(item)

Memory: O(N). Crash mid-process: lose progress made so far. Aggregations: easy.

Stream:

python

for page in pages:
    for item in page:
        process(item)

Memory: O(page_size). Crash mid-process: prior pages already done. Aggregations: count as you go.

When to stream

Use streaming when	Use collect when
N is large (thousands+)	N is small (~100)
Each item processed independently	Need to sort/aggregate the whole set
Failure-recovery matters	Script runs once, no recovery
First-item latency matters	Latency doesn't matter
Combining with state-across-runs	Single-shot script

Streaming + state across runs

The killer combination:

python

checkpoint = read_state()                  # last processed id
page_token = None

for _ in range(MAX_PAGES):
    args = {"page_token": page_token} if page_token else {}
    result = fetch(args)
    
    for item in result["items"]:
        if item["id"] == checkpoint:
            return                          # caught up
        process(item)
        write_state(item["id"])             # advance checkpoint
    
    page_token = result.get("nextPageToken")
    if not page_token:
        break

A crash on item 5,432 of 100K means item 5,432 is unfinished but items 1-5,431 are done and recorded. Re-run reads checkpoint=5431, picks up at 5432. Self-healing.

Counting as you go

For totals when streaming:

python

results = {"ok": 0, "fail": 0}

for page in pages:
    for item in page:
        try:
            process(item)
            results["ok"] += 1
        except Exception:
            results["fail"] += 1

One counter dict; updated per item. Final values reflect every item ever processed in this run.

Yield-based streaming (advanced)

For reusable streaming logic:

python

def iter_emails(max_pages=5):
    page_token = None
    for _ in range(max_pages):
        ...
        for item in result["messages"]:
            yield item
        if not result.get("nextPageToken"):
            return
        page_token = result["nextPageToken"]

for msg in iter_emails():
    process(msg)

Generators. Python Patterns covers them properly. For Patterns track, the inline shape is enough.

Day 24 · ~12 min●

Yesterday: collect items across pages, then process. Two failure modes at scale: (1) memory grows linearly with total items, (2) a crash on page 17 of 20 loses everything you collected.

The streaming alternative — process each page as it arrives. Memory stays at one-page-worth. A crash on page 17 means pages 1-16 are already done.

python

processed = 0
page_token = None

for page_num in range(5):                            # MAX_PAGES
    args = {"max_results": 5}
    if page_token:
        args["page_token"] = page_token
    
    result = toolset.execute_action(Action.GMAIL_FETCH_EMAILS, args)
    page = result.get("messages", [])
    
    # process this page immediately — don't collect
    for item in page:
        # ... do work for `item` here ...
        processed += 1
    
    page_token = result.get("nextPageToken")
    if not page_token:
        break

print(f"streamed {processed} items")

No all_items list. Each page is processed and discarded before the next fetch.

When does this matter?

Are there downsides?

Streaming-style read+process

Two patterns side-by-side

Collect, then process (yesterday):

python

all_items = []
for page in pages:
    all_items.extend(page)

for item in all_items:
    process(item)

Memory: O(N). Crash mid-process: lose progress made so far. Aggregations: easy.

Stream:

python

for page in pages:
    for item in page:
        process(item)

Memory: O(page_size). Crash mid-process: prior pages already done. Aggregations: count as you go.

When to stream

Use streaming when	Use collect when
N is large (thousands+)	N is small (~100)
Each item processed independently	Need to sort/aggregate the whole set
Failure-recovery matters	Script runs once, no recovery
First-item latency matters	Latency doesn't matter
Combining with state-across-runs	Single-shot script

Streaming + state across runs

The killer combination:

python

checkpoint = read_state()                  # last processed id
page_token = None

for _ in range(MAX_PAGES):
    args = {"page_token": page_token} if page_token else {}
    result = fetch(args)
    
    for item in result["items"]:
        if item["id"] == checkpoint:
            return                          # caught up
        process(item)
        write_state(item["id"])             # advance checkpoint
    
    page_token = result.get("nextPageToken")
    if not page_token:
        break

A crash on item 5,432 of 100K means item 5,432 is unfinished but items 1-5,431 are done and recorded. Re-run reads checkpoint=5431, picks up at 5432. Self-healing.

Counting as you go

For totals when streaming:

python

results = {"ok": 0, "fail": 0}

for page in pages:
    for item in page:
        try:
            process(item)
            results["ok"] += 1
        except Exception:
            results["fail"] += 1

One counter dict; updated per item. Final values reflect every item ever processed in this run.

Yield-based streaming (advanced)

For reusable streaming logic:

python

def iter_emails(max_pages=5):
    page_token = None
    for _ in range(max_pages):
        ...
        for item in result["messages"]:
            yield item
        if not result.get("nextPageToken"):
            return
        page_token = result["nextPageToken"]

for msg in iter_emails():
    process(msg)

Generators. Python Patterns covers them properly. For Patterns track, the inline shape is enough.

Streaming-style read+process

Two patterns side-by-side

When to stream

Streaming + state across runs

Counting as you go

Yield-based streaming (advanced)

Streaming-style read+process

Two patterns side-by-side

When to stream

Streaming + state across runs

Counting as you go

Yield-based streaming (advanced)

Streaming-style read+process

Two patterns side-by-side

When to stream

Streaming + state across runs

Counting as you go

Yield-based streaming (advanced)

Sign up to practice

Streaming-style read+process

Two patterns side-by-side

When to stream

Streaming + state across runs

Counting as you go

Yield-based streaming (advanced)

Sign up to practice