sources:

• text: Standard textbook reference

This section covers computational thinking, data structures, algorithms, and systems. Understanding these concepts is critical for both theory examinations and practical programming assessments.

Diagnostic tests in GCSE Computer Science help you identify which areas of the specification you have already mastered and which require further study. Computer science is a subject where knowledge builds cumulatively — you cannot understand algorithms without first understanding data representation, and you cannot analyse programs without understanding logic and Boolean algebra. Diagnostics reveal these prerequisite gaps before they become obstacles.

Prerequisites: Review the prerequisite topics before attempting this section.

• Diag Algorithms
• Diag Programming

Unlike revision tests or mock exams, diagnostic tests are designed to probe your understanding across the full breadth of the specification. They are not graded — their purpose is to generate a map of your current knowledge. The results tell you exactly where to focus your remaining revision time.

A good diagnostic test covers topics from every section of the specification: systems architecture, memory and storage, computer networks, cybersecurity, algorithms, programming fundamentals, data representation, and computational thinking. Questions range from basic recall (definitions, facts) to application (solving a problem using a concept) to evaluation (comparing approaches or explaining trade-offs).

1. You attempt every question — Even if you are unsure, make your best attempt. Partial credit and wrong answers are both informative.
2. You mark your answers — Use the mark scheme to score each question. Be honest — do not give yourself marks for answers you got right by luck.
3. You analyse the results — Group your answers by topic. Which topics did you score well in? Which topics need more work?
4. You create a study plan — Allocate your remaining revision time proportionally to your weakest areas.
5. You retake the diagnostic — After a period of targeted study, retake the diagnostic (or a similar one) to measure improvement.

Computer science has a unique challenge: the subject combines theoretical knowledge (algorithms, data structures, Boolean algebra) with practical skills (programming, debugging, testing). Many students are strong in one area but weak in the other. Diagnostics help identify this imbalance.

Additionally, computer science topics are highly interconnected. You cannot understand sorting algorithms without understanding variables and loops. You cannot analyse network security without understanding binary and data representation. Diagnostics reveal these prerequisite gaps that might not be obvious from classroom work alone.

• Understand the core principles and definitions covered in this section
• Apply key concepts to solve problems and answer exam-style questions
• Connect this material to prerequisite topics and related sections
• Identify specific knowledge gaps across the GCSE Computer Science specification
• Develop a targeted revision strategy based on diagnostic results

Begin with the topic summaries, then work through the practice problems to test your understanding. Use the cross-references to link related concepts across subjects where applicable.

Step 1: Baseline Diagnostic

Before doing any targeted revision, complete the diagnostic test under exam conditions. Set a timer, do not use notes, and attempt every question. This gives you an honest baseline.

Step 2: Mark and Annotate

Use the mark scheme to mark your test. For each question you got wrong or partially correct, write a brief note about why you got it wrong:

• Did you not know the content at all?
• Did you partially understand but make a specific error?
• Did you understand the concept but apply it incorrectly?
• Did you run out of time?

Step 3: Categorise Weaknesses

Group your errors by topic:

• Systems Architecture — Processor components, fetch-decode-execute cycle, Von Neumann architecture
• Memory and Storage — RAM, ROM, primary and secondary storage, memory hierarchy
• Computer Networks — Network types (LAN, WAN), protocols, topologies, client-server vs peer-to-peer
• Cybersecurity — Threats, vulnerabilities, prevention methods, encryption
• Algorithms — Searching, sorting, graph algorithms, Big O notation
• Programming — Variables, data types, control structures, functions, object-oriented concepts
• Data Representation — Binary, hexadecimal, ASCII, Unicode, image and sound representation
• Computational Thinking — Decomposition, abstraction, algorithms, pattern recognition

Step 4: Prioritise

Not all weak areas are equally important or equally easy to improve. Consider:

• How many marks are allocated to this topic in the exam?
• How much time would it take to improve in this area?
• Is this a prerequisite for other topics?

Step 5: Study and Retest

Study your weakest areas using the topic notes, then retake the diagnostic to measure improvement.

