8.1 Programming Concepts

By the end of this lesson, you will be able to:

• Declare and use variables and constants using Cambridge IGCSE pseudocode and Python.
• Choose and use INTEGER, REAL, CHAR, STRING and BOOLEAN appropriately.
• Use INPUT and OUTPUT correctly and explain common input and output devices.
• Apply sequence, selection and iteration, including IF, CASE, FOR, WHILE and REPEAT...UNTIL.
• Use nested statements, totalling and counting to solve programming problems.
• Manipulate strings using length, substring, uppercase, lowercase and character positions.
• Use arithmetic, logical and Boolean operators correctly.
• Define and call procedures and functions, with and without parameters.
• Explain local and global variables and their scope.
• Use library routines such as MOD, DIV, ROUND and RANDOM.
• Write maintainable programs using clear layout, indentation, comments, meaningful names, white space and sub-programs.

• Variable- An identifier whose stored value can change while the program runs.
• Constant- An identifier whose value is set once and is not changed during the program.
• Data type- A classification that describes the kind of data a variable stores.
• Integer- A whole number.
• Real- A number with a fractional part.
• Character (CHAR)- A single character.
• String- A sequence of characters.
• Boolean- A value that is TRUE or FALSE.
• Casting- Changing data from one data type to another.
• Input- A value read from an input device.
• Output- A value sent to an output device.
• Sequence- Executing instructions in order.
• Selection- Choosing which statements execute according to a condition.
• Iteration- Repeating a statement or block using a loop.
• Nested statement- A statement placed inside another statement.
• Parameter- A placeholder that receives a value when a sub-program is called.
• Procedure- A sub-program that performs a task and does not return a value.
• Function- A sub-program that performs a task and returns a value.
• Local variable- A variable available only in its defined scope.
• Global variable- A variable declared outside sub-programs and accessible across the program.
• Library routine- Reusable code provided through a library or module.
• Maintainability- How easy a program is to read, understand, modify and manage.

A variable is an identifier that can change during the lifetime of a program. The notes describe identifiers as mixed case (Pascal case), using letters and digits and starting with a capital letter rather than a digit. Declaring a variable associates it with a data type and memory is allocated according to that type.

• Use a variable when the stored value may change.
• Declare the data type so the program knows what kind of value is stored.
• Cambridge pseudocode uses DECLARE <identifier> : <datatype>.
• Examples include Age : INTEGER, Price : REAL and GameOver : BOOLEAN.

DECLARE <identifier> : <datatype>
DECLARE Age : INTEGER
DECLARE Price : REAL
DECLARE GameOver : BOOLEAN

score = int()
cost = float()
light = bool()

What is a constant?

• A constant is an identifier set once during the lifetime of a program.
• Constants are generally named in uppercase characters.
• Constants aid readability and maintainability.
• If a constant needs changing, it should only need to be altered in one place.

DECLARE Age : INTEGER
DECLARE Price : REAL
DECLARE GameOver : BOOLEAN

Check Your Understanding: Variables & Constants

A data type classifies data according to the kind of value it represents. The notes identify five basic data types and stress choosing the correct type for accuracy and efficiency.

Data types can be changed within a program; this is called casting.

Check Your Understanding: Data Types

What is an input?

• An input is a value read from an input device and processed by a program.
• Typical input devices include keyboards, mice, sensors and microphones.
• Without inputs, programs cannot interact with the outside world and would always produce the same result.
• The keyboard is the standard user-input device in the notes.
• When INPUT executes, the program waits for the user to type a sequence of characters.

What is an output?

• An output is a value sent from a computer program to an output device.
• Typical output devices include a monitor, speaker and printer.
• The monitor is the standard user-output device in the notes.
• OUTPUT sends information to the screen in Cambridge pseudocode.

INPUT Name
IF Name = "James" OR Name = "Rob" THEN
    OUTPUT "Great names!"
ENDIF

name = input("Enter your name: ")
if name == "James" or name == "Rob":
    print("Great names!")

INPUT Name
IF Name = "James" OR Name = "Rob" THEN
    OUTPUT "Great names!"
ENDIF

Check Your Understanding: Input & Output

Sequence means executing lines of code one at a time in their written order. It is fundamental to program flow; an instruction out of sequence can cause unexpected behaviour or errors.

Swapping line 01 and line 02 gives an unexpected interaction because the user is asked for input before being told what to enter.

FUNCTION CalculateArea(length, width)
    area ← length * width
    RETURN area
ENDFUNCTION

length ← 5
width ← 3
correct_area ← CalculateArea(length, width)
OUTPUT "Correct area (length * width): ", correct_area

def calculate_area(length, width):
    area = length * width
    return area

