Administrator: Add English DGB 4 translation

2026-09-11T18:09:09Z

Add English DGB 4 translation

Neue Seite

{{DISPLAYTITLE:DGB 4: Designing Programs with Combined Control Structures}}
← [[DGB 4. Klasse/en|Digital Literacy – Year 4]]

In Year 4, programming moves from isolated commands to deliberately designed program flow.
Students combine decisions and repetition, plan before coding, test boundary cases and improve
solutions iteratively. Readability and debugging become part of the solution rather than optional
extras.

== Curriculum reference ==

{| class="wikitable"
! Area !! Classification
|-
| '''Competence area''' || Production
|-
| '''Perspectives''' || T, I
|-
| '''Focus''' || Designing and iteratively developing programs with combined control structures
|-
| '''Competence''' || Plan, implement, test and improve programs that combine conditions, logical operators and nested loops.
|}

== Learning objectives ==

Students can:

* explain and apply conditions and loops;
* use if, else and elif structures appropriately;
* form compound conditions with logical operators;
* use nested loops for multi-stage repetition;
* decompose a program into manageable parts before coding;
* translate an algorithm into a working program;
* develop software iteratively in small steps;
* design test cases including boundary values;
* locate and correct errors systematically;
* explain how control structures affect program execution;
* structure and comment programs clearly;
* compare alternative solutions and simplify them.

== Learning content ==

=== Control structures ===

Sequence, selection and repetition determine program flow. Conditions allow different actions
depending on data, while loops repeat instructions until a count or condition is satisfied.

=== Nested loops ===

A loop inside another loop is useful for grids, tables, repeated patterns and combinations.
Students should trace small examples by hand before building larger ones.

=== Compound conditions ===

Logical operators such as and, or and not combine several tests. Parentheses and clear
expressions make intended logic easier to read and debug.

=== Design before coding ===

Pseudocode, test examples and flow diagrams help clarify inputs, outputs and decisions before
syntax problems distract from the algorithm.

=== Iterative development ===

Build the smallest working version first, test it, then add one feature at a time. This makes errors
easier to locate and keeps development understandable.

=== Testing and debugging ===

Use normal inputs, edge cases and invalid input where appropriate. Reproduce an error,
identify the responsible section, change one thing and test again.

=== Readability and maintainability ===

Meaningful names, consistent indentation, small logical blocks and useful comments make
programs easier to understand and modify.

=== Typical projects ===

Suitable projects include quizzes, menu-driven programs, small games, simulations, drawing
patterns, simple data checks and calculators with validation.

== Classroom activities ==

=== Develop a loop pattern ===

Start with one loop and gradually extend it to create a structured pattern.

'''Expected outcome:''' A working program and iteration notes.

=== Process a grid ===

Use nested loops to visit rows and columns in a small grid.

'''Expected outcome:''' A grid-processing program.

=== Combine conditions ===

Solve cases that require and/or/not rather than a single comparison.

'''Expected outcome:''' A tested condition set.

=== Control-flow bug hunt ===

Trace and fix programs with wrong conditions or misplaced loops.

'''Expected outcome:''' A debugging record.

=== Iteratively extend a menu ===

Build a simple menu and add validated options one at a time.

'''Expected outcome:''' A versioned mini-program.

=== Create a quiz with scoring ===

Use conditions and repetition to implement questions, scoring and feedback.

'''Expected outcome:''' A working quiz.

=== Turtle or Scratch patterns ===

Create repeated graphical patterns using nested loops.

'''Expected outcome:''' A visual program.

=== Plan with pseudocode ===

Design a program before writing code and compare plan to final implementation.

'''Expected outcome:''' A plan-to-code comparison.

=== Boundary tests ===

Create test cases for minimum, maximum and invalid values.

'''Expected outcome:''' A test table.

=== Peer improvement ===

Review readability and logic in another program and revise your own.

'''Expected outcome:''' A change log.

=== Build a mini-game ===

Combine input, conditions, loops and scoring in a small project.

'''Expected outcome:''' A playable prototype.

=== Compare solutions ===

Compare two ways to solve the same task and simplify unnecessary complexity.

'''Expected outcome:''' A reasoned comparison.

== Self-check ==

* I can combine conditions and loops.
* I can use logical operators correctly.
* I can plan program flow before coding.
* I develop programs in small testable steps.
* I can design boundary tests and debug systematically.
* I can explain and improve the readability of my program.

== See also ==

[[DGB 4: Programme und Webanwendungen/en|Programming Simple Applications]]
[[DGB 4: Abstraktionsebenen und Softwareschichten/en|Application Software, System Software and Hardware Layers]]
[[DGB 4: Grenzen und Moeglichkeiten von KI/en|AI – Opportunities and Limitations]]

[[Kategorie:Digitale Grundbildung]]
[[Kategorie:DGB 4]]

DGB 4: Programme und Kontrollstrukturen/en - Versionsgeschichte

Administrator: Add English DGB 4 translation