This section introduces fundamental concepts that form the foundation for advanced study. Understanding these core ideas is essential before progressing to more complex topics.

The processor (CPU) is the brain of the computer. It executes instructions stored in memory and performs arithmetic and logic operations. Key concepts include:

• Von Neumann architecture — Programs and data are stored in the same memory. The CPU reads instructions from memory, decodes them, executes them, and stores results back to memory. This is the foundation of virtually all modern computers.

• The fetch-decode-execute cycle:

  1. Fetch — The control unit fetches the next instruction from memory using the address in the program counter
  2. Decode — The control unit decodes the instruction to determine what operation to perform
  3. Execute — The ALU (Arithmetic Logic Unit) performs the operation
  4. Store — The result is written back to memory or a register The program counter is then incremented to point to the next instruction.

• Registers — Small, fast storage locations within the CPU. Key registers include the program counter (PC), memory address register (MAR), memory data register (MDR), accumulator, and index register.

• CPU performance — Clock speed (cycles per second), number of cores, cache size, and word size all affect performance. Clock speed alone does not determine performance — two CPUs with the same clock speed may have very different architectures.

All data in a computer is stored as binary (ones and zeros). Understanding how different types of data are represented is essential:

• Binary numbers — Positional notation in base 2. Each position represents a power of 2. Example: $1101_2 = 8 + 4 + 0 + 1 = 13_{10}$

• Hexadecimal — Base 16, used as a compact representation of binary. Each hex digit represents 4 bits. Example: $D_{16} = 1101_2 = 13_{10}$

• Text encoding — ASCII (7-bit, 128 characters) and Unicode (variable-width, supports all writing systems). ASCII ‘A’ = 65, ‘a’ = 97.

• Image representation — Bitmap images store colour values for each pixel. Resolution (width × height) and colour depth (bits per pixel) determine file size. Vector images store mathematical descriptions of shapes.

• Sound representation — Sound waves are sampled at regular intervals (sampling rate, e.g. 44.1 kHz for CD quality). Each sample records the amplitude (bit depth, e.g. 16-bit). More samples and higher bit depth produce better quality but larger files.

An algorithm is a step-by-step procedure for solving a problem. In computer science, algorithms are expressed as programs or pseudocode. Key concepts include:

Searching:

• Linear search — Check each element in order. Time complexity: $O(n)$. Works on any list, sorted or unsorted.
• Binary search — Repeatedly divide the search interval in half. Time complexity: $O(\log n)$. Requires a sorted list.

Sorting:

• Bubble sort — Repeatedly swap adjacent elements if they are in the wrong order. Time complexity: $O(n^2)$.
• Merge sort — Divide the list in half, sort each half recursively, merge the sorted halves. Time complexity: $O(n \log n)$.
• Insertion sort — Build the sorted list one element at a time by inserting each element into its correct position. Time complexity: $O(n^2)$ average, $O(n)$ best case.

Graph algorithms:

• BFS (Breadth-First Search) — Explore all neighbours at the current depth before moving deeper. Uses a queue.
• DFS (Depth-First Search) — Explore as far as possible along each branch before backtracking. Uses a stack (or recursion).

Variables and data types:

• Integer — Whole numbers (e.g. x = 42)
• Float/Real — Decimal numbers (e.g. pi = 3.14159)
• String — Text (e.g. name = "Alice")
• Boolean — True or false (e.g. is_active = True)
• Character — Single character (e.g. letter = 'A')

Control structures:

• Sequence — Instructions executed one after another
• Selection — if, elif/else — choose which path to take based on a condition
• Iteration — for loop (count-controlled), while loop (condition-controlled)

Functions:

• A function is a reusable block of code that performs a specific task
• Functions take parameters (inputs) and return values (outputs)
• Functions promote code reuse, modularity, and readability

Data structures:

• Array/List — Ordered collection of elements, accessed by index
• Stack — Last-in, first-out (LIFO). push to add, pop to remove.
• Queue — First-in, first-out (FIFO). enqueue to add, dequeue to remove.
• Dictionary/Hash Map — Key-value pairs for fast lookup.

