Why is "Treating a detail as essential or non-essential 'in general', rather than in relation to the model's purpose." a common mistake in Computational Thinking Skills?

Why it happens: Students judge importance from everyday experience instead of asking what the model is actually for. How to avoid it: Always re-read the stated PURPOSE first, then test each detail: 'Does this affect the thing the model is built to do?' If not, it is irrelevant detail to remove. Source: Examiner reports note that abstraction marks are lost when candidates ignore the context/purpose given in the question.

Why is "Confusing abstraction with decomposition — e.g. answering a 'decompose' question by listing details to remove." a common mistake in Computational Thinking Skills?

Why it happens: Both are computational-thinking skills, so students blur them together. How to avoid it: Abstraction = remove/keep DETAILS to build a model. Decomposition = break the PROBLEM into smaller sub-problems/modules. Match your answer to the verb in the question.

Why is "Stating a procedure returns a value, or that a function does not." a common mistake in Computational Thinking Skills?

Why it happens: Both are 'modules' that take parameters, so the return-value distinction gets forgotten. How to avoid it: Memorise the one rule that decides it: a FUNCTION returns a value; a PROCEDURE does not.

Why is "Putting the whole problem into a single module (e.g. 'RunProgram') and calling it decomposition." a common mistake in Computational Thinking Skills?

Why it happens: Students give a module name but do not actually break the problem into distinct tasks. How to avoid it: Identify each separate task in the scenario and create one module per task, named with a verb-noun (e.g. CheckPayment).

Why is "Naming modules vaguely (e.g. 'Module1', 'DoStuff') so their purpose is unclear." a common mistake in Computational Thinking Skills?

Why it happens: Students focus on counting modules rather than describing what each does. How to avoid it: Use descriptive verb-noun names that say what the module does — AcceptCoins, DispenseDrink, SearchCatalogue.

Why is "Listing benefits of modules/abstraction without developing them, e.g. just writing 'it's simpler' three times." a common mistake in Computational Thinking Skills?

Why it happens: Students know the headline ideas but do not explain WHY each benefit follows. How to avoid it: For each benefit, add a 'because…' that explains the consequence: easier to test BECAUSE each module can be tested on its own; reusable BECAUSE it does one self-contained task. Source: Mark schemes award the development mark only when the benefit is explained, not merely named.

Cambridge International A Levels Computer Science (9618)

Computational Thinking Skills

0% Complete

Detailed Study Notes

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

Computational Thinking Skills — Cambridge AS & A Level Computer Science 9618 Study Notes (2027-2029)

The two computational-thinking skills you must master before you can solve problems on Paper 2: abstraction (keeping only the essential details to build a useful model) and decomposition (breaking a problem into smaller sub-problems that become program modules — procedures and functions). All Paper 2 answers are written in pseudocode and no calculator is allowed.

At a glance

Abstraction = remove/hide unnecessary detail, keep only what is essential for the purpose.
A detail is essential or not only in relation to the model's purpose — never 'in general'.
Abstraction produces a simpler abstract model that is easier to understand and build.
Decomposition = break a (large) problem into smaller sub-problems.
Each sub-problem can become a program module — a named block doing one task.
A module is implemented as a procedure or a function.
Function = returns a value; procedure = performs a task but returns no value.
Decomposition can be repeated — a module can itself be broken down further.
Modules make a program easier to understand, test, debug, reuse and build in teams.

What you’ll learn

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

9.1 — Show understanding of the need for and benefits of abstraction.
9.1 — Show understanding of the purpose of abstraction.
9.1 — Produce an abstract model of a system by including only essential details and removing irrelevant detail.
9.1 — Show understanding of how to decompose a problem into sub-problems.
9.1 — Show understanding that decomposition leads to the concept of a program module (a procedure or a function).

What is computational thinking?

Two thinking skills — abstraction and decomposition — that turn a messy real-world problem into something you can program.

Before you can write a single line of pseudocode you have to think about the problem in the right way. Computational thinking is the set of skills that lets you do this. For section 9.1 you need two of them:

Skill	What it does
Abstraction	Simplify a system by keeping only the essential details and removing the rest.
Decomposition	Break a big problem into smaller sub-problems you can solve one at a time.

