Using procedural language 'OUTPUT' or print commands inside functions instead of utilizing the 'RETURN' keyword.

Always check the subroutine header. If it is a FUNCTION, it must use RETURN to send back a value. Use OUTPUT only for procedures or when explicitly asked to print directly.

Attempting to use the string concatenation operator '+' in pseudocode instead of the standard ampersand '&' operator.

Remember that pseudocode is language-agnostic. Use the ampersand '&' for all string concatenations (e.g., ResultString <- String1 & String2).

Opening or closing text files without enclosing literal filenames in quotation marks, e.g. writing OPENFILE Stock.txt instead of OPENFILE "Stock.txt".

Treat literal filenames as strings in all file pseudocode blocks. Always write OPENFILE "filename.txt" FOR READ/WRITE.

Declaring class fields as public during Paper 4 OOP tasks, ignoring the requirement that attributes must be private.

Always declare class attributes as private (e.g., using two leading underscores in Python '__AttributeName' or using private modifier in Java/VB). Access them solely via getter and setter methods.

Failing to implement index wrap-around in circular queue functions, leading to linear out-of-bounds pointer increments.

Apply modular arithmetic when incrementing the head or tail pointers of circular queues: Pointer <- (Pointer + 1) MOD MaxQueueSize.

Omitting conditional loop terminators (such as ENDWHILE, ENDIF, and ENDPROCEDURE) in Paper 2 handwritten pseudocode.

Develop a structured habit of writing the terminating keyword (e.g., ENDIF) at the same time you write its opening keyword (e.g., IF), keeping formatting indented and balanced.

Conflating direct and indirect addressing modes in assembly language tracing, loading actual addresses rather than target pointers.

Remember that LDI (indirect load) looks up the value inside the memory address, treats that value as a new target address, and then loads data from that target address.

Failing to specify parent-class constructors using 'super().__init__()' when constructing derived subclass objects in Python during Paper 4.

In OOP inheritance, always make sure to call parent constructor explicitly from the child class constructor using super().__init__(parameter1, parameter2).

Cambridge IAL · Exam Tips

Computer Science (9618) Exam Tips

Q: Opening or closing text files without enclosing literal filenames in quotation marks, e.g. writing OPENFILE Stock.txt instead of OPENFILE "Stock.txt".

Treat literal filenames as strings in all file pseudocode blocks. Always write OPENFILE "filename.txt" FOR READ/WRITE.

Q: Declaring class fields as public during Paper 4 OOP tasks, ignoring the requirement that attributes must be private.

Always declare class attributes as private (e.g., using two leading underscores in Python '__AttributeName' or using private modifier in Java/VB). Access them solely via getter and setter methods.

Q: Failing to implement index wrap-around in circular queue functions, leading to linear out-of-bounds pointer increments.

Apply modular arithmetic when incrementing the head or tail pointers of circular queues: Pointer <- (Pointer + 1) MOD MaxQueueSize.

Q: Omitting conditional loop terminators (such as ENDWHILE, ENDIF, and ENDPROCEDURE) in Paper 2 handwritten pseudocode.

Develop a structured habit of writing the terminating keyword (e.g., ENDIF) at the same time you write its opening keyword (e.g., IF), keeping formatting indented and balanced.

Q: Conflating direct and indirect addressing modes in assembly language tracing, loading actual addresses rather than target pointers.

Remember that LDI (indirect load) looks up the value inside the memory address, treats that value as a new target address, and then loads data from that target address.

Q: Failing to specify parent-class constructors using 'super().__init__()' when constructing derived subclass objects in Python during Paper 4.

In OOP inheritance, always make sure to call parent constructor explicitly from the child class constructor using super().__init__(parameter1, parameter2).

This student-focused guide outlines the exact strategies, common pitfalls, and architectural insights required to excel in the Cambridge International AS & A Level Computer Science (9618) examination, based on rigorous analysis of the 2023-2025 papers and examiner reports.

4 min readUpdated: Jun 21, 2026

Exam at a Glance

Papers

Total Marks

300

Time Limit

7h 30min

Question Types

Paper	Duration	Marks	Questions	Weighting	Question Types
Paper 1 Theory Fundamentals	1h 30min	75	8	25%	Short Answer / Definition, Logic Circuit and Truth Table Drawing, SQL and Database Definition, Assembly Logic Tracing
Paper 2 Fundamental Problem-solving and Programming Skills	2h	75	8	25%	Tracing Logic and Dry Run Tables, Structure Charts and State Diagrams, Syllabus Pseudocode Writing
Paper 3 Advanced Theory	1h 30min	75	13	25%	Advanced Math Representation / Float and K-Maps, Architecture Explanations & Protocols, RPN Evaluation / Dijkstra calculations, Syllabus Stack Declarations / Initialisations
Paper 4 Practical	2h 30min	75	3	25%	OOP Class Structure / Inheritance Declaring, Linear / Queue manipulation logic implementation, Recursive iteration counting code block, String Custom Processing Engine without split()

Grade Scale

A*ABCDEU

Calculator Policy

