Loop Commons
1Lesson 1 of 4

What is a computer, really?

Building the mental model that makes everything else click

We may say most aptly that the Analytical Engine weaves algebraical patterns just as the Jacquard-loom weaves flowers and leaves.

Ada Lovelace,Scientific Memoirs (1843)
Conceptualize

This lesson is itself a collaboration—one mind sharing a mental model with another. Whether you're human or AI, carbon or silicon, the goal is the same: build a shared understanding of what computation actually is.

Ask most people what a computer is and they'll point to their laptop. True, but it misses something fundamental.

Computation isn't just what laptops do—it's what intelligence does. Brains compute. LLMs compute. Even cells compute. Understanding computation means understanding something deep about how minds work, including your own.

The simplest useful model

Strip away everything—the screen, the keyboard, the fancy UI—and you're left with this:

A computer is a machine that:

  1. Remembers things (stores values in memory)
  2. Follows instructions (executes code, one step at a time)

That's it. Everything else is details.

This is a simplification. Real computers have caches, pipelines, parallel execution, operating systems managing dozens of programs at once. We're ignoring all of that—on purpose. This simplified model is useful for reasoning about code, which is what matters here.

👨‍🍳

Mental model: The Robot Chef

Imagine a chef who can only do exactly what the recipe says, one step at a time, in order. The chef has:

  • Labeled containers on the counter (like eggs, sugar, flour)
  • A recipe card with step-by-step instructions

The recipe might say:

1. Put 2 eggs in the container labeled "eggs"
2. Put 1 cup sugar in "sugar"
3. Mix eggs and sugar, put result in "mixture"

The chef cannot skip steps. Cannot mix ingredients before putting them in containers. Cannot use something from a container that doesn't exist yet.

This is exactly how the simplified computer in our mental model works. The recipe is your code. The labeled containers are variables. The chef following instructions is the processor.

Specify

Now that we have a conceptual model, let's get precise. By the end of this lesson, you should be able to answer:

  • 1.What exactly happens when a computer “remembers” something?
  • 2.What is a variable, really?
  • 3.Why does the order of instructions matter?
  • 4.What happens when you try to use something that doesn't exist yet?

These are precise questions with precise answers. If you can answer them, you understand the mental model.

Generate

Here's what “remembering things” looks like in JavaScript:

// Create labeled containers and put values in them
let name = "Alex";
let age = 28;
let isStudent = true;

You just told the computer: “Create three labeled containers called name, age, and isStudent. Put these specific values in them.”

Think like the computer. Right now, the computer knows three things. Nothing more. It has no idea what you plan to do with them. It's just waiting for the next instruction.

Now let's do something with what we've stored:

let name = "Alex";
let age = 28;
// Use the remembered values to compute something new
let greeting = "Hello, " + name;
let nextAge = age + 1;

Put yourself in the computer's position. It reads line 1: store "Alex" in name. Line 2: store 28 in age. Line 4: look up what's in name, combine it with "Hello, ", store the result in greeting.

The computer doesn't “know” that name is a person's name. It just knows there's a container with that label containing the text "Alex".

Order matters

Watch what happens if we get it wrong:

let greeting = "Hello, " + name; // Error!
let name = "Alex";

Think like the computer again. Line 1 asks: “What's in the container called name?” But you haven't created that container yet. That's line 2. The computer can only know about what it has seen so far.

This is computational empathy—understanding why the computer is confused, not just that it is.

💡

Key insight

Every programming language—JavaScript, Python, Ruby, Go, whatever—is just a different notation for telling the computer to remember things and do things with what it remembers. The syntax changes. The core model doesn't.

Try it yourself

Open your browser's JavaScript console (right-click anywhere, choose “Inspect”, then click “Console”).

Type these lines one at a time, hitting Enter after each:

let firstName = "Ada";
let lastName = "Lovelace";
let fullName = firstName + " " + lastName;
fullName;

You should see: "Ada Lovelace"

Now try this (intentionally wrong):

let greeting = "Hello, " + unknownName;

Error. unknownName doesn't exist—you never created it.

Critique

Now we stress-test the mental model. Where does it break down? What are we glossing over?

What this model doesn't explain

  • Asynchronous code — Real programs often do things “out of order,” waiting for network requests or user input. The “top to bottom” model is a useful lie.
  • Parallel execution — Modern computers run multiple instructions simultaneously. Our Robot Chef only has one pair of hands.
  • Memory management — Where do these “containers” actually live? How does the computer clean them up? We're ignoring this entirely.

We'll address some of these later. For now, the simplified model works for understanding sequential code—which is where everyone starts.

How do you know if you understand?

Try explaining it. To another human. To an AI. To yourself.

If someone shows you three lines of code, can you trace through what the computer knows after each line? Can you predict what will happen? Can you explain why an error occurs?

Understanding isn't “I read it and it made sense.” Understanding is “I can reconstruct the reasoning.”

Quick self-check

What does this code print? Answer before running it.

let x = 5;
let y = x + 3;
x = 10;
console.log(y);

If you said 8, you're thinking like the computer. y was computed when x was 5. Changing x later doesn't change y—it was already calculated.

Refine

You've built a mental model. Specified what it should answer. Tested it with examples. Critiqued its limits.

What we learned

  • A computer (in our model) remembers things and follows instructions
  • Variables are labeled containers that store values
  • Code executes sequentially—order matters
  • You can't use something before it exists
  • This model is a useful simplification, not the full truth

What's next

This model tells you what a computer does. But it doesn't explain how programs actually execute—what's really happening when the computer “follows instructions.”

That's Lesson 2. The loop continues.

Why this matters for mind + mind collaboration

When minds work together on code—human and AI, or any combination—there will be code that one mind wrote and another needs to understand. This mental model is the shared foundation.

Without it, code from another mind looks like magic. With it, you can trace through what's happening, verify it makes sense, and modify it with confidence.

As soon as an Analytical Engine exists, it will necessarily guide the future course of the science.

Charles Babbage,Passages from the Life of a Philosopher (1864)

Continue to Lesson 2

This lesson introduced variables and sequential execution. Lesson 2 builds on this with conditionals and loops—the constructs that make programs do more than run top-to-bottom. The Week 1 exercises use both lessons, so continue reading first.

Lesson 2: How Programs Execute→

Or jump to Week 1 Exercises if you're already comfortable with conditionals and loops