Algorithms & Problem Solving Grade 10

Before writing a single line of code, good programmers plan their solution. This page covers algorithms, pseudocode, flowcharts, IPO tables and trace tables — the thinking tools of programming.

What is an Algorithm?

Imagine you want to make a cup of tea. You don't just randomly pour hot water and hope for the best — you follow steps: boil water, put teabag in cup, pour water, wait, add milk. That ordered list of steps is an algorithm.

In computing, an algorithm is a precise, step-by-step set of instructions used to solve a problem or complete a task. Every program you write starts as an algorithm in your head (or on paper) before it becomes code.

Key Characteristics of a Good Algorithm

Why Do Algorithms Matter?

Before writing code, planning with an algorithm helps you:

• Spot logical errors before they become code bugs
• Save time — plan once, code faster
• Communicate your solution to others
• Prove your solution is correct

The Problem-Solving Cycle

1. Understand the problem — State it in your own words. What is given? What must be produced?
2. Plan the solution — Write pseudocode or draw a flowchart. Use an IPO table.
3. Implement — Convert your plan into Delphi code.
4. Test — Run the program and check output against expected results using a trace table.
5. Fix errors — Debug and correct any mistakes, then retest.

IPO Tables (Input – Process – Output)

An IPO table is the first planning tool you use. It forces you to identify three things before writing any code: what data goes in, what happens to it (process), and what comes out.

TOE Charts (Task – Object – Event)

Once a program has several buttons and several jobs to do, an IPO table stops being enough on its own — it never says which component is responsible for a job, or what has to happen before that component springs into action. A TOE chart closes that gap: for every task the program must carry out, it records the object (component) that will handle it and the event that sets that component's code running.

Worked Example: Tuck Shop Cooldrink Stand

A cooldrink at the school tuck shop costs R12. A learner types in how many cooldrinks they want, clicks a button to see the total, types in the money they handed over, then clicks a second button to see their change. Breaking that down task by task produces the following TOE chart:

Once the chart is finished, coding becomes close to mechanical: open one event handler for every distinct event you listed, and turn that row's task into a line or two of Delphi inside it.

Flowcharts

A flowchart shows the steps of an algorithm as a picture using standard symbols connected by arrows. It is easier to spot errors in a diagram than in written text, which is why flowcharts are so useful.

Flowchart Symbol Reference

Flowchart example: checking if a colour is blue

Worked Example: Is a Number Even or Odd?

This flowchart takes a number as input, checks if it divides evenly by 2, and displays "Even" or "Odd" before ending.

Worked Example: Nested Decisions

Here one decision sits inside another. First we check the age; only if that is True do we ask the second question about the licence.

Flowchart: nested decisions — check age first; only if True check the licence.

Pseudocode

Pseudocode is fake code written in plain English that describes the logic of a program. It is not real Delphi code — it is for planning only. Anyone who understands programming should be able to read your pseudocode, even if they don't know Delphi.

Pseudocode Rules

• Use CAPITALS for keywords: IF, THEN, ELSE, ENDIF, WHILE, FOR, INPUT, OUTPUT
• Indent inside structures to show what is inside a block
• Use := or = for assignment (both are accepted)
• Keep it short and clear — no Delphi syntax needed
• Start with START and end with END

SET total TO 10          // assignment
INPUT age                // get data from user
OUTPUT total             // show result
SET area TO length * width   // calculation

IF age >= 18 THEN
    OUTPUT "May vote"
ELSE
    OUTPUT "Too young to vote"
ENDIF

Example: Find the Average of Three Marks

START
    INPUT mark1
    INPUT mark2
    INPUT mark3
    SET total TO mark1 + mark2 + mark3
    SET average TO total / 3
    OUTPUT "Total: ", total
    OUTPUT "Average: ", average
END

Example: Even or Odd

START
    INPUT num
    IF num MOD 2 = 0 THEN
        OUTPUT num, " is Even"
    ELSE
        OUTPUT num, " is Odd"
    ENDIF
END

Trace Tables

A trace table is used to test an algorithm by hand. You pick a test value, then track every variable as you step through the algorithm line by line. This helps you check whether the algorithm produces the correct output.

Trace Table Example: Even or Odd (num = 7)

Trace Table Example: Average of Three Marks (90, 70, 80)

Comparing Algorithms

When two algorithms solve the same problem, we compare them. Three key criteria matter in CAPS exams:

Common Algorithm Patterns in Delphi

Finding Smallest and Largest Values

The trick: assume the first value is both smallest and largest, then compare the rest one by one.

var
  iNum1, iNum2, iNum3: Integer;
  iSmallest, iLargest: Integer;
begin
  iNum1 := StrToInt(edtNum1.Text);
  iNum2 := StrToInt(edtNum2.Text);
  iNum3 := StrToInt(edtNum3.Text);

  iSmallest := iNum1;   // assume first is smallest
  iLargest  := iNum1;   // assume first is largest

  if iNum2 < iSmallest then iSmallest := iNum2;
  if iNum3 < iSmallest then iSmallest := iNum3;
  if iNum2 > iLargest  then iLargest  := iNum2;
  if iNum3 > iLargest  then iLargest  := iNum3;

  lblResult.Caption := 'Smallest: ' + IntToStr(iSmallest)
                     + ' Largest: ' + IntToStr(iLargest);
end;

Swapping Two Values

var
  iA, iB, iTemp: Integer;
begin
  iA := StrToInt(edtA.Text);
  iB := StrToInt(edtB.Text);

  iTemp := iA;    // step 1: save A into temp
  iA    := iB;    // step 2: overwrite A with B
  iB    := iTemp; // step 3: put saved A into B

  edtA.Text := IntToStr(iA);
  edtB.Text := IntToStr(iB);
end;

Even or Odd

var
  iNum: Integer;
begin
  iNum := StrToInt(edtNum.Text);
  if iNum MOD 2 = 0 then
    lblResult.Caption := 'Even number'
  else
    lblResult.Caption := 'Odd number';
end;

Factor Check

A number is a factor if it divides another with no remainder (MOD = 0). For example, 3 is a factor of 12 because 12 ÷ 3 = 4 with remainder 0.

if iNum2 MOD iNum1 = 0 then
  lblResult.Caption := IntToStr(iNum1) + ' is a factor of ' + IntToStr(iNum2)
else
  lblResult.Caption := IntToStr(iNum1) + ' is NOT a factor of ' + IntToStr(iNum2);

Introduction to Delphi Grade 10

Delphi is a visual programming environment — you design the screen AND write the code. You drag components onto a form to build the interface, then write Delphi code to make it all work. This page covers the IDE layout, components, naming, events, and your first program.

The Delphi IDE — What You See When You Open It

When you open Delphi, this is what you will see. It might look overwhelming at first — but each area has one clear job:

Delphi 11 — Design View (this is where you build the form your user will see)

Object Inspector — set properties like Name, Caption, Color

Tool Palette — drag components from here onto the form

Switching to Code View

Press F12 to toggle between the Design View (what you see above) and the Code View (where you type your Delphi code).

Code View — this is the Delphi code structure that is automatically created for you

The Delphi IDE Layout

An Integrated Development Environment (IDE) is a software application that combines the tools a programmer needs — a code editor, a compiler, and a debugger — into a single interface, so you can design, write, test and run a program without switching between separate tools.

Key IDE Panels

Objects, Classes & Components

Delphi is an Object-Oriented Programming (OOP) language, so almost everything you place on a form is an object. To talk about objects precisely, three related terms are used:

Every object has:

• Attributes — what it looks like and contains, described through its properties and events.
• Behaviour — what it can do, described through its methods.

Basic Format of Statements

An assignment statement stores a value in a property or variable using the assignment operator :=. We use code in Delphi to assign values to properties of components in the following format:

Component.Property := Value;

All the properties a component has can be seen in the Object Inspector when that component is selected — the same properties you set visually at design time can also be set in code.

Form1.Height := 500;
Form1.Width := 700;
Button1.Caption := 'Register';
Shape1.Top := 20;
Shape1.Left := 20;

Step-by-Step: Creating Your First Project