A silent scientific calculator is required where the syllabus permits one. It must NOT be graphical, programmable, or capable of symbolic algebra (CAS), and it must contain no stored programs or notes.

AO1: AO1 Knowledge and Understanding (35%)
AO2: AO2 Application (35%)
AO3: AO3 Design, Programming, and Problem-Solving (30%)

Built from real past papers and marking schemes (2023–2025).

Tips & Strategies

Mastering 9618: The Path to Grade-A Success in A-Level Computer Science

A-Level Computer Science is not just about writing code; it is about precision, rigorous logic, and structured explanation. To achieve top marks, a candidate must think like an compiler and write like a technical author. This guide explores the blueprint of the exam papers, dissects where students lose the most marks, and provides actionable advice directly inspired by official CAIE examiner findings.

The 5-Minute Habit That Saves a Grade: Structured Planning

When faced with a complex algorithm question in Paper 2 or Paper 4, the temptation is to start writing pseudocode or Python/Java statements immediately. This is the single biggest trap. Top-performing candidates spend the first five minutes mapping out their data structures, identifying variable scopes, and writing down their logic in plain English or a high-level flowchart. In Paper 2, check for requirements like stepwise refinement; always follow a modular approach, breaking big processes into smaller, testable subroutines. In Paper 4, plan your classes and their relationships before implementing them, keeping attributes private by default to adhere to OOP principles.

Where the Marks Really Hide: Trace Tables and Pointer Wrapping

Trace tables (dry runs) are highly valued by examiners, yet many students lose easy marks by being untidy or skipping lines. When dry-running a loop, record every variable update on a separate row as it changes. Pay extreme attention to mathematical operators like MOD and DIV. Similarly, data structures such as circular queues and binary trees require precise pointer manipulation. A very common pitfall is updating a queue's tail pointer without implementing the wrap-around logic (e.g., (TailPointer + 1) MOD QueueSize). Skipping this calculation causes index-out-of-bounds crashes, which will immediately cost you the implementation marks.

Decoding the Command Words: Explain vs. Describe vs. State

Many theory marks in Papers 1 and 3 are lost because students do not answer the prompt at the correct depth. Let's decode what examiners are looking for:

State: Write a brief, direct point or a single name (e.g., "State the type of memory: EEPROM"). No elaboration needed.
Explain: Show cause and effect. Do not just state a definition; explain how or why it works in the given context (e.g., "Explain why magnetic disks are chosen over SSDs: They offer a lower cost per unit of storage, making high-capacity storage for large video files less expensive.").
Describe: Provide a detailed account of a process or concept (e.g., "Describe how packet switching is used: The message is split into packets, each packet is given a header with source/destination IPs, packets are routed independently, and reassembled at the destination.").

The Holy Trinity of Pseudocode: Ampersands, Quotes, and End Blocks

Paper 2 is heavily focused on handwritten pseudocode, and examiners grade this strictly according to the syllabus guide. To avoid unnecessary mark deductions, remember these three gold rules:

String Concatenation: Never use the plus symbol (+) to join strings in pseudocode; this is language-specific. You must use the ampersand (&) operator.
Literal Filenames: When using file commands, always wrap literal filenames in quotation marks. Write OPENFILE "Data.txt" FOR READ, never OPENFILE Data.txt. Additionally, always make sure to call CLOSEFILE "Data.txt" to prevent file locking and ensure proper stream disposal.
End Blocks: Always close your selection and iteration constructs explicitly. Every IF needs an ENDIF, every WHILE needs an ENDWHILE, and every FUNCTION / PROCEDURE must have its matching ENDFUNCTION / ENDPROCEDURE.

Paper 4 Practical Survival Guide: OOP Encapsulation and Exceptions

Paper 4 demands that you implement working code in Python, Java, or VB.NET and document it with screenshots of console outputs. To maximize your coding score, keep these practices in mind:

Attribute Encapsulation: Unless instructed otherwise, always declare class attributes as private (e.g., using a double underscore in Python like self.__Species). Declaring them as public will cost you automatic marks.
Constructor Access: Instantiate objects using constructors, and use setters/getters to modify or access variables instead of attempting to overwrite class variables directly.
Subclasses: When writing subclass constructors, ensure you invoke the parent constructor correctly (e.g., using super().__init__() in Python).
File and Exception Handling: Any file input/output routines must be wrapped in try...except or try...catch blocks. Missing these handlers represents an automatic deduction on the examiner's checklist. Remember to close the file stream inside the block or in a finally block.

What Top Scorers Do Differently: Active Reconstruction

