Cambridge 9618 October/November 2021 Examiner Report Analysis

The October/November 2021 examination series was the second opportunity for candidates to sit the revised Cambridge AS & A Level Computer Science (9618) syllabus. Although students had become more familiar with the new specification, the examiner reports revealed many of the same recurring issues seen in the May/June series, along with several new implementation mistakes in Python and pseudocode.

One of the strongest messages throughout the report is that understanding a concept is not enough. Candidates frequently lost marks because they used imprecise technical language, misunderstood recursion, confused data structures, or failed to implement algorithms exactly as required.

This article analyses the official examiner report, highlights the most important lessons for each paper, and provides model solutions that reflect Cambridge's expectations.

Examination Components Covered

The October/November 2021 examiner report includes:

Paper 2: Recursion and the Call Stack

Recursion continues to be one of the weakest areas for many candidates. The examiner observed that students often memorized recursive code without understanding what happens during execution.

Many answers simply stated that recursion "calls itself" without explaining how recursive calls are managed.

Cambridge expected candidates to explain that each recursive call is pushed onto the call stack during the winding phase. Once the base case is reached, functions begin returning one by one during the unwinding phase until the original call receives the final result.

Understanding this process is essential for both Paper 2 theory questions and Paper 4 programming tasks.

Examiner Takeaway

When explaining recursion, always describe:

• The recursive call.
• The base case.
• The call stack.
• Winding.
• Unwinding.
• Returning values.

Merely stating that a function calls itself is not enough.

Example: Recursive Factorial

def Factorial(Number):

    if Number == 0:
        return 1

    return Number * Factorial(Number - 1)

Why This Scores Well

This solution demonstrates:

• A clear base case.
• A recursive call.
• Returning accumulated values during unwinding.

One common mistake identified by examiners was forgetting to multiply the returned value after the recursive call.

Paper 2: File Handling Logic

A surprisingly common mistake involved questions asking candidates to output the last three lines of a text file.

Many candidates incorrectly described algorithms that output the first three lines instead.

Others attempted to read the file backwards, even though the question expected a forward-reading solution using a buffer or sliding window.

Examiner Takeaway

When reading files:

• Identify exactly what must be stored.
• Think about how many values need to remain in memory.
• Avoid assumptions based on familiar programming patterns.

Better Algorithm

Instead of storing every line:

• Read each line sequentially.
• Maintain only the most recent three lines.
• Output those lines after reaching EOF.

This approach minimizes memory usage while satisfying the problem requirements.

Paper 1: Cryptography Explanations

The examiner highlighted another recurring issue.

Candidates frequently answered encryption questions with vague statements such as:

Encryption prevents hacking.

or

Nobody can read the message.

These statements were considered too general.

Cambridge expected candidates to explain how asymmetric encryption works rather than simply describing its purpose.

High-Scoring Explanation

A message is encrypted using the recipient's public key.

Only the matching private key can decrypt the ciphertext.

Therefore, only the intended recipient can read the original message.

Notice the logical chain of reasoning.

This is exactly what Cambridge expects in "Explain" questions.

Paper 4: Binary Tree Representation

Many candidates struggled with array-based binary trees.

The report noted confusion between:

• Array indices
• Node values
• Left pointers
• Right pointers

Candidates often attempted to treat pointer values as node data.

Model Python Example

def InOrder(ArrayNodes, Root):

    if Root == -1:
        return

    LeftPointer = ArrayNodes[Root][0]
    Data = ArrayNodes[Root][1]
    RightPointer = ArrayNodes[Root][2]

    InOrder(ArrayNodes, LeftPointer)

    print(Data)

    InOrder(ArrayNodes, RightPointer)

Why This Scores Well

This implementation:

• Checks the base case first.
• Visits the left subtree.
• Prints the current node.
• Visits the right subtree.

It follows the correct In-Order traversal sequence.

Common Binary Tree Mistakes

According to the examiner report, students often:

• Forgot to test for null pointers.
• Mixed up node values and pointers.
• Used iterative loops inside recursive functions.
• Produced incorrect traversal orders.

A good revision strategy is to draw the tree and trace the recursive calls by hand.

Paper 4: Reading Objects from Files

Another major issue appeared during object-oriented programming questions.

Candidates could usually declare classes correctly but struggled when reading object data from files.

Many forgot to instantiate new objects.

Others failed to handle missing files using exception handling.

Model Implementation

class Picture:

    def __init__(self, Description, Width, Height, Colour):

        self.__Description = Description
        self.__Width = Width
        self.__Height = Height
        self.__Colour = Colour

Reading the file:

try:

    File = open("Pictures.txt","r")

    Description = File.readline().strip()

    while Description != "":

        Width = int(File.readline())

        Height = int(File.readline())

        Colour = File.readline().strip()

        PictureArray.append(
            Picture(Description, Width, Height, Colour)
        )

        Description = File.readline().strip()

    File.close()

except IOError:

    print("Cannot open file")

Why This Scores Well

This solution demonstrates:

• Proper exception handling.
• Object instantiation.
• Reading grouped records.
• Correct loop termination.
• Closing the file.

These are exactly the skills Cambridge was assessing.

Common Python Mistakes

The examiner highlighted several recurring implementation errors.

Students frequently:

• Printed objects instead of attributes.
• Forgot to instantiate objects.
• Ignored exception handling.
• Mismanaged arrays of objects.
• Forgot to close files.

These are relatively easy marks once students become familiar with Python's object-oriented syntax.

Revision Checklist

Before attempting the exam, make sure you can:

✅ Explain recursion using the call stack.

✅ Identify winding and unwinding.

✅ Write recursive base cases.

✅ Read structured files correctly.

✅ Instantiate Python objects.

✅ Implement binary tree traversal.

✅ Explain asymmetric encryption accurately.

Biggest Lessons from October/November 2021

The October/November 2021 examiner report reinforces a pattern that continues throughout later examination series: Cambridge rewards precise technical communication and well-structured algorithms.

Students who understand why recursion works, who can distinguish pointers from data, and who use correct Computer Science terminology consistently perform better than those relying solely on memorized code.

If you're preparing for Cambridge 9618, reviewing examiner reports alongside past papers will help you recognize these recurring pitfalls before they appear in your own exam.

Key Takeaways

Author Bio

Ahmed Elmalla is a Computer Science educator, Certified Cambridge International AS & A Level Computer Science (9618) teacher, and software engineer with over 20 years of teaching, software engineering, and international tutoring experience. He specializes in AP Computer Science A (Java) and Cambridge IGCSE (0478) and AS & A Level Computer Science (9618), helping students build strong programming, computational thinking, and exam-solving skills. Through his Learn with Kemo platform, he has mentored students from around the world using practical, exam-focused instruction tailored to each learner's needs. His lessons combine real-world software engineering experience with personalized one-to-one tutoring, making complex Java and Computer Science concepts easier to understand. Ahmed is passionate about helping students gain confidence, improve academic performance, and achieve outstanding results in international Computer Science examinations.

LinkedIn: https://www.linkedin.com/in/akelmalla

WhatsApp: https://wa.me/60194028484