Cambridge IGCSE Computer Science 0478 — Complete Revision Guide

Cambridge IGCSE Computer Science is studied by students worldwide and is offered in two versions: 0478 (standard) and 0984 (Cambridge IGCSE (9–1)). This guide covers both, as the content is essentially the same — the main difference is the grading scale.

Which Specification Are You Studying?

0478: Traditional A*–G grading, available globally
0984: 9–1 grading (aligned with UK GCSE reform), primarily for UK-based international schools

The content, assessment objectives, and exam format are the same for both.

Exam Structure

Cambridge IGCSE Computer Science has two written papers:

Paper	Name	Marks	Time	Weighting
Paper 1	Theory	75 marks	1 hr 45 min	60%
Paper 2	Problem-solving and Programming	50 marks	1 hr 45 min	40%

There is no coursework or practical component. Both papers are sat at the end of the course (May/June or October/November series).

Paper 1: Theory

Paper 1 tests theoretical knowledge of computer systems. Questions range from short answer to extended response.

1. Data Representation

Number systems: binary, denary, hexadecimal — conversions between all three
Binary arithmetic: addition, overflow
Negative numbers: two’s complement
Text: ASCII, Unicode
Images: pixels, resolution, colour depth, file size calculations
Sound: sampling, sample rate, bit depth
Compression: lossy vs lossless, common algorithms (run-length encoding)

2. Data Transmission

Types of transmission: serial vs parallel, simplex, half-duplex, full-duplex
Packet switching: packets, headers, IP addresses, routers
Error detection: parity checks (odd/even), checksums, echo checking
Encryption: symmetric vs asymmetric, Caesar cipher (understand the concept)

3. Hardware

The processor: ALU, CU, registers (PC, MDR, MAR, accumulator), cache
Fetch-decode-execute cycle: detail of each stage
Primary storage: RAM (volatile) vs ROM (non-volatile), virtual memory
Secondary storage: HDD, SSD, optical (CD/DVD/Blu-ray), magnetic tape
Input/output devices: scanner, barcode reader, touchscreen, speaker, actuator
Embedded systems: examples and characteristics

4. Software

Types of software: system software vs application software
The operating system: memory management, process management, file management, security
Programming languages: machine code, assembly, high-level languages
Translators: assembler, interpreter, compiler — differences and uses

5. The Internet and its Uses

The internet vs the World Wide Web — students often confuse these
URL structure: protocol, domain name, file path
HTML basics: structure of a web page, key tags
How the internet works: IP addresses, routers, DNS, ISP
Cyber security: malware types (virus, worm, trojan, spyware, ransomware), phishing, pharming, hacking
Security measures: firewalls, SSL/TLS, user authentication, anti-malware, two-factor authentication

6. Automated and Emerging Technologies

Artificial intelligence (AI): machine learning, neural networks, natural language processing
Robotics: uses of robots, sensors, actuators
Expert systems: knowledge base, inference engine, user interface
The impact of technology on society, employment, and privacy

Paper 2: Problem-Solving and Programming

Paper 2 assesses your ability to use computational thinking and programming skills. This is the paper where candidates most commonly lose marks.

Section A: Problem-Solving

Section A questions present real-world problems and ask you to:

Identify inputs, processes, and outputs
Create flowcharts to represent algorithms
Write pseudocode using Cambridge’s own pseudocode syntax
Complete or modify given algorithms
Complete trace tables

Cambridge Pseudocode Syntax

Cambridge uses its own pseudocode style. Key conventions:

// Input and output
INPUT Name
OUTPUT "Hello, " & Name

// Variables
DECLARE Score : INTEGER
DECLARE Name : STRING
DECLARE Average : REAL

// Selection
IF Score >= 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
ENDIF

// Iteration
FOR Count ← 1 TO 10
    OUTPUT Count
NEXT Count

WHILE Score < 0 OR Score > 100 DO
    INPUT Score
ENDWHILE

