Edexcel GCSE CS – Topic 1: Computational Thinking

Overview

Computational thinking is a fundamental set of skills that enable students to model, analyse, and solve problems using logical, systematic approaches. This topic introduces the main principles and techniques used to break down real-world problems and design solutions in computer science.

1.1 Decomposition and Abstraction

Learning Objectives:

Understand the benefit of decomposition for modelling real-world systems and problem-solving (Syllabus 1.1.1).
Explain abstraction and its role in focusing on the essential aspects of problems, disregarding irrelevant details (Syllabus 1.1.1).

What Students Need to Know:

Decomposition: Breaking a complex problem into smaller, manageable tasks or components.
Abstraction: Simplifying complexity by modelling only relevant information and ignoring unnecessary details.
Use subprograms to divide tasks in program design and understand their benefits (Syllabus 1.1.2).

1.1.1 Learn Decomposition

Concept
Decomposition is the systematic process of breaking complex systems or problems into smaller, clearly defined, and more manageable sub-problems.

Analogy: Like solving a jigsaw puzzle, focus on the edges first, then group similar colors, then complete the whole image.
Application:
- In programming, this means separating input, process, and output.
- In projects, assign login systems, data processing, and output separately.

How to Decompose:

Identify the overall problem or goal.
List the main sub-tasks required to reach the goal.
For each sub-task, break it down further if needed.

Example Walkthrough:
A “Library Management System” is decomposed into:

Managing users (register, remove, authenticate)
Managing books (catalogue, borrow, return)
Notifications (overdue reminders)

Students should practice drawing a decomposition tree for any major problem.

1.1.1 Abstraction

Concept
Abstraction is modeling a problem by removing details that are not necessary for solving it, focusing only on the parts that matter for the task.

Analogy: The London Underground map is not geographically accurate—it omits distances, building types, or street names, focusing only on stations and connections.
Academic Example: In simulating animal movement, you only consider location, speed, and direction—not fur color or eye shape.

How to Abstract:

List everything you could possibly know about a system.
Eliminate what does not affect the outcome for your purpose.
Sketch a model keeping only what matters.

Practice Activity:
Students try to draw different kinds of maps: a “tourist” map (with only attractions), a “commuter” map (with only train lines), and reflect on which details were removed and why.

1.1.2 Subprograms

In-depth Concepts:

Subprograms (procedures/functions) encapsulate code for a single, repeatable task.
Well-designed subprograms have clear, descriptive names and accept inputs as parameters.
Outputs from subprograms can be returned directly, stored in variables, or cause visible effects (printing, updating display).

Student Activity:
Write a main program that simulates a quiz. Decompose it into subprograms:

get_question()
check_answer()
update_score()
display_score()

Now, modify one subprogram and demonstrate that the main program does not need further changes, highlighting maintainability.

1.2 Algorithms

Learning Objectives:

Define what an algorithm is and explain its use for problem-solving (Syllabus 1.2.1).
Be able to follow, interpret, and write algorithms in both flowcharts and pseudocode formats (Syllabus 1.2.2, 1.2.3).

What Students Need to Know:

An algorithm is a step-by-step sequence of instructions to solve a specific problem.
Students should recognize standard flowchart symbols and produce flowcharts for simple algorithms.
Students must use pseudocode to represent algorithms and transition between flowcharts and pseudocode.

Algorithms, Flowcharts, and Pseudocode

Algorithm Step-by-Step:

Define input
Define output
Plan steps between input and output
Decide where decisions (branches) and loops are needed

Flowcharts:

Best practices: Keep arrows clear, avoid lines crossing, label decisions YES/NO, and match each flowchart shape to its specific use.
Student task: Draw a flowchart for a vending machine that accepts coins, checks values, dispenses products, and returns change.

Pseudocode:

Follows simple structures, e.g.,textIF temperature > 25 THEN PRINT "It's hot" ELSE PRINT "It's comfortable" END IF

Guided Example:
Have students write pseudocode for calculating BMI given height and weight, then test their instructions on real or sample data.

Variables, Constants, and Data Structures

Variables:

Store changing data; choose clear names (e.g., ‘studentCount’, ‘totalPrice’).
Can be local (within subprogram) or global (across the whole program).

Constants:

Use uppercase (e.g., MAX_SCORE)
Prevent errors from accidental changes

Data Structures:

List/Array: Used for storing multiple values, accessed by index, e.g., student names.
Record: Used for grouping data with multiple attributes, e.g., a “Book” with title, author, ISBN.

Student Activity:
Design and fill a “Student” record, then write pseudocode to loop over a list of records to print all student names with scores above 80.

1.2.3 Operators

Arithmetic: +, -, *, /, MOD (remainder), DIV (integer division)

Show modulus and integer division with examples (e.g., 17 DIV 3 = 5; 17 MOD 3 = 2)

Relational: ==, !=, >, <, >=, <=

Use for making decisions in IF statements

Logical: AND, OR, NOT

Use with Boolean expressions; truth table exploration (combine AND and OR in statements and test input combinations)

Task:
Given three numbers, write pseudocode to check if all are positive AND at least one is even.

