Why is "Using = for assignment, e.g. writing Sum = First + Second instead of Sum ← First + Second." a common mistake in Programming Basics?

Why it happens: Many real languages (and everyday maths) use = to assign, so students carry the habit into Cambridge pseudocode. How to avoid it: In 9618 pseudocode, assignment is always the arrow ←. The symbol = is reserved for comparison ('is equal to'). Read ← out loud as 'becomes'. Source: Examiner reports note marks lost when assignment is shown with = rather than the ← operator.

Why is "Declaring a constant as if it were a variable, e.g. DECLARE Pi : REAL then Pi ← 3.14, or CONSTANT Pi : REAL." a common mistake in Programming Basics?

Why it happens: Students apply the variable DECLARE pattern to constants out of habit. How to avoid it: A constant is written in one line with its value: CONSTANT Pi = 3.14. No data type and no separate assignment are used.

Why is "Confusing / with DIV (and forgetting MOD), e.g. using / when the design needs the whole-number quotient." a common mistake in Programming Basics?

Why it happens: All three look like division, so students reach for the most familiar symbol /. How to avoid it: Use / for ordinary (real) division that keeps decimals, DIV for the whole-number quotient, and MOD for the remainder. Check whether the answer should have a decimal part.

Why is "Choosing the wrong data type — e.g. declaring a price or average as INTEGER, which loses the decimal part." a common mistake in Programming Basics?

Why it happens: Students default to INTEGER for any number without thinking about whether fractions are needed. How to avoid it: Ask: can this value have a fractional part? Money, averages and measurements need REAL; counts and quantities use INTEGER.

Why is "Using OR when both conditions must be true (or AND when only one must be), e.g. for a range check 0 to 100." a common mistake in Programming Basics?

Why it happens: Everyday English uses 'and'/'or' loosely, so students don't map them precisely to AND/OR. How to avoid it: If ALL conditions must hold, use AND. If ANY one is enough, use OR. A range like 0–100 needs (Score >= 0) AND (Score <= 100).

Why is "Outputting a bare value with no message, or writing the message text without quotation marks, e.g. OUTPUT Total instead of OUTPUT 'Total: ', Total (with the text in quotes)." a common mistake in Programming Basics?

Why it happens: Students focus on the calculation and treat the OUTPUT as an afterthought, or forget that text must be in quotation marks. How to avoid it: Always quote literal text ("...") and join it to the value with a comma or the & operator. The question usually asks for a 'suitable' or 'clear' message — a bare number can lose the output mark.

Cambridge International A Levels Computer Science (9618)

Programming Basics

Q: Why is "Outputting a bare value with no message, or writing the message text without quotation marks, e.g. OUTPUT Total instead of OUTPUT 'Total: ', Total (with the text in quotes)." a common mistake in Programming Basics?

Why it happens: Students focus on the calculation and treat the OUTPUT as an afterthought, or forget that text must be in quotation marks. How to avoid it: Always quote literal text ("...") and join it to the value with a comma or the & operator. The question usually asks for a 'suitable' or 'clear' message — a bare number can lose the output mark.

0% Complete

Detailed Study Notes

Detailed notes on Programming for Cambridge International A Levels Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Programming Basics — Cambridge AS & A Level Computer Science 9618 Study Notes (2027-2029)

The building blocks of every program written in Cambridge pseudocode: constants and variables, data types, assignment, expressions using arithmetic and logical operators, reading input and writing output, and calling built-in functions. You also learn to turn a design — a program flowchart or structured English — into correct pseudocode for Paper 2. No calculator is allowed, so every value is reasoned by hand.

At a glance

A variable can change; a constant is fixed — CONSTANT Pi = 3.14.
Declare variables with a data type: DECLARE Count : INTEGER.
Common types: INTEGER, REAL, CHAR, STRING, BOOLEAN.
Assignment uses the arrow ← ('becomes'); = is only for comparison.
Arithmetic: + − * /, plus DIV (integer quotient) and MOD (remainder).
Logical: AND OR NOT; comparison: = <> < > <= >=.
INPUT reads from the keyboard; OUTPUT writes to the screen; join text with & or commas.
Built-in functions (LENGTH, LEFT, UCASE…) are provided in the exam — call them, don't memorise them.
You must convert a flowchart or structured English design into pseudocode.

What you’ll learn

Mapped to the Cambridge International A Level 9618 syllabus (2027-2029).

11.1 — Write pseudocode to declare and initialise a constant.
11.1 — Write pseudocode to declare a variable with an appropriate data type.
11.1 — Write pseudocode for the assignment of a value to a variable.
11.1 — Write expressions using arithmetic, logical and comparison operators.
11.1 — Write pseudocode for input from the keyboard (INPUT) and output to the console (OUTPUT).
11.1 — Use built-in functions and library routines (any non-guide functions are provided; string functions are always given).
11.1 — Write program code (pseudocode) corresponding to a given design (program flowchart or structured English).