These two skills work together. You abstract to decide what matters, and you decompose to split the work into manageable pieces. The pieces (sub-problems) then become the modules of your program — the procedures and functions you will study later in the programming topics.

Think of building a house: an architect first draws a simplified plan (abstraction — no need to draw every brick) and then divides the build into jobs like foundations, walls and roof (decomposition).

Computational thinking = problem-solving skills before coding.
9.1 focuses on abstraction and decomposition.
Abstraction decides WHAT matters; decomposition splits the WORK.
Sub-problems become program modules (procedures/functions).

Abstraction: keeping only what matters

Remove irrelevant detail; keep only the details essential to the model's purpose.

Abstraction is the process of removing or hiding unnecessary detail so that only the features essential to the purpose remain. The result is an abstract model — a simplified version of the real system.

The single most important idea is this: a detail is essential or irrelevant only in relation to the PURPOSE of the model. The same detail can be essential in one model and pointless in another.

Example — a car. For a fuel-economy model, the engine size and fuel-tank capacity are essential, while the paint colour is irrelevant. For a paint-shop model, the colour is essential and the engine size is irrelevant.

The need for and benefits of abstraction:

The problem becomes simpler to understand, because you are not distracted by detail that does not matter.
The solution is easier and faster to design, because there is less to model.
The model can be more general/reusable, because it is not tied to irrelevant specifics.

A classic everyday abstraction is an underground railway map: it keeps station order, line colours and interchanges (essential for planning a journey) but throws away real distances and the street layout (irrelevant for that purpose).

Abstraction = remove unnecessary detail, keep essential detail.
Essential vs irrelevant is decided by the model's PURPOSE.
Benefits: simpler to understand, faster to design, more reusable.
Underground map = keep route info, drop real geography.

See the full worked example for computational thinking skills →

Producing an abstract model

Work through each candidate detail and sort it into 'keep' or 'remove' against the purpose.

In the exam you may be given a system and a purpose, and asked to produce an abstract model by choosing which details to include. A reliable method:

Write down the purpose of the model in one line.
List the candidate details of the real system.
For each detail ask: "Does this affect the thing the model is for?" — keep it if yes (essential), remove it if no (irrelevant).

The diagram below shows this filtering for a fuel-economy model of a car:

The kept details form the abstract model; everything on the right is discarded because it has no effect on fuel economy. If the purpose changed (say, a comfort-rating model), seat fabric and cup holders might move to the 'keep' side.

Step 1: state the purpose.
Step 2: list the candidate details.
Step 3: keep details that affect the purpose; remove the rest.
The same detail can switch sides if the purpose changes.

See the full worked example for computational thinking skills →

Decomposition: breaking a problem into sub-problems

Split a big, complex problem into smaller sub-problems that can each be solved separately.

Decomposition is breaking a large or complex problem into smaller, more manageable sub-problems. Each sub-problem is easier to understand and solve on its own, and you can tackle them one at a time.

How to decompose a problem:

Read the problem and identify the distinct tasks it involves.
Make one sub-problem per task.
If a sub-problem is still large, decompose it again — decomposition can be repeated to as many levels as you need.

Example — an online quiz program decomposes into: present a question, mark the answer, display the final score. Each can be developed and tested separately.

The tree below shows a drinks vending machine decomposed into sub-problems, with one of them (Take Payment) broken down a second time:

Notice that decomposition is recursive in nature: Take Payment is itself decomposed into Accept Coins and Give Change.

Decomposition = break a problem into smaller sub-problems.
One sub-problem per distinct task.
Repeat the process if a sub-problem is still large.
Each sub-problem becomes a module of the program.

See the full worked example for computational thinking skills →

From sub-problems to program modules

Each sub-problem becomes a named module — a procedure or a function.

Once a problem is decomposed, each sub-problem is written as a program module: a self-contained, named block of code that performs one specific task. This is exactly how decomposition 'leads to the concept of a program module'.

In 9618, a module is one of two kinds:

	Returns a value?	Typical use	Pseudocode header
