Algorithms and Flowcharts

An instruction is an order precise enough to be carried out without deciding anything: “move forward one square”, “multiply by \(2\)”, “draw a segment of \(4\)~cm”. “Go to the station” is not an instruction: whoever receives it still has to choose the way.
A sequence of instructions — a program — is a list of instructions carried out in order, the first one first, the last one last. The same instructions in another order make another program: starting from \(3\), “multiply by \(2\), then add \(5\)” gives \(11\), while “add \(5\), then multiply by \(2\)” gives \(16\).

The input of a program is what is given before executing it; the output is what is obtained after. The program itself does not change: it is written once and works for every allowed input.

	Input	Output
Robot program	the starting square and direction	the arrival square and direction
Calculation program	the number chosen	the number written
Construction program	a blank sheet	the figure

The instruction “repeat \(n\) times ( …\ )” executes the group written between the brackets ( ) (also called parentheses) — its body — \(n\) times in a row, then continues with what follows the closing bracket. Each execution of the body is a turn. It is also written \(n \times (\ldots)\): \(4 \times (\rightarrow\ \rightarrow\ \curvearrowright)\) and “repeat \(4\) times \((\rightarrow\ \rightarrow\ \curvearrowright)\)” say the same thing.
A program with a repeat has two counts:

• the instructions written: the “repeat” line and the instructions of its body — for “repeat \(4\) times \((\rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright)\)”, \(1 + 4 = 5\) written instructions;
• the instructions executed: the body as many times as there are turns — \(4 \times 4 = 16\) instructions.

A flowchart is a drawing of a program: each instruction is written in a box, and arrows join the boxes in the order in which they are executed. The shape of a box tells what it does:

• a box with rounded ends marks the start or the end of the program — there is one Start and one End;
• a process box, a rectangle, holds one instruction: “add \(5\)”, “divide the number by \(2\)”;
• an input or output box, a parallelogram, receives the input (“input a number”) or writes the output (“output the number”).

In a flowchart, a loop is drawn with a return arrow: it leaves from below a box and goes back up to an earlier box, and it is marked with a count, such as “\(10\) times”. The boxes between the end of the return arrow and its start are executed that number of times in a row; each pass through them is a turn, the word already used for “repeat”. After the last turn, the flow goes on along the arrow that goes down. To trace a loop by hand, execute its boxes as many times as the count says, with one line of the trace table per turn.
A loop marked “\(10\) times” is the drawing of “repeat \(10\) times ( …\ )”: the boxes of the loop are its body.

A block program is a sequence of instructions written as blocks stacked from top to bottom: one block is one instruction, the stack is the sequence, and it is executed from the top. A repeat block contains its body; the blocks placed inside it are executed at each turn, the block placed under it after the last turn.

In Scratch, a program is executed by a character, the sprite, on a rectangle called the stage. The stage is \(480\) steps wide and \(360\) steps high; every point of it has two coordinates, \(x\) from \(-240\) to \(240\) and \(y\) from \(-180\) to \(180\), with the centre at \((0, 0)\). There are no squares on the stage: the step is its unit of length (“\(10\) steps = one square” was only a convention of the grid); on the figures, one grid square is \(50\) steps. The sprite always has a position \((x, y)\) and a direction, given in degrees: \(90\) means “looking to the right”, \(0\) “looking up”, \(-90\) “to the left”, \(180\) “down”.
A script is a pile of blocks that snap together; a block is one instruction, and the sprite executes them from top to bottom. The blocks are sorted in categories, one colour each: motion (blue), looks (purple), events (yellow), control (orange), sensing (light blue), operators (green), variables (dark orange), pen (dark green).

A script starts with an event block, a “hat” block that nothing can be placed above. The most common is “when green flag clicked”: the script runs when the green flag above the stage is clicked. A pile of blocks without a hat does not start with the flag — it only runs when someone clicks on it.
The flag resets nothing: position, direction, pen up or down, drawings stay as the last run left them. A script that draws therefore begins with its initial state: erase all, pen up, go to a chosen point, point in a chosen direction, pen down — the pen lifted first, otherwise the jump to the starting point leaves a line.

