Build your first block program

Start with a tiny program whose result is easy to recognise. A program is a set of instructions for the computer. This first one has a single instruction: display a greeting. The blue block below is the same block you can edit in your practice editor, not a screenshot of another application.

Read the label from left to right: say, then the message to say. The white socket contains text. Text is a sequence of characters, including spaces and punctuation. At this point there is no model and nothing is being trained; you are learning how to give a precise instruction.

Choose Try this stage to put a copy in your editor. Press Run and look at Output. You can also build it yourself: choose Add blocks, find the Basics group, and add a say block. Click its white socket and enter the greeting. Do not type the word say into the socket; the block already supplies the instruction.

A stack gives the computer an order. It performs the top statement, then the next statement underneath. A statement is an instruction that does something, such as displaying text or storing a value. Touching blocks form one connected program when their joints snap together.

Adding a second say block does not replace the first one. You now have two instructions and should expect two output lines. Predict which line comes first before you run. This habit makes it easier to notice an accidental gap or a block placed in the wrong position.

Add a second say block below the first. Drag its top joint toward the first block's bottom joint and release when the insertion indicator appears. The two blocks should form one stack. Use Try this stage if you want to compare your arrangement with a working copy; Undo restores your previous work.

Now separate the data from the instruction that uses it. The set block creates a variable called name and gives it the text Ada. A variable is a name your program uses to refer to a stored value. You can choose another value while keeping the later instructions the same.

The rounded name block is a value block. It supplies the current value of name to the say block's socket. Typing the letters name into the socket instead would print the literal word name. The visual connection shows which value is being read.

Put set name to Ada first. Add the labelled say block below it. Type Hello into the label field, then insert the rounded name value into its value socket. Find name in the variable menu after its set block exists. Keep the set block above the first block that uses name.

Text and numbers have different jobs. A name is text, but an age used for arithmetic should be a number. In this block editor, entering an ordinary numeric value such as 12 in an any-value socket produces a number in the generated program.

Create a separate variable called age. It does not change name; each variable refers to its own value. The two labelled output blocks let you inspect both. Labels such as Hello and Age are text chosen for the person reading the output, not variables the computer looks up.

Add set age to 12 after the name assignment. Put an age value block into a labelled say block below the greeting. Run the whole stack from the top. All the values used later must first be created in this run.

A calculation can sit inside a set block's value socket. Here the plus block reads age and adds one. Its result is stored as next_age. The computer evaluates that inner calculation before completing the outer assignment.

The name next_age is one name containing an underscore, not two words separated by a space. It describes what the value means. We keep the original age so that the two output lines can show before and after together.

Build a plus value block with the age variable in the left socket and 1 in the right. Place the whole plus block inside set next_age to. Add an output line that reads next_age. Compare the nesting carefully: the value is inside the assignment, and the assignment is a statement in the main stack.

A loop repeats the statements placed inside its open body. This repeat block runs its body three times. The greeting is inside; the next-birthday output is below the loop and outside it. That placement determines how often each statement runs.

Follow the program in order. It stores name and age, calculates next_age once, enters the loop, prints the greeting three times, leaves the loop, and prints the final age once. A loop does not repeat every statement visually near it.

Add repeat from Control and set its count to 3. Move the greeting into the indented opening inside the repeat block. Keep Next birthday below the closing edge. If you load this stage, inspect the indentation before running rather than treating its output as a surprise.

Editing is part of programming. You will move a block into the wrong place, delete a useful step, or try a change that does not help. Undo lets you return to an earlier source arrangement. It does not erase a fact from the world or turn back a completed training run; it changes the program you will run next.

This stage returns to the simpler personal greeting. Keeping a small working version makes mistakes easier to locate. Read each statement and say what it contributes before adding anything else.

Change the age, run, and observe the new result. Use Undo to restore the previous edit and run again. Use Redo to reapply it. The previous output remains visible until another run produces a result, so always connect your observation to the program version that actually ran.

A repeated change can build a result. Begin with total equal to zero. The change block reads the current total, adds three, and stores the new value under the same name. The repeat body performs that update five times.

Trace the stored value: before the loop it is 0; after the first turn it is 3; then 6, 9, 12, and finally 15. The set block is outside the loop. Inside, it would reset total to zero every turn, so the final value would be 3. Location changes meaning even when every individual block is valid.

Build the three outer statements shown. Drag change total by 3 into repeat's opening. Keep set total to 0 above repeat and the labelled output below it. Run and compare with the five-value trace.

A temporary output statement is a debugging tool. Place it after change, inside the loop, to reveal the value each turn just stored. Keep the final output outside as well. The program now shows both the journey and the result.

Before change, the diagnostic output would show the old value: 0, 3, 6, 9, 12. After change, it shows 3, 6, 9, 12, 15. Both are correct descriptions of different moments. When debugging, ask not only which value you printed, but when you printed it.

Add a labelled output inside repeat immediately after change. Run. Use its Block actions menu to delete the diagnostic statement and Undo to restore it. Read whether the menu removes a block or its connected group before confirming.

Choose View Python in your practice editor. The block program becomes ordinary Python text. set name to Ada becomes name = "Ada". The equals sign assigns a value to a name. Quotes identify text. The age assignment uses a number without quotes.

The nested addition becomes next_age = age + 1, and a labelled say block becomes a print call. You have already chosen the order, values, and operation. Python expresses those same choices with characters instead of connected shapes. Later lessons teach the punctuation and indentation you must supply when typing those instructions yourself.

Read the generated Python from top to bottom while comparing it with the blocks. Switch back to Blocks to edit this lesson's program. View Python is a view of that program, so its text changes when you change the blocks. Use Download practice code if you want to keep a source copy.