What are the basic programming concepts covered in the Cambridge IGCSE Computer Science syllabus?

The Cambridge IGCSE Computer Science syllabus covers fundamental programming concepts such as variables, data types, operators, control structures (like loops and conditionals), functions, and arrays. These concepts form the foundation for understanding how to write and analyze simple programs.

How do variables and data types function in programming?

In programming, variables are used to store data that can be manipulated by the program. Each variable has a data type that defines the kind of data it can hold, such as integers, floats, or strings. Understanding variables and data types is crucial for managing data effectively in any programming language.

What is the importance of control structures in programming?

Control structures, such as loops and conditionals, are essential in programming because they allow the flow of the program to change based on certain conditions. This enables programmers to execute code repeatedly (using loops) or make decisions (using conditionals), which is vital for creating dynamic and responsive programs.

Can you explain the concept of functions in programming?

Functions are reusable blocks of code that perform a specific task. They help in organizing code, making it more readable and maintainable. By using functions, programmers can avoid redundancy, as the same function can be called multiple times with different inputs to produce different outputs.

What role do arrays play in programming?

Arrays are data structures that store multiple values of the same data type in a single variable. They are useful for managing collections of data, such as lists of numbers or strings. Arrays allow programmers to efficiently access and manipulate large sets of data using indexing.

Why is "Using a variable for something that should be a constant" a common mistake in Programming Concepts?

Why it happens: Students declare everything as a variable. How to avoid it: If the value WON'T change (π, VAT rate at the time of the program, max users), use a CONSTANT. Documents intent and prevents accidental modification. Source: 0478 Examiner Reports 2022-2024

Why is "Using Integer for prices" a common mistake in Programming Concepts?

Why it happens: Prices look like 'whole numbers'. How to avoid it: Prices have pence/cents — use REAL (or a dedicated Currency/Decimal type). Integer prices lose accuracy on calculations.

Why is "Calling a procedure a function (or vice versa)" a common mistake in Programming Concepts?

Why it happens: Both are 'subroutines'. How to avoid it: Function RETURNS a value. Procedure does NOT return a value. The distinction is exactly that one rule.

Why is "Making every variable global" a common mistake in Programming Concepts?

Why it happens: Globals are accessible everywhere; feels easier. How to avoid it: Overuse of globals leads to spaghetti code and bugs from unintended side effects. Default to LOCAL; promote to global only when truly needed.

ProgrammingCambridge IGCSE Computer Science (0478)

Programming Concepts

Work through the notes, try the practice questions, then take the quiz. The report tells you exactly what to revise next.

PreviousNext

Learn this Topic

Start with the slides for the quick version, then go deeper with the full study notes.

Short Study Notes in the form of Slides

Read the notes first. If the method in a worked example clicks, you're ready for the questions.

Page 1 / 0

Detailed Study Notes

Full prose, callouts and a recap — built for A* mastery, not just a quick scan.

Take these study notes with you

Download a branded PDF — full prose, callouts, recap and memorise list for Programming Concepts, ready to print or save offline.

Programming Concepts Study Notes — Cambridge IGCSE Computer Science 0478 (2026-2028 syllabus)

The building blocks of every program. Variables, constants and the standard data types. Operators, expressions, the three control structures. Subroutines (procedures and functions), parameters, scope (local vs global), and string-manipulation functions.

What you’ll learn

Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).

1.22.1 — Distinguish variables and constants.
1.22.2 — Identify common data types and their use.
1.22.3 — Use the three control structures.
1.22.4 — Use procedures and functions; pass parameters.
1.22.5 — Distinguish local and global variables.
1.22.6 — Use string-manipulation functions.

Variables and constants

Storage with a name. Variable can change; constant cannot.

A variable is a named storage location whose value CAN CHANGE while the program runs. Use for things that may take different values over time — user input, counters, totals, current state.

A constant is a named storage location whose value DOES NOT CHANGE after it's set. Use for fixed values:

Mathematical constants (π = 3.14159...).
Configuration limits (MAX_USERS = 100, VAT_RATE = 0.20).
Magic numbers (DAYS_IN_WEEK = 7) — replacing them with named constants makes code self-documenting.

Why prefer constants when possible.

Self-documenting (circumference ← 2 * PI * radius reads better than circumference ← 2 * 3.14159 * radius).
Single source of truth — change in one place if the value updates.
Compiler / interpreter can prevent accidental modification.

Cambridge tip. Mark scheme expects the precise distinction: variable = changeable, constant = fixed. Don't say 'constants are like variables but...'.

Variable: value changes.
Constant: value stays fixed.
Constants are self-documenting and safer.

Common data types

Six types you'll see on every paper.

Cambridge tests these data types:

Type	Stores	Example
Integer	Whole numbers	-3, 0, 42
Real (Float)	Numbers with decimals	3.14, -0.5
Boolean	TRUE / FALSE	TRUE
String	Sequence of characters	"Hello"
Char	Single character	'A'
Date	Date / DateTime	09/05/2026

Choose the right type.

Counter / age / quantity → integer.
Price / measurement / scientific value → real.
Yes/no / on/off / true/false → boolean.
Names / addresses / messages → string.
Single grade letter / single character flag → char (or string of length 1).
Birthdays / timestamps → date / datetime.

Cambridge tip. Match the type to the SCENARIO. Using integer for prices loses pence; using string for ages prevents arithmetic.

Six common types — know each.
Real (not integer) for prices.
Boolean for yes/no flags.

See the full worked example for programming concepts →

Procedures and functions

Reusable blocks. Procedure does; function returns.

A subroutine is a self-contained block of code that does a task. Two kinds:

Procedure. Does a task; does NOT return a value.

PROCEDURE DisplayMenu()
  OUTPUT "1. Add"
  OUTPUT "2. Remove"
  OUTPUT "3. Quit"
ENDPROCEDURE

Called: CALL DisplayMenu().

Function. Does a task; RETURNS a value to the caller.

FUNCTION AreaOfCircle(radius : REAL) RETURNS REAL
  RETURN 3.14159 * radius * radius
ENDFUNCTION

Called: area ← AreaOfCircle(5).

Both share:

They take parameters (variables that receive values from the caller).
They have local variables (private to the subroutine).
They can be called from many places — write once, use many times.

Why use subroutines.

Reuse — write once, call from many places.
Less duplication — no copy-pasted code drifting out of sync.
Easier to test — test each subroutine in isolation.
Modular — top-level code reads as a sequence of named operations.

Cambridge tip. When asked to distinguish, the SINGLE rule is: function returns a value, procedure does not.

Procedure does; function returns.
Both take parameters and have local scope.
Subroutines enable reuse, less duplication, easier testing.

See the full worked example for programming concepts →

Local vs global scope

Where can you SEE the variable?

A variable's scope is the part of the program where it's accessible.

Local variables. Declared INSIDE a subroutine; only accessible within that subroutine. Created when the subroutine is called and destroyed when it ends.

Global variables. Declared OUTSIDE all subroutines; accessible EVERYWHERE in the program. Persists for the program's lifetime.

Why prefer local.

Encapsulation — one subroutine can't accidentally change another's variables.
Easier debugging — variable changes localised.
Less memory — local variables are reclaimed when the subroutine ends.
Reuse — subroutines work on parameters and locals; can be lifted between programs.

When global IS appropriate.

Configuration values needed everywhere (often defined as CONSTANTS, not variables).
A few clearly-named state variables shared across the whole program.

Cambridge tip. Mark scheme expects the distinction (where declared / where visible) AND a stated advantage of local (one of: encapsulation, debugging, memory, reuse).

Local: inside subroutine; created/destroyed with it.
Global: outside all subroutines; everywhere; persistent.
Default to local for safety.

See the full worked example for programming concepts →

String-manipulation functions

LENGTH, SUBSTRING, UCASE, LCASE — Cambridge pseudocode standards.