1. File → New → Windows VCL Application — creates a blank Form (TForm).
2. Place components by clicking them in the Tool Palette, then clicking on the form.
3. Set properties in the Object Inspector (e.g. change a button's Caption).
4. Double-click a button to go to Code View and write the event handler.
5. File → Save All (Ctrl+Shift+S) — save in a NEW dedicated folder.
6. Press F9 to compile and run.

The Files Delphi Creates

Delphi creates several files for every program, but you only ever need to save two of them yourself — Delphi regenerates the rest automatically when you run the program.

Visual Component Reference

Components are the building blocks placed on a form. Each is an object with properties and events. Here is what the most common ones look like:

Naming Convention

Every component gets a prefix that indicates its type, followed by a meaningful name. This makes code readable.

Accelerator (Hot) Keys

Placing an & in front of a letter in a component's Caption underlines that letter and turns it into a keyboard shortcut. Pressing Alt + that letter clicks the component without using the mouse.

btnRed.Caption := '&Red';   // underlines the R — press Alt+R to click the button

Event-Driven Programming

Delphi programs are event-driven — code only runs when something HAPPENS (an event), like pressing a button, typing in a box, or a timer ticking.

How to Create an Event Handler

1. In Design View, double-click a button to create its OnClick handler automatically.
2. For other events, go to the Events tab in the Object Inspector and double-click next to the event name.
3. Delphi creates a skeleton procedure. Write your code between begin and end.
4. Never change the procedure header — only add code inside.

procedure TForm1.btnCalculateClick(Sender: TObject);
begin
  // Your code goes here
  ShowMessage('Button clicked!');
end;

ShowMessage and InputBox

ShowMessage displays a pop-up with a message. InputBox pops up a window asking the user to type something. Both are modal — the program pauses until the user responds.

ShowMessage('Hello world!');
ShowMessage('Result: ' + IntToStr(iAnswer));

// Returns a string
sName   := InputBox('Name', 'Enter your name:', '');

// Convert to integer
iNum    := StrToInt(InputBox('Number', 'Enter a number:', ''));

// Convert to real
rAmount := StrToFloat(InputBox('Amount', 'Enter amount:', ''));

// Get first character only
cClass  := InputBox('Class', 'Enter class:', '')[1];

Components — Properties

Properties control how a component looks and behaves. Set them in the Object Inspector or through code.

More Properties in Code

The same Component.Property := Value; format works for every property, including nested ones like Font.Color:

Label1.Font.Color   := clGreen;
Shape1.Brush.Color  := clRed;

Methods

Methods are pre-written operations that perform tasks on components. Format: ComponentName.Method;

Syntax Rules

Delphi Components & Events Grade 10

Beyond buttons and labels — these components are used in most IT practical exams. Know each one's key property and how to use it in code.

Input Components

Output Components

Bitmap Buttons (TBitBtn)

A TBitBtn is a special type of button that can show a caption and a small picture (bitmap) on its face, making an interface look more professional. Its most useful property is Kind — setting it gives the button pre-programmed behaviour, so some Bitmap Buttons need no code at all.

ComboBox — Adding Items

// At design time: use Items property in Object Inspector
// At runtime:
cboMonth.Items.Add('January');
cboMonth.Items.Add('February');
cboMonth.ItemIndex := 0;  // select first item

// Reading selected item
sSelected := cboMonth.Text;
iIndex    := cboMonth.ItemIndex;

ListBox — Adding, Clearing, Accessing Items

lstNames.Items.Add('Alice');         // add item
lstNames.Items.Clear;                 // remove all
lstNames.Items.Delete(0);            // remove first item
iCount := lstNames.Items.Count;       // number of items
sItem  := lstNames.Items[2];         // access item at index 2
sSelected := lstNames.Items[lstNames.ItemIndex]; // selected item

Resetting a Selection — the -1 Trick

The ItemIndex property tells you which item is selected, counting from 0 (the first item). When nothing is selected, ItemIndex is -1.

This works in reverse too: setting ItemIndex := -1 deselects everything and visually clears the box. This is the standard way to reset a TComboBox, TListBox or TRadioGroup — for example when a user clicks a "Clear form" button.

cboMonth.ItemIndex  := -1;   // ComboBox: no month selected (box appears empty)
rgpGender.ItemIndex := -1;   // RadioGroup: no radio button filled in
lstNames.ItemIndex  := -1;   // ListBox: nothing highlighted

if cboMonth.ItemIndex = -1 then
  ShowMessage('Please select a month first.')
else
  sMonth := cboMonth.Text;

Naming Convention for Components

Timer Component

A TTimer fires its OnTimer event at regular intervals without user input.

var
  iSeconds: Integer;  // global variable

// OnTimer event (fires every 1000ms)
procedure TForm1.tmrCountTimer(Sender: TObject);
begin
  Dec(iSeconds);
  lblTime.Caption := IntToStr(iSeconds) + ' seconds left';
  if iSeconds <= 0 then
  begin
    tmrCount.Enabled := False;
    ShowMessage('Time is up!');
  end;
end;

PageControl (Tabbed Forms)

A TPageControl creates tabbed pages on a form. Each tab is a TTabSheet.

Creating tabs

1. Add TPageControl to the form
2. Right-click → New Page to add tabs
3. Set each TTabSheet.Caption in the Object Inspector
4. Drop other components onto each tab — they belong to that tab

Controlling tabs in code

// Show a tab
TabSheet2.TabVisible := True;

// Hide a tab
TabSheet2.TabVisible := False;

// Jump to a specific tab
pgcMain.ActivePage := TabSheet3;

Data Types & Variables Grade 10

Every value in Delphi has a data type. Variables are the containers that hold these values while your program runs. Constants hold values that never change.

Data Types

rTotalStock := iBoxesIn + iBoxesReturned;   // fine — a whole number fits happily into a Real
iBoxesIn    := rTotalStock * 2;             // rejected — a Real value won't fit into an Integer

Variables

A variable is a named storage location that holds a value during program execution. Think of it as a labelled cup — it holds one thing at a time, but you can empty it and refill it whenever you like.

Variables must be: Declared → Populated → Used.

Rules for Variable Names

Delphi won't accept just any piece of text as a variable name — a handful of rules apply every time you choose one:

• It has to begin with a letter or an underscore _ — never a digit or another symbol
• Spaces are not allowed anywhere in the name
• Once past the first character, digits and underscores may join the letters — but nothing else
• You can't reuse one of Delphi's own reserved words, since words like begin, var or end already have a fixed meaning to the compiler
• Delphi stops paying attention after the 255th character, so an extremely long name gains you nothing beyond that point

Naming Convention — Prefixes

Declaring Variables

Declaring a variable means creating a named container that we can populate later, in the var section, using the format: variableName : DataType;

Local Declaration (inside a procedure)

procedure TForm1.btnClickClick(Sender: TObject);
var
  sName:   string;
  iNumber: integer;
begin
  // code here
end;

Global Declaration (available to all procedures)

var
  Form1:   TForm1;
  sName:   string;   // declared here, below existing var block
  iNumber: integer;

Populating (Assigning) Variables

Use the assignment operator := to put a value into a variable that has already been declared.

sName   := 'Jannie';
sName   := edtName.Text;        // from a text box
iNumber := 15;
iNumber := sedNum.Value;         // from a spin edit
bFlag   := True;

Initialising Variables

i        := 0;
iTotal   := 0;
sReverse := '';
cLetter  := '';

Using Variables

lblFullName.Caption := sName + ' ' + sSurname;
memOut.Lines.Add(sName + ' ' + sSurname);
iAnswer := iNum1 + iNum2;
memOut.Lines.Add(IntToStr(iNum1) + ' + ' + IntToStr(iNum2)
               + ' = ' + IntToStr(iAnswer));

lblResult.Caption := 'Test 1: 78%' + #13 + 'Test 2: 84%';
memOut.Lines.Add('Player' + #9 + 'Score');

Incrementing and Decrementing Variables

Instead of writing out a full assignment every time a counter needs to move up or down by one, Delphi gives you two ready-made procedures: Inc and Dec. Call one with just the variable name and it steps by one; give it a second number and it steps by that amount instead.

Getting Input with InputBox

Not every value needs its own Edit box sitting on the form. The InputBox function opens a small dialog of its own, waits for the user to type something, and hands back whatever they entered — always packaged as a string, no matter what kind of data it looks like.

sTeam := InputBox('House Team', 'Which house are you in?', '');

Since the result is always text, wrap it in a conversion function whenever you actually need a number or a single character:

Constants

A constant holds a value that is known before the program runs and cannot change while it runs. Use const instead of var. No data type is needed, and use = not :=.

const
  VAT       = 0.15;
  MAX_ITEMS = 100;

// Using a constant — exactly like a variable
rVatAmount := rCostPrice * VAT;
rTotal     := rCostPrice + rVatAmount;

Type Conversion

Components like TEdit only hold strings. You must convert to the right type before using in calculations.

var
  iValue, iCode : Integer;
begin
  Val(edtAge.Text, iValue, iCode);
  if iCode = 0 then
    ShowMessage('Valid number: ' + IntToStr(iValue))
  else
    ShowMessage('Not a valid number!');   // iCode = position of the bad character
end;

Formatting Real Numbers

// FloatToStrF(value, format, totalDigits, decimals)
lblPrice.Caption := FloatToStrF(rPrice, ffCurrency, 4, 2);  // → R24.50
lblPrice.Caption := FloatToStrF(rPrice, ffFixed,    4, 2);  // → 24.50

Types of Errors

Only a syntax error stops the program from compiling at all — Delphi catches it immediately. Runtime and logical errors both let the program compile and run, which makes them harder to catch: a runtime error only shows itself when the exact conditions that break it occur (e.g. the user finally types a letter instead of a number), and a logical error may never show itself at all — the program keeps running and simply produces the wrong answer.

Preventing and Handling Runtime Errors with Try..Except

A try..except block protects against any runtime error, not just a bad conversion. Code that might fail — a conversion, a calculation, anything risky — goes inside the try section. The moment something in there raises an error, Delphi abandons whatever was left in that section and jumps straight to except, running the recovery code written there instead of letting the program crash.

try
  // risky code that might raise a runtime error
except
  // code that runs only if an error occurred above
end;

var
  rAmount : real;
begin
  try
    rAmount := StrToFloat(edtAmount.Text);
  except
    ShowMessage('Invalid amount entered');
  end;
end;

Finding Logical Errors — Debugging Tools

Logical errors are the hardest to find because the program runs without crashing. Besides tracing the code by hand with a paper-based trace table, Delphi's built-in debugger lets you watch a program execute one line at a time and see exactly what is happening inside it.

Operators & Functions Grade 10

Operators perform calculations. Delphi also has a rich library of built-in functions for maths, string handling, and more.

Arithmetic Operators

MOD and DIV Examples

Worked Example — Isolating the Digits of a Number

A favourite exam task: pull a number apart digit by digit. The trick is the pair MOD 10 (gives the last digit) and DIV 10 (chops the last digit off). Repeat in a loop until nothing is left. Here we add up the digits, e.g. 1234 → 1+2+3+4 = 10.

var
  iNum, iDigit, iSum : Integer;
begin
  iNum := StrToInt(edtNum.Text);   // e.g. 1234
  iSum := 0;
  while iNum > 0 do
  begin
    iDigit := iNum mod 10;   // MOD 10 grabs the LAST digit  (1234 -> 4)
    iSum   := iSum + iDigit;
    iNum   := iNum div 10;   // DIV 10 chops it off          (1234 -> 123)
  end;
  lblSum.Caption := 'Digit sum: ' + IntToStr(iSum);
end;

Operator Precedence (Order of Operations)

result := 2 + 3 * 4;         // = 14  (3*4 first)
result := (2 + 3) * 4;       // = 20  (brackets first)
result := 10 DIV 2 + 3;      // = 8   (DIV first)

Mathematical Functions

Add Math to your uses section to access power, floor, ceil etc.

Inc and Dec

Upcase and Trim

Ord and Chr

Ord and Chr convert between characters and their ASCII numeric codes.

Caesar Cipher Example

var
  sInput, sOutput: string;
  i, iShift: Integer;
begin
  sInput := InputBox('Text', 'Enter text:', 'ABC');
  iShift := StrToInt(InputBox('Shift', 'Enter shift (1-25):', '3'));
  sOutput := '';
  for i := 1 to Length(sInput) do
    // wrap back to 'A' after 'Z' using MOD 26
    sOutput := sOutput + Chr(Ord('A') + (Ord(sInput[i]) - Ord('A') + iShift) mod 26);
  ShowMessage('Shifted: ' + sOutput);  // ABC → DEF, XYZ → ABC
end;

Decision Making — IF & CASE Grade 10

Decision structures let your program choose different paths based on conditions. Delphi uses if…then…else and case for this.

What is Decision Making?

Decision-making (also called conditional logic) is when a program tests whether something is true or false and then chooses what to do next based on the answer. A condition is any question that can only be answered with true or false — for example, "is the age 18 or more?".

Everyday analogy: A robot (traffic light) at an intersection makes a decision for you. If the light is green you go; else you stop. Your program does the same thing — it looks at a condition and takes one path or another.

Why Do Programs Need to Make Decisions?

Without decisions, a program could only ever do the exact same thing every single time it runs. Decisions make a program react to its data and its user.

• React to input – an age-check on a website: if you are old enough it lets you in, otherwise it blocks you.
• Validate data – if a mark is below 0 or above 100, warn the user it is invalid.
• Choose an outcome – if a learner scored 50 or more, display "Passed", otherwise display "Failed".
• Stay safe – if the password matches, grant access; otherwise deny it.

The IF Statement

The IF statement evaluates a condition that must resolve to True or False, and executes a statement only when that condition is True.

In plain words it says: "If this is true, then do that; otherwise (else) do something else." Everyday analogy: "If it is raining, take an umbrella, else wear a cap." The "if it is raining" part is the condition that is checked first.

IF … THEN (one-way)

if condition then
  statement;

IF … THEN … ELSE (two-way)

if condition then
  statement
else
  statement;

Multiple Statements — use BEGIN…END

if iAge >= 18 then
begin
  lblResult.Caption := 'Adult';
  btnVote.Enabled   := True;
end
else
begin
  lblResult.Caption := 'Minor';
  btnVote.Enabled   := False;
end;

Examples

if iNum1 > iNum2 then
  ShowMessage(IntToStr(iNum1) + ' is larger');

if iAge >= 18 then
  ShowMessage('Old enough to vote');

if sUsername <> 'admin' then
  ShowMessage('Access denied')
else
  ShowMessage('Welcome, administrator!');

Comparison Operators

Nested IF

An IF inside another IF.

if iAge >= 18 then
begin
  if bHasLicense = True then
    bDrive := True
  else
    bDrive := False;
end
else
  bDrive := False;

Boolean Operators

Combine multiple conditions in one statement.

Boolean operators let you ask more than one question at the same time. Everyday analogy: to get into a club you might need to be 18 AND have an ID — both must be true. To qualify for a discount you might need to be a student OR a pensioner — either one is enough. NOT simply flips an answer around, like saying "if it is not a holiday, school is open".

if (iAge >= 18) AND (bHasLicense = True) then
  bCanDrive := True;

if (iScore >= 30) OR (bHasSymbol = True) then
  lblResult.Caption := 'Passed';

Shortcut — Assigning a Boolean Directly

Sometimes an entire if…then…else exists purely to store True or False in a Boolean variable. In that case the condition already is the answer you want, so the if is not needed at all — the condition can be assigned straight to the variable.

// Longer version:
if iMark >= 50 then
  bPassed := True
else
  bPassed := False;

// Shorter, equivalent version:
bPassed := iMark >= 50;

Simplifying a Long Condition with 'Flags'

A single if line that strings together many ANDs and ORs across several variables becomes hard to read, and one misplaced bracket can break the whole thing. A tidier approach is to work out each separate rule on its own line first, storing every result in its own Boolean variable (often called a flag), and letting the final decision combine only the flags.

Consider selecting a learner for the school athletics team: they must have run the trial faster than the qualifying time, attended at least 80% of the practice sessions, and not currently be under a sports suspension.

var
  bFastEnough, bAttendedEnough, bMaySelect : boolean;
  rTrialTime, rQualifyTime, rAttendancePercent : real;
  bSuspended : boolean;
begin
  bFastEnough     := rTrialTime <= rQualifyTime;
  bAttendedEnough := rAttendancePercent >= 80;
  bMaySelect      := NOT bSuspended;

  if bFastEnough AND bAttendedEnough AND bMaySelect then
    lblResult.Caption := 'Selected for the team'
  else
    lblResult.Caption := 'Not selected';
end;

The IN Operator

Tests if a value is in a set. Cleaner than multiple OR conditions.

// Check for specific values
if iNumber IN [1, 3, 5, 7] then
  ShowMessage('Odd single digit found');

// Range using ..
if iMark IN [0..49] then
  lblSymbol.Caption := 'F';

// Works with Char too
if cLetter IN ['A', 'E', 'I', 'O', 'U'] then
  ShowMessage('Vowel');

Sets, Ordinal Types & Sub-Ranges

Everything written inside those square brackets is called a set. Sets only work with ordinal data types — types where every value has one clear predecessor and one clear successor, so the values can be counted off in order. Integer, Char and Boolean all qualify. Real and String do not: between any two real numbers there are infinitely many more real numbers, so there is no single "next" one, which rules them out of a set.

Instead of listing every value separately, a sub-range lets you give just the two endpoints as <lowest> .. <highest>. A single set is allowed to mix plain values and sub-ranges together, separated by commas:

if cGrade IN ['A'..'C'] then
  ShowMessage('Well done — top achiever!');

if NOT (iSeat IN [1..15, 40..55]) then
  ShowMessage('Seat number must be 1-15 or 40-55');

Decision Components

RadioGroup

Uses an ItemIndex property — first item is index 0.

if rgpGender.ItemIndex = 0 then
  sGender := 'Male'
else
  sGender := 'Female';

CheckBox

Uses the Checked property — True or False.

if chkInsurance.Checked = True then
  rCost := rCost + rInsuranceAmount;

The CASE Statement

Cleaner alternative to multiple IF…ELSE when testing one variable against many values. Works with Integer and Char only.

Use CASE when one variable could take many possible values and each value leads to a different outcome — like turning a mark into a grade symbol. Everyday analogy: a vending machine. You press one button (the value), and depending on which button it was, a different snack drops out. Writing that as a long chain of IF…ELSE statements works, but CASE lays it out neatly so it is much easier to read.

case expression of
  value1: statement1;
  value2: statement2;
  value3: statement3;
else
  statementDefault;
end;

case iMark of
  80..100: lblSymbol.Caption := '7 — Outstanding';
  70..79:  lblSymbol.Caption := '6 — Meritorious';
  60..69:  lblSymbol.Caption := '5 — Substantial';
  50..59:  lblSymbol.Caption := '4 — Adequate';
  40..49:  lblSymbol.Caption := '3 — Moderate';
  30..39:  lblSymbol.Caption := '2 — Elementary';
else
  lblSymbol.Caption := '1 — Not Achieved';
end;

What Can Go in a CaseList

The value being tested (the Selector Expression, straight after the word case) must be ordinal. Each individual caseList is flexible about how it lists the values it matches — it can be one constant on its own, several constants separated by commas, a sub-range, or any mixture of these on the same line. The only rule is that a value may not show up in two different caseLists.

case iZone of
  1             : rFare := 12;
  2, 3          : rFare := 18;
  4..6          : rFare := 25;
  7, 8, 10..12 : rFare := 35;
end;

A caseList is not restricted to a single statement either — wrap several statements in begin…end exactly as you would for a multi-statement IF:

case iArrivalMinutes of
  0..5    : Inc(iOnTime);
  6..15   : Inc(iLate);
  16..60  : begin
                Inc(iLate);
                Inc(iVeryLate);
              end
else
  ShowMessage('Please check the time entered');
end; // end of case

MessageDlg

A pop-up dialog that asks the user a yes/no question and returns a result.

if MessageDlg('Are you sure?', mtConfirmation, mbYesNo, 0) = mrYes then
  // execute if user clicked Yes
  ShowMessage('Confirmed!');

Input Validation

No amount of clever code can rescue a program that starts with bad data — this is often summed up as GIGO: Garbage In, Garbage Out. Before a program uses a value in a calculation or a decision, it should first check that the value is reasonable. Checking a value before it gets used is called input validation, and the IF statement is the tool most often used to do it.

It helps to separate two ideas that are easy to confuse:

• Valid data — the value falls within rules a program can check on its own, e.g. a ticket quantity of 4 is a whole number the program can accept.
• Correct data — the value is actually the right one for this situation, e.g. that this particular learner really did order 4 tickets. A program cannot verify this by itself; a person has to check it against a reliable source.

A validation rule spells out exactly what "valid" means for a piece of data, for example: "the number of matric dance tickets ordered must be a whole number from 1 to 6." Once the rule is written down, an IF statement can enforce it:

if (iTickets < 1) or (iTickets > 6) then
  ShowMessage('You may order between 1 and 6 tickets.');

Validation matters most when an invalid value would otherwise crash the program during a calculation. Delphi's Sqrt function, for instance, cannot handle a negative number, so the sign has to be checked first:

if rNumber < 0 then
  ShowMessage('Cannot calculate the square root of a negative number')
else
  rAnswer := Sqrt(rNumber);

repeat
  iTickets := StrToInt(edtTickets.Text);
  if not (iTickets in [1..6]) then
    ShowMessage('You may order between 1 and 6 tickets.');
until iTickets in [1..6];

A range is only one kind of validation rule. Depending on the field, a program might instead need to check:

• Format — does the value match an expected pattern, e.g. a South African ID number must be exactly 13 digits.
• Type — is the value the right kind of data, e.g. rejecting text where a numeric mark is expected.
• Presence — has a required field been left empty, e.g. testing edtName.Text <> ''.

Worked Example — Validate, Grade & Decide

A typical question chains several decisions together: first validate the input with an if, then use a case to map the mark to a symbol, then a final if to decide pass/fail. This shows exactly when to reach for if and when for case.

procedure TForm1.btnGradeClick(Sender: TObject);
var
  iMark   : Integer;
  sSymbol : string;
begin
  iMark := StrToInt(edtMark.Text);

  // 1. Validate first — reject impossible marks (IF with OR)
  if (iMark < 0) or (iMark > 100) then
  begin
    ShowMessage('A mark must be between 0 and 100.');
    Exit;                       // stop here — don't grade an invalid mark
  end;

  // 2. Map the mark to a symbol — CASE handles the many bands neatly
  case iMark of
    80..100: sSymbol := '7';
    70..79:  sSymbol := '6';
    60..69:  sSymbol := '5';
    50..59:  sSymbol := '4';
    40..49:  sSymbol := '3';
    30..39:  sSymbol := '2';
  else
    sSymbol := '1';
  end;

  // 3. A final pass/fail decision (IF)
  if iMark >= 50 then
    lblResult.Caption := 'Symbol ' + sSymbol + ' - PASS'
  else
    lblResult.Caption := 'Symbol ' + sSymbol + ' - needs improvement';
end;

Loops Grade 10

Loops repeat a block of code multiple times. Delphi has three loop types — choose based on whether you know how many times to repeat.

What is a Loop?

A loop is a programming structure that repeats a block of code over and over until a certain point is reached. Instead of writing the same instruction many times, you write it once and tell the computer how often, or until when, to repeat it.

Everyday analogy: Think of doing push-ups. The coach does not shout "do a push-up" fifty separate times. He says "do fifty push-ups." That single instruction, repeated until you reach fifty, is a loop. The action (one push-up) is the loop body, and "fifty" is the condition that tells you when to stop.

Why Do We Use Loops?

Loops save us from repeating ourselves and let programs handle any amount of work with the same short piece of code.

• Less code – printing the numbers 1 to 100 takes three lines with a loop instead of one hundred lines without one.
• Fewer mistakes – you write the instruction once, so there is only one place where a typo could hide.
• Flexibility – the same loop can run 5 times or 5 000 times just by changing one number, so your program copes with any size of data.
• Processing collections – loops let you visit every item in a list, every learner in a class, or every character in a string, one at a time.

The Three Loop Types in Plain Words

Choosing the right loop comes down to one question: do you know in advance how many times to repeat?

• FOR – use it when you know the exact number of repeats. Analogy: climbing a staircase with a known number of steps — you count "step 1, step 2…" up to the top.
• WHILE – use it when you do not know how many times, and you must check first before doing anything. Analogy: filling a glass of water — you keep checking "is it full yet?" before each pour, and if the glass was already full you never pour at all.
• REPEAT…UNTIL – use it when you do not know how many times, but you must do the action at least once and check afterwards. Analogy: asking someone for their PIN — you always ask once, then check if it was right, and ask again only if it was wrong.

Types of Loops

FOR Loop (Fixed / Unconditional)

Runs a set number of times. The counter increments or decrements automatically.

We call it fixed or unconditional because the number of repeats is decided before the loop even starts and cannot change while it runs. You give it a start value and an end value, and Delphi handles the counting for you — you never have to add 1 to the counter yourself.

for counter := lowest to highest do
begin
  // code repeated each iteration
end;

for i := 1 to 5 do
begin
  memOut.Lines.Add(IntToStr(i));
end;

FOR … DOWNTO (counting down)

for i := 5 downto 1 do
begin
  memOut.Lines.Add(IntToStr(i));
end;

FOR Loop — Running Total

var
  i, iTotal: Integer;
begin
  iTotal := 0;  // initialise!
  for i := 1 to 10 do
    iTotal := iTotal + i;
  lblTotal.Caption := 'Sum = ' + IntToStr(iTotal);
end;

FOR Loop — the Counter Can Be Any Ordinal Type

A FOR loop's counter does not have to be an Integer — it can be declared as any ordinal type, provided the start value, end value and the counter variable itself all agree on that type. A Char counter, for instance, steps through the alphabet one letter at a time instead of counting through numbers.

var
  cLetter: char;
begin
  for cLetter := 'B' to 'F' do
    memOut.Lines.Add(cLetter);
end;

WHILE … DO Loop (Pre-Conditional)

Checks the condition before each iteration. If the condition is false from the start, the loop body never runs.

We call it pre-conditional ("pre" = before) because it tests the condition first, and only then decides whether to run the body. This makes it the safe choice when there is a chance the loop should not run at all.

while condition do
begin
  // code
end;

The ITC-Principle

A handy checklist for building a correct WHILE loop is the ITC-principle — three things that must all be true of your code, in this order:

var
  Counter: Integer;
begin
  Counter := 1;           // initialise BEFORE loop
  while Counter <= 5 do
  begin
    memOut.Lines.Add('Counter: ' + IntToStr(Counter));
    Inc(Counter);          // increment INSIDE loop
  end;
end;

WHILE — Reading user input until sentinel

var
  iNum, iTotal: Integer;
begin
  iTotal := 0;
  iNum   := StrToInt(InputBox('Input', 'Enter number (0 to stop):', ''));
  while iNum <> 0 do
  begin
    iTotal := iTotal + iNum;
    iNum   := StrToInt(InputBox('Input', 'Enter number (0 to stop):', ''));
  end;
  lblTotal.Caption := 'Total: ' + IntToStr(iTotal);
end;

Letting the User Interrupt a Loop While It Runs

A different situation arises when nobody knows how many times a loop should run until the user physically clicks a [Stop] Button partway through — a reaction game or a live counter are typical examples. This needs a Boolean variable that both the button that starts the loop and the button that stops it can share, so it must be declared in the private section of the form (giving it class scope) rather than inside a single procedure.

private
  bRunning : boolean;   // shared by both button handlers below

procedure TForm1.btnGoClick(Sender: TObject);
var
  iTick : byte;
begin
  bRunning := True;
  iTick    := 0;
  while bRunning do
  begin
    Inc(iTick);
    memLog.Lines.Add(IntToStr(iTick));
    Sleep(300);                    // short pause so the numbers are readable
    Application.ProcessMessages;   // give the form a chance to react to the click
  end;
end;

procedure TForm1.btnHaltClick(Sender: TObject);
begin
  bRunning := False;
end;

REPEAT … UNTIL Loop (Post-Conditional)

Runs the body first, then checks the condition. Guaranteed to run at least once. Loop continues while condition is false; stops when it becomes true.

We call it post-conditional ("post" = after) because it does the work first and asks the question afterwards. That is the opposite of the WHILE loop, and it is exactly what you want when the action must happen at least one time no matter what.

repeat
  // code
until condition;

REPEAT follows the same three checks as the WHILE loop's ITC-principle, only in a swapped order — Initialise, Change, then Test — since the body always fires once before the condition is ever looked at. Lining the two loops up side by side shows how they really are opposites of each other:

var
  i: Integer;
begin
  i := 1;
  repeat
    memOut.Lines.Add(IntToStr(i));
    i := i + 1;
  until i > 10;
end;

REPEAT — Validate input

var
  iMark: Integer;
begin
  repeat
    iMark := StrToInt(InputBox('Mark', 'Enter mark (0-100):', ''));
    if (iMark < 0) OR (iMark > 100) then
      ShowMessage('Invalid! Enter 0-100');
  until (iMark >= 0) AND (iMark <= 100);
end;

Worked Example — Count, Average & Highest

One loop can gather several answers at once. Here we read marks until the user enters -1, and while looping we keep a counter, a running total and the highest so far — then work out the average at the end.

var
  iMark, iCount, iTotal, iHighest : Integer;
  rAverage : Real;
begin
  iCount   := 0;      // initialise all three trackers before the loop
  iTotal   := 0;
  iHighest := 0;

  iMark := StrToInt(InputBox('Marks', 'Enter a mark (-1 to stop):', ''));
  while iMark <> -1 do
  begin
    Inc(iCount);                 // how many so far
    iTotal := iTotal + iMark;    // running total
    if iMark > iHighest then    // track the maximum
      iHighest := iMark;
    iMark := StrToInt(InputBox('Marks', 'Enter a mark (-1 to stop):', ''));
  end;

  if iCount > 0 then            // guard against dividing by zero
  begin
    rAverage := iTotal / iCount;
    memOut.Lines.Add('Count:   ' + IntToStr(iCount));
    memOut.Lines.Add('Average: ' + FloatToStrF(rAverage, ffFixed, 4, 1));
    memOut.Lines.Add('Highest: ' + IntToStr(iHighest));
  end
  else
    ShowMessage('No marks were entered.');
end;

Comparison: Which Loop to Use?

Loop Control — How a Loop Is Controlled

Beyond picking FOR, WHILE or REPEAT, it is useful to describe what decides when a loop stops. This splits loops into two broad groups: definite repetition, where the number of passes can be worked out ahead of time, and indefinite repetition, where it cannot.

Counter Controlled Loops (Definite Repetition)

Because that change is predictable, you can always calculate in advance exactly how many times a counter controlled loop will run — a FOR loop is the most obvious example, but a WHILE or REPEAT loop built around a simple counter is counter controlled too.

iRow := 1;
while iRow <= 10 do
begin
  iResult := iRow * 8;
  memOut.Lines.Add(IntToStr(iRow) + ' x 8 = ' + IntToStr(iResult));
  iRow := iRow + 1;
end; {while}

Sentinel Controlled Loops (Indefinite Repetition)

The "WHILE — Reading user input until sentinel" example further up this page is a sentinel controlled loop: 0 is the signal that tells it to stop. Since nobody can predict how many real numbers the user will enter before typing that sentinel, the number of passes is unknown in advance — which is why sentinel controlled loops fall under indefinite repetition.

Result Controlled Loops (Indefinite Repetition)

iSpins := 0;
repeat
  iSlot := Random(8) + 1;
  Inc(iSpins);
until iSlot = 8;
ShowMessage('Jackpot landed after ' + IntToStr(iSpins) + ' spins');

Nothing here counts down towards a known number of repeats, and there is no value the user types to signal "stop" — the loop simply keeps spinning until the result it is watching for (slot 8) actually comes up.

Nested Loops

A nested loop is simply a loop placed inside the body of another loop. Each time the outer loop takes one step, the inner loop runs through its entire range from start to finish before the outer loop is allowed to take its next step. The inner and outer loops don't have to be the same kind — a FOR loop can quite happily sit inside a WHILE loop, or inside another FOR loop.

Suppose an exam venue needs a code for every seat: a block letter ('A' to 'C'), a row number (1 to 3) and a seat letter within the row ('a' to 'c'). Three nested FOR loops can generate the complete list in one go.

procedure TfrmVenue.btnListSeatsClick(Sender: TObject);
var
  iRow : integer;
  cBlock, cSeat : char;
  iSeatCount : integer;
  sSeatCode : string;
begin
  iSeatCount := 0;
  for cBlock := 'A' to 'C' do       // outer loop
  begin
    for iRow := 1 to 3 do          // middle loop
    begin
      for cSeat := 'a' to 'c' do       // inner loop
      begin
        sSeatCode := cBlock + IntToStr(iRow) + cSeat;
        Inc(iSeatCount);
        memSeats.Lines.Add(sSeatCode);
      end; // for cSeat
    end; // for iRow
  end; // for cBlock
  memSeats.Lines.Add('Total seats = ' + IntToStr(iSeatCount));
end;

String Manipulation Grade 10

Strings are sequences of characters. Delphi provides built-in functions and procedures to analyse, extract, and modify strings.

What is String Manipulation?

String manipulation is the process of working with text inside a program — searching it, pulling pieces out of it, changing it and measuring it. A string is simply a piece of text: a name, an ID number, an email address or a whole sentence are all strings.

Everyday analogy: Think of a string like a row of bead letters on a piece of string, exactly like a beaded keyring that spells a name. Each bead is one character and it sits in a fixed position. String manipulation is what you do when you slide beads off the end, count how many there are, swap a small to a capital bead, or read which bead is sitting in position 3.

Note: In Delphi, the very first character of a string sits at position 1 (not 0). This is why the reference string below numbers its letters starting at 1.

Quick Reference

Length — String Length

IntegerVariable := Length(SourceText);

iX := Length(sSourceText);   // = 13 (length of 'Andre is cute')
iX := Length('Hello');       // = 5

Group 4 — Changing Case

Changing case means turning all the letters into capitals (UpperCase) or all into small letters (LowerCase). The most important reason we do this is to compare text fairly. The computer thinks 'YES', 'yes' and 'Yes' are three different strings, so if you force them all to lowercase first, they all match.

Everyday analogy: Imagine a teacher marking a one-word answer. Whether a learner wrote "Cape Town", "CAPE TOWN" or "cape town", it is the same correct answer. Lowercasing both the answer and the memo before comparing is how you make sure capitals do not unfairly mark someone wrong.

Important Rule: UpperCase and LowerCase return a new string — they do not change the original unless you store the result back into a variable.

UpperCase and LowerCase

sResult := UpperCase(sSourceText);
// 'Andre is cute' → 'ANDRE IS CUTE'

sResult := LowerCase(sSourceText);
// 'Andre is cute' → 'andre is cute'

Group 1 — Searching a String

Searching means asking "is this smaller piece of text in there, and if so, where?" The answer you get back is a position number. This is the first thing you do before you can extract or change part of a string, because you usually need to know where something is first.

Everyday analogy: It is like using Find (Ctrl+F) in a document. You type a word, and the computer jumps to the spot where it appears and tells you where it is. Pos is Delphi's version of that "Find".

Pos — Find Position

Returns the integer position of the first occurrence of a substring. Returns 0 if not found.

IntegerVariable := Pos(StrToBeFound, SourceText);

iX := Pos('e', sSourceText);    // = 5  (first 'e' in 'Andre')
iX := Pos('is', sSourceText);   // = 7
iX := Pos('xyz', sSourceText);  // = 0  (not found)

Index [ ] — Character at Position

Access a single character using square brackets and a position number.

StringVariable := SourceText[CharacterPosition];

sNewText := sSourceText[2];   // = 'n'
sNewText := sSourceText[5];   // = 'e'

Group 2 — Extracting Part of a String

Extracting means taking a copy of a piece of the string without changing the original. You decide where to start and how many characters to grab. This is how you pull a first name out of a full name, a year out of a date, or an area code out of a phone number.

Everyday analogy: Think of cutting a slice out of a loaf of bread. The loaf (the original string) stays whole; you just take a slice from a chosen spot of a chosen thickness. Copy takes the slice, and Index [ ] takes a single thin slice — just one character.

Copy — Extract Substring

Extracts a section of text starting at a position for a given number of characters.

StringVariable := Copy(SourceText, BeginPosition, Length);

sNewText := Copy(sSourceText, 10, 4);  // = 'cute'  (start at 10, take 4)
sNewText := Copy(sSourceText, 1, 5);  // = 'Andre' (start at 1, take 5)

Group 3 — Changing a String

Changing a string means actually modifying it — adding text in, taking text out, or measuring it. Unlike extracting, these Insert and Delete procedures change the original string directly, so afterwards the string is different from before.

Everyday analogy: This is like editing a sentence in your exercise book. Insert squeezes a new word into the middle of the sentence; Delete rubs a few words out. Length is just counting how many letters the sentence now has.

Insert — Add Text

Inserts text into an existing string at a given position. Modifies the string directly.

Insert(InsertText, SourceText, Position);

Insert('very ', sSourceText, 10);
// sSourceText is now: 'Andre is very cute'

Delete — Remove Text

Removes a section of text from a string. Modifies the string directly.

Delete(SourceText, Position, Length);

Delete(sSourceText, 9, 5);
// sSourceText is now: 'Andre is' (removed ' cute')

Practical Patterns

Reverse a String

var
  sInput, sReverse: string;
  i: Integer;
begin
  sInput   := edtInput.Text;
  sReverse := '';
  for i := Length(sInput) downto 1 do
    sReverse := sReverse + sInput[i];
  lblResult.Caption := sReverse;
end;

Count Occurrences of a Character

var
  sText: string;
  i, iCount: Integer;
begin
  sText  := LowerCase(edtInput.Text);
  iCount := 0;
  for i := 1 to Length(sText) do
    if sText[i] IN ['a','e','i','o','u'] then
      Inc(iCount);
  lblResult.Caption := 'Vowels: ' + IntToStr(iCount);
end;

Extract First Name from "Surname, Name"

var
  sFullName, sName, sSurname: string;
  iCommaPos: Integer;
begin
  sFullName  := edtInput.Text;           // e.g. 'Smith, John'
  iCommaPos  := Pos(',', sFullName);
  sSurname   := Copy(sFullName, 1, iCommaPos - 1);
  sName      := Copy(sFullName, iCommaPos + 2, Length(sFullName));
  lblOut.Caption := 'Name: ' + sName + '  Surname: ' + sSurname;
end;

Worked Example — Reading a South African ID Number

A South African ID number is a 13-digit string that packs several pieces of information into fixed positions — a favourite exam question because it uses Length, Copy and the index [ ] all at once.

var
  sID, sDOB, sGender, sStatus : string;
  iSeq : Integer;
begin
  sID := edtID.Text;

  // 1. Validate — an ID must be exactly 13 characters long
  if Length(sID) <> 13 then
  begin
    ShowMessage('An ID number must be exactly 13 digits.');
    Exit;
  end;

  // 2. Date of birth — YY at 1, MM at 3, DD at 5 (rebuild as DD/MM/YY)
  sDOB := Copy(sID, 5, 2) + '/' + Copy(sID, 3, 2) + '/' + Copy(sID, 1, 2);

  // 3. Gender — the 4 digits at positions 7-10; 5000 and up = male
  iSeq := StrToInt(Copy(sID, 7, 4));
  if iSeq >= 5000 then
    sGender := 'Male'
  else
    sGender := 'Female';

  // 4. Citizenship — the single character at position 11
  if sID[11] = '0' then
    sStatus := 'SA citizen'
  else
    sStatus := 'Permanent resident';

  // 5. Show the result
  memOut.Lines.Add('Date of birth: ' + sDOB);
  memOut.Lines.Add('Gender: ' + sGender);
  memOut.Lines.Add('Status: ' + sStatus);
end;

Digital Technologies & ICT Grade 10

Understanding what digital technology and ICT actually mean, how computers process information, and the basic model behind every computer system.

Digital Technologies

Digital technologies are electronic tools, systems and devices that use digital data (0s and 1s) to collect, process, store and communicate information.

Examples: computers, smartphones, networks, cloud computing, databases, AI systems, IoT devices.

ICT vs IT

Types of Computers

Computers come in different forms, each suited to a different purpose. They differ mainly in processing power, size / portability and typical use.

Roughly from most to least processing power: server → desktop → laptop → tablet → smartphone → embedded; for physical size the order is broadly the reverse.

Data vs Information vs Knowledge

Characteristics of a Computer

• Speed — performs millions of operations per second
• Accuracy — follows instructions exactly
• Diligence — does not get tired or distracted
• Storage — large amounts of data can be stored
• Automation — tasks can be executed automatically
• Versatility — can perform many different types of tasks

The Information Processing Cycle

All computer operations follow this cycle:

Benefits and Negative Impacts of ICT

The Digital Divide

The digital divide is the growing gap between people with access to digital technology ("haves") and those without ("have-nots"). Factors include:

• Education — higher-educated households use technology more
• Income — lower-income areas lack infrastructure
• Location — rural areas have limited access

Green Computing

Green computing is the environmentally responsible use of computers and digital devices — using technology in ways that reduce energy consumption and electronic waste.

• Use energy-efficient hardware and enable power-saving/sleep settings
• Turn off computers and monitors when not in use, instead of leaving them on standby
• Reduce unnecessary printing; print double-sided when you must
• Choose a laptop over a desktop where possible — laptops use less power
• Recycle e-waste responsibly instead of throwing old devices in the bin
• Use cloud storage instead of buying and running extra physical storage hardware

Hardware Grade 10

Hardware is every physical component of a computer — the parts you can actually touch. Software is the instructions that tell hardware what to do. Together they make a complete computing system.

Keyboard

Most common input device for typing text and commands

Mouse

Pointing device for navigating graphical interfaces

Touchpad

Built-in pointer control surface on laptops

Touchscreen

Detects finger or stylus touch directly on the display

Hardware vs Software — The Body Analogy

The Computer System — Five Categories

Every hardware component falls into one of five categories. Data flows through the system in a loop: Input → Processing → Output, while Memory holds data temporarily and Storage saves it permanently. Communication devices connect the computer to other devices.

Hardware Categories

Input Devices in Detail

Keyboard

• Used to type letters, numbers, symbols, and commands
• Types: mechanical (tactile click), membrane (quiet, cheap), wireless, ergonomic
• Special keys: F1–F12 (function keys), Ctrl, Alt, Shift (modifier keys), shortcuts like Ctrl+C (copy)
• You use this when: typing a document, entering a password, coding in Delphi

Mouse

• Pointing device for graphical interfaces (GUI)
• Types: optical (uses LED light), laser (more precise), trackball, wireless
• Actions: left-click (select), double-click (open), right-click (context menu), drag-and-drop, scroll wheel
• You use this when: navigating a desktop, clicking buttons, drawing in a graphics program

Other Input Devices

Output Devices

Monitors

LCD/LED Monitor

Printers

DPI (dots per inch) = print quality (higher = sharper).
PPM (pages per minute) = print speed.

Storage Devices

HDD

Hard Disk Drive — magnetic spinning platters, large capacity

SSD

Solid State Drive — fast, silent, no moving parts

USB Flash Drive

Portable flash memory in a pocket-sized stick

SD Card

Small flash memory card used in cameras and phones

Optical Disc — CD/DVD

Laser-read disc; mostly obsolete but still examined

HDD vs SSD — Detailed Comparison

Types of Computers

Desktop

Powerful, upgradeable, sits on a desk; separate tower and monitor

Laptop

Portable all-in-one computer with built-in screen and battery

Tablet

Larger touchscreen device between a phone and laptop

Smartphone

Pocket-sized computer with touchscreen, camera, and mobile apps

Server

High-performance computer that provides services to other computers on a network

Embedded computer

A tiny computer (microcontroller) built into another device to control one specific task, e.g. a washing machine, car or smart TV

Memory vs Storage

Memory Hierarchy — Speed vs Capacity

The higher up the pyramid, the faster and more expensive the memory — but there's less of it.

CPU cache itself comes in levels, from smallest/fastest to largest/slowest: L1 cache is extremely fast and very small, built directly into each CPU core; L2 cache is larger but slightly slower, usually still per-core; L3 cache is bigger again but slower than L2, and is shared across all the CPU's cores.

Processing — CPU & GPU

• CPU (Central Processing Unit) — the "brain" of the computer. Fetches instructions from memory, decodes them, and executes them. Measured by: clock speed (GHz — higher = faster), number of cores (more cores = more tasks at once), and cache size. Example: Intel Core i5, AMD Ryzen 5.
• GPU (Graphics Processing Unit) — specialist processor for parallel tasks like rendering graphics, gaming, and AI. Can be integrated (built into the CPU — uses less power) or dedicated (separate card with its own memory, like NVIDIA GeForce). Example: your phone camera uses a GPU to apply filters in real-time.

Ports & Connectors

Ports are the sockets on a computer's case used to connect peripherals and cables. Knowing the common ones helps you pick the right cable for the right job.

USB speed depends on its version: USB 2.0 transfers at up to 480 Mbps, USB 3.0 up to 5 Gbps, and USB 3.1/3.2 even faster — always check the version, not just the connector shape, when speed matters.

Storage Units

Software & Licensing Grade 10

Software is the set of instructions that tells hardware what to do. Without software, a computer is just an expensive paperweight. Understanding the different types and how they are licensed is essential IT knowledge.

What is Software?

Software is a collection of programs and data that tells a computer how to perform tasks. You can't touch software — it only exists digitally. Hardware is the body; software is the brain telling the body what to do.

Software Licensing

When you "buy" software, you're not actually buying the software — you're buying a licence to use it. The developer keeps ownership. Software licences define what you are and aren't allowed to do with the software.

EULA — End User Licence Agreement

The EULA is the legal agreement between you and the software developer. It's that long wall of text you click "I Agree" on when installing software.

It specifies: how many devices you can install on, what you're not allowed to do, and who owns the software.

Software Piracy & Copyright

Copyright is the legal right that protects a creator's work. Software is automatically protected by copyright the moment it is created. You cannot copy, share or distribute software without the copyright holder's permission.

Piracy is the illegal copying or distribution of copyrighted software. It is a crime in South Africa and most countries.

Forms of software piracy:

• Softlifting: installing one licensed copy on multiple computers
• Counterfeiting: making and selling fake copies of licensed software
• Online piracy: downloading software illegally from the internet (torrents, crack sites)
• Hard disk loading: selling computers with pirated software pre-installed
• Client-server overuse: exceeding the number of users a network licence actually allows (e.g. a school's licence covers 20 lab computers but it's installed on 30)

Copyleft & Creative Commons

These are alternative licensing systems that allow sharing and collaboration while still giving creators some protection.

• Attribution (BY): You can use the work if you credit the creator
• Non-Commercial (NC): You can use it, but not for profit
• Share-Alike (SA / Copyleft): Any work you create from it must use the same licence
• No Derivatives (ND): You cannot modify the original work

System Software

System software manages and controls the hardware. The most important type is the Operating System (OS).

Operating System (OS)

The Operating System (OS) is system software that manages a computer's hardware and software resources, and provides a platform on which application software can run. It is the first software to load when a computer starts up, and every other program runs through it.

What the OS does:

• User interface — provides the desktop, windows and menus you interact with
• Hardware management — controls how programs access the CPU, RAM and storage
• File management — organises files and folders on storage devices
• Process management — runs multiple programs at once (multitasking)
• Security — manages user accounts and access permissions

Utility Programs

Utility programs are small tools that help maintain the computer. They come with the OS or can be downloaded.

• Antivirus software (e.g. Avast, Windows Defender)
• Disk cleanup and defragmentation tools
• File compression tools (e.g. WinZip, 7-Zip)
• Backup software

Device Drivers

A device driver is a small program that allows the OS to communicate with a hardware device. Without the correct driver, hardware won't work properly.

Example: When you plug in a new printer, Windows downloads or installs the printer driver so it knows how to send data to that specific printer model.

Firmware

Firmware is specialised, permanent software stored on non-volatile memory (usually a ROM or flash chip) inside a hardware device, controlling its most basic functions. Unlike a normal application, you don't install firmware yourself — it comes built into the device and is only changed through a controlled firmware update.

Examples: the BIOS/UEFI firmware that starts up a computer before the OS loads, the firmware inside a Wi-Fi router, or the firmware that runs a printer or smart TV.

Application Software

Application software lets you perform specific tasks — it uses the OS as its foundation.

Data Representation Grade 10

Computers only understand two states: on (1) and off (0). Everything — text, images, sound, video — must first be converted to those 1s and 0s before a computer can process it. This page explains how that conversion works.

Why Only 1s and 0s?

Deep inside your computer, everything is built from tiny transistors — microscopic electronic switches. Each switch can only be in one of two states: on (1) or off (0). This is called binary because there are only two options.

A single 1 or 0 is called a bit (short for binary digit). On its own, one bit can only represent two things. But group 8 bits together into a byte, and suddenly you can represent 256 different values (2⁸ = 256) — enough for every letter, digit, and common symbol.

Bits and Bytes — Visual Diagram

Eight bits grouped together form one byte. The example below shows the byte 01000001 — the binary code for the letter A in ASCII.

Number Systems Overview

Binary (Base 2)

In decimal, each column is worth 10× the column to its right (1, 10, 100, 1000…). In binary, each column is worth 2× the column to its right — these are the powers of 2.

Step-by-Step Conversion Examples

Binary → Decimal

Multiply each bit by its place value, then add them all up. Only count the columns where the bit is 1.

(0 × 2⁷) + (0 × 2⁶) + (1 × 2⁵) + (0 × 2⁴) + (1 × 2³) + (1 × 2²) + (0 × 2¹) + (1 × 2⁰)

= (0 × 128) + (0 × 64) + (1 × 32) + (0 × 16) + (1 × 8) + (1 × 4) + (0 × 2) + (1 × 1)

= 0 + 0 + 32 + 0 + 8 + 4 + 0 + 1

= 45

(1 × 2⁴) + (0 × 2³) + (1 × 2²) + (1 × 2¹) + (0 × 2⁰)

= (1 × 16) + (0 × 8) + (1 × 4) + (1 × 2) + (0 × 1)

= 16 + 0 + 4 + 2 + 0

= 22

Decimal → Binary (Divide by 2 Method)

Divide the number by 2 repeatedly. Write down each remainder. Read the remainders from bottom to top.

25 ÷ 2 = 12  remainder  1   ← LSB (written last, read first from bottom)
12 ÷ 2 =  6  remainder  0
 6 ÷ 2 =  3  remainder  0
 3 ÷ 2 =  1  remainder  1
 1 ÷ 2 =  0  remainder  1   ← MSB (written first, read last from bottom)

Read remainders bottom to top:  1  1  0  0  1
                                                = 11001₂

Verify:  16 + 8 + 0 + 0 + 1 = 25 ✓

13 ÷ 2 = 6  remainder  1
 6 ÷ 2 = 3  remainder  0
 3 ÷ 2 = 1  remainder  1
 1 ÷ 2 = 0  remainder  1

Read bottom to top:  1  1  0  1  =  1101₂

Verify:  8 + 4 + 0 + 1 = 13 ✓

Hexadecimal (Base 16)

Hexadecimal (hex) uses 16 symbols: the digits 0–9, then the letters A–F for values 10–15. Because one hex digit represents exactly 4 binary bits, hex is a much shorter way to write binary numbers. For example, 11111111 in binary is just FF in hex.

Hex Digit Table

Hex → Decimal Conversion

Each position in hex is worth 16× the position to its right (just like binary uses powers of 2, hex uses powers of 16).

2A₁₆ has two digits: 2 and A (=10)

(2 × 16¹) + (A × 16⁰)

= (2 × 16) + (10 × 1)

= 32 + 10

= 42₁₀

3F₁₆ has two digits: 3 and F (=15)

(3 × 16¹) + (F × 16⁰)

= (3 × 16) + (15 × 1)

= 48 + 15

= 63₁₀

Decimal → Hex Conversion (Divide by 16)

200 ÷ 16 = 12  remainder  8    →  8
 12 ÷ 16 =  0  remainder  12   →  C  (12 in hex = C)

Read remainders bottom to top:  C  8  →  C8₁₆

Verify:  12 × 16 + 8 = 192 + 8 = 200 ✓

ASCII — Storing Text

A computer stores text by mapping each character to a number. The most common mapping is ASCII (American Standard Code for Information Interchange). Each character has a unique number — a code — which is then stored in binary.

Key ASCII Values to Memorise

Unicode and UTF-8

Data Representation in Delphi

// Ord: char → ASCII number
iCode := Ord('A');         // = 65
iCode := Ord('a');         // = 97

// Chr: ASCII number → char
cChar := Chr(65);           // = 'A'
cChar := Chr(97);           // = 'a'

// Convert lowercase to uppercase using the +32 rule:
cUpper := Chr(Ord(cLower) - 32);

// Print ASCII values of each character in a string
for i := 1 to Length(sText) do
  memOut.Lines.Add(sText[i] + ' = ' + IntToStr(Ord(sText[i])));

Storage Units

File Compression

Compression reduces the amount of disk space a file uses. Decompression restores a compressed file back to a usable form. Higher compression means a smaller file size and faster download/streaming, but too much compression can reduce quality (pixelation in images, distortion in audio).

Networks Grade 10

A computer network connects two or more computing devices so they can communicate and share resources. Networks are what make the internet, school computer labs, and your home Wi-Fi possible.

Why Would You Connect Computers Together?

Imagine your school has 30 computers but only 2 printers. Without a network, only the computers physically connected to a printer could print. With a network, every computer can send print jobs to either printer — that's sharing resources.

Networks make all of the following possible:

• Resource sharing — share printers, scanners, internet connections, and storage across multiple computers
• File sharing — send a document from one computer to another without a USB drive
• Communication — email, instant messaging, video calls (e.g. your school uses Microsoft Teams or Google Meet)
• Centralised data and backups — store all student data on one server so it's accessible from any computer in the lab
• Internet access — one router can give all devices in a building internet access
• Remote work — teachers can access school systems from home via a VPN (Virtual Private Network)

Network Size Classifications

Network Topologies — Star Topology

A topology describes the physical layout of how devices are connected in a network. The most common topology used in school labs and offices is the Star Topology: every device connects directly to a central switch or hub.

Star Topology — Advantages and Disadvantages

Essential Network Components

Data from your computer travels through several devices before it reaches the internet. Here is how they connect:

Network Hardware Reference

Network Types — Client-Server vs Peer-to-Peer

Client-Server Network

A central server provides services (files, printers, internet access, authentication) to multiple client computers. The server is a dedicated, powerful computer that is always on.

Peer-to-Peer (P2P) Network

All computers have equal status — any device can be both client and server. No single central machine is in charge. Common in small home networks.

Communication Media

The medium is the physical pathway over which data travels. Choosing the right medium depends on the required speed, distance, security, and budget.

Mobile Hotspot / Tethering

A smartphone has its own built-in communication hardware (Wi-Fi and Bluetooth), so it can share its mobile data connection with other devices. This is called using the phone as a hotspot (or tethering) — a laptop or tablet connects to the phone's Wi-Fi signal and browses the internet through the phone's LTE/5G data, useful when no other Wi-Fi network is available.

Internet & WWW Grade 10

The Internet and the World Wide Web are related but different. Learn how they work and how to use search engines effectively.

Internet vs World Wide Web

Key Concepts

Web Browsers

A web browser interprets HTML and displays web pages. Examples: Chrome, Firefox, Edge, Safari.

How Websites Remember You — Cookies & Caching

Search Engine Techniques

Common Internet Threats

Internet Services Grade 10

The internet provides far more than just web browsing. This page covers plug-in applications, common internet services, and the technologies that power them.

Plug-in Applications

A plug-in is additional software installed into an existing application (e.g. a browser) to extend its functionality.

Internet Services Technologies

Internet services technologies cover web development, web design, networking and e-commerce. They are used together to create functional, interactive websites.

Common Internet Services

W3C — World Wide Web Consortium

The W3C sets the standards that all web browsers and websites should follow to ensure web pages display correctly across all devices and browsers. Web designers follow these standards.

E-Communication Grade 10

Electronic communication covers all methods of exchanging information digitally — from email and instant messaging to video calls and social media.

Forms of Electronic Communication

Email

Email Address Format

username@domain.co.za — e.g. student@school.co.za

Netiquette (Network Etiquette)

• Use a clear, descriptive subject line
• Begin with a greeting; end with a signature
• Keep messages short and professional
• AVOID ALL CAPS — it looks like shouting
• Proofread for spelling and grammar before sending
• Compress large attachments before sending
• Do not forward spam or chain emails
• Never send sensitive info (passwords, banking details) via email

E-Communication Factors

Synchronous vs Asynchronous Communication

Electronic communication can be grouped by when the people involved take part:

• Synchronous communication happens in real time — everyone takes part at the same moment, like a live conversation (e.g. a VoIP/phone call, video conference, or live instant-messaging chat).
• Asynchronous communication does not happen at the same time — you send a message and the receiver replies whenever it suits them (e.g. email, SMS, a forum post or a blog).

Ergonomics and Health

• Sit upright; monitor at eye level
• Keyboard and mouse at comfortable arm height
• Take breaks every 30–60 minutes
• Use the 20-20-20 rule: every 20 min, look 20m away for 20 seconds

Social Issues

• Cyberbullying — harassment via digital channels
• Fake news — always verify with reputable sources
• Privacy — be careful what you share online; it leaves a digital footprint
• Green computing — turn off devices, reduce printing, recycle e-waste

Computer Management & Security Grade 10

Keeping a computer running well and securely requires regular maintenance tasks and an understanding of common threats.

General Housekeeping Tasks

Types of Backup

Backup Locations

• Local — external hard drive kept at same location
• Off-site — physical device kept at a different location
• Cloud/online — e.g. Google Drive, OneDrive — automatic, accessible anywhere

Common Malware Threats

Security Measures

Organising Files & Folders

A file is a collection of data stored as a single unit (a document, image, song, program). A folder (directory) is a container used to group related files. Organising files means storing them in a logical, meaningful way so they are easy to find later.

Anatomy of a File Path

A path describes exactly where a file lives on a storage device — the drive, the folders, the file name and its extension.

Put together: C:\Users\Mari\Documents\IT\report.docx

Common File Extensions

The extension (the letters after the dot) tells the operating system which program should open the file.

Why Use a Good File Structure?

• Makes files easier and faster to find
• Reduces duplication — you don't save the same file in many places
• Improves organisation and reduces clutter
• Makes backing up specific folders simpler

A File Manager (e.g. Windows File Explorer) is the software used to view, move, copy, rename and delete files and folders.

Save As vs Export

File Naming Best Practices

• Use meaningful file names: 2025_Term1_IT_Project.docx ✓, untitled2.docx ✗
• Organise files into logical folder structures
• Avoid special characters in file names: \ / : * ? " < > |
• Use underscores or dashes instead of spaces
• Back up regularly — at least weekly

Grade 10 — Year Planner Grade 10

Based on the 2026 IT CAPS Annual Teaching Plan. Practical (Paper 1) and Theory (Paper 2) topics per term.

Exam Extras Out-of-CAPS

These topics are not explicitly required by CAPS but have appeared in NSC past papers (2015–2024). Knowing them can mean the difference between a pass and a distinction.

The Software Development Process

CAPS never teaches "how to plan a whole program" as one topic — instead it hands you the individual planning tools (IPO tables, TOE charts, pseudocode) at different points across Grade 10 and 11. Strung together in order, those tools form a complete process for turning a vague idea into a finished, working program. None of this is examinable on its own, but following it will make your PAT — and any open-ended practical question — far less overwhelming.

1. Pin down exactly what the program must do. A one-line description ("a till program") is not enough to start coding from — write out every input the program will receive, every calculation or decision it must make, and every output it must produce. This is the same information an IPO table asks for (Grade 10 T1, Algorithms & Problem Solving), just applied to the whole program instead of one calculation.
2. Sketch the interface before placing a single component. Decide which forms the user will see, what components sit on each one, and how the user moves between them. Keep the same layout, colours and button placement on every form — a program that looks different from screen to screen feels unfinished even when the code is solid.
3. Map out which event triggers which task. For every button, checkbox or form event, list precisely what must happen when it fires — this is exactly what a TOE (Task–Object–Event) chart is for (also covered on the Algorithms & Problem Solving page). Doing this before writing code stops the common mistake of half-remembering what a button was supposed to do halfway through typing its handler.
4. Break the plan into procedures and functions before typing the body of any of them. Decide which pieces of logic will repeat, which need a return value and which don't, and what needs to pass between them as parameters — this is where the Procedures & Functions (Grade 11 T2) content and the local-vs-global variable rules on that page earn their keep.
5. Write the code in small, testable pieces rather than the whole program at once — build and run after every procedure or two so that when something breaks, you know it's in the last few lines you typed, not buried somewhere in 200 lines you haven't tested yet.
6. Test with data designed to break it, not just data that works. Run the program with an empty text box, a negative number, the largest and smallest values it should accept, and anything else a careless user might type — this is the mindset behind the Input Validation content (Grade 10 T2). Where something goes wrong before you can even see the output, Delphi's debugger (breakpoints, F8 stepping, the Watch List — see Data Types & Variables) will show you exactly which line is responsible.

Practical Extras — Paper 1 (Delphi)

These Delphi functions, components and techniques are not listed in CAPS but appear regularly in exam questions or are needed to solve exam problems efficiently.

Theory Extras — Paper 2

These theory topics have appeared in NSC Theory papers but sit at the edge of or outside the formal CAPS scope. They typically appear in social implications or "current technology" questions.

Complete Delphi Functions Quick Reference

A comprehensive reference of all Delphi functions you need to know — both CAPS-required and commonly appearing in exams.

String Functions

Math Functions

Type Conversion Functions

Past Paper Patterns & Tips

Paper 1 (Practical) — What Always Appears

Paper 2 (Theory) — What Always Appears

General Exam Advice