length = 5
width = 3
correct_area = calculate_area(length, width)
print(f"Correct area (length * width): {correct_area}")

area ← length * width
RETURN area

Check Your Understanding: Sequence

Selection changes program flow according to a condition. The notes identify IF...THEN...ELSE...ENDIF and CASE as the two main forms.

IF <condition> THEN
    <statement>
ENDIF

IF Player2Score > Player1Score THEN
    IF Player2Score > HighScore THEN
        OUTPUT Player2, " is champion and highest scorer"
    ELSE
        OUTPUT Player2, " is the new champion"
    ENDIF
ELSE
    OUTPUT Player1, " is still the champion"
    IF Player1Score > HighScore THEN
        OUTPUT Player1, " is also the highest scorer"
    ENDIF
ENDIF

CASE OF Move
    'W' : Position ← Position - 10
    'E' : Position ← Position + 10
    'A' : Position ← Position - 1
    'D' : Position ← Position + 1
    OTHERWISE
        OUTPUT "Beep"
ENDCASE

CASE can mean less code when comparing multiple values of the same variable. IF is more flexible and is generally used more in Python.

INPUT A
INPUT B
INPUT C
IF A >= B AND A >= C THEN
    OUTPUT A
ELSE IF B >= A AND B >= C THEN
    OUTPUT B
ELSE
    OUTPUT C
ENDIF

Check Your Understanding: Selection

Iteration repeats a line or block of code using a loop. The notes describe count-controlled, condition-controlled and nested iteration.

FOR <identifier> ← <value1> TO <value2>
    <statements>
NEXT <identifier>

FOR <identifier> ← <value1> TO <value2> STEP <increment>
    <statements>
NEXT <identifier>

Condition-controlled loops

REPEAT
    INPUT Colour
UNTIL Colour = "red"

WHILE Colour <> "Red" DO
    INPUT Colour
ENDWHILE

Nested iteration

A nested loop is a loop within another loop.

Total ← 0
FOR Row ← 1 TO MaxRow
    RowTotal ← 0
    FOR Column ← 1 TO 10
        RowTotal ← RowTotal + Amount[Row, Column]
    NEXT Column
    OUTPUT "Total for Row ", Row, " is ", RowTotal
    Total ← Total + RowTotal
NEXT Row
OUTPUT "The grand total is ", Total

Nested Statements — additional TED-note section

The TED notes explicitly cover nested statements: nesting means putting one statement inside another, including selection inside selection and loops inside loops.

x ← 10
y ← 5
IF x > 0 THEN
    OUTPUT "x is positive"
    IF y > 0 THEN
        OUTPUT "y is also positive"
    ELSE
        OUTPUT "y is not positive"
    ENDIF
ELSE
    OUTPUT "x is not positive"
ENDIF

FOR i ← 0 TO 2
    FOR j ← 0 TO 1
        OUTPUT "(", i, ", ", j, ")"
    NEXT j
NEXT i

Check Your Understanding: Iteration

Totalling

Totalling means adding values together, often inside a loop. The total variable starts at 0.

Total ← 0
FOR I ← 1 TO 10
    INPUT Num
    Total ← Total + Num
NEXT I
OUTPUT Total

total = 0
for i in range(1, 11):
    num = int(input("Enter a number: "))
    total = total + num
print("Total:", total)

Counting

Counting tracks how many times an event occurs. Count starts at 0 and is increased when the condition is met.

Count ← 0
FOR I ← 1 TO 10
    INPUT Num
    IF Num > 5 THEN
        Count ← Count + 1
    ENDIF
NEXT I
OUTPUT Count

Count ← 0
FOR x ← 1 TO 20
    INPUT Number
    IF Number > 50 THEN
        Count ← Count + 1
    ENDIF
NEXT x
OUTPUT Count

Total ← 0
FOR I ← 1 TO 5
    INPUT Num
    Total ← Total + Num
NEXT I
OUTPUT Total

Count ← 0
FOR I ← 1 TO 10
    INPUT Mark
    IF Mark >= 80 THEN
        Count ← Count + 1
    ENDIF
NEXT I
OUTPUT Count

Check Your Understanding: Totalling & Counting

String manipulation uses programming techniques to modify, analyse or extract information from a string.

Password ← "letmein"
OUTPUT LENGTH(Password)

Password = "letmein"
print(len(Password))

The source notes emphasise that substring start positions use 1 in pseudocode and 0 in Python.

X ← "Save my exams"
OUTPUT LENGTH(X)
Y ← 9
Z ← 5
OUTPUT SUBSTRING(X, Y, Z)

INPUT Password
IF LENGTH(Password) >= 8 THEN
    OUTPUT "Password accepted"