Variables and constants

A variable is a labelled box whose contents can change; a constant is fixed for the whole run.

A variable is best pictured as a labelled box in memory. The label is the variable's name and the contents are its current value, which can change as the program runs.

You bring a variable into existence with a DECLARE statement that gives its name and its data type:

DECLARE Count : INTEGER
DECLARE Average : REAL
DECLARE Name : STRING

A constant is a value you fix when you write the program and that cannot change while it runs. It is declared on one line, with its value, using CONSTANT — there is no data type and no separate assignment:

CONSTANT Pi = 3.14
CONSTANT TaxRate = 0.07

Why bother with a constant rather than just typing the number? Because it gives the value a meaningful name, defines it in one place, and stops it being changed by accident. If the tax rate ever changes, you edit a single line.

Variable = labelled box; its value can change.
DECLARE Name : Type introduces a variable.
Constant = fixed value, set once: CONSTANT Pi = 3.14.
Constants improve readability and are changed in one place.

See the full worked example for programming basics →

Data types, initialisation and assignment

Pick the type that matches the value; use ← to store a value in a variable.

Every variable has a data type that says what kind of value it can hold. The 9618 types you need are:

Data type	Holds	Example value
INTEGER	a whole number	42, −7
REAL	a number with a fractional part	3.14, 12.50
CHAR	a single character	'A', '?'
STRING	text (zero or more characters)	"Aisha"
BOOLEAN	a truth value	TRUE, FALSE

Choosing the right type matters: a price or an average needs REAL (so the decimals survive); a count of items needs INTEGER.

Assignment stores a value in a variable using the arrow ← (read it as 'becomes'). The right-hand side is worked out first, then the result is placed in the variable on the left:

Total ← 0                // initialisation: a starting value
Total ← Price + Delivery // expression evaluated, then stored
Count ← Count + 1        // take Count, add 1, store it back

Initialisation is simply the first assignment that gives a variable its starting value — for example setting a running total or counter to 0 before a loop. The symbol = is NOT used for assignment in 9618 — it means 'is equal to' (a comparison). Mixing them up is the single most common slip in this topic.

Types: INTEGER, REAL, CHAR, STRING, BOOLEAN.
REAL for money/averages/measurements; INTEGER for counts.
Assignment uses ← ('becomes'); evaluate the right, store on the left.
Initialisation = the first value given to a variable (e.g. Total ← 0).

See the full worked example for programming basics →

Expressions and operators

Combine values with arithmetic, comparison and logical operators to compute a result.

An expression is anything the computer evaluates to a single value. Expressions are built from three families of operators.

Arithmetic operators (give a number):

Operator	Meaning	Example
+ − *	add, subtract, multiply	4 * 3 = 12
/	real division (keeps decimals)	7 / 2 = 3.5
DIV	integer quotient (whole part)	17 DIV 5 = 3
MOD	remainder	17 MOD 5 = 2

Comparison operators (give TRUE/FALSE): = (equal), <> (not equal), <, >, <=, >=.

Logical operators (combine TRUE/FALSE values): AND (both true), OR (at least one true), NOT (reverse).

Area    ← Length * Width
Minutes ← Seconds DIV 60
InRange ← (Score >= 0) AND (Score <= 100)

A handy mental model for DIV and MOD is the bus problem: 45 people, 10 seats per bus. You need 45 DIV 10 = 4 full buses, and 45 MOD 10 = 5 people left over.

Use brackets to make the order of evaluation clear and correct — for a range check, brackets around each comparison keep the meaning obvious.

Arithmetic: + − * / plus DIV (quotient) and MOD (remainder).
Comparison: = <> < > <= >= → produce TRUE/FALSE.
Logical: AND (both), OR (either), NOT (reverse).
Use brackets around each condition in a compound expression.

See the full worked example for programming basics →

Input and output

INPUT reads from the keyboard; OUTPUT writes to the screen; this is the input→process→output flow.

Almost every program follows the same shape: it reads some data, processes it, and shows a result.

INPUT reads a value typed at the keyboard into a variable:

INPUT Age
INPUT FirstName

OUTPUT displays text and/or values on the console. Literal text must be in quotation marks, and you join text to values with a comma or the & concatenation operator:

OUTPUT "Welcome, ", FirstName
OUTPUT "You are ", Age, " years old"
OUTPUT "Hello " & FirstName        // & joins strings into one

A good OUTPUT gives the reader context — a bare number on its own is hard to interpret and can cost the output mark when the question asks for a 'clear' or 'suitable' message.

INPUT reads a keyboard value into a variable.
OUTPUT writes text/values to the screen.
Put literal text in quotes; join with comma or &.
Always give the output a clear, labelled message.

See the full worked example for programming basics →

Built-in (library) functions

Call ready-made routines by name; in exams the string functions are always provided.

A built-in (library) function is a ready-made routine supplied by the language. It does a common job and returns a value, so you don't have to write it yourself — you just call it by name and pass argument(s).