Procedure	No	performs an action	`PROCEDURE DisplayMenu()`
Function	Yes (one value)	computes/returns a result	`FUNCTION Average(a, b, c : INTEGER) RETURNS REAL`

The deciding rule: if the sub-problem must give a value back to the rest of the program, write a function; if it only performs an action, write a procedure.

Here is each kind as a 9618-style pseudocode skeleton:

PROCEDURE DisplayMenu()
   OUTPUT "1. Borrow   2. Return   3. Search"
ENDPROCEDURE

FUNCTION Average(a, b, c : INTEGER) RETURNS REAL
   RETURN (a + b + c) / 3
ENDFUNCTION

Why decompose into modules at all? Modules give real benefits:

Easier to understand — focus on one small task at a time.
Easier to test and debug — each module is tested on its own; errors are localised.
Reusable — a single-task module can be called many times or in other programs.
Teamwork — different programmers can build different modules at the same time.

Module = self-contained, named block doing one task.
Procedure = no return value; Function = returns one value.
Choose by whether a value must be returned.
Benefits: understand, test/debug, reuse, build in teams.

See the full worked example for computational thinking skills →

Quick recap

Abstraction = remove unnecessary detail, keep only what is essential for the purpose.
A detail is essential or irrelevant only in relation to the model's purpose.
Abstraction produces a simpler abstract model, easier to understand and build.
Decomposition = break a problem into smaller sub-problems, solved one at a time.
Decomposition can be repeated — a sub-problem can be decomposed further.
Each sub-problem becomes a program module (a procedure or a function).
Function returns a value; procedure performs a task and returns none.
Modules make programs easier to understand, test, reuse and build in teams.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Abstraction = remove unnecessary detail; keep only essential detail for the purpose.
Essential vs irrelevant is decided by the model's PURPOSE.
Decomposition = break a problem into smaller sub-problems.
A sub-problem becomes a program module.
Function RETURNS a value; procedure does NOT.
Module benefits: understand / test & debug / reuse / teamwork.

How it’s examined

Section 9.1 is assessed in Paper 2 (Fundamental Problem-solving and Programming Skills, 2 hours, 75 marks) — written, externally assessed, with all programming answers in pseudocode and no calculator. Expect short 'state/explain/describe' questions on abstraction and decomposition, and tasks that ask you to: identify essential vs non-essential details for a given model, decompose a stated problem into named modules, and say whether each module should be a procedure or a function (with a justification). Always tie abstraction to the model's PURPOSE and tie procedure/function to whether a value is returned — these are the points the mark scheme rewards.

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

Take this whole topic with you

Step-by-step worked examples — Computational Thinking Skills

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

Question type:

1Essential vs non-essential details for a model
Getting startedIdentify & classify• 9618 Paper 2 style• abstraction, model, AO1
Question
A programmer is creating an abstract model of a car to be used in a fuel-economy calculator. From the list below, identify TWO details that are essential to the model and TWO details that should be removed. List: fuel-tank capacity, paint colour, engine size, number of cup holders. (4 marks)
Step-by-step solution
1. Step 1
  Abstraction means keeping only the details that are RELEVANT TO THE PURPOSE of the model. Re-read the purpose: a fuel-economy calculator.
2. Step 2
  Ask of each detail: 'Does this affect how much fuel the car uses or how far it can go?' Fuel-tank capacity affects range; engine size affects fuel consumption — both essential.
3. Step 3
  Paint colour and number of cup holders have no effect on fuel economy, so they are irrelevant detail and should be removed from the model.
Answer
Essential: fuel-tank capacity and engine size. Remove: paint colour and number of cup holders.
Examiner tip
1 mark per correct essential detail and 1 mark per correct removed detail (max 4). The deciding test is always 'relevant to the stated purpose' — a detail is not essential or non-essential in the abstract, only in relation to what the model is for.
2State the benefit of abstraction
Getting startedWord problem• 9618 Paper 2 style• abstraction, benefit, AO1
Question
Explain what is meant by abstraction and give ONE benefit of using abstraction when modelling a real-world system. (3 marks)
Step-by-step solution
1. Step 1
  Define abstraction: the process of removing or hiding unnecessary detail so that only the essential features needed for the purpose remain.