ELSE
    OUTPUT "Password too short"
ENDIF

X ← "Save my exams"
Y ← 9
Z ← 5
OUTPUT SUBSTRING(X, Y, Z)

Check Your Understanding: String Handling

An operator is a symbol used to instruct a computer to perform an operation on one or more values.

• AND returns TRUE when both conditions are TRUE.
• OR returns TRUE when one or both conditions are TRUE.
• NOT returns the opposite Boolean value.
• Boolean operators are often used with comparison operators in IF and loops.

user_input = int(input("Enter a number: "))
if user_input % 2 == 0:
    print("The number is even.")
else:
    print("The number is odd.")

radius = float(input("Enter the radius of the circle: "))
area = 3.14159 * radius ** 2
print("The area of the circle with radius", radius, "is", area)

IF Number MOD 2 = 0 THEN
    OUTPUT "Even"
ELSE
    OUTPUT "Odd"
ENDIF

IF score >= 90 AND score <= 100 THEN
    OUTPUT "Grade: A"
ENDIF

Five-question maths quiz example

The source notes include a Python program that generates five maths questions, accepts an operator (+, - or *), checks each answer and keeps a score.

score = 0
for x in range(5):
    num1 = int(input("Enter the first number: "))
    operator = input("Enter the operator (+, -, *): ")
    num2 = int(input("Enter the second number: "))
    user_answer = int(input("What is " + str(num1) + " " + str(operator) + " " + str(num2) + "? "))
    if operator == '+':
        correct_answer = num1 + num2
    elif operator == '-':
        correct_answer = num1 - num2
    elif operator == '*':
        correct_answer = num1 * num2
    else:
        print("Invalid operator!")
        continue
    if user_answer == correct_answer:
        score = score + 1
    else:
        print("Sorry, that's incorrect.")
print("Your score is:", score)

Check Your Understanding: Operators

Procedures and functions are sub-programs: sequences of instructions that perform specific tasks. They help break a program into smaller, manageable parts.

• Sub-programs avoid duplicated code and can be reused.
• They improve readability and maintainability.
• They can perform calculations, retrieve data or make decisions.
• Parameters are values or variables passed into a sub-program.
• Functions return a value; procedures do not.

PROCEDURE <identifier>
    <statements>
ENDPROCEDURE

PROCEDURE <identifier>(<param1> : <data type>, <param2> : <data type>)
    <statements>
ENDPROCEDURE

CALL <identifier>
CALL <identifier>(Value1, Value2)

PROCEDURE CalculateArea(length : INTEGER, width : INTEGER)
    area ← length * width
    OUTPUT "The area is ", area
ENDPROCEDURE

CALL CalculateArea(5, 3)

FUNCTION CalculateArea(length : INTEGER, width : INTEGER) RETURNS INTEGER
    area ← length * width
    RETURN area
ENDFUNCTION

OUTPUT CalculateArea(5, 3)

def flightCost(passengers, ticket_type):
    if ticket_type == "economy":
        cost = 199 * passengers
    elif ticket_type == "first":
        cost = 595 * passengers
    return cost

print(flightCost(3, "economy"))

The notes emphasise: in Cambridge pseudocode, do not use CALL for a function; use the function in an expression such as OUTPUT CalculateArea(5,3). CALL is used for procedures.

FUNCTION CalculateArea(length : INTEGER, width : INTEGER) RETURNS INTEGER
    area ← length * width
    RETURN area
ENDFUNCTION

OUTPUT CalculateArea(5, 3)

Procedure menu example from the notes

The notes also show a Python program where a main menu calls addition, subtraction, multiplication, division and exit procedures. No parameters are needed for these procedures.

# Procedure definition for the main menu
def main_menu():
    print("1. Addition")
    print("2. Subtraction")
    print("3. Multiplication")
    print("4. Division")
    print("5. Exit")
    choice = int(input("Enter your choice: "))
    if choice == 1:
        addition()
    elif choice == 2:
        subtraction()
    elif choice == 3:
        multiplication()
    elif choice == 4:
        division()
    elif choice == 5:
        exit_program()

def addition():
    num1 = int(input("Enter the first number: "))
    num2 = int(input("Enter the second number: "))
    print("Result:", num1 + num2)

def subtraction():
    num1 = int(input("Enter the first number: "))
    num2 = int(input("Enter the second number: "))
    print("Result:", num1 - num2)

def multiplication():
    num1 = int(input("Enter the first number: "))
    num2 = int(input("Enter the second number: "))
    print("Result:", num1 * num2)

def division():
    num1 = int(input("Enter the first number: "))
    num2 = int(input("Enter the second number: "))
    if num2 != 0:
        print("Result:", num1 / num2)
    else:
        print("Error: Division by zero is not allowed.")

