L24 — Algorithms & Programs

🎯Learning Objectives

• Explain in your own words what an algorithm is
• List the main properties an algorithm must have
• Read a simple flowchart and trace what it does step by step
• Tell the difference between a linear, a branching, and a cyclic algorithm
• Build your first tiny program in Scratch directly in the browser — no installation

📖Theory

1. What Is an Algorithm?

Every morning you do almost the same thing: wake up, brush teeth, get dressed, eat breakfast, go to school. If you forget a step, the result is... not great.

Examples from real life that are algorithms:

• A recipe for making pancakes
• Instructions for a board game
• A map route from home to school
• Steps to solve a math problem

Computers don't know how to solve a problem on their own. We give them an algorithm, and they follow it exactly — every single time, without shortcuts.

2. The Performer (Executor)

The one who carries out the algorithm is called the performer (executor). Each performer only understands a fixed list of commands.

If you tell the Scratch cat to "bake a cake", nothing happens — that command isn't in its list. The algorithm must only use commands the performer knows.

3. Properties of a Good Algorithm

Not every instruction is an algorithm. A real algorithm has five properties:

1. Discreteness — broken into clear, separate steps.
2. Definiteness — each step has only one possible meaning (no "do something with the eggs").
3. Finiteness — always ends after a finite number of steps (no infinite loops).
4. Input — there are starting values (ingredients, numbers, a starting position).
5. Output — the algorithm produces a result (a meal, an answer, a finished drawing).

4. Ways to Write Down an Algorithm

The same algorithm can be written in different forms, depending on who will read it:

A flowchart is the most useful form for learning, because it shows the structure of the algorithm at a glance.

5. Flowchart Symbols

Every flowchart is built from a small set of shapes. Memorise these five:

Example — flowchart for "Make a cup of tea":

    ( Start )
        |
    [ Boil water ]
        |
    [ Put tea bag in cup ]
        |
    [ Pour water into cup ]
        |
    [ Wait 3 minutes ]
        |
    [ Remove tea bag ]
        |
    (  End  )

6. Three Types of Algorithms

Almost every algorithm in the world is a mix of three building blocks.

Linear — steps run one after another, top to bottom. No questions, no repeats.

Example: the tea recipe above is linear.

Branching — the algorithm asks a question and takes one of two paths.

( Start )
    |
[ Look outside ]
    |
  < Is it raining? >
   /             \
  Yes            No
   |              |
[ Take umbrella ] [ Wear sunglasses ]
   \             /
    \           /
    (   End   )

Example: crossing the road. "Is the light green?" — Yes → cross. No → wait.

Cyclic (loop) — one or more steps are repeated until some condition is met.

( Start )
    |
[ count = 0 ]
    |
   < count < 4 ? > ──No──> ( End )
    | Yes
[ Draw a square side ]
    |
[ count = count + 1 ]
    |
    └──────────────→ (back to the question)

Example: brushing teeth — repeat "move brush" until all teeth are clean.

7. From Algorithm to Program

A program is an algorithm written in a programming language — a language the computer understands directly.

• The algorithm is the idea: "ask the user's name, then greet them".
• The program is that idea written in Python, JavaScript, Scratch, etc.

The same algorithm can be written in many languages — like the same story can be told in Russian or English. The meaning is identical; only the words change.

8. The Tools We'll Use Today

All three work in the browser. Nothing to install.

💻Code Examples

Example A — A linear algorithm in words and in a flowchart

Task: greet a friend by name.

Steps in words:

1. Ask the friend's name.
2. Read the name.
3. Print: "Hello, <name>!".

Flowchart:

    ( Start )
        |
    ▱ Ask "What is your name?" ▱
        |
    ▱ Read the answer → name ▱
        |
    ▭ Print "Hello, " + name + "!" ▭
        |
    (  End  )

Example B — A branching algorithm

Task: is a number positive or negative?

     ( Start )
         |
    ▱ Read x ▱
         |
      ◇ x > 0 ? ◇
       /        \
     Yes         No
      |           |
 ▭ Print        ▭ Print
   "positive"     "not positive"
      \           /
       \         /
        (  End  )

Example C — A cyclic algorithm (Scratch blocks)

This is how the same "draw a square" idea looks as Scratch blocks. You'll rebuild it yourself in Task 1.

when [green flag] clicked
repeat (4)
    move (100) steps
    turn right (90) degrees
end

The repeat (4) block is a loop — it runs the two steps inside it four times, then stops. Four sides → a square.

✏️Practice Tasks

⚠️Common Mistakes

Giving a step that the performer can't do

Writing "the Scratch cat bakes a cake" is not an algorithm for Scratch — that command doesn't exist. Always use only commands from the performer's list.

Forgetting the End in a flowchart

A flowchart must have exactly one Start (oval) and at least one End. Without an end, the reader doesn't know where the algorithm finishes.

Confusing a rectangle with a diamond

A rectangle is an action ("do this"). A diamond is a question ("is this true?"). A diamond must have two arrows leaving it — one for "Yes" and one for "No".

An infinite loop

repeat until (false) will never stop — the computer spins forever. Every loop needs a condition that eventually becomes true. In Scratch, you can click the red stop sign to break out of an accidental forever-loop.

Skipping steps because "they're obvious"

A recipe that says "make the cake" is not an algorithm — it's a wish. Every step must be small enough that the performer can execute it without thinking.

🎓Instructor Notes

⚡ How to run this lesson (~80 min)

• [5 min] Hook. Ask the room: "Who can tell me exactly how to make a cup of tea, step by step?" First student usually skips a step; the second corrects them. You've just introduced algorithms without saying the word.
• [10 min] Theory — what is an algorithm + properties. Keep it fast and example-driven. Don't lecture — keep asking "is this an algorithm or not?" with examples (a recipe ✅, "be happy" ❌, "walk home" — maybe; how would a robot do it?).
• [10 min] Flowchart symbols on the board. Draw the five shapes. Have the class draw the tea flowchart with you — step by step.
• [10 min] Linear / branching / cyclic. For each type, show one everyday example and one flowchart example. Don't worry about code yet.
• [5 min] Demo Scratch on the projector. Open scratch.mit.edu, click Create, drag 3 blocks, press the green flag. Emphasise: "no download, no login, it just works."
• [25 min] Task 1 in class — first Scratch program. Walk around. Common problems: (a) blocks not connected, (b) student clicks on a block instead of the flag, (c) browser blocks the site → offer the offline alternative scratch.mit.edu/download for the computer lab.
• [10 min] Task 2 in class — flowchart in draw.io. Demo the first two shapes on the projector. Let them finish on their own. Check each flowchart for: Start + End ovals, diamond with Yes/No labels.
• [5 min] Wrap up + assign homework. Preview L25: mobile applications. Assign Task 3 (Blockly Maze) — it's fun and they'll happily do it.

💬 Discussion questions

• "Is making breakfast an algorithm? Why or why not?"
• "What's the difference between an algorithm and a program?"
• "Name one algorithm you followed today before coming to class."
• "Why can't a computer just 'figure out' a task without an algorithm?"

🧰 Classroom resources

• Scratch online: scratch.mit.edu — no install, no login needed to try
• Scratch offline: scratch.mit.edu/download — ~180 MB, for labs without internet
• Blockly Games: blockly.games — works offline after first load
• draw.io: app.diagrams.net — save files to local disk
• Code.org "Hour of Code": code.org/hourofcode — backup option if Scratch is blocked by school firewall