Logic first, code second. Every project starts with a flowchart, builds with blocks, and graduates to text code when the student is ready.
The thinking behind how we teach in Computer Club.
If you can draw the logic in a flowchart, you can implement it in any language. We focus on computational thinking — sequence, selection, iteration, decomposition — before writing a single line of code.
Every project starts with understanding what we're trying to do and why, before how. Students sketch the system, identify inputs and outputs, and map the logic before touching hardware.
Not every student is at the same level. The scaffolding ladder lets students enter at the right point: some will work in blocks all term, others will transition to text code quickly. Both are valid.
The real test of understanding is teaching someone else. When a group hands over a strand, their flowcharts, project cards, and walkthroughs demonstrate genuine comprehension.
Hardware doesn't always work. Sensors give odd readings. Wires come loose. This is the point — debugging a real system teaches more than a perfect tutorial ever could.
Every project solves a real problem: monitoring air quality, powering a device with solar energy, watering plants automatically. The learning is a byproduct of building something that matters.
Every project follows this progression. Students move up at their own pace.
Before any technology, draw the logic. What are the inputs? What decisions are made? What are the outputs? Use standard flowchart symbols: oval (start/end), rectangle (process), diamond (decision), parallelogram (input/output). This can be on paper, whiteboard, or a digital tool.
Example: "If temperature > 25°C, turn fan ON, else turn fan OFF"
Translate the flowchart into block-based code using mBlock. Each flowchart shape maps to a block type: process → action block, decision → if/else block, loop → repeat block. Students see their logic come to life without worrying about semicolons, brackets, or spelling.
Why mBlock: Supports ESP32 & Micro:bit. Built-in Wi-Fi and MQTT blocks. Scratch-based, so students already know the interface. Generates real Python/C code from blocks.
mBlock shows the text code alongside the blocks. Students compare: "my if/else block became if temp > 25: in Python." This is a reading exercise, not a writing exercise. Annotate the generated code: what does each line do? Which flowchart box does it match?
Make small changes directly in the text code: change a threshold value, add a new elif condition, adjust a delay. The blocks and code stay in sync in mBlock, so students can see the effect of their text edits reflected in the block view. Builds confidence incrementally.
Using Thonny IDE or VS Code, students write MicroPython directly for the ESP32. They still start with a flowchart, but the implementation is fully text-based. At this stage the flowchart is a design tool, not a crutch — just like a professional engineer's design document.
Two custom-built tools that match the scaffolding ladder.
Design programs visually using computational thinking concepts: variables, input, output, selection, iteration, procedures, and functions.
Map logic onto real hardware: GPIO pins, sensors, motors, serial communication. Generates Arduino C code for flashing to devices.
.ino code ready for Arduino IDE
1. Design in FlowCode — get the logic right first. What are the inputs? What decisions? What outputs?
2. Implement in ArduinoFlow — map that logic onto real pins and hardware blocks. Which GPIO? What sensor library?
3. Deploy to device — copy the generated code into Thonny (MicroPython) or Arduino IDE (C) and flash it.
The flowchart is the constant throughout. Whether a student is at Tier 1 or Tier 2, the design always starts the same way.
See how the same logic flows through all three representations.
from machine import Pin
from dht import DHT22
from umqtt.simple import MQTTClient
import time
sensor = DHT22(Pin(4))
fan = Pin(5, Pin.OUT)
client = MQTTClient("esp32", "192.168.1.1")
client.connect()
while True:
sensor.measure()
temp = sensor.temperature()
# Decision: flowchart diamond
if temp > 25:
fan.value(1) # Fan ON
else:
fan.value(0) # Fan OFF
client.publish("sensors/temp",
str(temp))
time.sleep(5)How a 60-minute club session flows using this approach.
Where did we get to last week? Review the flowchart and current progress.
5 minExtend the flowchart for today's goal. Discuss as a group: what inputs, decisions, outputs?
10 minWire the hardware. Implement the flowchart in mBlock (or text code). Test and debug.
30 minDoes it match the flowchart? What works? What doesn't? Update the flowchart if the logic changed.
10 minUpdate your digital project card. Take photos. Note challenges and solutions.
5 minWe use standard flowchart symbols so the diagrams are consistent across all strands and groups.
Oval (rounded rectangle). Marks where the program begins and ends.
Rectangle. An action or instruction: "Set fan to ON", "Read sensor".
Diamond. A yes/no question: "Is temp > 25?". Two paths out.
Parallelogram. Data in or out: "Display temperature", "Read button".
How the Computer Club directly supports the Jersey Curriculum — Computing across its three areas: Computer Science, Digital Literacy, and IT Skills.
The Jersey Curriculum aims to ensure all pupils:
| Curriculum Aim | How the Club Delivers |
|---|---|
| Understand and apply the fundamental principles and concepts of computer science, including abstraction, logic, algorithms and data representation | Every project begins with a flowchart (abstraction & algorithms). Decision diamonds teach logic. Sensor data encoding teaches data representation. |
| Can analyse problems in computational terms, and have repeated practical experience of writing computer programs in order to solve such problems | The flowchart-first approach is computational analysis. Students write programs every session across blocks and MicroPython, solving real physical computing problems. |
| Can evaluate and apply information technology, including new or unfamiliar technologies, analytically to solve problems | Students work with Micro:bit, ESP32, LoRa, Node-RED, MQTT, solar power — unfamiliar technologies applied analytically to real problems. |
| Are responsible, competent, confident and creative users of information and communication technology | The baton-pass model builds confidence and responsibility. Creative projects (vehicle design, dashboard UI, weatherproof enclosures) develop creativity. Portfolio cards evidence competence. |