What Is Code?

Chapter 01 What Programming Actually Is

Programming is writing instructions for a machine that has zero common sense. Imagine telling someone to make a peanut butter sandwich. A human grabs the jar, opens it, picks up a knife. A computer? It stares at the sealed jar because you didn't say "open the jar." Every instruction must be explicit, literal, and in order.

A program is a text file containing these instructions. Not a mysterious binary blob—a plain text file you can open in any editor. An interpreter (for languages like Python) or a compiler (for languages like Rust) translates your human-readable text into instructions the machine's processor can execute.

Why Code Exists

Computers understand one thing: voltage patterns. High voltage = 1. Low voltage = 0. That's it. Programming languages exist so humans don't have to think in ones and zeros. Between the Python you write and the voltages flipping in the CPU, there are several translation layers—and you never need to touch the lower ones.

The Language Landscape

Different programming languages exist for different jobs, the same way you'd use a screwdriver for screws and a hammer for nails. Here are the major categories:

What Software Actually Looks Like

The diagram above shows language categories. But what are the things people build with them? Almost all software falls into a few major categories—and most real products combine several.

Web Systems (Frontend + Backend)

A web application is anything you use in a browser: Gmail, YouTube, GitHub, online banking. It has two halves:

• Frontend — what you see. HTML structures the page, CSS styles it, JavaScript makes it interactive. When you click a button and a menu appears without the page reloading, that's JavaScript running in your browser.
• Backend — what you don't see. A server (often written in Python, Node.js, Go, or Rust) processes requests, enforces business rules, and talks to a database. When you log in, the backend checks your password. When you post a comment, the backend saves it.

The frontend and backend communicate over HTTP—the same protocol you'll learn in Chapter 13. Every URL you visit triggers an HTTP request to a backend somewhere.

Real example: Twitter/X. The frontend renders your timeline in the browser. The backend handles authentication, stores tweets in a database, runs the recommendation algorithm, and serves the timeline data as JSON over HTTP. Millions of users, thousands of backend servers, one seamless experience.

Mobile Applications

Apps on your phone. Two approaches:

• Native apps — built specifically for one platform. Swift for iOS, Kotlin for Android. Best performance, full access to device hardware (camera, GPS, sensors). Instagram, the iOS Calculator, and Apple Health are native.
• Cross-platform apps — one codebase, both platforms. React Native (JavaScript) or Flutter (Dart) generate iOS and Android versions from the same code. Faster to develop, slightly less polished. Many startups use this.

Most mobile apps still need a backend—they're just a different frontend talking to the same kind of server over HTTP.

Databases

A database is organized, persistent storage. Without one, your data disappears when the program stops. There are two main families:

• Relational (SQL) — data in tables with rows and columns, like a spreadsheet with strict rules. PostgreSQL, MySQL, SQLite. Best when data has clear relationships (users have orders, orders have items). You'll use SQLite in Chapter 15.
• Non-relational (NoSQL) — flexible structures: documents (MongoDB), key-value pairs (Redis), or graphs (Neo4j). Best for unstructured data, caching, or relationships that don't fit neatly into tables.

Real example: An e-commerce site like Shopify uses a relational database for products, orders, and customers (structured, relational data). It might use Redis (NoSQL) for caching product pages so they load instantly, and a search engine like Elasticsearch for product search.

How They Fit Together

A modern application typically combines all three. Consider a ride-sharing app like Uber:

• Mobile app (frontend) — shows the map, lets you request a ride, displays the driver's location in real time
• Backend servers — match riders to drivers, calculate pricing, process payments, handle surge pricing logic
• Databases — store user profiles, trip history, payment methods, driver ratings
• Web dashboard — lets drivers manage their account, lets admins monitor the system

This curriculum focuses on Python backends and SQLite databases because that's the foundation. Once you understand how a backend processes requests and stores data, everything else—frontends, mobile apps, cloud infrastructure—is a variation on the same patterns.

Common Misconceptions

Micro-Exercise 1

Micro-Exercise 2

Where TaskForge Fits

Throughout this course, you'll build TaskForge—a command-line task manager. It starts as a 40-line Python file and grows into a multi-agent project by Phase 5. Right now, just know: TaskForge is a text file containing instructions. By the end of this chapter, you already know what that means.

