Comprehensive Study Notes for Edexcel International GCSE Computer Science

Course Structure

This book is designed for students taking the Pearson Edexcel International GCSE (9-1) Computer Science course and covers the entire two-year syllabus. The course content is divided into six units:

  1. Problem Solving
  2. Programming
  3. Data
  4. Computers
  5. Communication and the Internet
  6. The Bigger Picture

Each unit is further divided into sections, offering a mix of learning and activities. Each section includes summary questions to aid in exam preparation for Paper 1 (Principles of Computer Science) and Paper 2 (Application of Computational Thinking).

Unit 1: Problem Solving

1. Understanding Algorithms

  • Learning Objectives: Understand algorithms, their uses, and how to interpret them via flowcharts, pseudocode, and written descriptions. Learn to use arithmetic operators and to code algorithms in high-level languages.
  • Algorithm Definition: A precise method for solving a problem. Key characteristics include being unambiguous, sequential, reusable, and providing a solution.
  • Successful Algorithms: Accuracy, consistency, and efficiency are crucial.
  • Algorithms and Programs: An algorithm serves as a detailed design; a program is the implementation of that design.
  • Displaying Algorithms: Algorithms can be expressed through written descriptions, flowcharts (using standard symbols like process, input/output, decision), and pseudocode.
  • Pseudocode example:
    SEND ‘Please enter the first number’ TO DISPLAY RECEIVE firstNumber FROM KEYBOARD SEND ‘Please enter the second number’ TO DISPLAY RECEIVE secondNumber FROM KEYBOARD SET total TO firstNumber + secondNumber SEND total TO DISPLAY
  • Arithmetic Operators: Includes addition (+, e.g., 8 + 5 = 13), subtraction (–, e.g., 17 – 4 = 13), multiplication (*, e.g., 6 * 9 = 54), real division (//, e.g., 13 / 4 = 3.25), quotient (DIV, e.g., 13 \text{ DIV } 4 = 3), modulus (MOD, e.g., 13 \text{ MOD } 4 = 1), and exponentiation (^, e.g., 3 ^ 3 = 27).
  • Variables and Constants: Variables store data that can change; constants hold fixed data. Descriptive identifiers (names) are crucial for readability.

2. Creating Algorithms

  • Learning Objectives: Create algorithms for problem-solving and use programming constructs (sequence, selection, and iteration) with appropriate conventions.
  • Algorithm Constructs: Sequence (ordered steps), selection (making choices between alternatives), and iteration (repeating a process until a condition is met).
  • Flowchart representation of selection and iteration: A question with two alternatives represents selection; arrows representing the iteration represent the repetition until the desired outcome is reached.

3. Sorting and Searching Algorithms

  • Learning Objectives: Understand and evaluate standard algorithms like bubble sort, merge sort, linear search, and binary search. Understand the influence of data structures on algorithm selection.
  • Sorting Algorithms:
    • Bubble Sort: Compares adjacent items and swaps them if they are in the wrong order, repeating until no swaps occur during a pass. Implementation Description:
      1. Start at the beginning of the list.
      2. Compare the values in position 1 and position 2 in the list – if they are not in ascending order then swap them.
      3. Compare the values in position 2 and position 3 in the list and swap if necessary.
      4. Continue to the end of the list.
      5. If there have been any swaps, repeat steps 1 to 4.
    • Merge Sort: Divides the list into smaller lists until each contains only one item, then repeatedly merges them back in sorted order (recursion).
  • Searching Algorithms:
    • Linear Search: Starts at the beginning and checks each item sequentially until the target is found or the end is reached. Implementation Description:
      1. Start at the first item in the list.
      2. Compare the item with the search item.
      3. If they are the same, then stop.
      4. If they are not, then move to the next item.
      5. Repeat 2 to 4 until the end of the list is reached.
    • Binary Search: Repeatedly selects the middle item to narrow down the search range, requiring a sorted list. (recursion) Implementation Description:
      1. Select the median item of the list.
      2. If the median item is equal to the search item, then stop.
      3. If the median is too high, then repeat 1 and 2 with the sub-list to the left.
      4. If the median is too low, then repeat 1 and 2 with the sub-list to the right.
      5. Repeat steps 3 and 4 until the item has been found or all of the itemshave been checked.
  • Efficiency: Bubble sort uses brute force, merge sort uses divide and conquer.
  • Algorithm Choice: Depends on the data volume & how often list needs to be searched, binary search must have a sorted list.

4. Decomposition and Abstraction

  • Learning Objectives: Analyze problems and design solutions, decompose problems into smaller parts, and use abstraction effectively.
  • Computational Thinking: Defining/analyzing problems, creating structured solutions (algorithms), and coding.
  • Decomposition: Breaking problems into manageable sub-problems for easier solving; enables parallel work and easier error correction.
  • Abstraction: Removing unnecessary details to focus on essential features for problem-solving.
  • Levels of Abstraction: Higher levels involve less detail, simplifying complex tasks (e.g., using "print" command without knowing its implementation details).
  • Coding Impact: High-level languages offer abstraction, but need translation into machine code for execution.

Unit 2: Programming

5. Develop Code

  • Learning Objectives: Explain the difference between algorithms and programs; code algorithms in pseudocode and high-level languages; describe the characteristics of data types and select appropriate data types for variables; use sequencing, selection, and iteration constructs in your programs.
  • Algorithms vs. Programs: An algorithm is a problem-solving method; a program is the coded implementation of the algorithm.
  • Data Types: Specifies the type of data stored in a variable (e.g., integer, real/float, Boolean, character, string). Selection depends on the operations being performed.
    • INTEGER: Whole numbers without decimals (e.g., 30).
    • REAL or FLOAT: Numbers with decimal points (e.g., 25.5).
    • BOOLEAN: True or False values.
    • CHARACTER: Single letters, symbols, or numbers.
    • STRING: Sequence of characters.
  • Variable Initialisation: Assigning an initial value to a variable before use to prevent errors.
  • Assignment Statement: Assigning values/changing the value to variables (SET var TO val).
  • Type Coercion: Changing a variable's data type during program execution, either automatically or manually.
  • Selection: IF…THEN…ELSE: Used to create a branching logic based on a condition.
  • Relational Operators: Used to compare values (==, >, >=, <, <=, !=).
  • Logical Operators: Combining conditions (AND, OR, NOT).
  • Iteration (LOOPS): Repeating set of instruction more than once (REPEAT..END REPEAT FOR .. END FOR): Definite (predetermined rounds) and indefinite (unknown) loops exists.

Unit 3: Data

  • Learning Objectives: Understand number systems (denary, binary, hexadecimal), data representation (text, sound, images), data storage, compression, and encryption.
  • Binary: Understand that computers use binary to represent data (numbers, text, sound, graphics) and program instructions