Boolean logic is the mathematics of true and false values. It underpins all digital electronics and programming conditions.

• AND (∧) — True only if both operands are true. True AND False = False
• OR (∨) — True if at least one operand is true. True OR False = True
• NOT (¬) — Inverts the value. NOT True = False
• XOR (⊕) — True if operands are different. True XOR False = True

Logic gates implement Boolean operations in hardware:

• AND gate, OR gate, NOT gate, NAND gate, NOR gate, XOR gate
• Truth tables show the output for every combination of inputs

Network types:

• LAN (Local Area Network) — Connects devices in a small area (e.g. a school or office)
• WAN (Wide Area Network) — Connects devices over a large area (e.g. the internet)
• PAN (Personal Area Network) — Connects devices in a very small area (e.g. Bluetooth devices)

Network topologies:

• Star — All devices connected to a central hub/switch. Most common in modern networks.
• Bus — All devices connected to a single cable. Simple but if the cable fails, the network goes down.
• Ring — Devices connected in a circle. Data travels in one direction.

Protocols:

• HTTP/HTTPS — Web browsing (HTTPS adds encryption via TLS/SSL)
• SMTP/POP3/IMAP — Email (sending and receiving)
• FTP — File transfer
• TCP/IP — The fundamental protocol suite of the internet. TCP ensures reliable delivery; IP handles addressing and routing.

Threats:

• Malware — Viruses, worms, trojans, ransomware, spyware
• Phishing — Deceptive emails or websites designed to steal credentials
• Social engineering — Manipulating people into revealing information
• Brute force attacks — Trying every possible password/key

Prevention methods:

• Encryption — Scrambling data so only authorised parties can read it. Symmetric encryption (same key for encrypt and decrypt) vs asymmetric encryption (public key for encrypt, private key for decrypt).
• Firewalls — Filter network traffic based on rules
• Authentication — Passwords, biometrics, two-factor authentication
• Backups — Regular copies of data stored separately

• Skipping prerequisite material before attempting this section: If you struggle with binary, you will struggle with data representation. If you struggle with variables, you will struggle with algorithms. Ensure foundations are solid.

• Not practising problems after reading the theory: Computer science is learned by doing — writing code, tracing algorithms, drawing logic gates, converting number bases. Reading alone is not sufficient.

• Failing to connect concepts across different topics: Networking relies on data representation (binary addressing), algorithms (routing), and security (encryption). Programming relies on data types, algorithms, and Boolean logic. Look for these connections.

• Confusing similar concepts: Common confusions include:

  • RAM (volatile, fast, temporary) vs ROM (non-volatile, stores firmware)
  • Compiler (translates entire program before execution) vs interpreter (translates line by line)
  • Syntax errors (grammar mistakes caught by compiler) vs logic errors (program runs but produces wrong output)
  • HTTP (unencrypted) vs HTTPS (encrypted)

• Not learning pseudocode conventions: The GCSE exam uses a specific pseudocode format. Familiarise yourself with it so you can read and write algorithms fluently.

• Ignoring the computational thinking questions: These questions test your ability to decompose problems, recognise patterns, and design algorithms. They often appear as extended-response questions and carry significant marks.

For deeper understanding, consult the recommended textbooks and additional resources linked throughout the topic pages.

• GCSE Computer Science for OCR by Bob Reeves — Comprehensive textbook aligned to the specification
• Computer Science: A Concise Introduction by David Cohen — Clear explanations of fundamental concepts
• Hello World! Computer Programming for Kids and Other Beginners by Warren and Carter Sande — Accessible introduction to programming
• CS Unplugged (csunplugged.org) — Activities for learning computer science without a computer

This section provides comprehensive study materials and resources. Content is organised to build understanding progressively, from foundational concepts to advanced applications.

• Core concepts and definitions
• Worked examples with step-by-step solutions
• Practice problems for self-assessment
• Cross-references to related topics

Begin with the introductory material before progressing to advanced topics. Use the practice problems to test your understanding and identify areas for further study.