Interactive Exercises

The exercises below run Python directly in your browser using a technology called Pyodide (Python compiled to run inside a web page). No extra install needed. Let's test it right now:

Chapter 02 How Computers Execute Code

Now that you know a program is a text file with instructions, let's see how the machine actually runs those instructions. The key idea: sequential execution—the computer reads your code top to bottom, one line at a time, in the exact order you wrote it.

Variables: Labeled Boxes

A variable is a labeled box that holds a value. Think of a row of mailboxes in an apartment building: each has a name on it, and you can swap out what's inside without changing the label. In Python, you create one with the = sign:

# This is Python — the language we'll use throughout this guide
speed = 85
name = "TaskForge"
running = True

The label (speed) stays. The value inside can be replaced. speed = 90 puts a new value in the same box—the old 85 is gone.

Data Types: Box Shapes

The type of a value determines what operations are valid:

Operators and Expressions

Now that you have values in boxes, you need to combine them. An expression is any piece of code that produces a value. 2 + 3 is an expression that produces 5.

Arithmetic Operators

price = 29.99
quantity = 3
total = price * quantity  # 89.97
print(total)

Note: + works differently depending on the type. 3 + 4 adds numbers. "hello" + " world" joins strings. Mixing types ("3" + 4) causes a TypeError—the machine takes you literally.

Micro-Exercise 3

a = 17
b = 5
result = a // b
remainder = a % b
print(result, remainder)

Errors as Feedback

When your code goes wrong, the computer tells you—if you know how to listen. There are three types of errors:

Micro-Exercise 1

a = 3
b = a
a = 7
print(b)

Micro-Exercise 2

name = 'world'
print('Hello, ' + name + '!')

TaskForge Connection

In TaskForge v0.1, the line task = {"id": len(tasks) + 1, "description": description, "status": "pending"} uses every concept from this chapter: a variable (task), integers (len(tasks) + 1), strings ("pending"), and assignment (=). By the time you read that code in Chapter 04, these will be familiar patterns.

Interactive Exercises

Chapter 03 Setting Up Your Environment

Before you can run Python code, you need two things: a terminal (where you type commands) and Python (the interpreter that runs your code). This chapter gets both working.

The Terminal

The terminal is a text-based interface to your computer. Instead of clicking File → New Folder, you type mkdir new_folder. It's faster, scriptable, and—crucially—it's how every AI coding tool works. Claude Code runs entirely in the terminal.

Upgrading Your Terminal Emulator

Installing iTerm2

After installing, open iTerm2 and make it your default: iTerm2 → Make iTerm2 Default Term (in the menu bar).

Essential iTerm2 Configuration

Open Preferences (Cmd + ,) and apply these settings:

iTerm2 Hotkeys You'll Use Daily

Terminal Speed: Shell Hotkeys

These work in any terminal—iTerm2, default Terminal, Windows Terminal, Linux. They use readline keybindings, which are the same across bash and zsh. Learn these and you'll never reach for the mouse while typing commands.

Installing Python

The REPL

Type python3 in your terminal. The >>> prompt appears—this is the REPL (Read-Eval-Print Loop). It's your sandbox: type any Python expression, see the result instantly. Type exit() to leave.

Your First File

Create a file called hello.py containing one line:

print("Hello, World!")

Run it: python3 hello.py. The terminal prints Hello, World!. That's it—you've written and executed a program.

Virtual Environments

Before you install any Python packages, you need to understand virtual environments. A virtual environment is a self-contained copy of Python for a specific project. Without one, every package you install goes into a single global location—and eventually, two projects will need different versions of the same package. Things break. Virtual environments prevent this entirely.

Creating a Virtual Environment

This creates a .venv folder inside your project. It contains a private copy of Python and a clean, empty set of packages. The folder name .venv is a convention—the dot makes it a hidden folder so it doesn't clutter your file listing.

Activating the Virtual Environment

How to Tell You're in a Virtual Environment

Two clues tell you it worked:

# 1. Your prompt changes — you'll see (.venv) at the beginning:
(.venv) ~/my-project $

# 2. which python points to the venv, not the global Python:
(.venv) ~/my-project $ which python
/Users/you/my-project/.venv/bin/python

Deactivating