def exit_program():
    print("Exiting the program. Goodbye!")
    exit()

while True:
    main_menu()

Check Your Understanding: Procedures & Functions

Local variables

A local variable is declared within a specific scope such as a function or block. It is accessible only within that scope, and its lifetime is limited to that block.

def print_value():
    localVariable = 10
    print("The value of the local variable is:", localVariable)

print_value()

• Local variables help keep a sub-program self-contained.
• They exist only while the sub-program or block is running.
• They can make sub-programs easier to reuse without interfering with other modules.
• The notes describe them as memory-efficient because they exist only where needed.

Global variables

A global variable is declared at the outermost level of a program, outside functions or procedures. It has global scope.

globalVariable = 10

def print_value():
    global globalVariable
    print("The value into the variable is:", globalVariable)

print_value()

The TED notes also illustrate a dice-game example where local variables x and y are used inside subroutines while a shared score is global.

Check Your Understanding: Local & Global Variables

A library routine is reusable code made available through reusable modules or functions. Using library routines saves time because working code has already been tested.

DECLARE number1, number2, result : INTEGER
number1 ← 15
number2 ← 7
result ← MOD(number1, number2)
OUTPUT "MOD Result:", result
result ← DIV(number1, number2)
OUTPUT "DIV Result:", result
DECLARE decimalNumber : REAL
decimalNumber ← 7.8
result ← ROUND(decimalNumber)
OUTPUT "ROUND Result:", result
result ← RANDOM(10)
OUTPUT "RANDOM Result:", result

result ← RANDOM(1, 6)

import random
number = random.randint(1, 10)

The notes give uses for random numbers including simulating a dice roll, selecting a random question, the national lottery and cryptography.

DECLARE Price : REAL
DECLARE RoundedPrice : REAL
Price ← 12.6789
RoundedPrice ← ROUND(Price, 2)
OUTPUT "The rounded price is ", RoundedPrice

The output shown in the notes is:The rounded price is 12.68.

Random choice and national lottery example

The notes also show random choice and a national-lottery example that creates available numbers, chooses six numbers, removes chosen numbers, sorts them, and outputs the winning numbers.

RandomIndex ← ROUND((RANDOM() * (50 - Count)), 0)
IF RandomIndex = 0 THEN
    RandomIndex ← 1
ENDIF
Number ← LotteryNumbers[RandomIndex]
ChosenNumbers[Count] ← Number

import random

lottery_numbers = list(range(1, 50))
chosen_numbers = []

for _ in range(6):
    number = random.choice(lottery_numbers)
    chosen_numbers.append(number)
    lottery_numbers.remove(number)

chosen_numbers.sort()
print("The winning numbers are:", chosen_numbers)

DECLARE Price : REAL
DECLARE RoundedPrice : REAL
Price ← 12.6789
RoundedPrice ← ROUND(Price, 2)
OUTPUT "The rounded price is ", RoundedPrice

Check Your Understanding: Library Routines

Maintainable programs are written so code is easy to read, understand and modify. The notes emphasise consistency.

When these techniques are used consistently, programs are easier to maintain.

def calculate_area_of_triangle(base, height):
    if base <= 0 or height <= 0:
        raise ValueError("Base and height must be positive values.")
    area = 0.5 * base * height
    return area

def main():
    try:
        base = float(input("Enter the base of the triangle: "))
        height = float(input("Enter the height of the triangle: "))
        area = calculate_area_of_triangle(base, height)
        print(f"The area of the triangle is approximately {area:.2f} square units.")
    except ValueError as error:
        print(f"Error: {error}")

main()

Check Your Understanding: Maintaining Programs

• Use DECLARE with a data type for Cambridge pseudocode variables.
• Use CONSTANT for fixed values; variables can change.
• Choose the basic data type that matches the value.
• INPUT brings data in; OUTPUT sends data out.
• Sequence = order; selection = decision; iteration = repetition.
• FOR is count-controlled; WHILE is pre-condition; REPEAT...UNTIL is post-condition.
• Nested statements place one selection or loop inside another.
• Totalling starts at 0 and adds values; counting starts at 0 and counts qualifying values.
• Use LENGTH, SUBSTRING, UCASE and LCASE for string handling in the source examples.
• Remember MOD, DIV, arithmetic, comparison and Boolean operators.
• Procedures do not return a value; functions do.
• Use local variables for values needed only inside a scope; globals can be shared.
• Library routines save time; RANDOM and ROUND are key source examples.
• Maintainable code uses layout, indentation, comments, meaningful names, white space and sub-programs.

The attached notes include these video resources.