// Arrays
DECLARE Names : ARRAY[1:10] OF STRING
Names[1] ← "Alice"

// Procedures and functions
PROCEDURE Greet(Name : STRING)
    OUTPUT "Hello, " & Name
ENDPROCEDURE

FUNCTION Add(A : INTEGER, B : INTEGER) RETURNS INTEGER
    RETURN A + B
ENDFUNCTION

Examiner tip: Cambridge pseudocode uses ← for assignment (not =), AND, OR, NOT (not &&, ||), and DIV/MOD for integer division and modulo. Use the exact syntax — markers accept minor variations but penalise consistently wrong notation.

Section B: Programming

Section B requires you to write actual code in one of the supported programming languages. Cambridge accepts:

Python
VB.NET
Java
C++
Pascal/Delphi

Most students use Python. The questions typically ask you to write programs that involve:

Reading input and producing output
Working with variables and arithmetic
Selection (if statements)
Iteration (for/while loops)
Arrays/lists
String handling
File reading/writing
Functions/procedures
Structured records

Standard algorithms tested

Linear search:

def linear_search(array, target):
    for i in range(len(array)):
        if array[i] == target:
            return i
    return -1

Bubble sort:

def bubble_sort(array):
    n = len(array)
    for pass_num in range(n - 1):
        for i in range(n - 1 - pass_num):
            if array[i] > array[i + 1]:
                array[i], array[i + 1] = array[i + 1], array[i]
    return array

Count occurrences:

items = ["apple", "banana", "apple", "cherry", "apple"]
count = 0
target = "apple"
for item in items:
    if item == target:
        count += 1
print(count)

Common Mistakes and How to Avoid Them

Paper 1

The internet ≠ the World Wide Web. The internet is the global network infrastructure; the WWW is a service that runs on top of it.
RAM vs ROM confusion. RAM is volatile (data lost when power off) and is used for currently running programs. ROM is non-volatile and contains firmware/BIOS.
“Explain” questions need two parts. For “explain why…”, state the fact AND say what happens as a result. One sentence is rarely enough.
Virus vs worm. A virus needs a host file and user action to spread. A worm is self-replicating and spreads across networks without user interaction.

Paper 2

ENDIF and ENDWHILE. Cambridge pseudocode requires explicit end markers. Forgetting them costs marks.
1-based array indexing. Cambridge pseudocode uses ARRAY[1:10] for a 10-element array (starting at 1, not 0). Python uses 0-based indexing — know which you’re using.
Trace tables. Always show every row. Write the variable values after each change, not just the final state.
Validation vs verification. Validation checks that data is sensible (in range, correct format). Verification checks that data was entered correctly (e.g., double entry, check digit). They are not the same thing.

Revision Strategy

Worked past papers

Cambridge releases past papers back to 2015 on the Cambridge Assessment website (or via your school). Work through at minimum the last 6 series.

Pseudocode practice

Write pseudocode for everyday tasks: making a cup of tea, sorting a list of names, finding the largest number. Then trace through to check your logic.

Program writing under time pressure

Paper 2 Section B is time-pressured. Practice writing programs by hand (or without your IDE’s autocomplete) to build speed.

Differences from UK GCSE Specs

Cambridge IGCSE is studied internationally and has some differences from the AQA, OCR, and Eduqas GCSE specs:

More emphasis on flowcharts in Paper 2
Cambridge-specific pseudocode syntax — different from AQA and OCR
HTML knowledge required (basic tag structure)
Different algorithm emphasis: Cambridge expects less on Big O notation and advanced sorting, more on core search and sort algorithms
Embedded systems and expert systems are Cambridge-specific topics

If you’re preparing for Cambridge IGCSE, make sure your revision resources are spec-specific. Our question bank covers 0478/0984 with Cambridge-specific question styles.

Need help with Cambridge IGCSE preparation? Book a 1-to-1 session with Gareth, who has experience teaching and examining across international Computer Science specifications.