01 //Academy
- Logic
- Problem solving
- Programming
- Creating
Ideas that turn into instructions.
Coding starts with logic a learner can see and moves into written code, so the step from blocks to a real language feels like the next sentence rather than a new subject.
01 //What learners build
Four things, in order.
- 01Logic and sequence
Turn “what should happen?” into a clear sequence of steps.
Before writing code, learners think in instructions: sequence, patterns, cause and effect, conditions, loops and simple algorithms, through visual challenges.
- 02Problem solving
Look at a difficult problem and know where to begin.
Decomposition: taking a large problem and turning it into smaller ones. Learners experiment, make mistakes, test approaches, and find that getting stuck is part of it.
- 03Programming
Make written code another way of expressing an idea.
Visual concepts become variables, conditions become code, repetition becomes loops, instructions become functions. The transition is gradual rather than a fresh start.
- 04Creating
Move from “I learned to code” to “I made this.”
A game, a drawing, a quiz, a calculator, a small automation. The project becomes the reason to learn the next concept.
02 //The coding journey
Think, build, break, fix, create.
A progression rather than a collection of disconnected lessons.
How a learner moves through the path
01
Think
Understand the problem before touching the code. Logic, patterns, sequences and algorithms.
02
Plan
Turn an idea into smaller steps, and sketch the solution before building it.
03
Build
Translate the plan into code. Concepts become instructions a computer can follow.
04
Debug
Something doesn't work. That's not failure, that's programming. Investigate, test, improve.
05
Create
Combine everything into something of their own. The learner becomes the creator.
03 //What they'll learn
A foundation for computational thinking.
- 01
Logic — how instructions, decisions and sequences work
- 02
Algorithms — describing a solution step by step
- 03
Variables — how programs store and use information
- 04
Conditions — teaching programs to make decisions
- 05
Loops — repeating actions efficiently
- 06
Functions — turning repeated ideas into reusable pieces
- 07
Events and interaction — responding to actions and inputs
- 08
Debugging — finding out why something isn't working
- 09
Data — working with information inside programs
- 10
Creative computing — code as a medium for experimentation
04 //Learning through projects
Every concept should have somewhere to go.
Rather than ending a lesson with another worksheet, learners apply what they've learned in small creative challenges.
- 01Project 01
Interactive story
A story where characters respond to user actions. Sequence, events, conditions.
- 02Project 02
Mini game
A simple game with rules, scoring and interaction. Variables, loops, conditions, events.
- 03Project 03
Quiz builder
A quiz that asks questions, checks answers and calculates a score. Variables, conditions, functions, data.
- 04Project 04
Creative drawing
Patterns, shapes, animations or generative artwork. Loops, coordinates, functions, repetition.
- 05Project 05
A useful little tool
A calculator, a converter, a planner, a random generator. Inputs, variables, logic, functions.
- 06Final project
Build something nobody assigned.
It begins with a question: what do you want to make? The learner defines the idea, breaks it into problems, writes the code, debugs it and presents it.
05 //How learning happens
Less watching. More making.
The shape of a session
01
Discover
Introduce a new idea through a visual problem, challenge or example.
02
Explore
Experiment with the concept before being expected to master it.
03
Build
Apply the concept inside a small project.
04
Debug
Find what went wrong, and understand why.
05
Extend
Change the project and see what happens.
06
Create
Use the concept independently.
06 //The learner progression
Start with curiosity. Grow into independence.
- 01Explorer
“What happens if I do this?”
Discovering basic logic, sequence and interaction.
- 02Builder
“I know how to make this work.”
Combining programming concepts to create small projects.
- 03Problem solver
“I know why it isn't working.”
Debugging, testing and improving their solutions.
- 04Creator
“I have an idea.”
Designing and building increasingly independent projects.
- 05Young programmer
“I can turn an idea into instructions.”
Beginning to think about software as something they can create, not only use.
07 //What parents can expect
Coding becomes a thinking skill.
The benefits extend beyond programming.
- 01
Problem solving
Learners practise approaching complex problems systematically.
- 02
Logical thinking
They learn to connect actions, conditions and outcomes.
- 03
Creativity
Code becomes a medium for turning imagination into something tangible.
- 04
Persistence
Debugging teaches learners to keep investigating when the first attempt doesn't work.
- 05
Confidence
Creating something from scratch gives visible evidence of what they can do.
- 06
Digital fluency
Learners move from using technology to understanding how it works.
08 //What learners leave with
Don't teach children to code. Teach them to think with code.
Programming languages will change. Tools will change. Interfaces will change. The ability to break down a problem, reason through a solution, experiment, debug and create will remain valuable — which is why the journey starts with thinking rather than syntax.
- A way to think
- And a way to solve problems.
- A way to express ideas
- And a way to experiment with them.
- A way to build
- And something they can point to and say: I made this.
09 //Questions
Common questions.
Other paths
Other paths
- 01
Game Development
Game development turns a familiar pastime into a design problem: rules, movement, difficulty and feedback all have to be decided by the person making it.
- 02
AI
AI is explored by using it and taking it apart: training something simple, seeing where it gets things wrong, and asking why.
- 03
Robotics
Robotics connects a program to the physical world, where a mistake is visible immediately: the motor turns the wrong way, the sensor reads nothing, or the robot simply refuses to do what you told it to.
An idea is only the beginning
Give it instructions. Give it logic. Give it code.
Then see what it can become.
