Programming Concepts

Introduction to Programming Concepts

Programming is the process of writing instructions for a computer to execute. These instructions are built using fundamental concepts that control the flow of the program and manage its data. For the Pearson EdExcel IGCSE, mastering variables, selection, iteration, and subprograms is essential. These are the building blocks of all software, from simple calculators to complex operating systems.

1. Variables and Constants

At the heart of any program is data. We use variables and constants to store this data in the computer's memory.

• A variable is a named memory location that stores a value which can change while the program is running. Think of it as a labeled box where you can put different items at different times.
• A constant is a named memory location that stores a fixed value that cannot be changed during program execution. This is useful for values that must remain consistent, such as the value of Pi (3.142) or the GST rate in Pakistan.

Data Types: Every variable or constant must have a defined data type, which tells the computer what kind of data it can hold. This is crucial for memory allocation and preventing errors.

• Integer: Stores whole numbers, positive or negative (e.g., 10, -5, 0). Used for counting items, like the number of students in a class.
• Real (or Float): Stores numbers with a decimal point (e.g., 98.6, -15.25). Used for measurements like temperature or bank balances.
• Boolean: Stores one of only two possible values: True or False. Essential for decision-making in selection and iteration.
• String: Stores a sequence of characters, such as text (e.g., "Karachi", "Computer Science 4CP0").
• Character (Char): Stores a single letter, number, or symbol (e.g., 'A', '7', '$').

Assignment: The process of giving a variable a value is called assignment. The EdExcel pseudocode uses the left arrow ← for this.

// Example of declaring and assigning variables DECLARE studentName : STRING DECLARE age : INTEGER DECLARE hasPassed : BOOLEAN

studentName ← "Ahmed" age ← 16 hasPassed ← True

2. Selection

Selection statements allow a program to make decisions and execute different blocks of code based on whether a condition is True or False. This is also known as conditional logic.

IF...THEN...ELSE

This is the most common selection structure. The ELSE part is optional.

• IF...THEN...ENDIF: Executes code only if the condition is true.
• IF...THEN...ELSE...ENDIF: Executes one block of code if the condition is true, and a different block if it is false.

// Example: Checking pass/fail status DECLARE marks : INTEGER marks ← 65 IF marks >= 50 THEN OUTPUT "Congratulations, you have passed." ELSE OUTPUT "You need to retake the exam." ENDIF

Nested IFs and ELSEIF

For multiple conditions, you can use ELSEIF to create a clean structure without deep nesting.

// Example: Grading based on marks IF marks >= 85 THEN OUTPUT "Grade: A*" ELSEIF marks >= 75 THEN OUTPUT "Grade: A" ELSEIF marks >= 60 THEN OUTPUT "Grade: B" ELSE OUTPUT "Grade: C or below" ENDIF

CASE...OF...OTHERWISE

This structure is a tidy alternative to a long ELSEIF chain when checking a single variable against multiple possible values.

// Example: Menu selection DECLARE choice : INTEGER OUTPUT "Enter 1 for Urdu, 2 for English" INPUT choice CASE choice OF 1 : OUTPUT "آپ نے اردو کا انتخاب کیا ہے۔" 2 : OUTPUT "You have selected English." OTHERWISE OUTPUT "Invalid selection." ENDCASE

Common Exam Trap: Confusing the assignment operator (←) with the comparison operator for equality (=). In an IF condition, always use =. For example, IF userChoice = 1 THEN....

3. Iteration

Iteration, or looping, allows a block of code to be executed repeatedly. This is essential for processing lists of data, repeating user input prompts, or running simulations.

Count-Controlled Loop: FOR...TO...NEXT

This loop runs a fixed number of times. It uses a counter variable that starts at one value, increments, and stops at an end value.

// Example: Printing times tables DECLARE i : INTEGER FOR i ← 1 TO 10 OUTPUT 5, " x ", i, " = ", 5*i NEXT i

Condition-Controlled Loops

These loops run as long as a certain condition is met. The number of repetitions is not known beforehand.

1. WHILE...DO...ENDWHILE (Pre-condition loop): The condition is checked before each iteration. If the condition is initially false, the loop will never execute.

    `// Example: Password validation`
    `DECLARE password : STRING`
    `password ← ""`
    `WHILE password <> "Edexcel123"`
    `  OUTPUT "Enter password:"`
    `  INPUT password`
    `ENDWHILE`
    `OUTPUT "Access granted."`

1. REPEAT...UNTIL (Post-condition loop): The condition is checked after each iteration. This guarantees the loop body will execute at least once.

    `// Example: Menu choice validation`
    `DECLARE choice : STRING`
    `REPEAT`
    `  OUTPUT "Do you want to play again? (Y/N)"`
    `  INPUT choice`
    `UNTIL choice = "Y" OR choice = "N"`

Common Misconception: The key difference between WHILE and REPEAT...UNTIL is the point of condition testing. Use WHILE when the loop might not need to run at all. Use REPEAT...UNTIL when you need the code to run at least one time, such as for initial data input.

4. Subprograms

As programs grow, it's vital to break them into smaller, manageable, and reusable chunks called subprograms. This practice is known as modular programming.

• Procedure: A subprogram that performs a specific task but does not return a value to the part of the code that called it. It is called using the CALL keyword.

    `// Procedure to display a welcome message`
    `PROCEDURE displayWelcome(name : STRING)`
    `  OUTPUT "Welcome, ", name`
    `ENDPROCEDURE`

    `// Calling the procedure`
    `CALL displayWelcome("Fatima")`

• Function: A subprogram that performs a task and returns a single value. It is used in expressions, often on the right side of an assignment statement.

    `// Function to calculate the area of a circle`
    `FUNCTION circleArea(radius : REAL) RETURNS REAL`
    `  DECLARE area : REAL`
    `  area ← 3.142 * radius * radius`
    `  RETURN area`
    `ENDFUNCTION`

    `// Calling the function`
    `DECLARE myArea : REAL`
    `myArea ← circleArea(10.0)`
    `OUTPUT "The area is: ", myArea`

Subprograms make code easier to read, test, and debug. They also promote code reuse, saving time and reducing errors.``` IF score >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail" ENDIF

Iteration (loops):

• FOR loop: Fixed number of repetitions
• WHILE loop: Repeat while a condition is True (check BEFORE loop)
• REPEAT...UNTIL: Repeat until condition (check AFTER loop — always runs at least once)

Subprograms:

• Procedures: Block of code with a name, no return value
• Functions: Returns a value (RETURN statement)

Local vs global variables: Local variables only exist inside the subprogram. Global variables can be accessed anywhere.

Validation: Checks input is reasonable (range check, type check, length check). Verification: Checks data entered correctly (double entry, visual check).