DGB 4: Designing Programs with Combined Control Structures

← 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

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.