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.

Caching read responses — Automation Patterns

Day 25 · ~12 min●

A loop that looks up the same tasklist_id for every item:

python

for item in items:                                          # 100 items
    lists = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})    # 100 calls
    tasklist_id = lists["items"][0]["id"]
    create_task(tasklist_id, item)

The first line of the loop hits the same API 100 times for the same answer. Cache it.

python

_cache = {}

def get_tasklist_id():
    if "tasklist_id" not in _cache:
        lists = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})
        items = lists.get("items") or lists.get("response_data", {}).get("items", [])
        _cache["tasklist_id"] = items[0]["id"]
    return _cache["tasklist_id"]

for item in items:                                          # 100 items
    tasklist_id = get_tasklist_id()                         # 1 call total
    create_task(tasklist_id, item)

First call: 1 API hit. Calls 2-100: dict lookup. Saved 99 quota slots and ~99× the latency.

When is caching safe? What if the data changes mid-run?

Cache only invariants for the duration of one run — things you'd be surprised to see change:

the user's default tasklist id (rarely changes)
the configured spreadsheet id (set in CONFIG; doesn't change)
the list of calendars (you'd notice in dev if it did)

Don't cache rapidly-changing data — unread email count, recent messages, current tasks. The whole point of reading those is to get fresh values.

Just a dict — no expiry, no eviction?

For one run: yes, just a dict. Scripts terminate; cache vanishes. For long-lived processes you'd add TTLs. Patterns scripts are short-lived, so a dict is enough.

Caching read responses

The pattern

python

_cache = {}

def cached_call(key, fetch_fn):
    if key not in _cache:
        _cache[key] = fetch_fn()
    return _cache[key]

Four lines. key identifies the value ("tasklist_id", f"emails:{query}"); fetch_fn is the actual API call.

What to cache

Invariant for the run. The shorter the script, the more things qualify:

tasklist_id — won't change in 5 minutes
spreadsheet_id from SEARCH_SPREADSHEETS — same
the result of LIST_CALENDARS — same
os.environ.get("USER_EMAIL") — same

What NOT to cache

Recent emails — you're querying them because they change
Calendar events for today — same
Any data you'll write to (caching the read locks in stale data and you'll override it)

Defensive cache writes

python

def get_tasklist_id():
    if "tasklist_id" not in _cache:
        result = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})
        items = result.get("items") or result.get("response_data", {}).get("items", [])
        if not items:
            raise RuntimeError("no task lists found")
        _cache["tasklist_id"] = items[0]["id"]
    return _cache["tasklist_id"]

Validate before storing. A cache that holds None because the API returned an empty list breaks every subsequent call site silently.

Multi-key cache

For cached results that depend on arguments:

python

def cached_search(query):
    key = f"search:{query}"
    if key not in _cache:
        _cache[key] = toolset.execute_action(Action.X, {"query": query})
    return _cache[key]

cached_search("is:unread")    # API call
cached_search("is:starred")   # API call (different key)
cached_search("is:unread")    # cache hit

Key schema: "verb:argv" — readable for debugging, unique enough for reasonable inputs.

Logging cache hits

For scripts where every quota slot matters:

python

def cached_call(key, fetch_fn):
    if key in _cache:
        log("cache_hit", key=key)
        return _cache[key]
    log("cache_miss", key=key)
    _cache[key] = fetch_fn()
    return _cache[key]

One line per call site shows you the hit rate. If you're seeing cache_miss more than expected, your key isn't normalized correctly (e.g., trailing whitespace, case).

Day 25 · ~12 min●

A loop that looks up the same tasklist_id for every item:

python

for item in items:                                          # 100 items
    lists = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})    # 100 calls
    tasklist_id = lists["items"][0]["id"]
    create_task(tasklist_id, item)

The first line of the loop hits the same API 100 times for the same answer. Cache it.

python

_cache = {}

def get_tasklist_id():
    if "tasklist_id" not in _cache:
        lists = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})
        items = lists.get("items") or lists.get("response_data", {}).get("items", [])
        _cache["tasklist_id"] = items[0]["id"]
    return _cache["tasklist_id"]

for item in items:                                          # 100 items
    tasklist_id = get_tasklist_id()                         # 1 call total
    create_task(tasklist_id, item)

First call: 1 API hit. Calls 2-100: dict lookup. Saved 99 quota slots and ~99× the latency.

When is caching safe? What if the data changes mid-run?

Cache only invariants for the duration of one run — things you'd be surprised to see change:

the user's default tasklist id (rarely changes)
the configured spreadsheet id (set in CONFIG; doesn't change)
the list of calendars (you'd notice in dev if it did)

Don't cache rapidly-changing data — unread email count, recent messages, current tasks. The whole point of reading those is to get fresh values.

Just a dict — no expiry, no eviction?

For one run: yes, just a dict. Scripts terminate; cache vanishes. For long-lived processes you'd add TTLs. Patterns scripts are short-lived, so a dict is enough.

Caching read responses

The pattern

python

_cache = {}

def cached_call(key, fetch_fn):
    if key not in _cache:
        _cache[key] = fetch_fn()
    return _cache[key]

Four lines. key identifies the value ("tasklist_id", f"emails:{query}"); fetch_fn is the actual API call.

What to cache

Invariant for the run. The shorter the script, the more things qualify:

tasklist_id — won't change in 5 minutes
spreadsheet_id from SEARCH_SPREADSHEETS — same
the result of LIST_CALENDARS — same
os.environ.get("USER_EMAIL") — same

What NOT to cache

Recent emails — you're querying them because they change
Calendar events for today — same
Any data you'll write to (caching the read locks in stale data and you'll override it)

Defensive cache writes

python

def get_tasklist_id():
    if "tasklist_id" not in _cache:
        result = toolset.execute_action(Action.GOOGLETASKS_LIST_TASK_LISTS, {})
        items = result.get("items") or result.get("response_data", {}).get("items", [])
        if not items:
            raise RuntimeError("no task lists found")
        _cache["tasklist_id"] = items[0]["id"]
    return _cache["tasklist_id"]

Validate before storing. A cache that holds None because the API returned an empty list breaks every subsequent call site silently.

Multi-key cache

For cached results that depend on arguments:

python

def cached_search(query):
    key = f"search:{query}"
    if key not in _cache:
        _cache[key] = toolset.execute_action(Action.X, {"query": query})
    return _cache[key]

cached_search("is:unread")    # API call
cached_search("is:starred")   # API call (different key)
cached_search("is:unread")    # cache hit

Key schema: "verb:argv" — readable for debugging, unique enough for reasonable inputs.

Logging cache hits

For scripts where every quota slot matters:

python

def cached_call(key, fetch_fn):
    if key in _cache:
        log("cache_hit", key=key)
        return _cache[key]
    log("cache_miss", key=key)
    _cache[key] = fetch_fn()
    return _cache[key]

One line per call site shows you the hit rate. If you're seeing cache_miss more than expected, your key isn't normalized correctly (e.g., trailing whitespace, case).

Caching read responses

The pattern

What to cache

What NOT to cache

Defensive cache writes

Multi-key cache

Logging cache hits

Caching read responses

The pattern

What to cache

What NOT to cache

Defensive cache writes

Multi-key cache

Logging cache hits

Caching read responses

The pattern

What to cache

What NOT to cache

Defensive cache writes

Multi-key cache

Logging cache hits

Sign up to practice

Caching read responses

The pattern

What to cache

What NOT to cache

Defensive cache writes

Multi-key cache

Logging cache hits

Sign up to practice