2. Step 2
  Link the definition to the idea of a model: the result is an abstract model that represents the system in a simpler form.
3. Step 3
  Give one clear benefit and say WHY it helps — e.g. the problem becomes simpler to understand and solve, so the solution is easier and quicker to design.
Answer
Abstraction is the removal of unnecessary detail so that only the features essential to the purpose remain, producing a simpler model of the system. Benefit: it reduces the complexity the programmer has to deal with, making the problem easier and faster to understand and solve.
Examiner tip
1 mark for 'remove/hide unnecessary detail', 1 mark for 'keep only essential/relevant detail', 1 mark for a developed benefit (simpler to understand / easier to solve / reusable). A bare 'it makes it simpler' with no development caps the marks.
3Decompose a vending machine into modules
Building confidenceMulti-step problem• 9618 Paper 2 style• decomposition, modules, AO2
Question
A drinks vending machine accepts coins, lets the customer choose a drink, checks enough money has been paid, dispenses the drink and returns any change. Decompose this problem into FOUR sensible sub-problems, naming each as a program module. (4 marks)
Step-by-step solution
1. Step 1
  Decomposition means breaking the whole problem into smaller, self-contained sub-problems. Read the description and identify the distinct tasks the machine performs.
2. Step 2
  Each distinct task becomes one sub-problem, and each sub-problem can be written as a program module (a procedure or function) with a clear, descriptive name.
3. Step 3
  Name modules by what they DO, using a verb-noun style so the purpose is obvious: AcceptCoins, SelectDrink, CheckPayment, DispenseDrink (and a fifth, ReturnChange, could be added).
Answer
Four modules: AcceptCoins (read inserted coins and total the amount), SelectDrink (let the customer choose and look up the price), CheckPayment (compare amount paid with price) and DispenseDrink (release the chosen drink). A natural fifth would be ReturnChange.
Examiner tip
1 mark per sensible, distinct module that maps to a task in the scenario (max 4). Modules must be named clearly and not overlap. Lumping everything into one 'RunMachine' module shows no decomposition and scores zero.
4Draw a structure chart for an ATM withdrawal
Building confidenceMulti-step problem• 9618 Paper 2 style• decomposition, structure chart, modules, AO2
Question
An ATM cash-withdrawal program performs these tasks: it validates the user's PIN, lets the user enter an amount, checks the account has enough money, and dispenses the cash. Draw a structure chart that shows the program decomposed into a top-level module and these four sub-modules. (4 marks)
Step-by-step solution
1. Step 1
  A structure chart is a hierarchical diagram. The whole program sits in one box at the top; each sub-problem from the decomposition becomes a box on the level below, connected to the top box by a line.
2. Step 2
  Identify and name the top-level module after the whole job: WithdrawCash. This is the box at the top of the chart.
3. Step 3
  Turn each task in the scenario into one sub-module, named with a verb-noun: ValidatePIN, EnterAmount, CheckBalance, DispenseCash. Draw these as four boxes on the level below WithdrawCash, in the left-to-right order they are carried out.
4. Step 4
  Connect the top box to each sub-module with a straight line. The chart below shows the required structure.
  $\texttt{ WithdrawCash}\\\texttt{ / | | \\}\\\texttt{ ValidatePIN EnterAmount CheckBalance DispenseCash}$
Answer
A structure chart with WithdrawCash as the single top-level box, and four sub-module boxes on the level below it — ValidatePIN, EnterAmount, CheckBalance and DispenseCash — each joined to WithdrawCash by a line and placed left-to-right in execution order.
Examiner tip
1 mark for a correctly named top-level module, up to 3 marks for the four sensible sub-modules drawn one level below and connected to it. Marks are lost for a flat list with no hierarchy, for missing connecting lines, or for vague module names. Sub-modules drawn left-to-right in call order is good practice but not separately credited here.
5Two-level decomposition of a library system
StretchMulti-step problem• 9618 Paper 2 style• decomposition, modules, sub-problem, AO2
Question
A school library system must let members borrow a book, return a book and search the catalogue. Decompose the system into THREE top-level modules, then break the 'borrow a book' module into TWO smaller sub-problems. State, for the smaller sub-problems, why a function may be preferable to a procedure for one of them. (6 marks)
Step-by-step solution
1. Step 1
  First-level decomposition: identify the three main tasks the system performs and name a module for each.