Strings are sequences of characters; Cambridge has a small set of built-in functions for manipulating them.

LENGTH(text). Returns the number of characters.

LENGTH("Hello")  → 5

SUBSTRING(text, start, length). Returns a slice of the string.

SUBSTRING("Computer", 1, 4)  → "Comp"
SUBSTRING("Computer", 5, 4)  → "uter"

UCASE(text). Convert to uppercase.

UCASE("hello")  → "HELLO"

LCASE(text). Convert to lowercase.

LCASE("WORLD")  → "world"

Concatenation (+). Join strings together.

Greeting ← "Hello, " + Name

Cambridge tip. Use Cambridge pseudocode names (LENGTH, SUBSTRING, UCASE, LCASE) — not Python's len/slice or Java's .length(). Mark schemes deduct for language-specific syntax.

LENGTH, SUBSTRING, UCASE, LCASE — Cambridge standards.
Concatenation with +.
Use Cambridge names, not Python/Java.

How it’s examined

Programming concepts appear on every Paper 2. Most-tested questions: identify data types for scenarios (6 marks), distinguish procedure / function (4-6 marks), local vs global (4 marks), string-manipulation pseudocode (6 marks). Examiner reports flag use of language-specific syntax instead of Cambridge pseudocode as the most common loss-of-marks issue.

Sources: Cambridge IGCSE Computer Science 0478 syllabus (2026-2028); 0478 Examiner Reports 2022-2024; 0478/22 Oct/Nov 2024 question paper and mark scheme. Last reviewed 2026-05-09.

Master this Topic

Worked examples, formulae, definitions and the mistakes examiners flag — everything you need to push from a pass to an A*.

Take this whole topic with you

Download a branded revision sheet — worked examples, formulae, definitions and common mistakes for Programming Concepts, ready to print or save as PDF.

Step-by-step worked examples — Programming Concepts

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

1Identify appropriate data types (6 marks)
Core• Adapted from 0478/22 Oct/Nov 2024 Q4• data-types
Question
For each scenario, identify the most appropriate DATA TYPE: (a) A student's age. (1 mark) (b) A product's price. (1 mark) (c) Whether a user is logged in. (1 mark) (d) A user's full name. (1 mark) (e) A single letter grade. (1 mark) (f) A timestamp. (1 mark)
Step-by-step solution
1. Step 1
  (a) Integer (1 mark). Whole number; ages are 0, 1, 2, ...
2. Step 2
  (b) Real / Float (1 mark). Has decimal places (£12.99). Currency could also use Decimal/Currency in some languages.
3. Step 3
  (c) Boolean (1 mark). TRUE / FALSE only.
4. Step 4
  (d) String (1 mark). Sequence of characters; arbitrary length.
5. Step 5
  (e) Char (1 mark). Single character ('A', 'B', 'C', ...). Could also be a String of length 1.
6. Step 6
  (f) Date / DateTime (1 mark). Stores date and time; some languages have a dedicated type.
Answer
Integer, Real, Boolean, String, Char, Date. Cambridge expects students to know all six common types.
2Distinguish a procedure and a function (6 marks)
Extended• subroutine
Question
Distinguish between a PROCEDURE and a FUNCTION. Give an example of when each would be used. (6 marks)
Step-by-step solution
1. Step 1
  Procedure (2 marks). A self-contained subroutine that performs a task but does NOT return a value to the caller. Example: DisplayMenu() prints the menu options to the screen.
2. Step 2
  Function (2 marks). A self-contained subroutine that performs a task AND RETURNS a value. Example: AreaOfCircle(radius) returns π × r².
3. Step 3
  Both share (2 marks). Take parameters; have local variables; can be called from anywhere they're in scope. Difference is purely whether they return a value.
Answer
Procedure: does something, returns nothing. Function: does something AND returns a value. Both reusable, both take parameters.
3Local vs global variables (4 marks)
Extended• scope
Question
Distinguish between local and global variables. State an advantage of using local variables. (4 marks)
Step-by-step solution
1. Step 1
  Local (2 marks). Declared INSIDE a subroutine; only accessible within that subroutine. Created when the subroutine is called and destroyed when it ends.