1.3 Problem Analysis & Computational Thinking Skills

Learning Objectives:

Apply decomposition and abstraction to a variety of scenarios (Syllabus 1.1.1, 1.1.2).
Use pattern recognition to identify similarities and trends that help in solving new problems more efficiently.

What Students Need to Know:

Pattern Recognition: Spotting common elements in problems, sequences, and systems to apply previously learned solutions.
Model real-world systems and physical processes computationally, design algorithms for these models, and evaluate their effectiveness.

1.4 Trace Tables, Logic, and Testing

Learning Objectives:

Read, interpret, and manually trace through algorithms using trace tables to find and fix errors.
Distinguish between syntax errors and logical errors in algorithms.

What Students Need to Know:

Trace Table: A tool for following the flow of an algorithm, recording variable values to verify its correctness.
Syntax Error: Mistakes in the rules of language (misspelling, missing brackets).
Logic Error: Flaws in the algorithm’s steps that make it work incorrectly even if the language is correct.

1.5 Computational Thinking in Practice

Learning Objectives:

Design, write, and refine algorithms to solve specific problems (Syllabus 1.2.4).
Evaluate alternative algorithms for utility and efficiency.
Test and debug algorithms to ensure their practical reliability.

What Students Need to Know:

Practical examples: Creating sorting algorithms, searching algorithms, and solutions for common computational problems.
Evaluate the algorithm’s effectiveness and discuss improvements.

Learning Trace Tables and Common Algorithms

1.2.4 Trace Tables and Output Testing

In-depth Steps:

Prepare all variable columns and list each step of the algorithm.
Fill in variable values at every change.
Identify steps with unexpected results.

Extension:
Use trace tables on buggy pseudocode to discover both logic and off-by-one errors.

1.2.5 Errors

Syntax: Immediate compiler/interpreter error.
Logic: Output is incorrect, but code runs (e.g., off-by-one error in loops, wrong operator).
Runtime: Caused by unforeseen events during execution (e.g. opening a non-existent file).

Practice:
Show sample buggy codes, have students identify and correct each error type.

1.2.6 Standard Algorithms

Linear Search:
Check each item in turn—use with unsorted data.

Code:

def linear_search(lst, target):
    """
    Search for target in lst using linear search.
    Returns index of target if found, else -1.
    """
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    return -1

# Example usage
numbers = [6, 3, 9, 2, 5, 1]
print(linear_search(numbers, 2))   # Output: 3
print(linear_search(numbers, 7))   # Output: -1

Binary Search:
Only works on sorted data; halve the list each time. Practice by acting out binary search with a number guessing game.

Code:

def binary_search(lst, target):
    """
    Search for target in sorted lst using binary search.
    Returns index of target if found, else -1.
    """
    left = 0
    right = len(lst) - 1
    while left <= right:
        mid = (left + right) // 2
        if lst[mid] == target:
            return mid
        elif lst[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# Example usage
numbers = [1, 2, 3, 5, 6, 9]
print(binary_search(numbers, 6))   # Output: 4
print(binary_search(numbers, 7))   # Output: -1

Bubble Sort:
Step through items, swapping those in wrong order, repeat until sorted.

Code:

def bubble_sort(lst):
    """
    Sort lst in ascending order using bubble sort.
    """
    n = len(lst)
    for i in range(n):
        for j in range(0, n-i-1):
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]

# Example usage
numbers = [6, 3, 9, 2, 5, 1]
bubble_sort(numbers)
print(numbers)   # Output: [1, 2, 3, 5, 6, 9]

Merge Sort:
Break list into halves until individual elements, merge each in sorted order. More difficult as this use the concept of recursion (calling a function wihtin a function)

Code:

def merge_sort(lst):
    """
    Sort lst in ascending order using merge sort.
    """
    if len(lst) > 1:
        mid = len(lst) // 2
        left_half = lst[:mid]
        right_half = lst[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0
        # Merge the two halves
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                lst[k] = left_half[i]
                i += 1
            else:
                lst[k] = right_half[j]
                j += 1
            k += 1

        # Copy any remaining elements
        while i < len(left_half):
            lst[k] = left_half[i]
            i += 1
            k += 1
        while j < len(right_half):
            lst[k] = right_half[j]
            j += 1
            k += 1

# Example usage
numbers = [6, 3, 9, 2, 5, 1]
merge_sort(numbers)
print(numbers)   # Output: [1, 2, 3, 5, 6, 9]

Guided Step Example:
Provide an unsorted list, apply Bubble Sort, and use trace tables to track swaps and passes for deep understanding.

1.2.7 Algorithm Fitness and Efficiency

Key Questions:

Does it always give the right answer? (Correctness)
How many steps does it take to run? (Efficiency/Big-O reasoning)
How much memory or storage does it use?

Activities:
Compare Bubble Sort (many passes) with Merge Sort (fewer passes) on big lists. Create a table of comparisons for visual effect.

1.3 Truth Tables

Practice combining three or more logical inputs.
Extend activities with Boolean algebra simplification (e.g., A AND (B OR NOT C)).
Use logic puzzles (light switches, alarm system triggers) to illustrate real-world usefulness.