Introduction to Programming

The secret to solving any big task is to break it into small, precise steps. Getting a robot out of a maze, or building a website, both start by splitting the work into stages.

Programmers often draw these steps as a flowchart: each action is a box, arrows show the order, and a diamond represents a condition (yes or no). The flowchart below shows how the steps run one after another:

Now a bigger maze. To get the robot to the apple, plan ahead: where to go straight, where to turn? Think through each turn in advance, that is what planning an algorithm means.

A variable is a named box where a value is stored. You can put a number, text, or a yes/no (boolean) value in it, and change it as often as you like.

Try the "score" box below. When you click the buttons, the value inside changes, but the name of the box stays the same:

Now the robot collects several apples. Each time it picks one up, the apple variable goes up by 1, just like a counter. Teach the robot to collect all three apples and watch the counter:

So far the robot has followed commands blindly. But real programs can look and make decisions: "if something is true, do this; otherwise, do something else". This is called a condition.

An everyday example is a traffic light: "if the light is red, stop; if it's green, go". The robot also "sees" what's ahead and picks its path accordingly. Below, two cases light up in turn:

Now the robot can land in two different situations, but it doesn't know in advance which one. Build a single program that works in both situations. The trick: use the "if there's a wall ahead, turn right" condition.

Use the "Situation A / B" button above to switch between the cases. One program (without changing it) must solve both.

Sometimes you need to write the same command over and over. A loop (repetition) shortens this: "repeat 6 times: forward" means run "forward" 6 times.

Below, the two give the same result, but the loop is much shorter:

The robot below moves using a loop. The loop counter goes up with each repetition (for example 1/5, 2/5 ...):

Guide the robot to the apple, but the path is long. Instead of writing "forward" many times, use a loop: click the "repeat" button and adjust the number with − / +.

Sometimes you use a group of commands over and over. If you bundle them under a single name, you get a function. After that you just "call" the name and the whole group runs.

An everyday example: say "brew tea" and every step happens on its own. Below, the stairs() function gives a name to the motion of climbing one "step":

The robot below climbs the steps by calling stairs(). When it's called, the function block lights up:

The robot needs to climb a staircase. Every step is the same motion, that is stairs(). Instead of rewriting four commands each time, call the function. Click the "stairs()" button a few times and take the apple.

Every programmer makes mistakes, and that's normal. When a program stops working or gives a wrong result, there is an error (in English, a "bug") in it. The process of finding and fixing an error is called debugging.

If the robot doesn't reach the apple or bumps into an obstacle, it means there is an error in the program. A good programmer doesn't panic, but finds the error with the following steps:

The program below has an error: the robot hits an obstacle instead of reaching the apple. First use "Run" to see where it stops, and check with "Step" if needed. The error is one extra "forward" in the first row. Click the extra command to delete it and run again.