The string functions you may meet (all provided in the exam, so they don't need memorising) include:

Function	Returns
`LENGTH(s)`	the number of characters in s (INTEGER)
`LEFT(s, n)`	the leftmost n characters of s
`RIGHT(s, n)`	the rightmost n characters of s
`MID(s, x, n)`	n characters of s starting at position x
`UCASE(s)`	s converted to UPPER case
`LCASE(s)`	s converted to lower case
`NUM_TO_STRING(x)`	a number converted to a string

You combine these like any expression, and store the result with ←:

Capitals ← UCASE(Name)                  // "aisha" → "AISHA"
Initials ← LEFT(FirstName, 1) & LEFT(Surname, 1)
Size     ← LENGTH(Name)                  // returns an INTEGER

The important exam habits are: use the correct arguments, remember what type each function returns (e.g. LENGTH returns an INTEGER, UCASE returns a STRING), and use the & operator to join string results together.

A function is reusable code that is called by name and returns a value.
String functions (LENGTH, LEFT, RIGHT, MID, UCASE, LCASE) are given in the exam.
Mind the return type: LENGTH → INTEGER, UCASE → STRING.
Join string results with the & concatenation operator.

See the full worked example for programming basics →

From design to pseudocode (flowcharts & structured English)

Translate each design element, in order, into the matching pseudocode statement.

Paper 2 often gives you a design — either a program flowchart or structured English — and asks you to write the matching pseudocode. The trick is to translate it element by element, in order, without inventing extra steps.

In a flowchart, each symbol maps to a statement:

Flowchart / structured English	Pseudocode
"input/read a value" (parallelogram)	`INPUT Value`
"calculate / set X to …" (rectangle)	`X ← expression`
"output/display …" (parallelogram)	`OUTPUT "msg", X`

Worked translation. Structured English: "Read a price. Add 7% tax. Output the total."

DECLARE Price : REAL
DECLARE Total : REAL
INPUT Price
Total ← Price * 1.07
OUTPUT "Total to pay: ", Total

Notice you must also declare the variables the design implies and pick sensible data types (REAL here, because money has decimals). Follow the design's order exactly — examiners credit faithful translation, not creativity.

Translate each design element in order; don't add steps.
Parallelogram → INPUT/OUTPUT; rectangle → assignment (←).
Add the DECLAREs the design implies, with sensible types.
Structured English maps almost line-for-line to pseudocode.

See the full worked example for programming basics →

Quick recap

A variable's value can change; a constant is fixed: CONSTANT Pi = 3.14.
Declare variables with a data type: DECLARE Count : INTEGER (INTEGER/REAL/CHAR/STRING/BOOLEAN).
Assignment uses ← ('becomes'); = is comparison, never assignment.
Arithmetic: + − * /, DIV (quotient), MOD (remainder); choose / vs DIV by whether decimals matter.
Comparison = <> < > <= >=; logical AND, OR, NOT combine conditions.
INPUT reads the keyboard; OUTPUT writes to the screen with quoted text joined by , or &.
Built-in functions (LENGTH, LEFT, UCASE…) are provided in the exam — call them with correct arguments; translate designs element by element.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Assignment is ← ('becomes'); = means 'is equal to'.
CONSTANT Name = Value (no type, no separate assignment).
DECLARE Name : Type for variables.
DIV = integer quotient, MOD = remainder (17 DIV 5 = 3, 17 MOD 5 = 2).
Comparison operators: = <> < > <= >=.
Logical operators: AND, OR, NOT.
String functions (LENGTH, LEFT, RIGHT, MID, UCASE, LCASE) are given in the exam.
Join strings/text with the & operator.

How it’s examined

Section 11.1 is assessed in Paper 2 (Fundamental Problem-solving and Programming Skills, 2 hours, 75 marks) — written, externally assessed, no calculator. All answers are written in pseudocode (Cambridge's standard). Expect to declare constants and variables with suitable data types, write expressions and assignments, read INPUT and write clear OUTPUT, call provided built-in functions, and — very commonly — convert a given program flowchart or structured-English design into pseudocode. Use the exact 9618 syntax (← for assignment, DIV/MOD, AND/OR/NOT, = <> <= >=) and choose appropriate data types; marks are awarded for correct, faithful translation, not invented extras.

Sources: Cambridge International AS & A Level Computer Science 9618 syllabus (2027-2029), section 11.1. Last reviewed 2026-06-21.

Take this whole topic with you

Step-by-step worked examples — Programming Basics

Step-by-step solutions to past-paper-style questions on programming basics, written exactly the way a tutor would explain them at the board.

Question type:

1Declare a constant and variables, then initialise
Getting startedIdentify & classify• 9618 Paper 2 style• declaration, constant, variable, AO2
Question
A program needs the fixed value of Pi (3.14), a whole-number counter and a real running total. Write pseudocode to declare these and initialise the counter and total to 0. (4 marks)
Step-by-step solution
1. Step 1
  A value that never changes is a CONSTANT — declare it with its value on the same line. CONSTANT names are conventionally written in a clear, descriptive way.
  $CONSTANT Pi = 3.14$
2. Step 2
  Values that change are VARIABLES. Each is DECLAREd with a name and a data type. A whole number is INTEGER; a number with a fractional part is REAL.
  $DECLARE Counter : INTEGER$
3. Step 3
  Declare the running total as REAL because it can hold a decimal value.
  $DECLARE Total : REAL$
4. Step 4
  Initialisation means giving a starting value. Use the assignment arrow ← to set the counter and total to 0.
  $Counter \leftarrow 0 \\ Total \leftarrow 0$
Answer
CONSTANT Pi = 3.14 DECLARE Counter : INTEGER DECLARE Total : REAL Counter ← 0 Total ← 0
Examiner tip
1 mark for the CONSTANT (value on the same line, no DECLARE), 1 mark each for the two DECLARE lines with correct types, 1 mark for both initialisations using ←. A common slip is writing CONSTANT Pi : REAL — constants take a value, not a type, and are not initialised separately.
2Complete the partially-written pseudocode
Getting startedIdentify & classify• 9618 Paper 2 style• complete the code, input, assignment, AO3
Question
The pseudocode below should read two whole numbers, calculate their sum, and output a clear message with the result. Three lines are incomplete, shown by the gaps ......... Copy and complete the three missing parts. (4 marks)

DECLARE First : INTEGER DECLARE Second : INTEGER DECLARE Sum : ......... INPUT First INPUT Second Sum ......... First + Second OUTPUT ........., Sum
Step-by-step solution
1. Step 1
  Gap 1 is the data type of Sum. It holds the sum of two whole numbers, which is itself a whole number, so the type is INTEGER.
  $DECLARE Sum : INTEGER$
2. Step 2
  Gap 2 is the assignment operator. In 9618 pseudocode a value is stored in a variable with the arrow ←, never with =. The + on the right is evaluated first, then the result is assigned.
  $Sum \leftarrow First + Second$
3. Step 3
  Gap 3 is the literal message text in the OUTPUT. Literal text must be enclosed in double quotation marks; it is separated from the value Sum by a comma.
  $OUTPUT "The sum is ", Sum$
4. Step 4
  Putting the three completions back gives a working program: declare, input, assign with ←, then output the message and value.
  $Sum : INTEGER \quad | \quad \leftarrow \quad | \quad "The sum is "$
Answer
DECLARE First : INTEGER DECLARE Second : INTEGER DECLARE Sum : INTEGER INPUT First INPUT Second Sum ← First + Second OUTPUT "The sum is ", Sum
Examiner tip
1 mark for INTEGER as the type of Sum, 1 mark for the ← assignment operator (not =), 1 mark for a quoted literal message string, 1 mark for a working completed program overall. The most common slip is filling gap 2 with = — in 9618 assignment is always ←, and = means 'is equal to'.
3Convert a flowchart to pseudocode
Building confidenceGraph or diagram• 9618 Paper 2 style• flowchart, design, expression, AO2
Question
A program flowchart shows: START → input a length in centimetres (CM) → calculate metres as CM divided by 100 → output the metres → STOP. Write the equivalent pseudocode. (4 marks)
Step-by-step solution
1. Step 1
  Each flowchart symbol maps to a pseudocode statement. A parallelogram = INPUT/OUTPUT; a rectangle = a process (assignment). Begin by declaring the variables. Metres can be a decimal, so use REAL.
  $DECLARE CM : INTEGER \\ DECLARE Metres : REAL$
2. Step 2
  The input parallelogram becomes an INPUT statement.
  $INPUT CM$
3. Step 3
  The process rectangle becomes an assignment. Use the / operator for real division so the fractional part is kept.
  $Metres \leftarrow CM / 100$
4. Step 4
  The output parallelogram becomes an OUTPUT statement with a message.
  $OUTPUT "Length in metres: ", Metres$
Answer
DECLARE CM : INTEGER DECLARE Metres : REAL INPUT CM Metres ← CM / 100 OUTPUT "Length in metres: ", Metres
Examiner tip
Read the flowchart top to bottom and translate each symbol in order. 1 mark per correctly translated step (declare/input, calculation with /, output). Use / (real division) here, not DIV — DIV would throw away the decimal and give the wrong answer for, say, 250 cm.
4Use DIV and MOD on a structured-English design
Building confidenceWord problem• 9618 Paper 2 style• DIV, MOD, operators, structured English, AO2
Question
A design in structured English reads: 'Read a number of seconds. Work out the whole number of complete minutes and the seconds left over. Output both.' Write pseudocode using the DIV and MOD operators. (5 marks)
Step-by-step solution
1. Step 1
  DIV gives the whole-number (integer) part of a division; MOD gives the remainder. Both produce INTEGER results, so declare all variables as INTEGER.
  $DECLARE TotalSeconds : INTEGER \\ DECLARE Minutes : INTEGER \\ DECLARE SecondsLeft : INTEGER$
2. Step 2
  Read the input.
  $INPUT TotalSeconds$
3. Step 3
  Complete minutes = TotalSeconds DIV 60. For example, 200 DIV 60 = 3 (because 60 goes into 200 three whole times).
  $Minutes \leftarrow TotalSeconds \; DIV \; 60$
4. Step 4
  Leftover seconds = TotalSeconds MOD 60. For example, 200 MOD 60 = 20 (the remainder after taking out 3 whole minutes).
  $SecondsLeft \leftarrow TotalSeconds \; MOD \; 60$
5. Step 5
  Output both results with clear messages.
  $OUTPUT Minutes, " minute(s) and ", SecondsLeft, " second(s)"$
Answer
DECLARE TotalSeconds : INTEGER DECLARE Minutes : INTEGER DECLARE SecondsLeft : INTEGER INPUT TotalSeconds Minutes ← TotalSeconds DIV 60 SecondsLeft ← TotalSeconds MOD 60 OUTPUT Minutes, " minute(s) and ", SecondsLeft, " second(s)"

For 200 seconds this outputs: 3 minute(s) and 20 second(s).
Examiner tip
DIV = integer quotient, MOD = remainder. Marks: declarations (1), input (1), correct DIV (1), correct MOD (1), output (1). Mixing up DIV and MOD, or using / and getting a decimal, are the classic errors here.
5Build a logical expression with AND, OR, NOT
StretchMulti-step problem• 9618 Paper 2 style• logical operators, Boolean, expression, AO2
Question
A theme-park ride allows a rider on if their height is at least 120 (cm) AND they are not younger than 8 (years). Read Height and Age, store whether the rider is allowed in a BOOLEAN variable using a single logical expression, then output the result. (5 marks)
Step-by-step solution
1. Step 1
  Declare two INTEGER inputs and a BOOLEAN to hold the True/False outcome.
  $DECLARE Height : INTEGER \\ DECLARE Age : INTEGER \\ DECLARE Allowed : BOOLEAN$
2. Step 2
  Read both inputs.
  $INPUT Height \\ INPUT Age$
3. Step 3
  Translate each condition into a comparison. 'At least 120' means Height >= 120. 'Not younger than 8' means the age is 8 or more, i.e. Age >= 8 (you could also write NOT (Age < 8)).
  $Height >= 120 \quad\text{and}\quad Age >= 8$
4. Step 4
  Join the two conditions with AND because BOTH must be true. The whole expression evaluates to TRUE or FALSE, which is assigned to the BOOLEAN.
  $Allowed \leftarrow (Height >= 120) \; AND \; (Age >= 8)$
5. Step 5
  Output the stored Boolean result.
  $OUTPUT "Allowed on ride: ", Allowed$
Answer
DECLARE Height : INTEGER DECLARE Age : INTEGER DECLARE Allowed : BOOLEAN INPUT Height INPUT Age Allowed ← (Height >= 120) AND (Age >= 8) OUTPUT "Allowed on ride: ", Allowed
Examiner tip
Comparison operators in 9618 are = <> < > <= >= (note <> for 'not equal'). Marks: declarations incl. BOOLEAN (1), inputs (1), two correct comparisons (1), correct use of AND so both must hold (1), output (1). Using a single = for comparison (it can be read as assignment) or '!=' (not valid 9618 pseudocode) loses marks.
6Use built-in string functions to build a username
StretchMulti-step problem• 9618 Paper 2 style• built-in functions, string, concatenation, AO2
Question
Read a first name and a surname. Create a username made of: the first 3 letters of the surname (in lower case) joined to the first letter of the first name (in lower case). Output the username. You may assume each name has at least 3 letters. (6 marks)
Step-by-step solution
1. Step 1
  Declare three STRING variables: the two inputs and the result.
  $DECLARE FirstName : STRING \\ DECLARE Surname : STRING \\ DECLARE Username : STRING$
2. Step 2
  Read both names from the keyboard.
  $INPUT FirstName \\ INPUT Surname$
3. Step 3
  LEFT(string, n) returns the leftmost n characters. LEFT(Surname, 3) gives the first 3 letters of the surname. (LEFT is a provided string function — it is given in the exam's function list.)
  $LEFT(Surname, 3)$
4. Step 4
  LCASE(string) converts a string to lower case. Apply it to the 3 surname letters and to the first initial. LEFT(FirstName, 1) gives the first letter of the first name. (LCASE and LENGTH/LEFT are all provided functions.)
  $LCASE(LEFT(Surname, 3)) \quad LCASE(LEFT(FirstName, 1))$
5. Step 5
  Join the two pieces with the string concatenation operator & and store the result.
  $Username \leftarrow LCASE(LEFT(Surname, 3)) \; \& \; LCASE(LEFT(FirstName, 1))$
6. Step 6
  Output the finished username.
  $OUTPUT "Your username is ", Username$
Answer
DECLARE FirstName : STRING DECLARE Surname : STRING DECLARE Username : STRING INPUT FirstName INPUT Surname Username ← LCASE(LEFT(Surname, 3)) & LCASE(LEFT(FirstName, 1)) OUTPUT "Your username is ", Username

For FirstName = "Aisha", Surname = "Khan" this produces "khaa".
Examiner tip
String functions such as LEFT, RIGHT, MID, LENGTH, LCASE and UCASE are always provided in the exam, so you do not memorise them — but you must use them with the correct arguments and the & concatenation operator. Marks: declarations (1), inputs (1), correct LEFT on surname (1), correct LCASE/first initial (1), correct & concatenation (1), output (1). Watch the order — surname part first, then first initial.

Model Answers — Programming Basics

High-scoring sample answers for programming basics on the Cambridge IGCSE paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
9618 Paper 2 style3 marks
State the difference between a constant and a variable, and give one reason a programmer would use a constant. (3 marks)
Model answer
A variable is a named storage location whose value can change while the program runs. A constant is a named value that is set once and cannot be changed during execution.

A programmer uses a constant so that an important fixed value (for example CONSTANT Pi = 3.14 or a tax rate) is given a meaningful name and is defined in one place — if it ever needs changing, only the single declaration is edited, which makes the program easier to read and to maintain, and prevents accidental changes to the value.
Why this scores
1 mark: variable value can change. 1 mark: constant value is fixed/cannot change after declaration. 1 mark: a valid reason (one place to change / readability / prevents accidental modification). Naming the value (e.g. Pi) is a good way to show understanding.
Question 2
9618 Paper 2 style4 marks
A student has written the pseudocode below to read a temperature in Celsius and convert it to Fahrenheit using the fixed multiplier 1.8. It contains three errors. Identify each error and write the corrected line. (4 marks)
```
Line 1:  CONSTANT Multiplier : 1.8
Line 2:  DECLARE Celsius : INTEGER
Line 3:  DECLARE Fahrenheit : INTEGER
Line 4:  INPUT Celsius
Line 5:  Fahrenheit = Celsius * Multiplier + 32
Line 6:  OUTPUT Fahrenheit
```
Model answer
Error 1 (Line 1): a CONSTANT is declared with = and a value, not a colon and a type. Corrected: CONSTANT Multiplier = 1.8

Error 2 (Line 3): Fahrenheit is calculated by multiplying by 1.8, so it can have a fractional part — INTEGER would lose the decimal. It must be REAL. Corrected: DECLARE Fahrenheit : REAL

Error 3 (Line 5): assignment in 9618 pseudocode uses the arrow ←, not =. Corrected: Fahrenheit ← Celsius * Multiplier + 32

The fully corrected program is:

CONSTANT Multiplier = 1.8 DECLARE Celsius : INTEGER DECLARE Fahrenheit : REAL INPUT Celsius Fahrenheit ← Celsius * Multiplier + 32 OUTPUT Fahrenheit
Why this scores
1 mark for spotting and fixing the CONSTANT syntax (= value, no type), 1 mark for changing Fahrenheit to REAL, 1 mark for the ← assignment operator on Line 5, 1 mark for an otherwise correct corrected program. Identifying the line is not enough — the corrected line must be given. The = vs ← confusion and the wrong data type for a value with decimals are the two most penalised basics in Paper 2.
Question 3
9618 Paper 2 style5 marks
A program flowchart performs these steps in order: START; input a price in dollars into PRICE; calculate the tax as PRICE multiplied by 0.07; calculate the total as PRICE plus tax; output the total; STOP. Write pseudocode for this design, declaring all variables with suitable data types. (5 marks)
Model answer
Prices and tax can have decimal parts, so they are declared as REAL:

DECLARE Price : REAL DECLARE Tax : REAL DECLARE Total : REAL INPUT Price Tax ← Price * 0.07 Total ← Price + Tax OUTPUT "Total to pay: \$", Total
Why this scores
Marks: REAL declarations (1), INPUT Price (1), correct tax calculation with * and ← (1), correct total calculation (1), OUTPUT of the total with a message (1). REAL is essential — using INTEGER would lose the cents. Follow the design's order exactly; inventing extra steps is not credited.
Question 4
9618 Paper 2 style6 marks
A program checks whether a number Score entered by a user is a valid percentage, i.e. between 0 and 100 inclusive. Write pseudocode to read Score, set a BOOLEAN variable Valid to TRUE only when the score is in range, and output a suitable message. Use a single logical expression. (6 marks)
Model answer
A valid percentage must be at least 0 AND at most 100, so both comparisons must be true — they are joined with AND:

DECLARE Score : INTEGER DECLARE Valid : BOOLEAN INPUT Score Valid ← (Score >= 0) AND (Score <= 100) OUTPUT "Valid percentage: ", Valid

The expression (Score >= 0) AND (Score <= 100) evaluates to TRUE only when the score is inside the range, and FALSE otherwise; the result is stored directly in the BOOLEAN Valid.
Why this scores
Marks: INTEGER and BOOLEAN declarations (1+1), INPUT (1), correct lower-bound comparison >= 0 (1), correct upper-bound comparison <= 100 joined with AND (1), output (1). AND (not OR) is essential — OR would wrongly accept almost any number. Note 9618 uses <= and >=, not =< or =>.
Question 5
9618 Paper 2 style7 marks
Explain what is meant by a built-in (library) function, and describe how a programmer would use the LENGTH and UCASE string functions to output a person's name in capital letters together with the number of characters in it. Include example pseudocode. (7 marks)
Model answer
A built-in (library) function is a ready-made routine provided by the programming language/environment that performs a common task and returns a value. The programmer simply calls it by name and passes the required argument(s) rather than writing the code from scratch. In 9618, string functions like LENGTH, UCASE, LCASE, LEFT, RIGHT and MID are always given in the exam, so they do not need to be memorised — only used correctly.

UCASE(string) returns the string converted to upper case.

LENGTH(string) returns the number of characters in the string (an INTEGER).

Example pseudocode:

DECLARE Name : STRING DECLARE Capitals : STRING DECLARE Size : INTEGER INPUT Name Capitals ← UCASE(Name) Size ← LENGTH(Name) OUTPUT Capitals, " has ", Size, " characters"

For Name = "Aisha" this outputs: AISHA has 5 characters.
Why this scores
Marks: definition of a function as reusable code that returns a value (1), called by name with argument(s)/provided by the language (1), correct description of UCASE (1) and LENGTH (1), correct UCASE call (1), correct LENGTH call returning an INTEGER (1), correct OUTPUT combining both (1). Strong answers note that these functions are given in the exam and that LENGTH returns an INTEGER while UCASE returns a STRING — getting the return types right shows real understanding.
Question 6
9618 Paper 2 style8 marks
Design and write a complete pseudocode program that: reads the number of items bought and the price of one item; calculates the subtotal; applies a fixed delivery charge held as a constant of $5; outputs the subtotal, the delivery charge and the grand total, each with a clear message. Choose suitable data types and use a named constant. (8 marks)
Model answer
The delivery charge never changes, so it is a named CONSTANT. The quantity is a whole number (INTEGER); the price, subtotal and totals can have cents (REAL):

CONSTANT Delivery = 5.00 DECLARE Quantity : INTEGER DECLARE UnitPrice : REAL DECLARE Subtotal : REAL DECLARE GrandTotal : REAL INPUT Quantity INPUT UnitPrice Subtotal ← Quantity * UnitPrice GrandTotal ← Subtotal + Delivery OUTPUT "Subtotal: \$", Subtotal OUTPUT "Delivery: \$", Delivery OUTPUT "Grand total: \$", GrandTotal

For Quantity = 3 and UnitPrice = 4.00, the subtotal is \$12.00, delivery \$5.00, and the grand total \$17.00.
Why this scores
Marks: CONSTANT used for the delivery charge (1), INTEGER quantity (1), REAL price/totals (1), two INPUTs (1), correct subtotal with * (1), correct grand total adding the constant (1), three OUTPUTs with messages (1), overall correct logic/order following the design (1). The key discriminators are using a CONSTANT (not a magic number 5 buried in the calculation) and choosing REAL for monetary values.

Key Definitions and Keywords — Programming Basics

Definitions to memorise and the exact keywords mark schemes credit for programming basics answers — sharpened from recent examiner reports for the 2026 Cambridge IGCSE sitting.

Variable
Examiner keyword
A named storage location, with a specific data type, whose value can change while a program runs. Declared with DECLARE Name : Type.
Example
DECLARE Count : INTEGER
Constant
Examiner keyword
A named value that is fixed when the program is written and cannot be changed while the program runs. Declared with CONSTANT Name = Value (no data type, no separate initialisation).
Example
CONSTANT Pi = 3.14
Declaration
Examiner keyword
A statement that introduces a variable (or constant) by giving its name and — for a variable — its data type, so the program knows it exists and what kind of value it holds.
Initialisation
Examiner keyword
Giving a variable its first (starting) value before it is used, usually with an assignment such as Total ← 0.
Assignment
Examiner keyword
Storing a value in a variable using the assignment operator ←. The expression on the right is evaluated, and the result is placed in the variable on the left.
Example
Sum ← First + Second
Data type
Examiner keyword
A classification that states what kind of value a variable can hold. Common 9618 types are INTEGER (whole number), REAL (number with a fractional part), CHAR (single character), STRING (text) and BOOLEAN (TRUE/FALSE).
Expression
Examiner keyword
A combination of values, variables and operators that the computer evaluates to produce a single result, e.g. (Price * 0.07) or (Age >= 8).
Arithmetic operators
Examiner keyword
Operators that perform calculations: + (add), − (subtract), * (multiply), / (real division), DIV (integer quotient) and MOD (remainder).
Example
17 DIV 5 = 3 and 17 MOD 5 = 2
Logical operators
Examiner keyword
Operators that combine or negate Boolean conditions: AND (both true), OR (at least one true) and NOT (reverses true/false).
Comparison (relational) operators
Examiner keyword
Operators that compare two values and produce a Boolean result: = (equal), <> (not equal), <, >, <= and >=.
INPUT and OUTPUT
Examiner keyword
INPUT reads a value typed at the keyboard into a variable; OUTPUT displays text and/or values on the screen (console). Strings in OUTPUT are joined to values with the & concatenation operator or separated by commas.
Example
INPUT Age / OUTPUT "Age is ", Age
Built-in (library) function
Examiner keyword
A ready-made routine provided by the language that performs a common task and returns a value; it is called by name with argument(s), e.g. LENGTH, UCASE, LEFT. In exams, any required string/library functions are always given.
Example
UCASE("aisha") returns "AISHA"

Common Mistakes and Misconceptions — Programming Basics

The traps other students keep falling into on programming basics questions — taken from recent Cambridge IGCSE examiner reports and mark schemes — and how to avoid them.

✕Using = for assignment, e.g. writing Sum = First + Second instead of Sum ← First + Second.
Examiner reports note marks lost when assignment is shown with = rather than the ← operator.
Why it happens
Many real languages (and everyday maths) use = to assign, so students carry the habit into Cambridge pseudocode.
How to avoid it
In 9618 pseudocode, assignment is always the arrow ←. The symbol = is reserved for comparison ('is equal to'). Read ← out loud as 'becomes'.
✕Declaring a constant as if it were a variable, e.g. DECLARE Pi : REAL then Pi ← 3.14, or CONSTANT Pi : REAL.
Why it happens
Students apply the variable DECLARE pattern to constants out of habit.
How to avoid it
A constant is written in one line with its value: CONSTANT Pi = 3.14. No data type and no separate assignment are used.
✕Confusing / with DIV (and forgetting MOD), e.g. using / when the design needs the whole-number quotient.
Why it happens
All three look like division, so students reach for the most familiar symbol /.
How to avoid it
Use / for ordinary (real) division that keeps decimals, DIV for the whole-number quotient, and MOD for the remainder. Check whether the answer should have a decimal part.
✕Choosing the wrong data type — e.g. declaring a price or average as INTEGER, which loses the decimal part.
Why it happens
Students default to INTEGER for any number without thinking about whether fractions are needed.
How to avoid it
Ask: can this value have a fractional part? Money, averages and measurements need REAL; counts and quantities use INTEGER.
✕Using OR when both conditions must be true (or AND when only one must be), e.g. for a range check 0 to 100.
Why it happens
Everyday English uses 'and'/'or' loosely, so students don't map them precisely to AND/OR.
How to avoid it
If ALL conditions must hold, use AND. If ANY one is enough, use OR. A range like 0–100 needs (Score >= 0) AND (Score <= 100).
✕Outputting a bare value with no message, or writing the message text without quotation marks, e.g. OUTPUT Total instead of OUTPUT 'Total: ', Total (with the text in quotes).
Why it happens
Students focus on the calculation and treat the OUTPUT as an afterthought, or forget that text must be in quotation marks.
How to avoid it
Always quote literal text ("...") and join it to the value with a comma or the & operator. The question usually asks for a 'suitable' or 'clear' message — a bare number can lose the output mark.

Programming Basics

Detailed Study Notes

At a glance

What you’ll learn

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Declare a constant and variables, then initialise

2Complete the partially-written pseudocode

3Convert a flowchart to pseudocode

4Use DIV and MOD on a structured-English design

5Build a logical expression with AND, OR, NOT

6Use built-in string functions to build a username

Variable

Constant

Declaration

Initialisation

Assignment

Data type

Expression

Arithmetic operators

Logical operators

Comparison (relational) operators

INPUT and OUTPUT

Built-in (library) function

✕Using = for assignment, e.g. writing Sum = First + Second instead of Sum ← First + Second.

✕Declaring a constant as if it were a variable, e.g. DECLARE Pi : REAL then Pi ← 3.14, or CONSTANT Pi : REAL.

✕Confusing / with DIV (and forgetting MOD), e.g. using / when the design needs the whole-number quotient.

✕Choosing the wrong data type — e.g. declaring a price or average as INTEGER, which loses the decimal part.

✕Using OR when both conditions must be true (or AND when only one must be), e.g. for a range check 0 to 100.

✕Outputting a bare value with no message, or writing the message text without quotation marks, e.g. OUTPUT Total instead of OUTPUT 'Total: ', Total (with the text in quotes).