Launching your learning experience…
Detailed notes on Algorithm design and problem-solving for Cambridge IGCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.
How to tackle big problems. DECOMPOSITION breaks a system into smaller subsystems; ABSTRACTION removes irrelevant detail. Structure diagrams show the decomposition; subroutines express it in code. The two together let large teams build complex systems they could never tackle as one piece.
Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).
Big problems become tractable when you break them down.
Decomposition is breaking a complex problem (or system) into smaller, more manageable subsystems or tasks. Each piece can be designed, built and tested independently.
Why decompose?
How to decompose well.
Cambridge tip. Mark scheme expects students to identify SUBSYSTEMS by FUNCTION (login, payment, notifications) rather than by data type (one subsystem per database table).
See the full worked example for subsystems and decomposition →
Show what matters; hide the rest.
Abstraction means REMOVING unnecessary detail to focus on what matters.
Examples in everyday life.
Examples in computing.
Abstraction makes complexity manageable. Without it, every level would have to deal with every other level's details — impossible at scale.
Cambridge tip. Mark scheme rewards students who give a clear example showing what's KEPT vs what's REMOVED.
See the full worked example for subsystems and decomposition →
A hierarchical map of a system's decomposition.
A structure diagram is a hierarchical drawing of a system's decomposition. The OVERALL system sits at the top; subsystems hang beneath; each subsystem can be broken down further into tasks.
What a structure diagram shows.
What it doesn't show. The ORDER of execution, conditions, loops or data flow. Those are the job of FLOWCHARTS or pseudocode. Structure diagrams are STATIC — they show the WHAT, not the HOW.
Why use them.
Cambridge tip. Mark scheme distinguishes structure diagrams from flowcharts. If a question asks for a structure diagram, draw the HIERARCHY — don't add arrows showing flow.
See the full worked example for subsystems and decomposition →
The code-level expression of a subsystem.
When the time comes to write the code, each subsystem typically becomes one or more subroutines — self-contained blocks of code that perform a specific task.
Two flavours:
Why use subroutines.
A program made up of clearly-defined subroutines is called modular. Modular programs are easier to maintain, debug and extend than monolithic 'one-big-blob' programs.
Cambridge tip. Mark scheme rewards 'reduces duplication / repetition' and 'allows reuse' as two of the standard advantages of subroutines.
Verbatim phrases and definitions Cambridge mark schemes credit.
Decomposition + abstraction appear on most Paper 2s. Most-tested questions: identify subsystems for a given scenario (6-8 marks), distinguish decomposition / abstraction (4 marks), describe a structure diagram (4-6 marks). Examiner reports flag the decomposition/abstraction confusion as the most common error.
Sources: Cambridge IGCSE Computer Science 0478 syllabus (2026-2028); 0478 Examiner Reports 2022-2024; 0478/22 Oct/Nov 2023 question paper and mark scheme. Last reviewed 2026-05-09.
Step-by-step solutions to past-paper-style questions on subsystems and decomposition, written exactly the way a tutor would explain them at the board.
Question
Computational thinking is made up of four elements. State TWO of these elements. (2 marks)
Step-by-step solution
Step 1
Recall the four elements: decomposition, pattern recognition, abstraction and algorithmic thinking. Any TWO named correctly earn the marks (1 mark each).
Step 2
Give the exact terms — not vague descriptions. Writing 'breaking it down' instead of 'decomposition' risks not being credited.
Answer
Any two of: decomposition, pattern recognition, abstraction, algorithmic thinking. (1 mark each.)
Examiner tip
Bookwork recall (AO1). Learn the four element names verbatim — they appear almost every series.
Question
A vending machine takes a coin and dispenses a drink. State ONE input and ONE process for this system. (2 marks)
Step-by-step solution
Step 1
Input (1 mark). Something entered INTO the system: the coin inserted (or the selection button pressed).
Step 2
Process (1 mark). Something the system DOES with the input: checking the coin value is enough / calculating the change due. (Dispensing the drink is the OUTPUT, not a process.)
Answer
Input: coin inserted / button pressed. Process: validate the amount paid / calculate change.
Examiner tip
Classic input/process/output sorting (AO2). Don't list an output where a process is asked for — dispensing the drink is the output.
Question
Distinguish between DECOMPOSITION and ABSTRACTION. Give one example of each. (4 marks)
Step-by-step solution
Step 1
Decomposition (2 marks). Breaking a complex problem INTO SMALLER PARTS that can be solved separately. Example: splitting an online bookstore into authentication, catalogue, basket, payments, fulfilment.
Step 2
Abstraction (2 marks). REMOVING unnecessary detail to focus on what matters. Example: a London Underground map abstracts geography away to show only stations and connections.
Answer
Decomposition: SPLIT into parts. Abstraction: HIDE unnecessary detail. Different computational-thinking moves; both used together.
Examiner tip
Definition + example each (AO1/AO2). Marks lost when the two terms are described as if they mean the same thing.
Question
Describe what a structure diagram shows and explain how it helps in system development. (6 marks)
Step-by-step solution
Step 1
What it shows (2 marks). A hierarchical diagram with the OVERALL system at the top and SUB-SYSTEMS broken down beneath, level by level. Each level decomposes the level above into smaller parts.
Step 2
How it helps — design (2 marks). Forces designers to identify subsystems clearly and split the problem into manageable pieces. Reveals dependencies and shared modules early.
Step 3
How it helps — team-working (2 marks). Different developers can be assigned different subsystems, working in parallel against the agreed structure. Easier to test each subsystem independently.
Answer
Structure diagram: hierarchical tree decomposing system → subsystems → tasks. Helps in design clarity, parallel team work, independent testing and easier maintenance.
Examiner tip
Two-part question (AO1/AO2). 'How it helps' needs DEVELOPED points, not one-word benefits — pair each benefit with a reason.
Question
An online banking system needs to be decomposed into subsystems. Identify FOUR subsystems and describe what each does. (8 marks)
Step-by-step solution
Step 1
Authentication (2 marks). Handles user log-in, MFA, password reset, session management.
Step 2
Account management (2 marks). Lets users view balances, statements, account settings, set up new accounts or close them.
Step 3
Payments / transfers (2 marks). Initiates transfers between accounts, scheduled payments, recipient management, fraud-check integration.
Step 4
Notifications (2 marks). Sends alerts via email/SMS/push for transactions, low balance, login from new device, etc.
Answer
Authentication, account management, payments, notifications. (Other valid: card management, customer support chat, statement download, lending, investment, fraud detection, audit logging.)
Examiner tip
1 mark naming + 1 mark describing each subsystem (AO2/AO3). A bare list with no descriptions caps at 4 marks.
Question
A weather-monitoring station reads temperature and humidity from sensors every minute, calculates daily averages, displays current readings on a screen and keeps a record for analysis. Decompose this system into its inputs, processes, outputs and storage. (8 marks)
Step-by-step solution
Step 1
Inputs (2 marks). Temperature reading from the temperature sensor; humidity reading from the humidity sensor (the raw data entering the system each minute).
Step 2
Processes (2 marks). Calculate the daily average temperature/humidity; compare a reading against a threshold (e.g. to flag extreme values). Processes manipulate the input data.
Step 3
Outputs (2 marks). Display the current temperature and humidity on the screen; show the calculated daily averages.
Step 4
Storage (2 marks). Save each minute's readings to a file/database so the record can be analysed later.
Answer
Inputs: sensor temperature + humidity readings. Processes: calculate daily averages, compare to thresholds. Outputs: display current readings + averages on screen. Storage: write the readings to a file/database for later analysis.
Examiner tip
The hardest decomposition pattern (AO3). Keep the four categories separate — calculating an average is a PROCESS, displaying it is an OUTPUT, and writing it to a file is STORAGE.
High-scoring sample answers for subsystems and decomposition on the Cambridge IGCSE 0478 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.
State what is meant by the term decomposition in computational thinking. [1]
Model answer
Breaking down a problem (or system) into smaller sub-problems / sub-systems that can be solved more easily.
Why this scores
1 mark (AO1, recall). Either 'smaller parts/sub-problems' or 'sub-systems' is accepted. Saying only 'making it simpler' without the idea of splitting would not score.
A student writes a program that asks the user for two numbers and prints their total. Identify one input and one output for this system. [2]
Model answer
Input: one of the two numbers entered by the user (the value typed in).
Output: the total / sum that is printed.
Why this scores
1 mark per correct item (AO2). Common error: giving the calculation of the total as the 'output' — that is a process; the output is the printed result.
A software team is designing a school library system. Explain why drawing a structure diagram would help them. [3]
Model answer
A structure diagram shows the whole system at the top and decomposes it into sub-systems beneath (e.g. member management, book catalogue, loans/returns). This makes the design clearer because each sub-system is identified and the relationships between them are visible. It also lets the work be divided between developers, so different team members can build different sub-systems in parallel and test each one independently.
Why this scores
3 marks (AO2). Mark 1: hierarchical/top-down decomposition into sub-systems. Mark 2: makes the design clearer / shows how parts relate. Mark 3: allows division of work / parallel development / independent testing. Each developed point scores once.
Explain what is meant by abstraction and describe how it is used when a programmer designs a map app that finds the shortest route between two places. [5]
Model answer
Abstraction means removing (or hiding) detail that is not needed to solve the problem, keeping only the information that matters.
When designing the route-finding map app the programmer abstracts the real world into a simpler model. Roads are represented as connections (edges) and junctions as points (nodes); the distance or travel time of each road is kept because it is needed to find the shortest route. Details that are irrelevant to routing — such as the colour of buildings, the weather, or the names of shops along the road — are removed. This produces a simpler model that the routing algorithm can work on quickly, without being overwhelmed by unnecessary real-world detail.
Why this scores
5 marks (AO1/AO2). 2 marks for the definition: removing/hiding unnecessary detail (1) to focus on what is relevant (1). 3 marks for the worked example: keeps relevant detail such as distances/connections (1), removes irrelevant detail such as building colour/shop names (1), giving a simpler model the algorithm can use (1). Generic 'it makes it simpler' with no map-specific detail caps at the definition marks.
An online cinema-ticket booking system lets customers search for films, choose seats and pay for tickets. Decompose this system into its inputs, processes, outputs and storage, giving at least one example of each. [6]
Model answer
Inputs: the film/showtime the customer searches for; the seat(s) they select; their payment card details.
Processes: check whether the chosen seats are still available; calculate the total price (number of tickets × price, applying any discounts); validate/authorise the payment.
Outputs: display the available seats; show the booking confirmation and a booking reference/e-ticket on screen or by email.
Storage: save the booking and the now-reserved seats to the database; store the customer/payment record.
Why this scores
6 marks (AO2/AO3): up to 2 marks in each of inputs, processes, outputs — and at least 1 must be storage — but capped at 6 overall, with credit only when items are placed in the correct category. A frequent error is listing 'pay for tickets' as an output; paying is a process, and the on-screen confirmation is the output. Marking the seats as reserved/booked is storage.
Explain the difference between decomposition and abstraction, and explain how a programmer would use both when developing a fitness-tracking app that records a user's daily steps and shows weekly progress. [8]
Model answer
Decomposition is breaking a problem down into smaller sub-problems or sub-systems that can each be tackled separately. Abstraction is removing unnecessary detail so that only the information relevant to the problem is kept. They are different computational-thinking elements: decomposition SPLITS the problem up, whereas abstraction SIMPLIFIES it by hiding detail — and they are usually used together.
Using decomposition on the fitness app, the programmer breaks it into sub-systems such as: a step-counting sub-system (reading the sensor and counting steps), a data-storage sub-system (saving each day's total), a progress sub-system (calculating the weekly total/average) and a display sub-system (showing the weekly progress chart). Each sub-system can be designed, written and tested independently, and different developers can work on them in parallel.
Using abstraction, the programmer keeps only the data the app needs — for example the step count, the date and the user's daily goal — and ignores irrelevant detail such as the exact GPS position of every step or the phone's battery temperature. The weekly progress is itself an abstraction: thousands of individual step events are reduced to a single daily total and then to a weekly figure, giving the user a simple, meaningful summary instead of raw sensor data.
Why this scores
8 marks (AO1/AO2/AO3). Up to 3 marks for the distinction: define decomposition (1), define abstraction (1), state the key difference — split vs hide detail (1). Up to 3 marks for applying decomposition: identifies sensible sub-systems (1), each can be developed independently (1), enables parallel work/independent testing (1). Up to 2 marks for applying abstraction: keeps only relevant data such as step count/date and ignores irrelevant detail (1), reducing raw step events to daily/weekly totals as an abstraction (1). Answers that only define the terms without applying them to the fitness app cannot exceed 3 marks.
Definitions to memorise and the exact keywords mark schemes credit for subsystems and decomposition answers — sharpened from recent examiner reports for the 2026 0478 sitting.
Breaking a complex problem or system into smaller, more manageable subsystems or tasks.
Removing unnecessary detail to focus on what matters. Lets you reason about a system without being overwhelmed by the inner workings.
A self-contained part of a larger system that performs a specific function (e.g. login subsystem, payment subsystem).
A hierarchical diagram showing how a system is decomposed into subsystems and tasks. Used in design.
A self-contained block of code that performs a specific task (procedure or function). The code-level expression of a subsystem.
Building software as a collection of independent, replaceable modules. Easier to develop, test, maintain and reuse.
The traps other students keep falling into on subsystems and decomposition questions — taken from recent Cambridge IGCSE 0478 examiner reports and mark schemes — and how to avoid them.
0478 Examiner Reports 2022-2024
Why it happens
Both are computational-thinking concepts.
How to avoid it
DECOMPOSITION = SPLIT into parts. ABSTRACTION = HIDE unnecessary details. Different operations; usually applied together.
Why it happens
Students decompose too aggressively.
How to avoid it
Subsystems are LOGICAL groupings of related functionality (login, payments, notifications). Functions are smaller — they live INSIDE a subsystem.
Why it happens
Both are tree-/box-shaped.
How to avoid it
Structure diagram = hierarchical decomposition (top-down tree). Flowchart = step-by-step PROCESS (sequence with branches and loops). Different things.
The things students keep getting wrong in this sub-topic, answered.