What to Study in Year 2 of A-Level Computer Science: No Optional Topics, A Section-by-Section Look at Cambridge Paper 3 Parts 13–20

First, a quick note: A-Level Computer Science has no optional topics. Both papers (Paper 3 and Paper 4) in Cambridge 9618 A Level are compulsory, and all content from Sections 13–20 of the syllabus must be studied. Edexcel IAL does not offer a "Computer Science" course (it offers "Information Technology" instead), so this article focuses only on Cambridge. This article covers the new content added in the second year (A Level stage). In How A-Level Computer Science is Assessed, we only listed the titles of Sections 13–20; for how to write the practical programming questions, see Computer Programming Questions. This article expands on the advanced theory content of Paper 3 section by section, based on the Cambridge 9618 syllabus. We have cross-checked and confirmed that the content of Sections 13–20 is identical in both the 2026 syllabus and the 2027–2029 syllabus (2nd edition).

1. The Two A Level Papers

• Paper 3 Advanced Theory: 1 hour 30 minutes, 75 marks, written exam, all questions compulsory, includes both short-answer and longer-response questions; covers Sections 13–20; accounts for 25% of the A Level;
• Paper 4 Practical: 2 hours 30 minutes, 75 marks, taken on a computer without internet or email access, using Java, Visual Basic (.NET), or Python (all in console mode); covers Sections 19–20, but does not test low-level programming or declarative programming; accounts for 25% of the A Level;
• Calculators are not allowed in any of the papers.

In other words, Sections 13–18 are only tested in the Paper 3 written exam; Sections 19–20 are tested for understanding in Paper 3 and for practical implementation in Paper 4.

2. Section 13: Data Representation

• User-defined data types: Why they are needed; non-composite types (enumerations, pointers); composite types (sets, records, classes/objects); designing appropriate types for a given problem;
• File organization and access: Three types of file organization: serial, sequential (by key field), and random (by record key); sequential access and direct access; hashing algorithms and their use in random file reading and writing;
• Floating-point numbers: Representing mantissa and exponent in two's complement binary; the effects of changing the bit allocation for mantissa and exponent; converting between binary floating-point and decimal; normalization and its reasons; overflow and underflow; binary representation is only an approximation and can lead to rounding errors.

3. Section 14: Communication and Internet Technologies

• Protocols: Why protocols are needed; the layered concept of protocol stacks; the functions of the four layers of TCP/IP (Application, Transport, Internet, and Link layers), and the process of sending a message from one host to another over the internet; the specific uses of HTTP, FTP, POP3, IMAP, SMTP, and BitTorrent (peer-to-peer file sharing);
• Circuit switching and packet switching: Their respective advantages, disadvantages, and suitable scenarios; the role of routers in packet switching; how packet switching transmits messages across networks (including the internet).

4. Section 15: Hardware and Virtual Machines

• Processors: Differences between RISC and CISC, and their respective interrupt handling; the roles of pipelining and registers in RISC processors; the four basic computer architectures: SISD, SIMD, MISD, and MIMD; characteristics of massively parallel computers; the concept of virtual machines, examples of their uses, and their pros and cons;
• Boolean algebra and logic circuits: Truth tables for half-adders and full-adders (logic gates with more than two inputs); circuits, truth tables, and storage functions of SR and JK flip-flops; De Morgan's laws and simplification using Boolean algebra; the purpose and usage of Karnaugh maps.

5. Section 16: System Software

• Operating systems: How to maximize resource utilization; how the user interface hides hardware complexity from the user; process management: multitasking, the three states of a process (running, ready, blocked), the necessity of scheduling, and four scheduling algorithms (round-robin, shortest job first, first-come-first-served, shortest remaining time); the kernel as an interrupt handler, and how interrupt handling manages low-level scheduling; virtual memory, paging, and segmentation, the differences between paging and segmentation, how pages are swapped, and how disk thrashing occurs;
• Translation software: How interpreters execute programs without generating a translated version; the stages of compilation (lexical analysis, syntax analysis, code generation, and optimization); representing language syntax using syntax diagrams or Backus-Naur Form (BNF); evaluating expressions using Reverse Polish Notation (RPN).

6. Section 17: Security

• Encryption: Public keys, private keys, plaintext, ciphertext, symmetric and asymmetric encryption; how to use keys to allow the public to send private messages to an individual or organization, and how to send authenticated messages to the public; the uses, advantages, and disadvantages of quantum cryptography;
• SSL/TLS: Their purposes, use in client-server communication, and appropriate scenarios for use;
• Digital certificates: How to obtain them and how they are used to generate digital signatures.

7. Section 18: Artificial Intelligence

• Use of graphs in AI: The purpose and structure of graphs; searching on graphs using the A* algorithm and Dijkstra's algorithm. The syllabus notes that students are not required to write algorithms for creating, traversing, or searching graphs;
• How artificial neural networks drive machine learning;
• Deep learning, machine learning, and reinforcement learning, along with the reasons for using these methods; categories of machine learning (including supervised and unsupervised learning);
• Backpropagation of error and regression methods in machine learning.

