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.

Privacy Terms

Day 24 · ~12 min●

You have multiple shapes — Rectangle, Circle, Triangle. Each can compute its area, but each computes it differently. How do you say "every shape must have an area() method" without copy-pasting it?

python

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius ** 2

print(Rectangle(3, 4).area())
print(Circle(1).area())

What does inheriting from ABC and adding @abstractmethod actually do?

Two things. (1) Can't instantiate. Shape() raises TypeError: Can't instantiate abstract class Shape with abstract method area. (2) Subclasses must override. If Rectangle forgets to define area, instantiating Rectangle(3, 4) raises the same error. The framework forces you to implement every abstract method.

Is that worth the boilerplate?

Sometimes. ABCs are great when you need a guaranteed contract — every plugin must implement these methods, every database adapter must support these operations. They're overkill when you just want a few related classes that happen to share an interface. Tomorrow's Protocol is the lighter alternative.

Why not just use plain inheritance with a normal method that raises NotImplementedError?

That works — and it's what people did before abc. The problem: the error only fires when someone calls the method. With @abstractmethod, the error fires at instantiation — earlier, clearer, and it's documented in the class definition rather than buried in the body.

Abstract base classes — required-to-implement contracts

python

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

    @abstractmethod
    def perimeter(self) -> float:
        ...

Two effects

Shape() raises TypeError — abstract classes can't be instantiated directly
Subclasses must override every @abstractmethod — otherwise instantiating the subclass also fails

python

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self) -> float:
        return self.side ** 2
    # forgot perimeter!

Square(5)    # TypeError: Can't instantiate abstract class Square with abstract method perimeter

`...` is a valid placeholder body

The ... (literal Ellipsis value) is conventional for "this method has no implementation." pass works the same. The body of an abstract method doesn't matter — it's never called.

Concrete methods can live on the base

Not every method has to be abstract. Common pattern: abstract methods for the variable parts, concrete methods that use them:

python

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

    def describe(self) -> str:
        return f"area is {self.area()}"

# Subclass only has to implement area; gets describe for free
class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

print(Square(5).describe())    # area is 25

This is the template method pattern — the base defines the skeleton, subclasses fill in the variable bits.

When to use ABCs

Yes:

Plugin systems where each plugin must implement specific methods
Database / storage / cache adapters with a fixed interface
A library exposing an extension point — "to add a custom X, subclass and implement these three methods"

No:

A few related classes that happen to share a method name — use plain inheritance or Protocol (tomorrow)
Single-implementation cases — no need for abstraction yet
When you just want type checker hints — Protocol is lighter

Comparison: ABC vs Protocol (preview of L25)

	ABC	Protocol
Inheritance required?	Yes — `class X(ABC)`	No — duck typing
Runtime check at instantiation?	Yes	Only with `@runtime_checkable`
Conceptual model	"is-a" relationship	"behaves-like" relationship
When to reach for	Strict plugin contracts	Loose interface descriptions

Use ABCs when you want to enforce the contract. Use Protocols when you want to describe the contract for type checkers without forcing inheritance.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Day 24 · ~12 min●

You have multiple shapes — Rectangle, Circle, Triangle. Each can compute its area, but each computes it differently. How do you say "every shape must have an area() method" without copy-pasting it?

python

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius ** 2

print(Rectangle(3, 4).area())
print(Circle(1).area())

What does inheriting from ABC and adding @abstractmethod actually do?

Two things. (1) Can't instantiate. Shape() raises TypeError: Can't instantiate abstract class Shape with abstract method area. (2) Subclasses must override. If Rectangle forgets to define area, instantiating Rectangle(3, 4) raises the same error. The framework forces you to implement every abstract method.

Is that worth the boilerplate?

Sometimes. ABCs are great when you need a guaranteed contract — every plugin must implement these methods, every database adapter must support these operations. They're overkill when you just want a few related classes that happen to share an interface. Tomorrow's Protocol is the lighter alternative.

Why not just use plain inheritance with a normal method that raises NotImplementedError?

That works — and it's what people did before abc. The problem: the error only fires when someone calls the method. With @abstractmethod, the error fires at instantiation — earlier, clearer, and it's documented in the class definition rather than buried in the body.

Abstract base classes — required-to-implement contracts

python

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

    @abstractmethod
    def perimeter(self) -> float:
        ...

Two effects

Shape() raises TypeError — abstract classes can't be instantiated directly
Subclasses must override every @abstractmethod — otherwise instantiating the subclass also fails

python

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self) -> float:
        return self.side ** 2
    # forgot perimeter!

Square(5)    # TypeError: Can't instantiate abstract class Square with abstract method perimeter

`...` is a valid placeholder body

The ... (literal Ellipsis value) is conventional for "this method has no implementation." pass works the same. The body of an abstract method doesn't matter — it's never called.

Concrete methods can live on the base

Not every method has to be abstract. Common pattern: abstract methods for the variable parts, concrete methods that use them:

python

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

    def describe(self) -> str:
        return f"area is {self.area()}"

# Subclass only has to implement area; gets describe for free
class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

print(Square(5).describe())    # area is 25

This is the template method pattern — the base defines the skeleton, subclasses fill in the variable bits.

When to use ABCs

Yes:

Plugin systems where each plugin must implement specific methods
Database / storage / cache adapters with a fixed interface
A library exposing an extension point — "to add a custom X, subclass and implement these three methods"

No:

A few related classes that happen to share a method name — use plain inheritance or Protocol (tomorrow)
Single-implementation cases — no need for abstraction yet
When you just want type checker hints — Protocol is lighter

Comparison: ABC vs Protocol (preview of L25)

	ABC	Protocol
Inheritance required?	Yes — `class X(ABC)`	No — duck typing
Runtime check at instantiation?	Yes	Only with `@runtime_checkable`
Conceptual model	"is-a" relationship	"behaves-like" relationship
When to reach for	Strict plugin contracts	Loose interface descriptions

Use ABCs when you want to enforce the contract. Use Protocols when you want to describe the contract for type checkers without forcing inheritance.

Sign up to practice

Create a free account to get started. Paid plans unlock all tracks.

or

Abstract base classes — required-to-implement contracts

Two effects

... is a valid placeholder body

Concrete methods can live on the base

When to use ABCs

Comparison: ABC vs Protocol (preview of L25)

Sign up to practice

Abstract base classes — required-to-implement contracts

Two effects

... is a valid placeholder body

Concrete methods can live on the base

When to use ABCs

Comparison: ABC vs Protocol (preview of L25)

Sign up to practice

`...` is a valid placeholder body

`...` is a valid placeholder body