2. Step 2
  Global (1 mark). Declared OUTSIDE all subroutines; accessible everywhere in the program. Persists for the program's lifetime.
3. Step 3
  Local-variable advantage (1 mark). Reduces unintended side effects — one subroutine can't accidentally change another's variables. Easier to reason about and debug. Memory is reclaimed when the subroutine ends.
Answer
Local: scope = subroutine. Global: scope = whole program. Local is preferred for encapsulation, debuggability and memory.

Key Definitions and Keywords — Programming Concepts

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

Variable
Examiner keyword
A named storage location whose value CAN CHANGE while the program runs.
Constant
Examiner keyword
A named storage location whose value DOES NOT CHANGE after it's set. Used for values like π, conversion factors, configuration limits.
Integer
Examiner keyword
Whole-number data type — no decimal places. Examples: -3, 0, 42.
Real (Float)
Examiner keyword
Numeric data type WITH decimal places. Examples: 3.14, -0.5, 2.0.
Boolean
Examiner keyword
Data type with only two values: TRUE or FALSE.
String
Examiner keyword
A sequence of characters of arbitrary length. Used for text.
Char
Examiner keyword
A single character. Often a separate type from String in strongly-typed languages.
Procedure
Examiner keyword
A subroutine that performs a task but does NOT return a value.
Function
Examiner keyword
A subroutine that performs a task AND returns a value.
Parameter
Examiner keyword
A variable that receives the value of an ARGUMENT passed to a subroutine. Lets the same subroutine work on different inputs.
Local variable
Examiner keyword
A variable declared inside a subroutine; accessible only within that subroutine.
Global variable
Examiner keyword
A variable declared outside any subroutine; accessible everywhere in the program.
String LENGTH function
Returns the number of characters in a string. Cambridge pseudocode: LENGTH(text).
String SUBSTRING function
Returns a portion of a string given start position and length. Cambridge pseudocode: SUBSTRING(text, start, length).

Common Mistakes and Misconceptions — Programming Concepts

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

✕Using a variable for something that should be a constant
0478 Examiner Reports 2022-2024
Why it happens
Students declare everything as a variable.
How to avoid it
If the value WON'T change (π, VAT rate at the time of the program, max users), use a CONSTANT. Documents intent and prevents accidental modification.
✕Using Integer for prices
Why it happens
Prices look like 'whole numbers'.
How to avoid it
Prices have pence/cents — use REAL (or a dedicated Currency/Decimal type). Integer prices lose accuracy on calculations.
✕Calling a procedure a function (or vice versa)
Why it happens
Both are 'subroutines'.
How to avoid it
Function RETURNS a value. Procedure does NOT return a value. The distinction is exactly that one rule.
✕Making every variable global
Why it happens
Globals are accessible everywhere; feels easier.
How to avoid it
Overuse of globals leads to spaghetti code and bugs from unintended side effects. Default to LOCAL; promote to global only when truly needed.

Practice questions

Exam-style questions with step-by-step worked solutions. Try one before checking the method.

Past paper style quiz

Get a report showing which sub-topics you've nailed and which ones still need work.

Programming Concepts — frequently asked questions

The things students keep getting wrong in this sub-topic, answered.

Programming Concepts

Short Study Notes in the form of Slides

Detailed Study Notes

What you’ll learn

How it’s examined

1Identify appropriate data types (6 marks)

2Distinguish a procedure and a function (6 marks)

3Local vs global variables (4 marks)

Variable

Constant

Integer

Real (Float)

Boolean

String

Char

Procedure

Function

Parameter

Local variable

Global variable

String LENGTH function

String SUBSTRING function

✕Using a variable for something that should be a constant

✕Using Integer for prices

✕Calling a procedure a function (or vice versa)

✕Making every variable global

Practice questions

Past paper style quiz

Assess your understanding

Programming Concepts — frequently asked questions