2. Step 2
  Three top-level modules: BorrowBook, ReturnBook and SearchCatalogue.
3. Step 3
  Decomposition can be repeated. Break BorrowBook into two smaller sub-problems: CheckMemberCanBorrow (has the member reached their loan limit?) and UpdateLoanRecord (record the book against the member and reduce stock).
4. Step 4
  CheckMemberCanBorrow is best written as a FUNCTION because it must return a value (TRUE/FALSE) so the calling code can decide whether to continue. UpdateLoanRecord only performs an action with no value to return, so a procedure suits it.
  $\texttt{FUNCTION CheckMemberCanBorrow(MemberID : INTEGER) RETURNS BOOLEAN}$
Answer
Top-level: BorrowBook, ReturnBook, SearchCatalogue. BorrowBook decomposes into CheckMemberCanBorrow and UpdateLoanRecord. CheckMemberCanBorrow is preferably a function because it returns a Boolean the rest of the program needs to test before borrowing can proceed.
Examiner tip
Up to 3 marks for three sensible top-level modules, up to 2 for the two smaller sub-problems, 1 for a correct function justification (returns a value the caller uses). Strong answers show that decomposition is recursive — a module can itself be broken down further.
6Build an abstract model of a railway map
StretchWord problem• 9618 Paper 2 style• abstraction, model, essential detail, AO2
Question
A city underground railway publishes a route map (like the famous London Tube map) that is an abstract model of the real network. (a) Explain TWO ways the map uses abstraction. (b) State ONE benefit to a passenger of this abstraction. (5 marks)
Step-by-step solution
1. Step 1
  Identify what the map's PURPOSE is: to help a passenger work out which trains to take and where to change — not to show real geography.
2. Step 2
  Way 1 — irrelevant detail is removed: the true distances, exact bends in the track and surface streets are left out because they do not help with choosing a route.
3. Step 3
  Way 2 — only essential information is kept and simplified: stations, the order they appear on each line, line colours and interchange points are shown clearly (lines drawn as straight horizontal, vertical or 45° segments).
4. Step 4
  State a benefit that follows from the abstraction: the simplified model is far easier and quicker for a passenger to read and plan a journey with.
Answer
(a) (1) Removes irrelevant detail — real distances, track curves and street layout are omitted because they don't help route planning. (2) Keeps and simplifies the essential detail — stations, station order, line colours and interchanges are shown using straight, evenly-spaced lines. (b) The passenger can read the map and plan a journey much more quickly and easily because only the relevant information is shown.
Examiner tip
(a) up to 4 marks (2 ways × 'what is removed' + 'what is kept'); (b) 1 mark for a benefit that follows from the simplification. The high-value idea is that abstraction is judged against PURPOSE — geographic accuracy is irrelevant detail for a route map but would be essential for a model used to plan tunnel construction.

Model Answers — Computational Thinking Skills

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

Question 1
9618 Paper 2 style2 marks
State what is meant by decomposition in computational thinking. (2 marks)
Model answer
Decomposition is the process of breaking a (large/complex) problem down into smaller, more manageable sub-problems. Each sub-problem can then be solved separately, and a sub-problem may itself become a program module (a procedure or function).
Why this scores
1 mark for 'break a problem into smaller parts/sub-problems', 1 mark for 'each part is easier to solve / becomes a module'. Naming the parts 'sub-problems' or linking them to procedures/functions earns the development mark.
Question 2
9618 Paper 2 style2 marks
Describe the purpose of abstraction when developing a computer model of a real-world system. (2 marks)
Model answer
The purpose of abstraction is to represent the system using only the details that are essential for the model's purpose, while removing or hiding the details that are not relevant. This produces a simpler model that is easier to understand, build and work with.
Why this scores
1 mark for 'keep only essential/relevant detail', 1 mark for 'remove/hide unnecessary detail'. A correct answer must mention BOTH sides — keeping the essential and discarding the irrelevant.
Question 3
9618 Paper 2 style4 marks
A program will model a weather station to predict tomorrow's temperature. State, with a reason, ONE detail that is essential to the model and ONE detail that should be left out. (4 marks)
Model answer
Essential detail — air temperature readings (and air pressure/humidity). Reason: these directly affect and help predict the temperature, so they are needed for the model to produce a useful forecast.

