DGB 3: Computational Thinking

← Digital Literacy – Year 3

Computational Thinking is a structured approach to solving problems. A problem is decomposed, patterns are identified, unnecessary detail is ignored, and an unambiguous algorithm is designed. Only then is the solution translated into blocks, pseudocode or program code and tested.

Curriculum reference

Area	Classification
Competence area	Production
Perspectives	T, I
Focus	Understanding computational thinking and implementing solution paths in a programming language
Competence	Decompose problems, recognise patterns, abstract, design algorithms and implement and test simple solutions in a programming language or block-based environment.

Learning objectives

Students can:

explain the main ideas of computational thinking;
decompose a problem into manageable sub-problems;
recognise repeated patterns and reuse solutions;
abstract by keeping relevant information and ignoring unnecessary detail;
write algorithms as precise step-by-step procedures;
use sequence, selection and repetition in simple programs;
translate algorithms into a block-based or text-based program;
test, debug and improve programs systematically;
compare different solution paths and discuss their advantages.

Learning content

What Computational Thinking means

Computational Thinking is not only programming. It is a way of structuring problems so that a solution can be described precisely and, where useful, automated.

Decomposing and structuring problems

Large problems become easier when split into smaller tasks with clear inputs, outputs and dependencies. Each part can then be solved and tested separately.

Recognising patterns

Similar sub-problems may use the same rule or procedure. Recognising repetition helps avoid solving the same type of problem from scratch.

Abstraction

Abstraction keeps the information needed for the problem and leaves out details that do not affect the solution. A useful model is simpler than reality but still supports correct decisions.

Algorithms as precise steps

An algorithm is an ordered, finite and sufficiently unambiguous procedure. It can be written in natural language, pseudocode, flowcharts or program code.

Programming structures

Sequence executes steps in order, selection chooses between alternatives, and repetition repeats actions. Variables store values that the algorithm needs.

From problem to program

A good workflow is: understand the problem → plan → create examples → design the algorithm → implement → test → improve. Coding is only one stage of the process.

Testing and debugging

Use normal cases, boundary cases and unexpected inputs. When a result is wrong, reproduce the error, locate the cause, change one thing and test again.

Transfer and improvement

A solution becomes more powerful when it can be adapted to similar problems. Clear naming, modular steps and documented assumptions make transfer easier.

Classroom activities

Decompose a problem

Break a familiar school or everyday task into sub-problems.

Expected outcome: A decomposition tree.

Recognise reusable patterns

Compare several tasks and identify steps that can be generalised.

Expected outcome: A pattern list.

Practise abstraction

Remove irrelevant details from a scenario while keeping what is needed for the solution.

Expected outcome: A simplified model.

Write an algorithm

Describe a task as an unambiguous sequence of steps.

Expected outcome: A tested algorithm.

Create a flowchart

Represent sequence, decisions and repetition visually.

Expected outcome: A correct flowchart.

Implement the solution

Translate a prepared algorithm into blocks or a programming language.

Expected outcome: A working program.

Use conditions and loops

Modify a program so that it reacts to input and repeats appropriate steps.

Expected outcome: A program with selection and repetition.

Debug systematically

Fix a faulty program using a recorded test-and-change process.

Expected outcome: A debugging log.

Develop your own solution

Plan and implement a small quiz, calculator, simulation or other suitable task.

Expected outcome: A mini-project.

Compare solutions

Compare two algorithms for the same task in clarity, efficiency and adaptability.

Expected outcome: A reasoned comparison.

Reflect on the process

Explain which stage—decomposition, abstraction, algorithm design, coding or testing—was most important in your task.

Expected outcome: A reflection.

Self-check

I can decompose a problem.
I can recognise patterns and abstract relevant information.
I can write a precise algorithm.
I can use sequence, selection and repetition.
I can implement a simple program.
I can test and debug systematically.
I can compare alternative solution paths.