Administrator: Add English DGB 3 translation

2026-09-11T17:50:51Z

Add English DGB 3 translation

Neue Seite

{{DISPLAYTITLE:DGB 3: Computational Thinking}}
← [[DGB 3. Klasse/en|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 ==

{| class="wikitable"
! 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.

== See also ==

* [[DGB 3: KI in Software und physischen Systemen/en|AI in Software and Physical Systems]]
* [[DGB 3: Daten Ursache Wirkung Vorhersagen/en|Data, Cause and Effect, and Predictions]]
* [[DGB 3: Viren und Schadsoftware/en|Viruses and Malware]]

[[Kategorie:Digitale Grundbildung]]
[[Kategorie:DGB 3]]

DGB 3: Computational Thinking/en - Versionsgeschichte

Administrator: Add English DGB 3 translation