Detail to leave out — the colour of the weather station's casing. Reason: it has no effect on the weather or the temperature prediction, so it is irrelevant detail and would only add unnecessary complexity to the model.
Why this scores
2 marks for the essential detail (identification + a reason linking it to the model's purpose) and 2 marks for the omitted detail (identification + a reason it is irrelevant). The reasons carry the marks — naming a detail without justifying its relevance to the PURPOSE scores half.
Question 4
9618 Paper 2 style5 marks
Explain what is meant by a program module, and describe the difference between a procedure and a function. (5 marks)
Model answer
Program module: a self-contained, named block of code that performs one specific task (one sub-problem of the larger program). Splitting a program into modules is the result of decomposition, and a module can be reused and tested on its own.

Procedure: a module that carries out a task but does not return a value to the part of the program that called it. It is called as a statement, e.g. CALL DisplayMenu().

Function: a module that carries out a task and returns a single value to the calling code. Because it returns a value, it is usually called as part of an expression, e.g. Total ← Sum(5, 7).
Why this scores
Up to 2 marks for the definition of a module (named/self-contained block performing one task; result of decomposition / reusable). Up to 3 marks for the procedure vs function difference: the key, mark-bearing distinction is that a function RETURNS A VALUE and a procedure does not.
Question 5
9618 Paper 2 style6 marks
A program is needed to manage an online quiz: it must present questions to the user, mark their answers and display a final score with a grade. (a) Decompose this problem into THREE sensible modules, naming each. (b) State, for each module, whether it is best implemented as a procedure or a function and justify your choice. (6 marks)
Model answer
(a) Three modules:

PresentQuestion — display a question and read the user's answer.

MarkAnswer — compare the user's answer with the correct answer and decide if it is right.

DisplayResult — show the final score and the corresponding grade.

(b) Procedure or function:

PresentQuestion → could be a function if it returns the user's answer to the main program (returns a value), or a procedure if it only displays the question.

MarkAnswer → function, because it must return a value (e.g. TRUE/FALSE or the marks earned) for the main program to add to the running score.

DisplayResult → procedure, because it only performs an action (outputs to screen) and returns no value.
Why this scores
(a) up to 3 marks for three sensible, distinct modules mapped to the scenario. (b) up to 3 marks for correct procedure/function choices with justifications. Full marks require every justification to hinge on whether a value is returned — that is the discriminator the mark scheme rewards.
Question 6
9618 Paper 2 style6 marks
Explain THREE benefits of decomposing a large program into modules. (6 marks)
Model answer
Benefit 1 — Easier to solve and understand. Each module deals with one small sub-problem, so a programmer can focus on (and understand) one manageable piece at a time rather than the whole complex program at once.

Benefit 2 — Easier to test and debug. Because each module is self-contained, it can be tested on its own; if there is an error, it can be located within the relevant module rather than searched for across the entire program.

Benefit 3 — Reusability and teamwork. A well-named module that performs a single task can be reused elsewhere (or in other programs), and different team members can work on different modules at the same time, speeding up development.
Why this scores
Up to 2 marks per benefit (point + development): manageable/understandable, easier testing/debugging, reusability, parallel teamwork, easier maintenance. Three clearly different, developed benefits earn full marks; three rewordings of 'it's simpler' do not.

Key Definitions and Keywords — Computational Thinking Skills

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

Computational thinking
Examiner keyword
A set of problem-solving skills used to express a problem in a way a computer can help solve, including abstraction and decomposition.
Abstraction
Examiner keyword
The process of removing or hiding unnecessary detail so that only the features essential to the purpose of a model remain.
Example
An underground railway map shows station order and interchanges but omits real distances and street layout.
Abstract model
Examiner keyword
A simplified representation of a real-world system that includes only the essential details needed for its purpose, with irrelevant detail removed.
Essential detail
A piece of information that is relevant to the purpose of a model and must therefore be kept when applying abstraction.
Decomposition
Examiner keyword
Breaking a (large or complex) problem down into smaller, more manageable sub-problems that can each be solved separately.
Sub-problem
Examiner keyword
A smaller part of a larger problem produced by decomposition. Each sub-problem can be solved on its own and may become a program module.
Program module
Examiner keyword
A self-contained, named block of code that performs one specific task (one sub-problem). In 9618 a module is implemented as a procedure or a function.
Procedure
Examiner keyword
A module that carries out a task but does NOT return a value to the part of the program that called it. Called using a CALL statement.
Example
CALL DisplayMenu()
Function
Examiner keyword
A module that carries out a task and RETURNS a single value to the calling code, so it is usually used within an expression.
Example
Total ← Sum(5, 7)
Reusability
The ability to use the same module in more than one place, or in different programs, without rewriting it — a key benefit of decomposing into modules.

Common Mistakes and Misconceptions — Computational Thinking Skills

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

✕Treating a detail as essential or non-essential 'in general', rather than in relation to the model's purpose.
Examiner reports note that abstraction marks are lost when candidates ignore the context/purpose given in the question.
Why it happens
Students judge importance from everyday experience instead of asking what the model is actually for.
How to avoid it
Always re-read the stated PURPOSE first, then test each detail: 'Does this affect the thing the model is built to do?' If not, it is irrelevant detail to remove.
✕Confusing abstraction with decomposition — e.g. answering a 'decompose' question by listing details to remove.
Why it happens
Both are computational-thinking skills, so students blur them together.
How to avoid it
Abstraction = remove/keep DETAILS to build a model. Decomposition = break the PROBLEM into smaller sub-problems/modules. Match your answer to the verb in the question.
✕Stating a procedure returns a value, or that a function does not.
Why it happens
Both are 'modules' that take parameters, so the return-value distinction gets forgotten.
How to avoid it
Memorise the one rule that decides it: a FUNCTION returns a value; a PROCEDURE does not.
✕Putting the whole problem into a single module (e.g. 'RunProgram') and calling it decomposition.
Why it happens
Students give a module name but do not actually break the problem into distinct tasks.
How to avoid it
Identify each separate task in the scenario and create one module per task, named with a verb-noun (e.g. CheckPayment).
✕Naming modules vaguely (e.g. 'Module1', 'DoStuff') so their purpose is unclear.
Why it happens
Students focus on counting modules rather than describing what each does.
How to avoid it
Use descriptive verb-noun names that say what the module does — AcceptCoins, DispenseDrink, SearchCatalogue.
✕Listing benefits of modules/abstraction without developing them, e.g. just writing 'it's simpler' three times.
Mark schemes award the development mark only when the benefit is explained, not merely named.
Why it happens
Students know the headline ideas but do not explain WHY each benefit follows.
How to avoid it
For each benefit, add a 'because…' that explains the consequence: easier to test BECAUSE each module can be tested on its own; reusable BECAUSE it does one self-contained task.

Computational Thinking Skills

Detailed Study Notes

At a glance

What you’ll learn

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Essential vs non-essential details for a model

2State the benefit of abstraction

3Decompose a vending machine into modules

4Draw a structure chart for an ATM withdrawal

5Two-level decomposition of a library system

6Build an abstract model of a railway map

Computational thinking

Abstraction

Abstract model

Essential detail

Decomposition

Sub-problem

Program module

Procedure

Function

Reusability

✕Treating a detail as essential or non-essential 'in general', rather than in relation to the model's purpose.

✕Confusing abstraction with decomposition — e.g. answering a 'decompose' question by listing details to remove.

✕Stating a procedure returns a value, or that a function does not.

✕Putting the whole problem into a single module (e.g. 'RunProgram') and calling it decomposition.

✕Naming modules vaguely (e.g. 'Module1', 'DoStuff') so their purpose is unclear.

✕Listing benefits of modules/abstraction without developing them, e.g. just writing 'it's simpler' three times.