When you're done working on a project, type deactivate to return to the global Python:

The (.venv) prefix disappears from your prompt, and which python points back to the system Python.

Micro-Exercise 3

Your Code Editor

You can write code in any text editor, but a code editor highlights syntax, catches typos, and integrates with the terminal. Start with VS Code (free, from code.visualstudio.com). AI-native editors like Cursor and Windsurf build AI assistance directly in—you'll use these in Phase 4.

VS Code Hotkeys That Save Real Time

These are the shortcuts professionals use constantly. On macOS, Cmd = ⌘. On Windows/Linux, replace Cmd with Ctrl.

Installing Packages

pip installs packages—code other people wrote that you can use. Example: pip install requests installs a library for making web requests. You'll use this in Chapter 11.

$ claude
╭──────────────────────────────────────╮
│ Claude Code                          │
│                                      │
│ /home/you/taskforge                  │
╰──────────────────────────────────────╯

> Explain the architecture of this project in one paragraph.

This project is a command-line task manager built in Python...

Micro-Exercise 1

Micro-Exercise 2

TaskForge Connection

You now have everything needed to run TaskForge v0.1. After this chapter, the command python3 taskforge.py will work on your machine. You'll do exactly that in Chapter 04.

Interactive Exercises

Chapter 04 Reading Code Before Writing It

Here's the paradigm shift: traditional education starts with writing code. AI-assisted work starts with reading code. When Claude Code generates 200 lines of Python for you, you won't write those lines—you'll read, evaluate, and decide whether to accept them. Reading code is your primary skill.

How to Read Code

Don't start at line 1 and grind forward. Use this three-pass approach:

Pattern Recognition

You don't need to write code from memory. You need to recognize patterns when you see them:

Before/After: Weak vs. Strong Reading

Micro-Exercise 1

def double(x):
    return x * 2

Micro-Exercise 2

for item in ['a', 'b', 'c']:
    print(item.upper())

TaskForge v0.1 — The Code

Here's the complete source code for TaskForge v0.1. This is the spine project you'll build on for the rest of the course. Read it now using the three-pass approach.

# taskforge.py — v0.1
# A minimal command-line task manager

tasks = []

def add_task(description):
    task = {"id": len(tasks) + 1, "description": description, "status": "pending"}
    tasks.append(task)
    return task

def complete_task(task_id):
    for task in tasks:
        if task["id"] == task_id:
            task["status"] = "complete"
            return task
    return None

def list_tasks():
    return tasks

def main():
    while True:
        command = input("\nTaskForge> ").strip().lower()
        if command == "add":
            desc = input("Description: ")
            task = add_task(desc)
            print(f"Added: #{task['id']} — {task['description']}")
        elif command == "done":
            task_id = int(input("Task ID: "))
            result = complete_task(task_id)
            if result:
                print(f"Completed: #{result['id']}")
            else:
                print("Task not found.")
        elif command == "list":
            for t in list_tasks():
                status = "✓" if t["status"] == "complete" else " "
                print(f"  [{status}] #{t['id']} — {t['description']}")
        elif command == "quit":
            break
        else:
            print("Commands: add, done, list, quit")

if __name__ == "__main__":
    main()

Run TaskForge Yourself

TaskForge> add
Description: Buy groceries
Added: #1 — Buy groceries

TaskForge> list
  [ ] #1 — Buy groceries

TaskForge> done
Task ID: 1
Completed: #1

TaskForge> list
  [✓] #1 — Buy groceries

TaskForge> quit

A Worked Three-Pass Reading

Before you analyze TaskForge on your own, here's the three-pass method applied to a short function. Watch how each pass reveals a different layer of understanding.

def find_max(numbers):
    if len(numbers) == 0:
        return None
    biggest = numbers[0]
    for num in numbers:
        if num > biggest:
            biggest = num
    return biggest

Three passes, maybe 60 seconds total, and you understand the function completely. Apply this same method to TaskForge below.

Interactive Exercises

Phase 1 Gate Checkpoint & TaskForge v0.1

TaskForge Checkpoint

You have read and analyzed TaskForge v0.1. You have NOT modified it. The project exists as a single .py file with no tests, no git, no structure. This is your baseline. In Phase 2, you'll start writing code to extend it.

What You Can Now Do