8. Section 19: Computational Thinking and Problem-solving

• Searching: Writing algorithms for linear search and binary search; the conditions for using binary search, and how its efficiency changes with the amount of data;
• Sorting: Writing algorithms for insertion sort and bubble sort; sorting efficiency depends on the initial order and size of the data;
• Abstract data types: Searching in linked lists and binary trees; inserting into stacks, queues, linked lists, and binary trees; deleting from stacks, queues, and linked lists; a graph is an abstract data type—students must be able to describe its characteristics and explain suitable scenarios, but are not required to write code for graphs; implementing stacks, queues, linked lists, dictionaries, and binary trees using built-in types or other abstract data types;
• Algorithm comparison: Comparing algorithms using criteria such as time and memory, and expressing time and space complexity using Big O notation;
• Recursion: The basic characteristics of recursion; how it is expressed in programming languages; writing and tracing recursive algorithms; when it is appropriate to use recursion; what the compiler must do to translate recursive code (use of the stack and "unwinding").

9. Section 20: Advanced Programming

• Four programming paradigms:
  • Low-level programming: Writing low-level code using the five addressing modes: immediate, direct, indirect, indexed, and relative;
  • Imperative (procedural) programming: Assumes structured programming from AS Level as prior knowledge;
  • Object-oriented programming: Terminology such as objects, attributes, methods, classes, inheritance, polymorphism, containment (aggregation), encapsulation, getters and setters, and instances; designing appropriate classes to solve problems; writing code that reflects object-oriented principles;
  • Declarative programming: Writing facts and rules based on given information, and writing code that uses these facts and rules to satisfy a goal;
• File handling and exception handling: Opening and closing files in read, write, and append modes; reading and writing records; operating on serial, sequential, and random files; when it is appropriate to use exception handling, and writing exception handling code.

Note: Low-level programming and declarative programming are only tested in the Paper 3 written exam, not in the Paper 4 practical exam.

10. How to Study

Here are some practical recommendations based on experience:

1. Distinguish between the "written" and "practical" papers: Sections 13–18 focus mainly on understanding and explanation, while Sections 19–20 require both explaining the principles and writing runnable code on a computer;
2. Practice manual calculations: Floating-point conversion and normalization, Boolean algebra simplification, Karnaugh maps, and RPN evaluation cannot use calculators; practice these step-by-step repeatedly;
3. Draw diagrams to remember processes: The four layers of TCP/IP, the three states of a process, the stages of compilation, and the processes of asymmetric encryption and digital signatures are all suitable for flowcharts or diagrams;
4. Manually trace A* and Dijkstra: The syllabus does not require writing graph algorithms, but you must be able to execute searches on graphs; take a few graphs and calculate step-by-step;
5. Implement abstract data types and recursion yourself: Write the insertion, searching, and deletion operations for stacks, queues, linked lists, and binary trees, as well as recursive algorithms, in your chosen programming language, while also preparing for Paper 4 (see Article 193);
6. Master "class design" for object-oriented programming: Don't just memorize terminology; practice designing classes, attributes, and methods starting from a problem description;
7. Use the correct syllabus version: There is a separate syllabus for the 2026 exams and the 2027–2029 exams. While the content of Sections 13–20 is identical, always refer to the syllabus for your specific exam year.

Conclusion

A-Level Computer Science has no optional topics. In the second year, you need to complete Sections 13–20: from floating-point numbers, network protocols, processor architectures, and operating systems, to encryption, artificial intelligence, algorithms, and programming paradigms. Paper 3 tests understanding and explanation, while Paper 4 tests practical implementation. By organizing your study section by section according to the syllabus, practicing accurate expression for the theory, and writing code by hand for the algorithms and programming parts, you will have a clear checklist for your second-year review. If you need A-Level Computer Science tutoring, feel free to chat with our teachers.

Verification note: This article was verified in September 2026: The duration, marks, weightings, answer formats, and assessment scope of Cambridge 9618 Paper 3 and Paper 4 (including that Paper 4 does not test low-level and declarative programming), the rule against using calculators, and the content and descriptions of each subsection in Sections 13–20 (including that writing graph algorithms or code for graph structures is not required) are sourced from Cambridge International's Computer Science 9618 syllabus for 2027, 2028 and 2029 (2nd edition). We have also cross-checked line-by-line with the 2026 syllabus, confirming that the content of Sections 13–20 is identical; the fact that Edexcel IAL does not offer a Computer Science course was verified in Article 170 on this site. The content of each subsection is our partial translation. The study methods are our practical recommendations based on experience.

References:

• Cambridge International: AS & A Level Computer Science (9618)
• Cambridge International: Computer Science 9618 Syllabus 2026 (PDF)
• Cambridge International: Computer Science 9618 Syllabus 2027–2029 (PDF)