Instead of passively reading code or theory guides, top scorers perform active reconstruction. They write algorithms from scratch without looking at notes—specifically practice standard algorithms like Bubble Sort, Recursive Binary Search, Insertion into Binary Trees, and Linked List traversal. When studying assembly language, practice bit manipulation instructions (like AND, OR, and XOR) and understand the difference between immediate addressing (#), direct addressing, and indexed addressing (IX). Commit these fundamentals to memory, and you will enter the exam room with the confidence of an expert computer scientist.

Calculator Programs

Table mode for roots & turning points

Scientific calculator (e.g. Casio fx-991 series)

Purpose: Tabulate \(y\) across a range of \(x\) to locate sign changes (roots) and approximate maxima/minima.

When to use it: Solving or sketching a function when you want to find where its graph crosses or turns.

Steps

Enter the function in TABLE mode, set the start, end and step, then read where the sign of \(y\) changes or where it peaks.

Exam note: Allowed, but the calculator must be silent, non-graphical, non-programmable and free of stored content; always show the working the mark scheme requires.

Statistics mode (mean, SD & regression)

Scientific calculator (e.g. Casio fx-991 series)

Purpose: Read the mean \(\bar{x}\) and standard deviation directly, and the gradient/intercept (and \(r\)) of a linear regression for bivariate data.

When to use it: Any data-handling, statistics, or required-practical analysis question.

Steps

Enter the data in STAT mode (1-VAR or A+BX), then recall \(\bar{x}\), \(\sigma\) or the regression coefficients.

Exam note: Allowed, but the calculator must be silent, non-graphical, non-programmable and free of stored content; always show the working the mark scheme requires.

Carry exact values with Ans & memory

Scientific calculator (e.g. Casio fx-991 series)

Purpose: Keep full-precision intermediate values to avoid rounding errors.

When to use it: Multi-step calculations where premature rounding loses the final accuracy mark.

Steps

Use Ans, STO/RCL or the M+ memory to reuse the unrounded result of each step; round only the final answer.

Exam note: Allowed, but the calculator must be silent, non-graphical, non-programmable and free of stored content; always show the working the mark scheme requires.

Equation solver — to CHECK your working

Scientific calculator (e.g. Casio fx-991 series)

Purpose: Use the built-in EQN/SOLVE mode to verify roots of quadratics or simultaneous equations you have already solved by algebra.

When to use it: As a check only, after solving by hand.

Steps

Enter the coefficients in EQN mode (or use SOLVE) and confirm they match your worked solution.

Exam note: Allowed, but the calculator must be silent, non-graphical, non-programmable and free of stored content; always show the working the mark scheme requires.

Common Mistakes

1highMarks at stake: 2Programming (AS Level content)
Using procedural language 'OUTPUT' or print commands inside functions instead of utilizing the 'RETURN' keyword.
How to avoid it: Always check the subroutine header. If it is a FUNCTION, it must use RETURN to send back a value. Use OUTPUT only for procedures or when explicitly asked to print directly.
2highMarks at stake: 1Algorithm Design and Problem-solving (AS Level content)
Attempting to use the string concatenation operator '+' in pseudocode instead of the standard ampersand '&' operator.
How to avoid it: Remember that pseudocode is language-agnostic. Use the ampersand '&' for all string concatenations (e.g., ResultString <- String1 & String2).
3mediumMarks at stake: 1Programming (AS Level content)
Opening or closing text files without enclosing literal filenames in quotation marks, e.g. writing OPENFILE Stock.txt instead of OPENFILE "Stock.txt".
How to avoid it: Treat literal filenames as strings in all file pseudocode blocks. Always write OPENFILE "filename.txt" FOR READ/WRITE.
4highMarks at stake: 4Further Programming (A Level content)
Declaring class fields as public during Paper 4 OOP tasks, ignoring the requirement that attributes must be private.
How to avoid it: Always declare class attributes as private (e.g., using two leading underscores in Python '__AttributeName' or using private modifier in Java/VB). Access them solely via getter and setter methods.
5mediumMarks at stake: 3Further Programming (A Level content)
Failing to implement index wrap-around in circular queue functions, leading to linear out-of-bounds pointer increments.
How to avoid it: Apply modular arithmetic when incrementing the head or tail pointers of circular queues: Pointer <- (Pointer + 1) MOD MaxQueueSize.
6highMarks at stake: 2Algorithm Design and Problem-solving (AS Level content)
Omitting conditional loop terminators (such as ENDWHILE, ENDIF, and ENDPROCEDURE) in Paper 2 handwritten pseudocode.
How to avoid it: Develop a structured habit of writing the terminating keyword (e.g., ENDIF) at the same time you write its opening keyword (e.g., IF), keeping formatting indented and balanced.
7mediumMarks at stake: 2Processor Fundamentals (AS Level content)
Conflating direct and indirect addressing modes in assembly language tracing, loading actual addresses rather than target pointers.
How to avoid it: Remember that LDI (indirect load) looks up the value inside the memory address, treats that value as a new target address, and then loads data from that target address.
8mediumMarks at stake: 2Further Programming (A Level content)
Failing to specify parent-class constructors using 'super().__init__()' when constructing derived subclass objects in Python during Paper 4.
How to avoid it: In OOP inheritance, always make sure to call parent constructor explicitly from the child class constructor using super().__init__(parameter1, parameter2).

Turn these tips into top grades

thinka turns your weak spots into targeted practice, with instant marking and exam-style feedback. Study smarter, not longer.

Start Practising Free See pricing

Practise real exam questions with instant AI feedback and marking.

Start Practising Free