1D Arrays Grade 11

Imagine you need to store 30 student marks. Without arrays you would need 30 separate variables — iMark1, iMark2, … iMark30. With an array, one name stores them all: arrMarks[1..30]. Arrays are a Grade 11 Term 1 topic.

Why Use Arrays?

What is a 1D Array?

A one-dimensional array is a structured data type that stores a fixed number of values of the same data type under a single variable name, with each individual value accessed using its own index (a whole number giving that value's position in the list).

Declaring an Array

arrName : array [lowerIndex..upperIndex] of DataType;

var
  arrNames  : array [1..30] of String;
  arrMarks  : array [1..30] of Integer;
  arrPrices : array [0..9]  of Real;

Arrays of Unknown Length — use a constant

You don't always know in advance exactly how many items you will store. A common trick is to declare a constant for the maximum size, then use it as the upper index. If the size needs to change later, you only edit one line.

const
  Max = 100;                          // maximum possible learners
var
  arrNames : array [1..Max] of String;
  iCount   : Integer;                  // how many are ACTUALLY used

Keep a separate counter (iCount) for how many elements are really in use, and loop 1 to iCount instead of 1 to Max.

Dynamic Arrays

A dynamic array has no fixed size when declared — you set (and can later change) its length while the program runs with SetLength. This is perfect when the number of items is only known at runtime (e.g. after reading a file).

var
  arrNum : array of Integer;   // note: NO index range given
  i : Integer;
begin
  SetLength(arrNum, 5);          // now holds 5 ints, index 0..4

  for i := Low(arrNum) to High(arrNum) do
    arrNum[i] := i * 2;           // 0, 2, 4, 6, 8

  SetLength(arrNum, 8);          // grow to 8 — existing values are kept
end;

Populating an Array

Method 1: Fixed values

arrNames[1] := 'Alice';
arrNames[2] := 'Bob';
arrNames[3] := 'Callie';

Method 2: Constant array (known at compile time)

const
  arrDays : array [1..7] of String =
    ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

Method 3: User input with a loop

for i := 1 to 30 do
  arrNames[i] := InputBox('Name', 'Enter name:', '');

Displaying & Calculating

// Display all
for i := 1 to Length(arrMarks) do
  memOut.Lines.Add(IntToStr(arrMarks[i]));

// Sum and average
iTotal := 0;
for i := 1 to Length(arrMarks) do
  iTotal := iTotal + arrMarks[i];
rAvg := iTotal / Length(arrMarks);

Shortcut: the Math Unit

Writing your own loop to total or average an array works, but Delphi's Math unit already has ready-made functions that do the same job in one line.

uses Math;   // add this to the uses clause first

rAvg     := Mean(arrPrices);
rTotal   := Sum(arrPrices);
rHighest := MaxValue(arrPrices);
rLowest  := MinValue(arrPrices);

Arrays with Meaningful Indices

Every index used so far has just meant "the Nth item in the list" — arrNames[3] is simply whoever happens to be third. Sometimes, though, it's more useful to let the index itself carry meaning. If arrVotes[4] always holds the vote count for competitor number 4, the index is the competitor number, not just a position in a queue.

Using a Char as the Index

An index isn't limited to whole numbers — any ordinal type can be used, including Char. This is handy whenever the letter itself is what you want to look values up by, e.g. tallying how many learners scored each grade symbol (A to F) in a test:

var
  arrSymbolCount : array ['A'..'F'] of Integer;
  cGrade : Char;
begin
  cGrade := 'A';
  while cGrade <= 'F' do
  begin
    arrSymbolCount[cGrade] := 0;   // reset every element to zero first
    cGrade := succ(cGrade);         // moves 'A' to 'B', 'B' to 'C', and so on
  end;

  // later, whenever a learner's symbol is worked out:
  Inc(arrSymbolCount[cLearnerSymbol]);

Matching a RadioGroup's ItemIndex to an Array

A RadioGroup's ItemIndex always starts counting from 0 for its first button — but an array you declare yourself might start at 1. When you use ItemIndex to pick an element to update (for example, tallying votes for a menu option), you need to decide which convention your array follows and stay consistent:

With the [1..5] version, the array index is always one more than ItemIndex, because ItemIndex itself never moves off its 0-based counting — only your array's lower bound changes.

Linear Search

bFound := False;
for i := 1 to Length(arrNames) do
  if arrNames[i] = sSearch then
  begin
    ShowMessage('Found at position ' + IntToStr(i));
    bFound := True;
    Break;
  end;
if not bFound then
  ShowMessage('Not found');

Binary Search (sorted array)

Binary search is much faster than linear — it halves the search range each step. The array must be sorted first. We are searching for 23 in the array [2, 5, 8, 12, 16, 23, 38, 56, 72, 91].

iLow := 1;
iHigh := Length(arrNums);
bFound := False;
while (iLow <= iHigh) and not bFound do
begin
  iMid := (iLow + iHigh) div 2;
  if arrNums[iMid] = iTarget then
    bFound := True
  else if arrNums[iMid] < iTarget then
    iLow := iMid + 1
  else
    iHigh := iMid - 1;
end;
if bFound then
  ShowMessage('Found at position ' + IntToStr(iMid));

How String Comparison Works

Sorting a string array with > and < only makes sense once you know what Delphi is actually comparing. It never looks at "the alphabet" directly — it walks each string letter by letter and compares the underlying ASCII value of each character, stopping at the first pair of letters that differ.

Bubble Sort — Pass by Pass

Bubble sort compares adjacent elements and swaps them if they are in the wrong order. After each full pass, the largest unsorted value "bubbles" to its correct position at the end. Array: [5, 3, 8, 1, 9] — sorting ascending.

for i := Length(arrNums) - 1 downto 1 do
  for j := 1 to i do
    if arrNums[j] > arrNums[j + 1] then
    begin
      iTemp := arrNums[j];
      arrNums[j] := arrNums[j + 1];
      arrNums[j + 1] := iTemp;
    end;

iEndCounter := Length(arrNums) - 1;
repeat
  bSwapped := False;
  for j := 1 to iEndCounter do
    if arrNums[j] > arrNums[j + 1] then
    begin
      iTemp := arrNums[j];
      arrNums[j] := arrNums[j + 1];
      arrNums[j + 1] := iTemp;
      bSwapped := True;
    end;
  Dec(iEndCounter);            // the tail end is sorted, so search one less item next time
until not bSwapped;         // no swaps this pass = fully sorted, stop looping

Selection Sort — Pass by Pass

Selection sort finds the smallest remaining element and swaps it into its correct position. Same array: [5, 3, 8, 1, 9].

for i := 1 to Length(arrNums) - 1 do
begin
  iMin := i;
  for j := i + 1 to Length(arrNums) do
    if arrNums[j] < arrNums[iMin] then
      iMin := j;
  if iMin <> i then
  begin
    iTemp := arrNums[i];
    arrNums[i] := arrNums[iMin];
    arrNums[iMin] := iTemp;
  end;
end;

Parallel Arrays

Two arrays are parallel when the same index refers to the same "record" — e.g. arrNames[3] and arrMarks[3] both belong to the same student. When you sort one, you must sort both to keep them in sync.

for i := 1 to Length(arrNames) - 1 do
  for j := i + 1 to Length(arrNames) do
    if arrNames[i] > arrNames[j] then
    begin
      // Swap both arrays at the same time
      sTemp := arrNames[i]; arrNames[i] := arrNames[j]; arrNames[j] := sTemp;
      iTemp := arrMarks[i]; arrMarks[i] := arrMarks[j]; arrMarks[j] := iTemp;
    end;

Date Methods (Grade 11)

Delphi has built-in functions for working with dates — required for Grade 11 Term 1.

// Display today's date
lblToday.Caption := DateToStr(Now);         // '2025/05/30'

// Calculate age in years
iAge := YearOf(Now) - YearOf(dtpBirth.Date); // e.g. 17

// Check leap year
if IsLeapYear(YearOf(Now)) then
  ShowMessage('This is a leap year')
else
  ShowMessage('Not a leap year');

Text Files Grade 11

Text files allow your Delphi program to save and load data that persists between runs. Learn the four operations: reading, writing, appending, and checking existence.

What Is a Text File?

A text file is a file that stores plain, readable characters with no special formatting — just letters, numbers and line breaks, exactly as you would type them into Notepad. There are no fonts, colours, or hidden layout codes like you would find in a Word document; it is simply text, one line after another.

Why Do We Use Files?

The variables in your program only live in memory (RAM) while the program is running. The moment you close the program, everything in those variables is gone. A file gives your data persistence — it is saved onto the disk so that it survives after the program closes and is still there the next time you run it.

Example: a marks program that lets a teacher capture results is useless if every mark vanishes when she closes it. By writing the marks to a text file, the data is safely stored and can be read back tomorrow.

Physical vs Logical Filename

When working with files in Delphi there are two "names" to keep straight:

• Physical filename – the real name of the file as it exists on the disk, for example 'Data.txt'. This is what you would see in File Explorer.
• Logical filename – the file variable inside your program (of type TextFile), for example F. Your code talks to this variable, not directly to the disk.

The AssignFile command is what links the two together — it tells Delphi "whenever I use the logical variable F, I really mean the physical file Data.txt on the disk".

What Each File Command Does

Before looking at the table, here is each command explained in plain words:

• AssignFile(F, 'file.txt') – links your file variable to the real file on disk. Always the very first step.
• Reset(F) – opens an existing file so you can read from it, starting at the very beginning.
• Rewrite(F) – creates a brand-new empty file for writing. If the file already exists, its old contents are wiped out, so use it with care.
• Append(F) – opens an existing file and moves to the very end, so new lines are added without destroying what is already there.
• ReadLn(F, S) – reads one whole line from the file into the variable S, then moves on to the next line.
• WriteLn(F, S) – writes the contents of S into the file as one line.
• CloseFile(F) – saves and properly closes the file. Like shutting and locking the postbox so nothing is lost.
• EOF(F) – short for "End Of File". Returns True once you have read the last line, so your loop knows when to stop.

Key Procedures and Functions

Reading a Text File

var
  F: TextFile;
  S: string;
begin
  if FileExists('Data.txt') then
  begin
    AssignFile(F, 'Data.txt');
    Reset(F);                          // open for reading
    while not EOF(F) do
    begin
      ReadLn(F, S);
      memOut.Lines.Add(S);             // process each line
    end;
    CloseFile(F);
  end
  else
    ShowMessage('File not found!');
end;

Quick Alternative — LoadFromFile and SaveToFile

A Memo or RichEdit's Lines property has two built-in methods that skip the whole AssignFile/Reset/ReadLn loop when you just want to dump a text file straight onto the screen (or the screen straight into a file). One line does the job of the entire loop above.

memOutput.Lines.Clear;
memOutput.Lines.LoadFromFile('Data.txt');   // reads the whole file into the Memo

// ... later, to save the Memo's content back to a file:
memOutput.Lines.SaveToFile('Output.txt');   // writes every line in the Memo to a file

Checking a File Exists with try..except

Using FileExists is the simplest way to avoid a crash. A second method is to try to open the file and catch the error if it is missing. A try..except block runs the risky code in the try part; if an exception happens (for example the file does not exist, so Reset fails), control jumps straight to the except part instead of crashing the program.

var
  F: TextFile;
  S: string;
begin
  AssignFile(F, 'Data.txt');
  try
    Reset(F);                          // raises an error if the file is missing
    while not EOF(F) do
    begin
      ReadLn(F, S);
      memOut.Lines.Add(S);
    end;
    CloseFile(F);
  except
    on E: EInOutError do
      ShowMessage('Could not open the file: ' + E.Message);
  end;
end;

Writing to a Text File (Overwrite)

var
  F: TextFile;
begin
  AssignFile(F, 'Output.txt');
  Rewrite(F);                          // creates or overwrites
  WriteLn(F, sName + ',' + sSurname + ',' + IntToStr(iAge));
  CloseFile(F);
end;

Appending to a Text File

var
  F: TextFile;
begin
  AssignFile(F, 'Data.txt');
  Append(F);                           // adds to existing file
  WriteLn(F, 'New data line');
  CloseFile(F);
end;

Reading CSV Data into Arrays

var
  F: TextFile;
  sLine, sName: string;
  iMark, iCount, iPos: Integer;
begin
  iCount := 0;
  AssignFile(F, 'marks.txt');
  Reset(F);
  while not EOF(F) do
  begin
    ReadLn(F, sLine);
    iPos := Pos(',', sLine);
    Inc(iCount);
    arrNames[iCount] := Copy(sLine, 1, iPos - 1);
    arrMarks[iCount] := StrToInt(Copy(sLine, iPos + 1, Length(sLine)));
  end;
  CloseFile(F);
end;

Worked Example — Putting It All Together

Exam questions rarely test one skill on its own. A typical Paper 1 question gives you a text file, asks you to extract and manipulate each line, store the parts in parallel arrays, and then process them. Here is that whole pattern in one example.

Coetzee,Mari,72
Naidoo,Priya,88
Botha,Jan,64
Khumalo,Sipho,91

Task: read the file into parallel arrays, then (a) display each learner as M. Coetzee: 72%, (b) show the class average, and (c) find the top learner.

Step 0 — Declare the parallel arrays

const
  Max = 100;                 // most learners the arrays can hold
var
  arrSurname : array[1..MAX] of string;
  arrName    : array[1..MAX] of string;
  arrMark    : array[1..MAX] of integer;
  iCount     : integer;          // how many learners were actually read

The three arrays are parallel: index [2] in each one belongs to the same learner (Priya Naidoo, 88).

Step 1 — Read the file & split each line

Read one line at a time. Use Pos to find each comma, then Copy and Delete to chop the line into its three fields.

var
  F     : TextFile;
  sLine : string;
  iPos  : integer;
begin
  iCount := 0;
  if not FileExists('marks.txt') then
  begin
    ShowMessage('File not found!');
    Exit;
  end;
  AssignFile(F, 'marks.txt');
  Reset(F);
  while not EOF(F) do
  begin
    ReadLn(F, sLine);                      // e.g. 'Coetzee,Mari,72'
    Inc(iCount);
    // field 1 - surname (up to the first comma)
    iPos := Pos(',', sLine);
    arrSurname[iCount] := Copy(sLine, 1, iPos - 1);   // 'Coetzee'
    Delete(sLine, 1, iPos);                          // -> 'Mari,72'
    // field 2 - first name (up to the next comma)
    iPos := Pos(',', sLine);
    arrName[iCount] := Copy(sLine, 1, iPos - 1);      // 'Mari'
    Delete(sLine, 1, iPos);                          // -> '72'
    // field 3 - whatever remains is the mark
    arrMark[iCount] := StrToInt(sLine);                // 72
  end;
  CloseFile(F);
end;

Step 2 — Manipulate the strings for display

Build the initial from the first letter of the first name with Copy(name, 1, 1).

var
  i        : integer;
  sInitial : string;
begin
  for i := 1 to iCount do
  begin
    sInitial := Copy(arrName[i], 1, 1);            // 'M'
    memOut.Lines.Add(sInitial + '. ' + arrSurname[i]
                     + ': ' + IntToStr(arrMark[i]) + '%');
  end;
end;

Output: M. Coetzee: 72%, P. Naidoo: 88%, J. Botha: 64%, S. Khumalo: 91%

Step 3 — Class average

(Assume iTotal : integer and rAverage : real are declared.)

iTotal := 0;
for i := 1 to iCount do
  iTotal := iTotal + arrMark[i];
rAverage := iTotal / iCount;
ShowMessage('Class average: ' +
            FloatToStrF(rAverage, ffFixed, 4, 1) + '%');

Step 4 — Find the top learner

Search arrMark for the highest value, remembering its index. Because the arrays are parallel, that same index gives you the winner's name and surname too.

iTopPos := 1;
for i := 2 to iCount do
  if arrMark[i] > arrMark[iTopPos] then
    iTopPos := i;
ShowMessage('Top learner: ' + arrName[iTopPos] + ' ' + arrSurname[iTopPos]
            + ' (' + IntToStr(arrMark[iTopPos]) + '%)');

And back out — writing the results to a new file

Often the last step is to write your processed results to a new text file. Use Rewrite to create it, WriteLn to add each line, and CloseFile to save. Here we write a pass/fail report from the arrays built above.

var
  Fout    : TextFile;
  i       : integer;
  sResult : string;
begin
  AssignFile(Fout, 'report.txt');
  Rewrite(Fout);                         // creates (or overwrites) the file
  for i := 1 to iCount do
  begin
    if arrMark[i] >= 50 then
      sResult := 'PASS'
    else
      sResult := 'FAIL';
    WriteLn(Fout, arrSurname[i] + ',' + IntToStr(arrMark[i]) + ',' + sResult);
  end;
  CloseFile(Fout);                       // saves and closes the file
end;

That completes the full read → process → write cycle: read the data in, work with it in arrays, then save the results back out to a new file.

Working with More Than One Text File at a Time

A practical question will sometimes ask you to read from one existing file and, in the same pass, sort its lines into two or more new files depending on a condition. Reusing the marks.txt file from the worked example above, here is a program that reads it once and writes each learner's surname into either Pass.txt or Fail.txt depending on their mark. The file being read only ever needs Reset; every file being created or overwritten needs its own Rewrite call, and all three files stay open together inside a single while not EOF loop.

var
  Fin, FPass, FFail : TextFile;
  sLine, sSurname     : string;
  iPos, iMark          : integer;
begin
  AssignFile(Fin, 'marks.txt');
  AssignFile(FPass, 'Pass.txt');
  AssignFile(FFail, 'Fail.txt');
  try
    Reset(Fin);                           // only the file being read needs a try..except
  except
    ShowMessage('marks.txt could not be opened');
    Exit;
  end;
  Rewrite(FPass);                         // creates/overwrites the two output files
  Rewrite(FFail);

  while not EOF(Fin) do
  begin
    ReadLn(Fin, sLine);                   // e.g. 'Coetzee,Mari,72'
    iPos := Pos(',', sLine);
    sSurname := Copy(sLine, 1, iPos - 1);
    Delete(sLine, 1, iPos);
    iPos := Pos(',', sLine);
    Delete(sLine, 1, iPos);           // discard the first name, keep the mark
    iMark := StrToInt(sLine);
    if iMark >= 50 then
      WriteLn(FPass, sSurname)
    else
      WriteLn(FFail, sSurname);
  end;
  CloseFile(Fin);
  CloseFile(FPass);
  CloseFile(FFail);
end;

sFilename := 'Computer' + edtNumber.Text + '.txt';   // e.g. 'Computer34.txt'
AssignFile(tCompFile, sFilename);

Writing Data to a Text File in Neat Columns

A field width indicator reserves a fixed number of character positions for a value and right-justifies it inside them, which is what makes data on separate lines line up into columns. Add a colon and a number straight after the value inside a WriteLn statement.

sSurname := 'Pillay';
WriteLn(tFile, sSurname:10);   // 'Pillay' padded with 4 leading spaces to fill 10 positions

A field width on its own only right-justifies. To left-align a value instead, pad an empty string out to whatever width is still needed (using Length) and write that padding before the next field:

sName := 'Ayesha';
sSurname := 'Pillay';
WriteLn(tFile, sName, ' ':10 - Length(sName), sSurname);   // surname always starts at column 11

To align decimal values so the decimal points line up under each other, use the Format function to first convert the number into a fixed-width string, then write that string with WriteLn.

WriteLn(tFile, Format('%10.2f', [rValue]));    // e.g. '     84.41'
WriteLn(tFile, Format('%12.2m', [rPrice]));   // e.g. '      R14.60'

Procedures & Functions Grade 11

User-defined procedures and functions let you break code into reusable, named blocks. This makes programs easier to read, maintain and debug.

What Is a Method?

A method is a named block of code that performs a specific task. Instead of writing the same instructions over and over inside your event handlers, you write them once, give that block a name, and then simply call that name whenever you need the task done. In Delphi we build methods in two forms: procedures and functions.

Why Do We Break Code Into Methods?

When you are starting out it can feel like extra work to split your program into little named blocks. But experienced programmers do it for very good reasons:

• DRY (Don't Repeat Yourself) – if the same instructions appear in three places and you copy-paste them, you now have to fix bugs in three places. Put them in one method and you fix it once.
• Readability – a well-named method like CalcAverage tells the reader exactly what is happening, far better than ten lines of arithmetic.
• Easier testing and debugging – you can test one small method on its own instead of hunting through a giant block of code.
• Reuse – once written, a method can be called from many different buttons and events.

What Is a Procedure?

A procedure is a named block of code that does a task but does not send a value back to where it was called. It simply carries out its instructions — showing a message, clearing some boxes, drawing on a canvas — and then control returns to the program.

Procedures

Without Parameters

// Declaration (above the event handlers)
procedure ShowHello;
begin
  ShowMessage('Hello!');
end;

// Calling it
procedure TForm1.btnShowClick(Sender: TObject);
begin
  ShowHello;   // called alone
end;

With Parameters

procedure DisplayGreeting(sMessage, sName: string);
begin
  ShowMessage(sMessage + ' ' + sName);
end;

// Call with arguments
DisplayGreeting('Good morning', 'Ms Coetzee');

Parameters vs Arguments

A parameter is a placeholder name listed in the method's declaration — it stands for a value the method will receive. An argument is the actual value you pass in when you call the method. In short: parameters live in the declaration; arguments are the real values you supply at the call.

Example: in DisplayGreeting(sMessage, sName: string) the names sMessage and sName are parameters. When you call DisplayGreeting('Good morning', 'Ms Coetzee'), the strings 'Good morning' and 'Ms Coetzee' are the arguments.

Value Parameters

A value parameter means the method receives a copy of the argument. The method can change that copy freely inside itself, but the original variable back in the calling code stays untouched. This is the default and safest kind of parameter, because the caller never has to worry about its variables being changed unexpectedly.

Reference (VAR) Parameters

A reference parameter — Delphi calls it a VAR parameter, marked with the keyword var in the declaration — doesn't hand the method a copy of anything. It points the method straight at the caller's own variable, so any change made inside the method sticks after the method finishes and control returns to the caller.

procedure DoubleIt(var iNum: Integer);
begin
  iNum := iNum * 2;   // changes the CALLER's variable directly
end;

// Call — no assignment needed, iScore itself is changed
DoubleIt(iScore);

Several of Delphi's own built-in procedures rely on VAR parameters to hand back a result without being functions — Inc and Dec are everyday examples:

Here iScore is the VAR parameter — it's the one actually overwritten with a new total — while iBonus (or iPenalty) is only ever a value parameter that Delphi reads once and then discards.

Returning More Than One Value

A function is limited to handing back a single value through Result. When a task genuinely needs to report back two or more separate pieces of information at once, write a procedure with more than one VAR parameter instead — each VAR parameter becomes its own "answer slot" that the procedure fills in, and every one of them is available to the caller as soon as the procedure finishes.

procedure CheckAttendance(iDaysPresent, iTotalDays: Integer; var bMeetsRule: Boolean; var sNote: string);
begin
  bMeetsRule := (iDaysPresent / iTotalDays) >= 0.8;
  if bMeetsRule then
    sNote := 'Meets the 80% attendance requirement.'
  else
    sNote := 'Below the 80% attendance requirement.';
end;

// Call — both bOk and sMsg are filled in by this one call
CheckAttendance(iPresent, iTotal, bOk, sMsg);
lblStatus.Caption := sMsg;

iDaysPresent and iTotalDays stay ordinary value parameters, since the procedure only needs to read them. bMeetsRule and sNote are VAR parameters, so after the call bOk holds whatever was assigned to bMeetsRule, and sMsg holds whatever was assigned to sNote — two results from one procedure call.

What Is a Function?

A function is a named block of code that does a task and then returns exactly one value back to where it was called. Inside the function you store the answer in the special variable Result, and that answer is handed back so you can use it — store it, display it, or calculate further with it.

Functions

Without Parameters

function GetAnswer: Integer;
begin
  Result := 42;
end;

// Must be assigned
iVal := GetAnswer;

With Parameters

In one line: function AddNumbers(num1, num2: Integer): Integer;

function AddNumbers(num1, num2: Integer): Integer;
begin
  Result := num1 + num2;
end;

// Call
iAnswer := AddNumbers(5, 3);          // = 8
lblResult.Caption := IntToStr(AddNumbers(iA, iB));

Function Example — Calculate Average

function CalcAverage(iTotal, iCount: Integer): Real;
begin
  if iCount = 0 then
    Result := 0
  else
    Result := iTotal / iCount;
end;

// Use it
rAvg := CalcAverage(iSum, iNumStudents);
lblAvg.Caption := FloatToStr(rAvg);

Procedures vs Functions

Local vs Global Variables

Where you declare a variable decides which parts of your program are allowed to see it. This is called the variable's scope.

• Local variable — declared inside a procedure or function's own var block (between the method header and its begin). It can only be used inside that method. As soon as the method ends, the variable and its value disappear.
• Global variable — declared at unit level, in the main var block near the top of the unit (below the form's type ... end; block, alongside Form1: TForm1;). It can be used and changed by any procedure or function in the whole program, and it keeps its value for as long as the program runs.

procedure TForm1.btnClick(Sender: TObject);
var
  sName   : string;    // local — only exists inside this procedure
  iNumber : Integer;
begin
  ...
end;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1   : TForm1;
  sName   : string;    // global — every procedure in this unit can see and change it
  iNumber : Integer;

Declaring a Method as Part of the Form's Class

Every procedure and function example so far has been a stand-alone routine, sitting in the unit above the event handlers. Delphi offers a second way to write your own methods: you can make a procedure or function part of the Form's own class, exactly like an event handler already is. To do this, add its declaration inside the Form's class(TForm) ... end; block — normally in the private section — and then write its full code down in the implementation section using the same TForm1.MethodName pattern you already recognise from event handlers.

type
  TForm1 = class(TForm)
    btnCalc: TButton;
    procedure btnCalcClick(Sender: TObject);
  private
    { Private declarations }
    procedure ShowAverage(iTotal, iCount: Integer);   // declaration
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

// definition — the class name TForm1 goes in front of the method name
procedure TForm1.ShowAverage(iTotal, iCount: Integer);
begin
  lblAverage.Caption := FloatToStr(iTotal / iCount);
end;

Both styles are valid Delphi and do exactly the same job. A stand-alone procedure is quick for a small helper needed in only one place; making a method part of the Form's class is the tidier choice once several event handlers need to share it, because every part of the Form's behaviour — its event handlers and its helper methods alike — is then declared together inside one class.

Passing an Array as a Parameter

An array can be passed into a procedure or function just like any other value — but Delphi won't let you type the array's size directly into a parameter list (writing something like arrScores: array[1..5] of Integer as a parameter is not allowed). Instead, declare the array as a named type above the Form's class first, and then use that type name wherever you need it — in the parameter list, and in any var block that needs a matching array.

type
  TQuizScores = array[1..5] of Integer;   // declared above the Form's class

  TForm1 = class(TForm)
    ...
  private
    function CalcTotal(arrScores: TQuizScores): Integer;
  public
    ...
  end;

implementation

function TForm1.CalcTotal(arrScores: TQuizScores): Integer;
var
  i, iSum: Integer;
begin
  iSum := 0;
  for i := 1 to 5 do
    iSum := iSum + arrScores[i];
  Result := iSum;
end;

Any variable declared with TQuizScores — for example arrQuiz1: TQuizScores; inside an event handler's own var block — can now be passed as the argument, because the variable and the parameter are built from the exact same named type.

Worked Example — Validate & Grade a Mark

A real button click usually calls several methods together. Here two functions (each returning a value) and one procedure (which just does a job) work as a team: one function checks the input is valid, another turns a mark into a symbol, and the procedure prints a line.

// FUNCTION — returns True/False (used to make a decision)
function IsValidMark(iMark: Integer): Boolean;
begin
  Result := (iMark >= 0) and (iMark <= 100);
end;

// FUNCTION — returns a string (used inside an expression)
function GetSymbol(iMark: Integer): string;
begin
  if iMark >= 80 then Result := 'A'
  else if iMark >= 70 then Result := 'B'
  else if iMark >= 60 then Result := 'C'
  else if iMark >= 50 then Result := 'D'
  else if iMark >= 40 then Result := 'E'
  else if iMark >= 30 then Result := 'F'
  else Result := 'G';
end;

// PROCEDURE — does a job, returns nothing
procedure TForm1.AddLine(sText: string);
begin
  memOut.Lines.Add(sText);
end;

// BUTTON — ties them together
procedure TForm1.btnProcessClick(Sender: TObject);
var
  iMark: Integer;
begin
  iMark := StrToInt(edtMark.Text);
  if IsValidMark(iMark) then              // function used AS the condition
    AddLine(IntToStr(iMark) + ' = symbol ' + GetSymbol(iMark))  // function inside an expression, then procedure prints
  else
    ShowMessage('Enter a mark between 0 and 100.');
end;

Why Use Procedures and Functions?

To bring it all together, here are the practical benefits you gain every time you reach for a method instead of writing one long block of code:

• Break large programs into manageable pieces
• Reuse code from multiple event handlers — no duplication
• Easier to find and fix bugs
• Easier to update — change in one place, works everywhere
• Each method should perform only one task

Databases in Delphi Grade 11

In Grade 11 you learn how to connect a Delphi program to a Microsoft Access database, display its data on screen, and add, edit or delete records using code — without SQL (SQL comes in Grade 12).

The Big Picture — How the Pieces Connect

Think of connecting to a database like setting up a water supply to a tap:

Understanding Each Component

TADOConnection — The Door to the Database

A TADOConnection is a non-visual Delphi component that establishes and manages the connection between your program and an external database file (such as a Microsoft Access .mdb file), using a connection string that specifies the file's location and the database provider (driver) to use.

ConnectionString  → Build... → Choose "Microsoft Jet 4.0 OLE DB Provider"
                             → Browse to your .mdb file
LoginPrompt       → False   (stops the "Enter password" popup appearing)

TADOTable — One Table from the Database

A database can have many tables (Students, Subjects, Classes…). A TADOTable represents one of those tables. You need one TADOTable for each table you want to work with.

Connection  → select your ADOConnection (dm.conDB)
TableName   → choose the table from the dropdown (e.g. "tblStudents")
Active      → True   (this "opens" the table so data loads)

TDataSource — The Go-Between

This is the part students find confusing. Why do we need it?

A TDataSource is a non-visual Delphi component that links a dataset (such as a TADOTable) to one or more data-aware controls — visual components, such as DBGrid, DBEdit or DBLabel, that are aware of and can display database data. You cannot connect a DBGrid directly to a TADOTable: every data-aware control must connect through a TDataSource.

DataSet → select your TADOTable (dm.tblStudents)

TDBGrid — The Table You See on Screen

The DBGrid is a component you drop onto your main form (not the Data Module). It displays the database records as rows and columns — just like a spreadsheet. It updates automatically as you navigate through records.

DataSource → select your TDataSource (dm.dsStudents)

Step-by-Step Setup

1. Create a Data Module: File → New → Data Module. Save it as DataModule_u.pas.
2. Drop TADOConnection onto the Data Module. Set up the connection string (browse to your .mdb file). Set LoginPrompt = False.
3. Drop TADOTable onto the Data Module. Set Connection to the ADOConnection. Set TableName. Set Active = True.
4. Drop TDataSource onto the Data Module. Set DataSet to the TADOTable.
5. On your main form: add the Data Module name to the uses clause at the top of your unit.
6. Drop TDBGrid onto your main form. Set its DataSource to the DataSource you created in the Data Module.
7. The grid should now show your database records!

Navigating Records

Think of records as pages in a book. These methods let you turn pages:

dm.tblStudents.First;                        // start at record 1
while not dm.tblStudents.Eof do           // keep going until past last
begin
  memOut.Lines.Add(dm.tblStudents['Name']); // do something with this record
  dm.tblStudents.Next;                       // move to next record
end;

Accessing Field Values in Code

Once connected, you can read the value of any field in the current record using this syntax:

variable := DataModuleName.TableName['FieldName'];

sName    := dm.tblStudents['Name'];        // reads the Name field
sSurname := dm.tblStudents['Surname'];    // reads the Surname field
iGrade   := dm.tblStudents['Grade'];      // reads the Grade field

// Display in a label
lblInfo.Caption := dm.tblStudents['Name'] + ' ' + dm.tblStudents['Surname'];

Dataset States

A TADOTable is always sitting in one of a small set of named states, and that state controls what you're allowed to do with the current record. You've actually been relying on these states already — calling Edit or Insert doesn't touch any data by itself, it just switches the dataset into a state where changing data is legal.

Inserting a New Record

Adding a new record is a 3-step process: prepare → fill in values → save.

dm.tblStudents.Insert;                    // Step 1: prepare a blank new record
dm.tblStudents['Name']    := edtName.Text;     // Step 2: fill in the fields
dm.tblStudents['Surname'] := edtSurname.Text;
dm.tblStudents['Grade']   := sedGrade.Value;
dm.tblStudents.Post;                      // Step 3: save to the database

function GetNewStudentNo: Integer;
var
  iLargest : Integer;
begin
  dm.tblStudents.First;
  iLargest := 0;
  while not dm.tblStudents.Eof do
  begin
    if dm.tblStudents['StudentNo'] > iLargest then
      iLargest := dm.tblStudents['StudentNo'];
    dm.tblStudents.Next;
  end;
  Result := iLargest + 1;
end;

Editing an Existing Record

// First navigate to the record you want to change, then:
dm.tblStudents.Edit;                      // Step 1: put the record into edit mode
dm.tblStudents['Grade'] := 12;            // Step 2: change the value
dm.tblStudents.Post;                      // Step 3: save the change

Deleting a Record

// Navigate to the record first, then:
dm.tblStudents.Delete;   // removes the current record permanently

Changing a Field for All Records at Once

Some tasks need to touch every record in a table, not just one — for example handing out 5 bonus marks to every student, or applying a fee discount to a whole grade. This is really the same "loop through all records" pattern used earlier, just with an Edit / Post pair added inside it:

dm.tblStudents.First;
dm.tblStudents.DisableControls;      // stop the DBGrid refreshing on every single record
while not dm.tblStudents.Eof do
begin
  dm.tblStudents.Edit;
  dm.tblStudents['Mark'] := dm.tblStudents['Mark'] + 5;
  dm.tblStudents.Post;
  dm.tblStudents.Next;
end;
dm.tblStudents.First;
dm.tblStudents.EnableControls;       // switch the grid's updates back on

Searching for a Record

To find a specific record, loop through all records and check each one:

dm.tblStudents.First;
while not dm.tblStudents.Eof do
begin
  if dm.tblStudents['Surname'] = edtSearch.Text then
  begin
    ShowMessage('Found: ' + dm.tblStudents['Name']);
    Break;   // stop searching once found
  end;
  dm.tblStudents.Next;
end;

Filtering Records

A TADOTable can also show only the records that match a condition, without writing any SQL. Set Filter to a condition string, then set Filtered to True to apply it.

dm.tblStudents.Filter := 'Grade = 11';         // only Grade 11 records
dm.tblStudents.Filtered := True;               // switch the filter on
...
dm.tblStudents.Filtered := False;              // switch it off again — shows all records

Sorting Records

dm.tblStudents.Sort := 'Surname ASC';         // A to Z by surname
dm.tblStudents.Sort := 'Mark DESC';           // highest mark first
dm.tblStudents.Sort := 'Grade ASC, Surname ASC'; // by grade, then surname

Complete Example — Finding the Highest Mark

var
  iHighest : Integer;
  sTopName : String;
begin
  iHighest := 0;
  sTopName := '';
  dm.tblStudents.First;
  while not dm.tblStudents.Eof do
  begin
    if dm.tblStudents['Mark'] > iHighest then
    begin
      iHighest := dm.tblStudents['Mark'];
      sTopName := dm.tblStudents['Name'];
    end;
    dm.tblStudents.Next;
  end;
  lblResult.Caption := sTopName + ' scored the highest: ' + IntToStr(iHighest);
end;

Editing Records Without Code — Data-Aware Controls

Everything else on this page shows how to insert, edit and delete records using code. Delphi also provides data-aware controls that let a user browse and change records directly on the Form, with no code at all.

TDBNavigator — A Toolbar for the Dataset

A TDBNavigator (from the Data Controls tab) is a data-aware control with a row of buttons for moving through and maintaining a dataset. Set its DataSource property the same way you would for a DBGrid.

DBEdit, DBText and DBCheckBox — Single-Field Controls

Sometimes a full grid is more than you need — you might just want one field of the current record shown somewhere on the Form, such as a name next to a photo. Each of these controls links to exactly one field, using the same two properties:

DataSource → select your TDataSource (dm.dsStudents)
DataField  → choose the field from the dropdown (e.g. "Surname")

Delphi doesn't write a change to the table the instant it's made — it sits in a buffer until something posts it. That happens automatically the moment the user moves to a different record, or you can trigger it sooner yourself, either in code or via a DBNavigator's Post button.

Connecting a Database Dynamically (in Code)

Everything above used components dropped onto a Data Module at design time. You can also build the whole connection at runtime with code — no components needed. This is called a dynamic connection, and it is useful when the database path is only known while the program runs (e.g. the user browses to the file).

Declare the three objects (usually under public in the Data Module, or in the form):

public
  conDB  : TADOConnection;
  tblStudents : TADOTable;
  dsStudents  : TDataSource;

Create and wire them together — build the connection string, point the table at the connection, then link the DataSource:

procedure TdmData.DataModuleCreate(Sender: TObject);
begin
  // 1. Create the connection object
  conDB := TADOConnection.Create(Self);
  conDB.LoginPrompt := False;        // don't ask for a password
  conDB.ConnectionString :=
    'Provider=Microsoft.Jet.OLEDB.4.0;' +
    'Data Source=' + ExtractFilePath(Application.ExeName) + 'Students.mdb;';
  conDB.Connected := True;

  // 2. Create the table and link it to the connection
  tblStudents := TADOTable.Create(Self);
  tblStudents.Connection := conDB;
  tblStudents.TableName  := 'tblStudents';
  tblStudents.Active      := True;

  // 3. Create the DataSource and link it to the table
  dsStudents := TDataSource.Create(Self);
  dsStudents.DataSet := tblStudents;
end;

Finally, link your on-screen TDBGrid to the DataSource. Do this in the main form's OnShow event:

procedure TfrmMain.FormShow(Sender: TObject);
begin
  dbgStudents.DataSource := dmData.dsStudents;
end;

Motherboard & Hardware Grade 11

A deeper look at what is inside the system unit — the motherboard, its components, buses, expansion cards, and how data flows between parts.

The Motherboard

The motherboard is a large printed circuit board that connects and provides power to all hardware components. It is the central hub of the computer.

Key Motherboard Components

BIOS Functions

• Performs the POST (Power-On Self-Test) — checks RAM, keyboard, storage
• Identifies and initialises hardware devices
• Locates the bootloader and hands control to the OS
• Provides low-level system settings

Motherboard Buses

A bus is a set of wires that transfers data between components.

Bus vs Point-to-Point Connections

Not every connection on the motherboard is a shared bus. A bus is a shared pathway — several devices can use the same lines to send and receive data (e.g. multiple USB devices sharing one USB controller). A point-to-point connection is a direct, dedicated link between exactly two components, with no other device sharing the line — this makes it faster and more efficient because there is no waiting for the line to be free.

Expansion Cards

An expansion card plugs into a PCI or PCIe slot to add extra functionality that the motherboard does not already provide.

Data Flow Between Components

Storage → RAM → CPU: Data is loaded from slow storage into fast RAM, then the CPU fetches from RAM for processing.

RAM → VRAM → GPU: Graphics data is moved from RAM to VRAM so the GPU can render images without burdening the CPU.

Cache Memory

Cache is a very small, very fast memory located close to (or inside) the CPU. It stores frequently used instructions so the CPU does not have to wait for slower RAM.

Types of Caching

Caching means keeping a copy of frequently used data somewhere faster to fetch it from. It happens at several levels of a computer system:

Modular Design

Motherboards use a modular design — individual components (RAM, CPU, GPU) can be upgraded or replaced without replacing the whole computer.

Processing Techniques Grade 11

Modern computers can execute multiple tasks simultaneously using multitasking, multithreading and multiprocessing. This page also covers operating-system types, virtual memory, compilers and interpreters.

Types of Operating Systems

You met the main operating-system (OS) types in Grade 10 — stand-alone (desktop), network/server, embedded and mobile. In Grade 11 you must be able to compare them in terms of cost, size, hardware needed and platform.

Processing Techniques (T1)

A processing technique is a method the operating system and CPU use to handle more than one job at a time so the computer feels fast and responsive. In the early days a computer could only do one thing from start to finish before moving on. Today we expect to type an email, listen to music and download a file all at once — and these techniques are what make that possible.

Why Do We Need This?

A CPU is incredibly fast, but a human is slow. While you pause to think about your next sentence, the CPU is sitting idle for millions of cycles. Processing techniques let the computer fill those gaps with other work, so no time is wasted and every program feels like it is running "at the same time".

• Multitasking – running several programs at once by switching rapidly between them. Only one task truly runs at any instant, but the switching is so quick it feels simultaneous.
• Multithreading – splitting a single program into smaller "threads" that progress together, so one slow part (like a download) does not freeze the rest of the program.
• Multiprocessing – using two or more CPU cores to genuinely execute different tasks at the same time. This is real parallelism, not an illusion.

Note: The key difference to remember is that multitasking and multithreading share one processor by taking turns, while multiprocessing uses multiple processors to do work truly at the same moment.

Virtual Memory

Virtual memory is storage space on the hard drive that the operating system uses as if it were extra RAM. When the real RAM fills up, the OS borrows a slice of the much larger (but much slower) hard drive to keep programs running instead of crashing.

Why Do We Need This?

RAM is expensive and limited. Without virtual memory, the moment your RAM filled up the computer would simply refuse to open the next program. Virtual memory acts as a safety valve so you can keep working even when memory is tight.

When RAM is full, the OS uses a section of the hard drive as temporary RAM — called virtual memory.

• Programs not currently in use are swapped from RAM to virtual memory
• When needed again, they are swapped back into RAM
• Allows more programs to run than physical RAM would normally allow
• Much slower than real RAM — heavy use causes thrashing (performance crash)

Thrashing is what happens when the computer spends more time swapping data back and forth between RAM and virtual memory than it spends doing actual useful work. The hard drive light stays on constantly, the mouse stutters, and everything slows to a crawl. In our desk analogy, thrashing is when your desk is so small that you are constantly running to the filing cabinet and back, never getting anything done.

Solutions when thrashing occurs:

• Close unnecessary background apps
• Increase physical RAM
• Upgrade to 64-bit OS
• Install smaller, lighter alternative programs in place of large ones, where possible

Compilers vs Interpreters

Computers only understand machine code (binary 1s and 0s), but humans write in readable programming languages. A translator is needed to bridge that gap. There are two main kinds, and the difference is all about when the translation happens.

• Compiler – a translator that converts the entire source code into machine code in one go, before the program ever runs, producing a standalone executable file.
• Interpreter – a translator that reads and runs the code one line at a time, translating each line just as it is about to be executed.

Virtualisation

Virtualisation is the technique of using software to create a "virtual" computer — called a virtual machine — that runs inside your real computer as if it were a separate physical machine with its own operating system.

Why Do We Need This?

One powerful computer can be split into several virtual machines, so a single server can do the work of many. This saves money, electricity and space, and lets you safely test risky software in a sealed-off environment without endangering your real system.

Example: Running Windows on a Mac, or a single cloud server hosting dozens of separate websites, each in its own virtual machine.

Why Use a Virtual Machine?

• Try a new OS safely — test an operating system like Ubuntu without installing it directly on your real computer.
• Test risky software — install a program you are not sure is safe. If it turns out to contain malware, you simply delete the whole virtual machine and your real computer is untouched.
• Backup and transfer — the image of a virtual hard drive can be used to back up a system, or move all its data and settings onto a new physical computer.
• Cross-platform app development — mobile developers can test an app on many different versions of Android and iOS using virtual machines, instead of buying hundreds of physical devices.

Programming Languages

Types of Errors

Database Management Grade 11

A database is like a highly organised digital filing cabinet — instead of papers stuffed into folders, your data is stored in neat tables with rows and columns, so you can find, sort and filter it in seconds. A DBMS (Database Management System) is the software that manages it all.

Key Terms

Common DBMS Software

Database Types by Usage

Database Careers

• DBA (Database Administrator) — maintains security, backups, performance tuning
• Database Programmer / Developer — writes queries, stored procedures, applications
• Database Analyst — designs structure, models relationships, plans migrations
• Data Scientist — analyses large datasets to find patterns and insights
• Project Manager — manages database projects, budgets and teams

What a Database Table Looks Like

A table in a database looks exactly like a spreadsheet grid. The table has a name, column headers (fields), and rows of data (records).

Primary Key vs Foreign Key

Keys are what make databases powerful — they link tables together so you do not repeat data.

Entity Relationship Diagram (ERD)

An ERD shows the tables in a database and how they are related. The line between tables shows the type of relationship (one-to-many, etc.).

Database Field Data Types

Each field in a table has a data type that controls what kind of data can be stored.

Metadata

Metadata is "data about data" — information that describes other data, rather than being the actual content itself. It helps you organise, categorise, search and correctly interpret data.

Table Relationships

Data Quality Characteristics

Data quality means the data is fit for purpose. Poor quality data leads to wrong decisions.

Data Integrity

Data integrity ensures data is accurate, consistent and reliable over its entire lifetime.

• Physical integrity — protection from hardware failure using RAID, backups, and UPS.
• Logical integrity — data follows rules: input validation, referential integrity, access control.
• Referential integrity — a FK value must exist as a PK in the related table (no orphan records).

Validation Types

Validation checks that data entered is reasonable and in the correct format — it does not check if data is true, just if it is acceptable.

Manual vs Electronic Methods

Data doesn't have to live in a computer database — it can also be recorded and processed by hand. Comparing the two shows why databases and DBMS software are so valuable.

Creating and Maintaining a Database

Setting up a working database is a process, not a single step:

1. Design the table — decide the purpose (e.g. track student information), the fields (columns) needed, and set a primary key (e.g. StudentID) so every record is unique.
2. Insert / import data — add records manually through a form (e.g. an MS Access form), or import them in bulk from a spreadsheet or CSV file.
3. Edit / update data — correct mistakes or update values as information changes (e.g. a learner moves up a grade).
4. Delete data — remove records that are no longer needed or were entered incorrectly.

Processing Data: Sort, Query, Filter, Report

Once data is stored, a DBMS lets you turn it into useful information in several ways:

Networks & Protocols Grade 11

Building on Grade 10 networks — this page covers topologies, network devices in depth, protocols, VoIP, VPN and acceptable use.

Network Topologies

A network topology is the layout or "shape" of a network — it describes how the computers and devices are physically or logically arranged and connected to one another. The topology you choose affects how easy the network is to set up, how it copes with a fault, and how easy it is to add new devices later.

Star Topology

In a star topology every device connects to one central point — usually a switch. Nothing connects directly to anything else; all traffic passes through the middle.

Ring Topology in Detail

In a ring topology, every device connects to exactly two neighbours, forming a closed loop. Data travels in a single direction around the ring, passing through each device in turn — every node acts as a repeater, regenerating the signal and passing it on to the next node until it reaches its destination.

Thin vs Thick Client

Key Protocols

VoIP

Voice over Internet Protocol allows phone/video calls using the Internet instead of traditional phone lines.

Your voice is broken into tiny digital packets, sent across the internet just like any other data, and reassembled at the other end. Because it rides on your existing internet connection, calls to other VoIP users are usually free no matter how far away they are — which makes it far cheaper than a traditional long-distance phone call.

• Examples: WhatsApp calls, Skype, Discord, Zoom
• Requires: stable internet, low latency, sufficient bandwidth

VPN

A Virtual Private Network creates an encrypted "tunnel" over the Internet.

• Allows remote users to access a private network securely
• Hides IP address and encrypts all data in transit
• Used by companies for remote workers

Internet vs Intranet vs Extranet

Acceptable Use Policies (AUP)

Rules governing how ICT resources may be used in an organisation. Key rules:

• No downloading illegal content
• Use computers for educational/work purposes
• No cyberbullying or harassment
• Respect copyright laws

Mobile Technology Grade 11

Mobile devices have transformed communication and computing. This page covers smartphones, tablets, wireless technologies, and location-based services.

What Is Mobile Technology (T2)?

Mobile technology is any portable, wireless technology that lets you communicate, compute and access information while on the move, without being tied to a desk or a cable. The key idea is mobility: the device travels with you, connects wirelessly, and runs off its own battery.

In South Africa mobile technology is especially important. Many people first reach the internet not through a desktop PC but through a smartphone, because data on a phone is often cheaper and more accessible than a fixed-line connection at home. This makes the smartphone the main computer in millions of households.

Common Mobile Devices Explained

• Smartphone – a pocket-sized computer that combines a phone, camera, GPS, web browser and thousands of apps. It connects through Wi-Fi and the cellular network and is by far the most common mobile device in South Africa. Its key feature is a connection to an app store — a centralised portal where users search for and download software applications.
• Feature phone – a step between a basic mobile phone and a smartphone. It can send multimedia messages, play music, take photos and browse the internet in a limited way, but unlike a smartphone it does not run a full mobile OS or third-party apps — it comes with extra features rather than functioning as a true pocket computer.
• Tablet – a larger touchscreen device, ideal for reading, watching media and light productivity. The bigger screen makes it more comfortable than a phone, but it is less pocket-friendly.
• Phablet – a device between a smartphone and a tablet (screen roughly 5.5"–7"), offering a bigger display while remaining somewhat portable.
• Wearables – devices worn on the body, such as smartwatches and fitness bands. They track health data like heart rate and steps, and show notifications from your phone.
• Smart camera – a digital camera with a built-in operating system (often Android), touchscreen, on-device image processing and Wi-Fi, so photos can be edited and shared straight from the camera or sent wirelessly to a phone.
• GPS – the Global Positioning System uses signals from satellites to work out exactly where a device is on Earth, which is what powers navigation apps.
• Bluetooth – a short-range wireless technology (about 10m) used to connect devices to each other, such as wireless earphones, keyboards or a car's hands-free system.
• Wi-Fi – a wireless technology that connects devices to the internet through a router or hotspot over a medium range, usually inside a home, school or office.
• 4G and 5G – generations of mobile cellular internet. 4G gave us reliable mobile browsing and video; 5G is far faster and more responsive, enabling things like real-time video and large numbers of connected smart devices.

Advantages and Limitations of Mobile Technology (T2)

Advantages – you can work, bank, learn and communicate from anywhere; devices are convenient and always with you; and a single phone replaces many separate gadgets (camera, torch, calculator, GPS).

Limitations – small screens and keyboards are harder to work on for long periods; battery life is limited; mobile data can be expensive in South Africa; and the constant connection raises privacy, security and "always-on" distraction concerns.

Mobile Device Types

Wireless Technologies

Location-Based Computing (LBC)

Software that uses your device's location (via GPS, Wi-Fi, cellular) to provide customised services.

Examples

• Weather apps showing your local forecast
• Uber/Bolt finding the nearest driver
• Food delivery apps delivering to your address
• Google Maps navigation

Social Implications of LBC

Connection Speed — Shaping and Throttling

• Shaping — ISP prioritises certain traffic types (e.g. video gets priority over downloads)
• Throttling — ISP intentionally slows your speed after you exceed a data cap

Computer Management Grade 11

Safeguarding a computer system requires understanding threats, knowing how malware works, and applying the right remedies.

Human Error Threats

• Sharing sensitive information with wrong people
• Writing down or reusing passwords
• Clicking links without verifying them
• Leaving devices unlocked / unattended
• Accidentally deleting valuable data
• Entering incorrect data — GIGO ("Garbage In, Garbage Out"): if the input is wrong, the output will be wrong too

Physical Threats

• Theft of devices or storage media
• Hard drive mechanical failure (moving parts)
• Power surges or outages damaging hardware
• Water/liquid spills causing short circuits

Malware

Network Vulnerabilities

Remedies and Protection

Reasons for Data Loss

Data loss occurs when files become unavailable, corrupted or destroyed. Knowing why data is lost helps you choose the right safeguard for each cause.

Backups

Backup Locations

• Local — external HDD at same location (fast, but vulnerable to fire/theft)
• Off-site — physical device at another location (protects against local disaster)
• Cloud — Google Drive, OneDrive (automatic, accessible anywhere)

E-Communications Grade 11

Mobile and wireless communication forms — blogs, podcasts, VoIP, instant messaging, video conferencing and webinars.

What Are E-Communications?

E-communication (electronic communication) is any way of sending and receiving information using electronic devices and the internet, instead of paper or face-to-face talking. It covers everything from a short WhatsApp message to a live video meeting with people on different continents.

The Communication Forms Explained

• Blogging – a blog is a regularly updated online journal where one person or organisation publishes articles ("posts"), with the newest post at the top. It is mostly one-way: the author writes, readers read. Think of it as a public diary anyone can visit.
• Microblogging – the same idea as blogging but with very short posts, like on X (Twitter). It is designed for quick, frequent updates shared with followers rather than long articles.
• SMS – a Short Message Service text message sent over the cellular network. Its great strength is that it needs no internet, which is why banks still use it for one-time PINs.
• Instant Messaging (IM) – real-time text and media chat over the internet, such as WhatsApp. Messages arrive instantly and you can chat one-on-one or in groups.
• VoIP – Voice over Internet Protocol carries your voice (and video) over the internet instead of the old telephone network, so calls between VoIP users are usually free.
• Video Conferencing – a live meeting where several people see and hear each other on video at the same time, such as on Zoom or Teams. Because you can see faces, it captures nonverbal cues that a phone call cannot.
• Vlogging / Videocasting – like blogging, but the "posts" are videos instead of text, published regularly to a channel such as YouTube or TikTok. It can be pre-recorded or streamed live.
• Webinar – short for "web seminar": a live, structured online presentation to an audience, usually with interactive features like polls and a Q&A session. Unlike an informal video call, it typically has a host presenting to many attendees.
• Podcasting – an audio series you can download and listen to offline, like a radio show on demand. Listeners subscribe and new episodes arrive automatically.

Mobile/Wireless E-Communication Forms

Synchronous vs Asynchronous Communication

E-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).

Advantages and Disadvantages of Key Forms

Instant Messaging

Video Conferencing

VoIP Requirements

• Stable, high-speed internet connection
• Low latency (minimal delay)
• Sufficient bandwidth for voice/video packets
• Microphone and speakers/headset

Types of Email Accounts

Not all email addresses come from the same place. Where your account is hosted affects how you access it and what happens if you switch internet providers.

Data Security in E-Communications

Because e-communications travel across networks that strangers also use, keeping your messages private and your accounts safe is essential. A few key ideas help here: HTTPS encrypts the link between your browser and a website; end-to-end encryption scrambles a message so that only the sender and the intended receiver can read it — not even the service in the middle; and multi-factor authentication (MFA) adds a second proof of identity (like a code on your phone) on top of your password, so a stolen password alone is not enough to break in.

• Use HTTPS for all web communication
• End-to-end encryption (only sender and receiver can read)
• Strong, unique passwords per account
• Multi-factor authentication (MFA)
• Avoid public Wi-Fi for sensitive communications

Internet & Multimedia Grade 11

The evolution of the web, Big Data concepts, streaming vs downloading, multimedia formats and compression technologies.

Evolution of the Web

Big Data Concepts

Big Data refers to extremely large and complex datasets that traditional software cannot process effectively.

The 3 Vs of Big Data

Uses of Big Data

• Healthcare: predict patient risk and personalise treatment
• Retail: recommend products based on browsing and purchase history
• Banking: detect fraud in real time
• Government: optimise traffic, predict crime

Multimedia on the Internet

Download vs Streaming

Live Broadcasts

Content streamed in real time as it happens — no pre-recording. Examples: live sport, news, gaming streams, webinars, online concerts.

VOD and IPTV

• VOD (Video on Demand): watch any content at any time — Netflix, Showmax, Disney+
• IPTV: TV over the internet; allows pausing live TV, time-shifting, catch-up TV

Compression Technology

Compression reduces file size to speed up transfer and save storage. The trade-off: higher compression = smaller file but lower quality.

Internet Services Grade 11

Types of websites, supporting web technologies, security services, and internet-related careers.

Internet Services

An internet service is any facility the internet provides that lets people find, share, communicate or transact online — from browsing websites to streaming video to online banking. The websites you visit are the most visible internet service, and they come in many types depending on their purpose.

Types of Websites

Online Services

Beyond browsing websites, the internet lets you carry out real transactions and access services that used to require visiting somewhere in person.

• Online / internet banking — checking balances, making payments (EFT) and transferring money through a bank's website or app, e.g. FNB App, Capitec app
• Online bookings and reservations — tickets, hotels, flights, restaurant tables, e.g. Webtickets, Booking.com
• E-learning — digital learning platforms for lessons, assessments and resources, e.g. Siyavula, Google Classroom

Static vs Dynamic Websites

Not all websites are built the same way. A static website shows the same fixed pages to everyone, and only changes when the developer manually edits the HTML files. A dynamic website builds its pages on the spot, pulling fresh content out of a database every time you visit, so what you see can differ from what the next person sees.

HTTP vs HTTPS

HTTP (HyperText Transfer Protocol) is the set of rules browsers and web servers use to send web pages to each other. HTTPS is the same protocol with an added layer of security (the "S" stands for Secure) that encrypts the data so nobody can read it while it travels across the internet.

Why Does the "S" Matter?

When you log in to your bank or type in your password, that information passes through many computers on its way across the internet. With plain HTTP, anyone who intercepts it can read it. HTTPS scrambles it into nonsense that only the destination can unlock.

Security Services

Multi-Factor Authentication (MFA)

Requires more than one proof of identity. Examples: password + SMS code; password + fingerprint.

• Advantages: much harder for attackers to access accounts
• Limitations: requires additional device; SMS can be intercepted

One-Time PIN (OTP)

A code sent to your device, valid for one login only. Prevents replay attacks even if code is intercepted later.

Security Token

A hardware device or app that generates a new code every 30–60 seconds. More secure than SMS-based OTPs.

Internet-Related Careers

Social Implications Grade 11

The impact of technology on society — covering IoT, Big Data, the Fourth Industrial Revolution, cybercrime, and digital ethics.

Digitalisation and the 4IR

The Gig Economy

The gig economy is a labour market built on short-term, flexible jobs or "gigs" (freelance or on-demand work) rather than permanent employment, usually arranged through online platforms.

• Examples: Uber/Bolt drivers, Mr D and other food-delivery couriers, freelancers on Fiverr or Upwork.
• Advantages: flexible hours, work from anywhere, an easy source of extra income.
• Disadvantages: no job security, no benefits (paid leave, medical aid, pension), and an unpredictable income.

Blockchain

A distributed digital ledger where data is stored in linked, tamper-resistant "blocks".

• Decentralised — no single owner
• Highly secure — changing one block breaks the chain
• Used for: cryptocurrency (Bitcoin), smart contracts, supply chain tracking

Cybercrime

Internet of Things (IoT)

A network of physical devices embedded with sensors and internet connectivity that collect and exchange data automatically.

Big Data

Extremely large and complex datasets that traditional software cannot handle. Characteristics: Volume, Velocity, Variety.

• Healthcare: track vitals, predict illnesses
• Marketing: personalised advertising
• Banking: fraud detection
• Risk: privacy erosion, data breaches, discrimination

Crowdsourcing

Crowdsourcing is getting ideas, content, services or funding by asking a large group of people (the "crowd"), usually online, rather than from traditional employees or suppliers. The internet makes it possible to reach huge numbers of contributors quickly.

Benefit: taps into a wide range of skills and ideas cheaply and quickly. Risk: contributions may be inaccurate, biased or unverified.

Privacy: Advantages & Disadvantages

Privacy is your right to control what personal information is collected about you and how it is used. Technology constantly gathers data — what you browse, buy, watch and where you go — which brings real convenience but also serious risks. In an exam you must be able to argue both sides.

Protecting Your Privacy

• Adjust privacy settings on social media and apps
• Limit the personal information you share online
• Review app permissions (location, camera, contacts)
• Use strong, unique passwords and 2FA
• Know your rights under POPIA — SA law protecting personal information

Digital Footprint

The trail of data you leave online. Active: data you intentionally share (posts, forms). Passive: data collected without your knowledge (cookies, browsing history).

Implications: affects reputation, privacy, can be used by employers or cybercriminals.

Grade 11 — Year Planner Grade 11

Based on the 2026 IT CAPS. Grade 11 introduces 1D arrays, text files, user-defined methods and databases. Note: SQL, OOP and 2D Arrays are Grade 12 topics.

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