8.1 Programming Concepts

A variable is a named storage location in the computer's memory whose value can change during the execution of a program.

Each variable has a name (identifier) and a data type that determines what kind of data it can hold.

Example (pseudocode):

Here, Age is the variable name, INTEGER is its data type, and the value 15 is assigned to it using the assignment operator ←.

A constant is a named value that does not change during the execution of a program. It is declared once and its value remains fixed throughout.

Reasons for using a constant:

• The value is fixed and should not be accidentally altered by the program (e.g. Pi = 3.14159, VAT = 0.05).
• It makes the program more readable and easier to maintain — if the value ever needs to change, the programmer only edits it in one place.

Example (pseudocode):

Example 1: CONSTANT Pi = 3.14159

Pi is a mathematical constant — its value never changes. Storing it as a constant prevents accidental modification and makes the code clearer.

Example 2: CONSTANT VAT_RATE = 0.05

The VAT (Value Added Tax) rate is fixed for the duration of the program. If the law changes, the programmer updates it once at the declaration, and every calculation that uses VAT_RATE is automatically updated.

• Memory efficiency: different data types use different amounts of memory. Choosing the smallest adequate type (e.g. INTEGER instead of REAL for an age) saves memory.
• Correct operations: arithmetic operators like DIV and MOD only work on numeric types. Boolean operators (AND / OR / NOT) only work on BOOLEAN values.
• Data validation: declaring a variable as INTEGER prevents a string like "abc" from being stored in it, reducing runtime errors.
• Avoiding truncation/rounding errors: storing 3.14 in an INTEGER variable would lose the fractional part and store only 3.
• Program clarity: the data type tells another reader what kind of value the variable holds, making the code easier to understand and maintain.

Pseudocode:

Output:

Every program — no matter how complex — is built using only these three constructs. This is sometimes called the three basic constructs principle.

An IF…THEN…ELSE statement evaluates a condition. If the condition is TRUE, the instructions after THEN are executed. If FALSE, the instructions after ELSE are executed instead.

Pseudocode:

Sample trace:

• If Mark = 65 → condition TRUE → output "Pass".
• If Mark = 30 → condition FALSE → output "Fail".

A nested IF statement is an IF statement placed inside another IF statement. It is used when there are multiple conditions to test in sequence, each producing a different outcome.

Pseudocode:

Each inner IF is only reached if the outer condition was FALSE. This is the standard pattern for handling multi-way selection when the conditions form a range.

A CASE…OF statement is a multi-way selection structure that chooses one of several paths based on the value of a single variable or expression. It is cleaner than a long chain of nested IFs when there are many distinct discrete values.

Pseudocode:

The OTHERWISE clause runs if none of the listed values match — useful for handling invalid input.

Rule of thumb: use IF for ranges and compound conditions, use CASE when testing one variable against many fixed, distinct values.

A FOR…NEXT loop is a count-controlled loop. It repeats a block of instructions a fixed, known number of times, using a loop counter that automatically increases (or decreases) by a step value each time.

Pseudocode:

Output:

The loop runs exactly 5 times — once each for N = 1, 2, 3, 4, 5. After N = 5, control passes to the statement after NEXT N.

A WHILE…DO loop is a condition-controlled loop. The condition is tested before each iteration. If TRUE, the loop body executes; if FALSE, the loop terminates immediately.

Because the test is at the start, the body may run zero or more times — if the condition is initially FALSE, the loop body never runs at all.

Pseudocode:

Sample trace (input: 5, 3, 7, 0):

A REPEAT…UNTIL loop is a condition-controlled loop where the condition is tested after each iteration. The loop body runs first, then the condition is checked — if FALSE, the loop runs again; if TRUE, it terminates.

Because the test is at the end, the body always runs at least once. Note: the loop continues while the condition is FALSE and stops when the condition becomes TRUE.

Pseudocode:

The body executes at least once, so even if the user's first input is "secret123" the prompt is shown once. If the user enters "abc" (too short), the loop repeats until a valid password is supplied.

Summary:

• Use FOR when you know in advance how many times to repeat (e.g. process 10 students).
• Use WHILE when the loop might not need to run at all (e.g. read until EOF — file may be empty).
• Use REPEAT when the loop must run at least once (e.g. display a menu, then check if user wants to quit).

DIV returns the integer quotient of a division (how many times the divisor goes in fully). MOD returns the remainder after that division.

For 23 ÷ 5 we have: 5 goes into 23 a total of 4 times (4 × 5 = 20), leaving a remainder of 3.

Every relational expression evaluates to a BOOLEAN value — either TRUE or FALSE — which is why relational operators are often combined with Boolean operators inside IF and WHILE conditions.

Boolean operators combine or modify Boolean (TRUE/FALSE) values and produce another Boolean value.

This uses a compound condition — two relational expressions combined with the Boolean operator AND.

Sample traces:

• Age = 20, Score = 75 → both TRUE → AND = TRUE → "Eligible".
• Age = 20, Score = 50 → second FALSE → AND = FALSE → "Not eligible".
• Age = 15, Score = 90 → first FALSE → AND = FALSE → "Not eligible".

Pseudocode:

Key ideas:

• INPUT reads a value from the user (or another source) and stores it in a variable.
• OUTPUT displays one or more values on the screen, separated by commas.
• Total acts as an accumulator (initialised to 0 before the loop).
• Average is REAL because Total / Count may produce a decimal.

A counter is an INTEGER variable that increases by 1 each time a particular event happens — it counts events. An accumulator (or totalling variable) is a numeric variable that adds up a running total — it accumulates values. Both must be initialised to 0 before the loop begins.

Pseudocode:

TotalMark is the accumulator (it stores the running sum of all 20 marks). PassCount is the counter (it stores how many marks were ≥ 50).

Both procedures and functions are subroutines — named, self-contained blocks of code that perform a specific task and can be called (invoked) from anywhere in the program.

Why use subroutines?

• Reusability: write once, call many times.
• Readability: the main program becomes short and clear.
• Maintainability: a bug fix in the subroutine automatically applies everywhere it is called.
• Teamwork: different programmers can work on different subroutines at the same time.

Note: Length and Width are parameters — values passed into the function when it is called. The function uses them to compute and RETURN the area, which the main program then outputs.