• Move. “move \(10\) steps” moves the sprite \(10\) steps forward, in its direction. “turn \(\circlearrowright\) \(15\) degrees” turns it clockwise — to its right — without moving it; “turn \(\circlearrowleft\)” turns it the other way. “go to x: \(0\) y: \(0\)” jumps to a point; “point in direction \(90\)” sets the direction.
• Draw. “pen down”: from now on, the sprite draws its path, “go to” jumps included; “pen up”: it moves without drawing; “erase all” cleans the stage.
• Say. “say Hello!” shows a speech bubble that stays; “say Hello! for \(2\) seconds” shows it two seconds, then removes it, and the script waits meanwhile.

The numbers and texts typed into the holes of a block — the \(10\) of “move \(10\) steps”, the “Hello!” of “say” — are its parameters: changing them changes what the script does without changing its blocks.   

The block “ask … and wait” makes the sprite ask the question in a speech bubble and shows a box to type in at the bottom of the stage; the script waits until the user validates. What was typed is then kept in answer, a round light blue block that can be dropped into other blocks. “say (answer)” shows it in the bubble.
“answer” is a single memory: each new “ask” replaces what it held. “answer” is a variable: a name under which a value is kept in memory — here “ask” fills it, and the script reads it.

The inputs of a script are what the user gives it while it runs: what is typed after an “ask”, a key pressed. Its outputs are what it shows: what the sprite says, what it draws, where it goes. The same script gives different outputs for different inputs — that is what it is written for. On paper, the input was given before executing (the number chosen, the starting square); a script receives it while it runs, when it asks for it. Its starting point is no longer an input: it is the initial state, which the script sets itself.

The green operator blocks compute: “( ) + ( )”, “( ) \(-\) ( )”, “( ) \(*\) ( )” for a product, “( ) / ( )” for a quotient. Each one has two round holes, where a number, “answer” or another operator block can be dropped. An operator inside another is computed first: nesting plays the part of brackets. The value is computed when the block is executed, with what “answer” holds at that moment. This block says the value of \((\text{answer} + 10) \times 2\).

The block “repeat \(n\)” is a loop, shaped like a C: the blocks placed inside the C — its body — are executed \(n\) times in a row, one turn after another; then the sprite goes on with the block placed below the C. A repeat inside a repeat is executed entirely at each turn of the outer one, as for the robot on paper.

A condition is a green hexagonal block that is either true or false: “( ) \(<\) ( )”, “( ) \(>\) ( )”, “( ) \(=\) ( )”. Its value is computed at the moment it is tested, with what the holes contain then — for “answer \(>\) 10”, with the last input. A hexagonal block only fits a hexagonal hole, such as that of an “if”.
There is no “\(\leqslant\)” block: “10 or less” is the “else” of “\(>\) 10”.

• “if … then” has one branch: when the condition is true, the blocks inside the C are executed; when it is false, nothing happens, and the script goes on below the C.
• “if … then … else” has two branches: the blocks of the first when the condition is true, the blocks after “else” when it is false. Exactly one of the two branches is executed, never both, never none.

  

The green block “( ) mod ( )” gives the remainder of the division of a whole number by a whole number other than \(0\): “17 mod 5” is \(2\), since \(17 = 3 \times 5 + 2\). A whole number is even when its remainder by \(2\) is \(0\), odd when it is \(1\): the condition “( answer mod 2 ) \(=\) 0” is true exactly for the even numbers — provided the input is a whole number.

A flowchart, the drawing of a program in boxes joined by arrows, can also show a choice. A decision box is a diamond holding a question answered by yes or no — a condition. Two arrows leave it, one labelled Yes and one labelled No; each leads to a branch, and the two branches meet again below. For a given input, exactly one branch is followed.
The decision box is the plan of an “if …\ then …\ else”: its question is the condition, its branch Yes the part after “then”, its branch No the part after “else”.