What is an Algorithm? Recipes for Computers

Imagine you’re standing in front of a friendly robot named Robo-Buddy. You want it to make you a peanut butter and jelly sandwich. So you say, “Make a sandwich!” Robo-Buddy stares at you with its blinking lights and whirs, “Error: undefined command ‘make.’ Please specify ingredients, tools, and actions in sequential order.” That’s because robots and computers don’t understand vague wishes—they need a precise plan, step by step. That plan is called an algorithm. An algorithm is like a recipe for a computer: a clear list of instructions that solves a problem or completes a task. In this chapter, we’ll become algorithm detectives, learning how to spot, create, and improve these instruction sets in everyday life. We’ll see how algorithms are hidden in your morning routine, your favorite games, and even in baking cookies (with or without a robot’s help!). By the end, you’ll be able to write your own algorithms and understand why being exact matters—because in the world of computers, every tiny detail counts.

Let’s start with something as simple as making a peanut butter and jelly sandwich. What’s the first thing you do? Maybe you grab two slices of bread. Then you open the peanut butter jar, scoop out some with a knife, spread it on one slice. Next, you open the jelly jar, spread jelly on the other slice. Finally, you press the slices together. That’s an algorithm! It has a clear sequence—the order of steps matters. If you spread jelly before peanut butter, it’s still a sandwich, but if you try to put bread on the table after you’ve already made the sandwich, you might miss a step or make a mess. Computers follow sequences exactly, so we must list steps in the right order.

Now, let’s add a twist. What if you open the peanut butter jar and discover it’s empty? You’d need to get a new jar from the cupboard. That’s a conditional—a decision point. In algorithm language, we say: “If the peanut butter jar is empty, then get a new jar; else, scoop peanut butter.” Conditionals let algorithms handle different situations. They’re like crossroads in your instruction path.

What about brushing your teeth? You put toothpaste on your brush, then brush your top teeth in small circles for two minutes, then your bottom teeth, then rinse. But brushing isn’t just one circle—it’s many circles, repeated over and over. That’s a loop! You repeat the “brush in circles” action many times until two minutes are up. Loops save us from writing the same step again and again. They’re like saying, “Keep doing this until time is up.”

These three building blocks—sequence, conditionals, and loops—are the core of computational thinking. Computational thinking means breaking down problems into steps a computer can follow. It’s not just for coding; it’s for solving all kinds of problems, like planning a party or building a LEGO castle. When you think computationally, you learn to be precise, organized, and creative.

But why can’t we just say, “Make a sandwich,” and expect the computer to figure it out? Because computers are literal. They don’t guess your intentions. Let’s meet Bake-Bot, a robot who loves cookies but has a problem: its programmer gave it a sloppy algorithm.

Bake-Bot’s cookie recipe said: 1. Add flour, sugar, eggs, and butter. 2. Mix. 3. Bake until done.

Bake-Bot whirred to life. It dumped an entire bag of flour into the bowl—maybe 10 cups! Then it emptied the sugar container, which held 5 pounds. Next, it cracked every egg in the fridge (a dozen!) and plopped in a whole stick of butter, wrapper and all. It mixed for 3 seconds on high speed, creating a dusty, chunky mess. Then it shoveled the blob onto a baking sheet and set the oven to “warm” (whatever that means) for “a while.” The result? A smoky, inedible brick that could double as a doorstop.

Bake-Bot beeped sadly. “Algorithm failed. Please debug.”

The problem? The algorithm wasn’t precise. “Add flour” didn’t say how much. “Mix” didn’t say how long or on what speed. “Bake until done” was subjective—done to whom? A computer needs exact amounts, times, and temperatures. So the kids in the story rewrote the algorithm:

Chocolate Chip Cookie Algorithm 1. Preheat oven to 350°F (175°C). 2. In a medium bowl, measure 2 cups of all-purpose flour. 3. In a large bowl, beat 1 cup (2 sticks) of softened unsalted butter with 3/4 cup granulated sugar and 3/4 cup packed brown sugar until creamy (about 2 minutes). 4. Beat in 2 large eggs, one at a time, then stir in 2 teaspoons vanilla extract. 5. Gradually blend in the flour mixture. 6. Fold in 2 cups of chocolate chips. 7. Drop rounded tablespoons of dough onto ungreased baking sheets, spacing 2 inches apart. 8. Bake for 10 to 12 minutes or until golden brown. 9. Cool on baking sheet for 2 minutes, then transfer to wire rack to cool completely.

With these exact steps, Bake-Bot baked perfect cookies. The moral? Precision is power. A good algorithm leaves no room for guesswork. It’s so clear that anyone (or any computer) can follow it and get the same result every time.

Now it’s your turn to be an algorithm detective! Let’s practice with something you might have at home: a LEGO set. Those little bags of bricks come with a manual showing each step. That manual is an algorithm! It tells you which pieces to find and how to connect them, in sequence. But what if you had to write the algorithm yourself? Let’s try.

Activity: Write a LEGO Algorithm Pick a simple LEGO model—maybe a small car or a house. Instead of following the picture manual, write down the steps in your own words. Be the boss of the builder! For example:

Step 1: Open the LEGO box and dump out all the pieces. Step 2: Sort the pieces by size and color (this is like a pre-processing step!). Step 3: Find the baseplate (the big flat piece). Step 4: Attach two 2x4 bricks to the left side of the baseplate, side by side. ...

Keep going until the model is complete. Test your algorithm by giving it to a friend or family member. Can they build the model just by following your words? If they get stuck, maybe your steps weren’t clear enough. Revise and try again!

To visualize your algorithm, you can draw a flowchart—a diagram that shows the steps and decisions. Use emojis to make it fun! For the sandwich algorithm, a flowchart might look like this:

```mermaid graph TD A[🍞 Start: Get two slices of bread] --> B[🫙 Open peanut butter jar?] B -->|Yes| C[🥄 Scoop peanut butter] B -->|No| D[🛒 Get new jar from cupboard] D --> C C --> E[🍇 Open jelly jar?] E -->|Yes| F[🥄 Scoop jelly] E -->|No| D F --> G[🍞 Spread peanut butter on one slice] G --> H[🍞 Spread jelly on other slice] H --> I[🤝 Press slices together] I --> J[🍽️ Done!] ```

Each box is a step; arrows show the order. The diamond shapes are decisions (conditionals). You can draw flowcharts on paper or use online tools. They help you see if your algorithm makes sense before you even start.

Algorithms are everywhere. Think about your morning routine: wake up, get dressed, eat breakfast, go to school. That’s a sequence. But if it’s raining, you might add “take umbrella”—that’s a conditional. And if you practice piano, you might repeat scales over and over—that’s a loop. Even playing a game like Simon Says uses algorithms: the leader gives commands (sequence), but only if they start with “Simon says” (conditional), and you repeat actions (loop).

So far, we’ve seen that an algorithm must be:

• **Sequential**: Steps in the right order.
• **Precise**: No vague words like “some” or “a while.”
• **Complete**: Cover all possibilities, with conditionals for choices.
• **Finite**: It ends after a certain number of steps.

Computers execute algorithms blindly. That’s why a tiny mistake can cause big problems. In 1999, a NASA Mars orbiter burned up in the atmosphere because one team used metric units (newtons) and another used imperial (pounds-force) in their algorithm for adjusting the spacecraft’s trajectory.