Decomposition

Decomposition is one of the four pillars of computational thinking. It involves breaking a complex problem down into smaller, more manageable sub-problems. Each sub-problem can then be solved individually, making the overall problem much easier to tackle. Decomposition is a fundamental skill in GCSE Computer Science and is used constantly in software development, systems design, and everyday problem-solving.

---

Why is Decomposition Important?

Large problems are difficult to solve all at once. By decomposing them, you can:

• Focus on one part at a time — reducing cognitive load
• Identify which parts are easy and which are hard — allowing you to prioritise
• Work in teams — different people can work on different sub-problems simultaneously
• Test each part independently — making debugging and error-finding much easier
• Reuse solutions — sub-problems that have already been solved elsewhere can be reused

Exam Tip: When asked to decompose a problem in an exam, draw a decomposition diagram (tree diagram) showing the main problem at the top and the sub-problems branching below it. This is a clear and structured way to present your answer.

---

How to Decompose a Problem

Follow these steps to decompose any problem:

1. Identify the main problem — What is the overall task you need to complete?
2. Break it into major sub-problems — What are the main components or stages?
3. Break each sub-problem down further — Can any sub-problem be split into even smaller parts?
4. Continue until each sub-problem is simple enough to solve directly

Example 1: Planning a School Event

Main problem: Organise a school charity event

Sub-Problem	Further Decomposition
Choose a venue	Check availability, compare costs, book the venue
Plan activities	Decide on games, arrange entertainment, set up stalls
Manage finances	Set a budget, track spending, count donations
Promote the event	Design posters, send emails, post on social media
Arrange catering	Choose a menu, order food, set up serving area

Each of these sub-problems is now much simpler to solve than the original problem.

---

Decomposition in Programming

In programming, decomposition is used to break a program into modules, functions, or procedures. Each function handles one specific task.

Example 2: Building a Quiz Program

Main problem: Create a multiple-choice quiz

Decomposition:

• Display a welcome message
• Load questions from a file
• Ask each question and collect the user's answer
• Check if the answer is correct
• Keep track of the score
• Display the final score at the end

Each of these can be written as a separate function or procedure:

FUNCTION displayWelcome()
    OUTPUT "Welcome to the Quiz!"
END FUNCTION

FUNCTION askQuestion(question, options, correctAnswer)
    OUTPUT question
    FOR EACH option IN options
        OUTPUT option
    END FOR
    INPUT userAnswer
    IF userAnswer == correctAnswer THEN
        RETURN TRUE
    ELSE
        RETURN FALSE
    END IF
END FUNCTION

FUNCTION displayScore(score, total)
    OUTPUT "You scored " + score + " out of " + total
END FUNCTION

This modular approach makes the program:

• Easier to read — each function has a clear purpose
• Easier to test — each function can be tested independently
• Easier to debug — if there is a bug, you can narrow it down to a specific function
• Easier to maintain — changes to one function do not affect others

---

Decomposition Diagrams

A decomposition diagram (also called a structure diagram or tree diagram) visually represents how a problem has been broken down. The main problem sits at the top, with sub-problems branching below.

                    Quiz Program
                    /    |    \
            Welcome   Questions   Results
            /           |    \        \
        Display      Load  Ask     Display
        message      file  question  score
                          |
                    Check answer

The same idea drawn as a mermaid subproblem tree:

graph TD
    Q["Quiz Program<br/>(complex problem)"] --> W["Welcome"]
    Q --> Qs["Questions"]
    Q --> R["Results"]
    W --> W1["Display message"]
    Qs --> Qs1["Load from file"]
    Qs --> Qs2["Ask question"]
    Qs --> Qs3["Check answer"]
    R --> R1["Track score"]
    R --> R2["Display final score"]

Exam Tip: If you are asked to draw a decomposition diagram, make sure the main problem is at the top, the sub-problems are clearly labelled, and you show at least two levels of decomposition. Use neat lines to connect related items.

---

Decomposition in Real Life

Decomposition is not limited to computer science. Here are some everyday examples:

• Cooking a meal: Decide on a recipe, buy ingredients, prepare ingredients, cook each dish, serve the meal
• Writing an essay: Plan the structure, research the topic, write the introduction, write each paragraph, write the conclusion, proofread
• Building a house: Lay foundations, build walls, install plumbing, install electrics, add the roof, decorate

In each case, the overall task is broken into stages that can be completed one at a time.

---

Common Mistakes

• Not decomposing enough — If a sub-problem is still complex, break it down further
• Making sub-problems dependent on each other unnecessarily — Try to keep sub-problems as independent as possible
• Forgetting to consider the order — Some sub-problems must be completed before others (e.g., you must load questions before you can ask them)

---

Summary

Decomposition is the process of breaking a complex problem into smaller, manageable sub-problems. It is essential for planning programs, working in teams, and solving real-world problems. In GCSE Computer Science, you should be able to decompose problems, draw decomposition diagrams, and explain how decomposition is applied in programming through the use of functions and procedures.

---

Extended Study: Decomposition as an Engineering Discipline

Decomposition is more than "chop a problem into bits". At AQA GCSE level it is the principal design technique you use to turn a vague requirement into a set of subroutines that can be coded, tested and maintained. Good decomposition gives a program low coupling (sub-problems depend on each other as little as possible) and high cohesion (each sub-problem does one clearly defined job). These two qualities are what make software easy to extend and cheap to fix.

Top-down design