Programming techniques

Allow queue can be circular or linear, stack can only be linear

Examiner’s Comments

The vast majority of candidates identified that item was the paramete

Allow queue

Examiner’s Comments

Many candidates identified that tailPointer was an example of a global variable in the code.

2 marks max for benefit
2 marks max for drawback

Examiner’s Comments

The majority of candidates struggled to describe the implications of using global variables, and this highlighted a lack of appreciation of parameter passing and variable scope. At AS Level candidates should become more adept at using parameters and develop an understanding of why this is beneficial – both in theoretical terms and

within their personal programming practice. There were few responses that were able to give complete descriptions.

Examiner’s Comments

Some candidates thought that if enqueue() returned True it meant that there would be space to add additional values. This was not the case; it meant that the item had been enqueued successfully, but it could have been the last item that then filled the queue to capacity.

Sometimes candidates did explain the reasons why True and False would be returned but were then unable to go on to say how they could be used. Good responses were seen such as ‘the main program can give an error message if the operation didn’t work if the queue was full’.

Exemplar 1

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

A candidate's handwritten answer:

The request() function returns "False" if the array variable is null (i.e. the null pointer is greater than equal to the pre-defined length) and the reference attribute has not been added. The function returns "True" if the query is not null and indicates the item has been added. Their other results can be used to select whether the item pointed to request() has been successfully added by assigning him to a variable : successful = request("x") for example.

This response showed clear understanding of the need to store the result returned by dequeue() to be used in the conditional loop test.

Do not award marks for the line number. The error must be related to the line number stated.

Examiner’s Comments

Many candidates identified at least one logical error, but few were able to identify three errors. The most common error identified was the error in line 02.

Examiner’s Comments

Some candidates mistakenly gave a definition for the dequeue() function instead of answering the question set. Candidates need to be mindful to read the question carefully.

Some candidates used a count-controlled loop whereas a conditional loop was required. Those who made a good attempt at a response often did not assign the result of dequeue() to a variable,

so could not effectively use the return value from the function as well as print the value returned.

Examiner’s Comments

Many responses were too vague, showing little knowledge of the properties of arrays. Relatively few candidates appeared to be able to make explicit links to the scenario to achieve full marks.

BP1 Do not award procedure or method

BP1 Allow self as an additional parameter if Python is used.

BP1 If an access modifier is given for the method, it must be public and not private.

BP2 Do not allow any modified name attribute to be returned.

Examiner’s Comments

While many candidates had little difficulty giving code for a getter() there were a number of common errors. Some candidates used a private access modifier when a getter() needs to be public. There was often erroneous use of ‘procedure’ whereas a getter() is a function that must return a value.
Some candidates tried to set values within the getter() function when it should only have returned the class attribute value.

MP2 allow any order of parameters

"Box" and "Money" must be strings and 25 must be an integer

Allow prize.new() as new is given as the constructor method in the class diagram

Examiner’s Comments

Many candidates struggled with the instantiation of an object. Where candidates made an attempt to instantiate some did not use a string for “box” and “money” or did not give 25 as an integer but instead gave the string “25”.

Give:

• 1 mark for stating a decision

• 1 mark for the action required if true

• 1 mark for the action required if false

Examiner’s Comments

There were only two reasonable decisions that could be given from the scenario details. Candidates needed to make it clear that a decision with a Boolean output was present that would dictate two potential outcomes. Some candidates quoted actions such as ‘randomly assign space for prize’ which did not represent a decision. Many responses described the mechanics of setting up the game and the random spaces but did not highlight the program conditions/decisions as required.

Allow minor changes to identifiers as long as purpose is clear.

Allow

procedure new(pName)
this.name = pName

…
(or similar e.g. self.name)

Allow two parameters if one is self and the response is clearly in Python.

The parameter name should be different to the attribute name.

Examiner’s Comments

It was clear that those candidates with limited OOP programming knowledge found the writing of a relatively simple constructor method difficult. Those with relevant programming experience often found this to be a very straightforward question. Common errors included passing additional values to set the experience, roadPosition and money attributes rather than setting them to the constant values indicated in the question.

Do not allow Function for BP1

BP2 parameters must be given in the correct order to match the calls to updateValues() in the question.

“money” and “experience” must be string values

Examiner’s Comments

The updateValues procedure again proved problematic for candidates with limited OOP experience. No marks were given for the first mark point if a function was declared as there

was no return value. Parameter names needed to be fit for purpose, understandable, and had to match the order given in the question scenario to work for the given example calls.

Allow road.length / len(road) instead of

50

Allow <=49 instead of < 50

Examiner’s Comments

Nearly all candidates achieved some marks, and a majority scored five or six marks.

Line 07 allow print(road[x].name)

Examiner’s Comments

Many candidates scored three or four marks but in general candidates found it harder to identify errors in the code than to complete code in the previous question. Some candidates didn’t give the line number but rewrote the incorrect line before giving the corrected line, which was acceptable, although not ideal given the scaffolding.

AO1: Knowledge and Understanding Indicative content

• Global variables are created when the program starts, all subroutines can access/update the contents
• Local variables are created in the subroutine they are created in, they are not accessible directly from any other subroutine
• Local variables are removed from memory when the subroutine ends.
• Local variables can be passed as parameters to a function to be updated, and then returned to override the original local variable
• Local variables can be passed by reference to a subroutine to allow the content of the variable to be updated

AO2: Application

• The variables will be stored in memory throughout the whole code execution. However, the amount of data they are storing is relatively low so would not use a lot of memory.
• When the game is expanded, the amount of data may increase so it could be memory intensive, especially if graphics are used in the game.
• Both arrays are needed throughout the whole game so keeping them as global will make writing the code easier as the programmer will not need to keep passing them as parameters and setting return values.
• Only one part of the game is being created initially and therefore the use of global variables would not affect the efficiency greatly. However, when the program expands, it could cause accuracy / testing / debugging and maintenance problems.

AO3: Evaluation

• As this is only a prototype, the use of global variables would be beneficial.

• However, when the game expands, the use of global variables could create issues such as running out of memory, coupling, testing & debugging problems and maintenance problems.

• The programmer may be best to keep the variables as local and then pass them between the different subroutines as parameters byVal and byRef.

Examiner’s Comments

Most responses were Level 2 for definitions and some expansion to passing parameters. Very few candidates were able to go into depth about alternatives to global variables such as passing by value and passing by reference in detail or extending to issues such as scalability within a larger more extended game. Few candidates picked up on the fact that this was a more limited prototype that was likely to be expanded on which would require more consideration to be given to variable scope.

BP2 – Allow any suitable logic for the while loop condition that iterates between 1 and a.

Allow != for <>
Allow += or equivalent for c = c + 1

Allow hard coded values for upper bound such as a = 12 or a = 13 depending on the relational operator used.

No marks awarded if a conditional loop has not been used.

Max 3 if solution does not completely work.

Examiner’s Comments

This question was generally well attempted with marks relatively evenly distributed throughout the range of marks available. There were some off- by-one errors, with the loop counter or the position of the output line being incorrectly positioned before/after the counter increment. Incorrect loops such as count-controlled for loops were rejected. If responses did not produce a fully correct output, marks given were limited to 3 marks.

Exemplar 1

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

while a > 0:
    c = 1
    while c <= a:
        print(c * a)
        c = c + 1

This response showed a typical off-by-one error where the candidate had not thought through the logic of the entire response. The condition

operator should have been <= rather than < to iterate through all values of c from 1 to 12.

Element/identifier on its own is not enough for BP1

Examiner’s Comments

Most candidates gained some credit for identifying that a variable holds a value, and this was the most popular response.
Element/identifier on its own was insufficient for the first mark point as there had to be a clear indication that the identifier referred to a memory/storage location.

Must have all three for the mark to be awarded.

Examiner’s Comments

The majority of candidates had little difficulty correctly identifying the variables given in the code.

Answer must cover both do loop and while loop for 2 marks to be awarded

BP1 and BP2 must be specific as to the location that the condition is placed

Examiner’s Comments

Many responses were vague and did not accurately identify or distinguish that a while loop

is a pre-condition loop while a do loop is a post- condition loop. Responses had to be clear as to the relative position of the condition in the loop. Accepted responses included a while loop is a pre-condition loop while a do loop is a post- condition loop. Fewer candidates identified that the body of a while loop may not be executed while the body of a do loop will always be executed at least once.

Examiner’s Comments

Most candidates scored at least the first 2 mark- points for the grid dimensions, but far fewer could construct OOP code requiring the attribute and the relevant default parameter value to be given.

Note candidates may attempt to access private attributes directly gameboard.grid(x,y) for example, instead of gameboard.getGridItem(x,y).

Credit cannot be given for the dependent second mark using appropriate get method if they do this, but FT marks can be awarded for later points if a reasonable attempt has been made.

Examiner’s Comments

Many candidate responses gave very little

beyond the procedure declaration and taking in the x and y coordinates as inputs, thus scoring 2 marks at most. There was less successful understanding of how to use the get() methods provided in the scenario to access the data. This is an area of the specification that candidates require extensive practical experience of to be able to fluently answer questions like this in examination conditions.

Many candidates tried to used grid[x,y] by inserting the coordinates into the parameter values and did not identify it as an instance of an object that needed its attributes to be accessed via the appropriate getter methods. Those candidates who tried to access the attributes directly without the appropriate getter methods did achieve some further marks with follow through marks.

Competent coders often gave responses worthy of full marks within just a few lines of code.

Exemplar 3

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

def pressGrid(Board):
    [unclear]
    x = int(input("enter x"))
    y = int(input("enter y"))
    place = Board.getGridItem(x, y)
    if place.getLevel() == 0:
        print("No treasure")
    else:
        print("Treasure found! [unclear] value is place.getValue()")
        print("x + y = place.getSum()")

This response clearly shows a logical and well- structured algorithm that uses the appropriate get() methods to access the relevant attributes of the passed parameter object. Candidates who are fluent in the use of OOP can present elegant and concise solutions.

AO1: Knowledge and Understanding Indicative content

• Local variable can only be accessed within sub-program/main program it is declared within
• Global variable can be accessed by all sub-programs
• Parameters are items passed to a subproblem
• Passing by reference sends a pointer to the original value, so this will be changed when control is returned
• Passing by value sends the a copy of the value, so the original will not be changed when control is returned

AO2: Application

• If board is local it can only be accessed in the main program

• This will need to be passed to any sub- programs that need to use it

• If the board needs to be changed it will need passing by reference, so that the board is updated

• If it only needs to be accessed and not changed it can be passed by value

AO3: Evaluation

• If global then this would be present in memory throughout hence using more memory
• …however the board will be required throughout the program so may be as efficient as passing it through parameters
• …if global then the programming may be more straight forward, and less likely to have errors with passing the board incorrectly to subprograms, i.e. it may not be updated when it needs to be
• Using local means that the board can be manipulated by subprograms without affecting the actual board if needed, for example to simulate potential changes.

Examiner’s Comments

A good range of Level 2 responses were observed with competent descriptive definitions of local versus global and byVal/byRef parameter passing.

There were far fewer high level AO3 evaluations

of relative memory use within the context of the scenario when passing byVal/byRef for a relatively large grid object. Good, contextualised responses took the elements of the scenario in section B of the paper and talked about the grid object and passing parameters like x and y coordinates. Responses such as this were relatively rare.

[An examiner's marking symbol, not shown here.]

Assessment for learning

Candidates would benefit from producing solutions centred around the scenario presented in Section B of the paper. Having extensive OOP programming experience in a relevant high level language will help candidates to successfully tackle questions where algorithms have to be presented. Sample Python code based on Section B is presented below for consideration.

Assessment for learning

# 2023 Section B

class Treasure:

  def __init__(self, pValue: int,
pLevel: str):
    self.__value = pValue

    self.__level = pLevel

  def getValue(self):
    return self.__value

  def setValue(self,pValue: int):
    return self.__pValue

  def getLevel(self):
    return self.__level

  def setLevel(self,pLevel: str):
    return self.__pLevel

class Board():

  def __init__(self):
    self.__grid = [[Treasure(-1,"")
for _ in range(20)] for _ in
range(10)]

  def getGridItem(self,x: int, y:
int):
    return self.__grid[x][y]

  def setGridItem(self,x: int,y:
int, pTreasure: Treasure):
    self.__grid[x][y] = pTreasure
def guessGrid(b: Board):
  row = int(input("Row: "))
  col = int(input("Col: "))
  t = b.getGridItem(row, col)

  if t.getLevel() == "":
    print("No treasure")
  else:
    print(f"Treasure found at {row}
{col}!")
    print(f"Level {t.getLevel()}
Value {t.getValue()}")

# Test code - Treasure @ 2,2 all
other locations no treasure
island = Board()
prize = Treasure(5,"Prize!")
island.setGridItem(2,2,prize)
guessGrid(island)

Penalise excessive spaces in identifiers such as ascii Value
instead of asciiValue

Examiner’s Comments

This question was generally well done (although slightly less well done than parts (a) (ii) and (a) (iii)), but many candidates did very well. The most common erroneous responses were giving the names of predefined functions/properties or giving relational operators.

Examiner’s Comments

This question required an exact answer only and

was answered correctly by the majority of candidates.

Examiner’s Comments

This question also required an exact answer only and was answered correctly by the majority of candidates.

Allow answers in context as long as they are clear what the features are.

Examiner’s Comments

Weaker responses were limited to one or two points for ‘calls itself’ with example such as ‘line 05’. Fewer candidates went on to identify the requirement for a base case. A variety of terminology was used for the base case such as terminating case and stopping case. If candidates were clearly referring to the case where the recursive calls stopped, and the recursion started to unwind, the mark was given.

Consider awarding description without feature.

Allow other suitable answers.

Examiner’s Comments

Most candidates scored well on this question which lent itself to a wide variety of potential answers. Some candidates quoted ‘autocorrect’ rather than auto complete or suggested predictive code. IDEs can have integrated run-time environments and translation software built-in or attached, but some responses were rather vague or included repetition and did not make it clear that they were referring to an integrated system. Sometimes the descriptive expansion or the initial identification of the point was vague and required the identification plus the description boxes to be taken in combination to give the mark. This was particularly evident when candidates gave a very vague ‘debugger/debugging’ identification.

Examiner’s Comments

Few candidates were able to clearly define the term 'local variable'. The concept of scope of variable s appeared to be poorly understood, with few able to define that a local variable’s scope was that of the function/procedure in which it was declared.

Examiner’s Comments

Some candidates confused the terms local variable and global variable and gave de finitions

the wrong way round. A significant number of responses demonstrated conceptual
misconceptions. The contents of dataArray could be used in other parts of the program if it was passed as a parameter to a
function/procedure, but could not be referenced directly. Responses such as giving ‘can’t be used anywhere else in the program’ as a disadvantage were, therefore, incorrect.

Examiner’s Comments

This question required the purpose of the lines of code to be described, but many candidates just described the functionally of the lines of code such as ‘line 03 is a counter controlled loop from 0 to number.length -1’. The expected purpose of this line of code was to set up a loop to iterate through each character in the input string parameter.

While many candidates could describe the purpose of at least one of the lines of code given, few could clearly describe the purpose of all three lines.

AO1: Knowledge and Understanding e.g.
IDE:

• pretty print / syntax highlighting
• auto-complete
• auto-correction
• breakpoints
• stepping

Editor:

• no helpful writing/debugging features
• no excess features/interface

AO2.1: Application
e.g.
IDE

• identify syntax errors as writing
• …saves trying to find them
• easier debugging as can step through a program
• auto-indenting avoids errors from incorrect indentation
• May have built in unit testing to automate testing and avoid new errors being introduced.

Editor

• does not offer suggestions on code corrections

• Has a lower footprint on memory/CPU which may be suited to quick alterations or working on lowed spec’d systems.

• May be better when learning to program as it forces the user to type everything in full / doesn’t give suggestions, helping things stick in memory.

AO3.3: Evaluation
e.g.

• IDE is helpful in reducing original errors
• IDE is helpful in finding and correcting errors
• Editor is a simpler system to use e.g. less memory needed to run it, does not try and auto-correct incorrectly or introduce errors that the programmer has not made.

Examiner’s Comments

A pleasing number of candidates could identify and describe a range of features of an IDE, with most being able to demonstrate sufficient knowledge to achieve mark band Level 2. Few candidates displayed a level of evaluative reasoning of sufficient depth to achieve mark band Level 3. More successful responses clearly explained how relevant debugging tools in an IDE led to much greater productivity than a text editor

because of the way that they could assist with finding logical errors in code through the use of stepping and tracing. An acknowledgement of the amount of system resources and the complexity of some IDE environments was less often evaluated.

Candidates need to focus on making clear logical arguments with evidence of evaluation (AO3) to be able to achieve mark band 3.

Award a recursive algorithm as equivalent

Examiner’s Comments

Very few candidates were able to produce a working function, but many gained some marks.

Some candidates had little idea of the concept of a function and struggled to define one. Many omitted the definition statement or omitted the required parameter and then asked for user input instead.

The standard of pseudocode/code was quite weak. Indentation of constructs was often missing or hard to follow. Mid-range marks were achieved when candidates effectively utilised MOD to determine if the remainder on division by two was odd or even, and then using DIV to find the next term in the sequence.

More successful responses demonstrated an ability to problem solve, think logically, and present clear working functions.

Allow other checks for a valid number. For example

denary.isInteger == False

Examiner’s Comments

Candidates found Question 4 (b) easier to approach than Question 4 (a). Most could write pseudocode to accept a user input. When validating the input to be a value between 1 and 255, there was incorrect use of relational operators with off -by-one errors on occasion. There was also incorrect use of logical operators where or was used instead of and, and vice- versa. When candidates called
toBinary(inputVal), the result was not always stored for later use.

[An examiner's marking symbol, not shown here.]

Assessment for learning

When preparing candidates for the examination, they will benefit from a wide range of
programming experience.

Questions such as 4 (a) and 4 (b) present an ideal opportunity for developing coded solutions to test and discuss before looking at how the algorithms could be presented as pseudocode.

Examiner’s Comments

Nearly all candidates correctly identified ‘sequence’ as the correct construct.

Examiner’s Comments

Nearly all candidates correctly identified ‘selection’ as the correct construct.

Examiner’s Comments

Most candidates correctly identified two variables from the given code.

Do not award a mark for the line number alone without correction.

Examiner’s Comments

Most candidates were given some marks, but fewer achieved full marks.

The context of the question indicated that the numbers input were positive integers, but candidates did not always appreciate this.

Examiner’s Comments

Most candidate correctly identified that checkValid() was a function because it returned a value. Some candidates erroneously stated ‘because it has an output’ which did not differentiate a function from a procedure since both can print an output as a side effect.

Allow 1/0, ‘T’/’F’, “Yes”/”No” or any sensible alternative as return values.

Examiner’s Comments

Many candidates were able to think
computationally to identify the points in a solution where a decision had to be taken. Occasionally some candidates did not specify the specific result that would be returned from the function after determining if a card was valid or not. There were also occurrences of incorrect logic such as returning valid using an AND condition on the same number and same suit clauses, rather than executing them in sequence.

Examiner’s Comments

Many candidates gained a mark by initialising the identifier cards, but fewer gained the second mark for correctly setting it to be a two- dimensional structure. Many obscure forms of syntax were observed, but marks was given if it was clear that the structure was two-dimensional, however, for many responses, it was clear that a one-dimensional list had been initialised.

Examiner’s Comments

Nearly all candidates gave the correct answer line 5.

Examiner’s Comments

Most candidates knew that a recursive algorithm is self-referential and calls itself, but some candidates were too vague specifying that it ‘calls a function’. Candidates often found it harder to gain the second mark and some gave answers not related to the question such as explanations of how recursion uses stack frames during execution. Technical vocabulary is important, and some candidates did not make it clear that recursion has a base case. Those that stated a stopping/terminating condition needed to qualify their response to say that these conditions stopped/halted the recursion. Where candidates

just wrote ‘stopping condition’ it was too vague as it was unqualified since they could have been talking about any conditional loop.

Examiner’s Comments

Those candidates who scored full marks in 7b had little difficulty giving the correct call calculate(10). Some candidates just wrote 10, which did not answer the question. Those who showed little understanding of recursion in 7b rarely gave the correct answer in 7c.

Examiner’s Comments

Most candidates scored full marks for this question, but the most common error was the omission of the pointerValue or the setting of

the pointerValue to 5 to point to the last element in the stack instead of the next free location at the top of the stack.

Examiner’s Comments

Many candidates answered the question clearly specifying a pointer to the next free index in the stack, but some candidates gave vague responses such as ‘location of next item’.

Examiner’s Comments

Most candidates gained some marks with many gaining full marks. The most common errors were writing identifiers for pointerValue and returnValue with spaces in, returning values as strings, or returning True/False instead of -1 as required in the question.

Ignore additional parameters in function definition

Do not accept the return of string values

FT following a reasonable attempt to check if the stack is full

Examiner’s Comments

Candidates produced a higher standard of pseudocode this session and many scored most if not full marks for a standard stack push routine.

Common errors included omitting a parameter and/or getting a user input as the value to place into the stack, returning strings or printing the return values, and off-by-one errors when testing to see if the stackPointer was at the top of the stack to determine if the stack was full.

It was noticeable that a number of students who were only familiar with Python gave list append type solutions rather than using the array and pointers as per the implementation given.

Another common error was incrementing the value of the stackPointer before the parameter was assigned to stackArray at the
stackPointer index, which was frequently seen when candidates did not know that the stackPointer actually pointed to the index of the next free space in the stack.

Exemplar 3

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

function push(num)
    if pointerValue == StackArray.length then
        return false
    else
        StackArray[pointerValue] = num
        pointerValue++
        return true
    endif
endfunction

Candidates are encouraged to present pseudocode solutions with clear indentation to aid readability. No specific language/syntax is expected, but the logic of the solution must be clear.

Accept

mathsStack = stack()

allow missing brackets this time only e.g. mathsStack = stack

Examiner’s Comments

Many candidates struggled to answer this question because they lacked practical experience of OOP that showed a lack of familiarity in terms of creating instances of a class. Some candidates tried to declare mathsStack as a procedure or class, and many got it the wrong way round and actually declared a new identifier called stack as an instance of the class mathStack.

Accept equivalent for print e.g. output

Examiner’s Comments

The majority of candidates scored some marks but relatively few gained full marks. Return was seen instead of print/output when the question did, on this occasion ask for the message to be output (as the code was specified as being in the main program rather than a subroutine).

Examiner’s Comments

The standard of pseudocode / programming code was better than in previous sessions and most candidates made a reasonable attempt to pop 20 values from the stack. Many candidates found it difficult to reference the class methods correctly or made assumptions about the existence of other methods that were not provided within the scenario (e.g. .full(), .empty(), .length(), .remove()) that should not be presumed to exist.

Those who had little understanding of
encapsulation often tried to access class attributes such as stackPointer directly to manipulate mathsStack, rather than using methods to interact with the instance of the stack.

When candidates did use the .pop() method to retrieve a value from mathsStack they frequently did not store the result for later use to check whether then stack was empty.

Allow 2 valid examples for 2 marks

Examiner’s Comments

Responses to caching were better than those seen in recent papers and many candidates managed to either describe the concept of caching or give an example of something that would realistically be cached. Far fewer managed to do both in detail.

Accept exact spelling only

Do not award numberOfWords if there are obvious spaces in ‘number of Words’. It must be a valid identifier.

Examiner’s Comments

The majority of candidates answered correctly, with the most popular answers being count and contents. A few candidates incorrectly gave data values from the array rather than identifying variables in the function.

Must cover byVal and byRef for 2 marks to be awarded.

Must be clear that byVal is a copy of the original

value.

Examiner’s Comments

It was pleasing to see an improvement in responses to this topic this session. There were still some answers that were too vague that did not specify that by value uses a copy of the parameter and that by reference passes the memory address. Other examples of vagueness that were not given marks included answers such as ‘by value can’t change the value while by reference can’ that did not qualify the scope within which changes can be made. A variable passed by value can clearly be changed in a function, but it is the local copy that is changed and then disregarded when the function finishes.

Accept:
while count <= numberOfWords - 1

Accept other combinations for example counting from 1 and then subtracting 1 for the array element (but do not credit off by one errors)

Accept:
len(words) for numberOfWords

Examiner’s Comments

Many candidates struggled with this question. Some candidates rewrote the for loop putting the word while in place of for showing little

understanding of the difference between a counter-controlled and a conditional loop.

Common errors included not initialising the count variable before using it within the body of the while loop, off-by-one errors, and forgetting to increment the count variable within the loop. Poor indentation was often a problem, and a number of candidates erroneously placed the return statement inside the body of the loop.

Off-by-One errors
There were many off-by-one errors observed, e.g. while count <= numberOfWords rather

than while count < numberOfWords.

Candidates need to give code that is logically accurate, and, in this instance, it required the loop to run the correct number of times so that all the words in the array were processed.

Examiner’s Comments

Many candidates found it easier to describe a benefit than to give a drawback. The most commonly identified benefit was that the array would have global scope (and would therefore not need to be passed as a parameter), but often the descriptions given were too vague, e.g. ‘can be accessed anywhere’. The correct technical vocabulary is required.

Drawbacks were poorly described. Potential side

effects and resultant complexity debugging were frequently alluded to as ‘accidental change’ but not fully developed into complete qualified points.

There was also a frequent misconception that you cannot have multiple variables with the same name, which is not true. When a local variable is declared with the same name as a global variable that already exists, it takes precedence within the local scope.

Examiner’s Comments

Most candidates achieved at least 2 marks by identifying two suitable features, but often the expansions to describe each feature were less clear. Developments in modern IDEs meant that there were many valid features, but auto- completion and breakpoints were particularly common answers.

Allow other suitable answers

Examiner’s Comments

Many candidates scored 1 mark, but fewer gave two clear benefits. Unqualified statements that were too vague were often given. A frequent response was ‘saves time’, but as an unqualified point it did not state how time was saved, e.g. ‘saves time as you don’t have to retype the same code/routine again’.

Candidates need to be reminded that at this level responses of a ‘quicker’ or ‘easier’ nature will not gain marks unless qualified.

Exemplar 1

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

A candidate's handwritten answer:

1. Saves time, as code has already been tested and written so less time need to be tested and written again (more accurate).
2. Easier to debug and test, as code components can be tested individually & (against the own well-defined requirements).

Candidates are expected to fully qualify the points that they make. This response shows clear identification of points followed by qualifying statements.

Examiner’s Comments
In many cases candidates gave the response 2 and did not iterate through the loop until the initial loop condition was false.

Examiner’s Comments
Nearly all candidates successfully identified the factual knowledge that a function returns a value.

Examiner’s Comments
Many candidates responded correctly and could identify the difference between a procedure call and a procedure declaration.

Examiner’s Comments
Many candidates identified that the procedure would reduce the change to 0 but few identified that it was because change was a global variable which meant that the initial value was being decreased to zero or that line 22 would need to be moved to before line 10 to resolve the error.

Allow “To typecast the variables”

Examiner’s Comments
Most candidates identified that the values needed to be converted from integer to string otherwise

an error would be generated because they could not be concatenated. Fewer identified the process as type casting.

Examiner’s Comments
Most candidates showed good recall of knowledge stating that an IDE was used to develop code.

Award 1 mark for stating a construct and then 1 mark for a suitable example that is relevant to the context.

Award a maximum of two marks for each programming construct.

Examiner’s Comments
Most candidates had factual knowledge of the specification point that lists sequence, iteration and branching as types of programming construct. However, many candidates found it more difficult to demonstrate computational thinking skills to logically break down the problem given in the stem of the question to give relevant examples.

Several candidates did confuse programming constructs with either computational thinking concepts such as abstraction and decomposition

or with other elements of programming such as procedures, functions or classes.

Award a maximum of two marks for each advantage.

Allow other suitable examples.

Examiner’s Comments
Many candidates did not give a clear explanation for a point made, and there were a number of ‘cheaper’ or ‘quicker’ type responses that had no qualification for what was being alluded to as ‘cheaper’ or ‘quicker’.

Exemplar 1

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

A candidate's handwritten answer:

1. Please you do not divide different [unclear] [unclear] [unclear] [unclear] components in [unclear], as one [unclear] [unclear] [unclear] [unclear] [unclear] they are [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear]

2. [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear] [unclear]

A response that shows a clear point being made with a detailed explanatory expansion for both benefits.

Examiner’s Comments
Most candidates achieved some marks for this question, but few achieved complete responses. Many identified iteration within the first version as key to repeating the sequence until the validation

conditions were met. Fewer could explain how version two of the code would allow invalid data to be entered into the system.

The procedure name must be relevant to the context in the question.

Both a procedure name and purpose must be stated for 2 marks.

Allow other suitable examples that are relevant to the context.

Examiner’s Comments
Candidates needed to apply computational thinking and show procedural identification. Most scored full marks and identified suitable procedures such as checking login details or adding items to shopping basket with clear descriptions.

Must cover by reference and by value to be given full marks.

Examiner’s Comments
More candidates were able to produce accurate definitions of passing by value and passing by reference than in previous series.

Knowledge and Understanding

• A module is a set/block of instructions which is given a name which can then be called upon by the main body of code to complete a task(s).
• The different modules within the program are then executed when the program is run in order to provide a solution to the problem.
• A module can be created using a function which is a block of code that will return a value, or a procedure which is a block of code that will not return a value.
• Alternatively, a module may contain a collection of different sub-programs (procedures/functions) that are combined together to complete a task.

Application

• The program is a large program and therefore the use of modules will allow the program to be split into different subtasks.

• Different programmers can agree the procedure names and parameters needed for each module.

• Each subtask can then be written and tested by different programmers simultaneously which will therefore reduce development time.

• Each subtask can be self-contained which means that the work carried out by one programmer should not affect another.

• Each subtask can be programmed by specific programmers who have the skills and expertise in that area/language being used.

Evaluation

• Modularity will reduce development time as the team of programmers can work together at the exact same time on the same program.
• Programmers can specialise in their area of expertise/language which therefore means blocks can be reused by other programmers who may not have expertise in some areas.
• Programmers may feel restricted if they have to follow the agreed house style. This could have a knock-on effect with other programmers if not followed.

Examiner’s Comments
Candidates continue to struggle with the banded response question on the paper and most responses did not have a clear structure.

These questions always require candidates to

show knowledge by defining the terms being used, applying knowledge to the specific context given in the question, and then weighing the merits or drawbacks in an evaluation.

Few candidates could develop the concept of modularity to the level of interfaces and the need for agreed standards for function calls and return values. Most responses focused on the basics of the use of functions and procedures but did not demonstrate how different modules might be integrated.

Examiner’s Comments
Candidates needed to apply computational thinking skills to identify the components of the problem presented in the stem of the question and to determine the order of the steps required. Many candidates responded in context and generally answered well, but a significant number either repeated the points they made or repeated steps already given in the diagram.

Accept

for i = 0 to row.length-1

for i = 0 to row.length

for i=0 to 5

Accept

for i = 0 to row.length-1

for i = 0 to row.length

for i=0 to 5

Do not award marks for line numbers alone without stating the error.

Consider 1 mark for not changing line 04 but changing 05 to true and 09 to False

AO1: Knowledge and Understanding Indicative content
Local variables:

• Scope within the module defined within
• Cannot access externally unless passed as parameter, or returned from function
• When module is exited, memory of variable is freed

Global variables:

• Scope within the entire program
• Can access from anywhere
• Retained in memory permanently

ByRef Points to location of variable
ByVal Sends the value

AO2: Application

• If global the arrays can be accessed from all modules by direct reference

• If local to the main, the arrays will need to be passed as parameters byreference

• Can send ByVal – but not always possible with arrays in some languages

• Modules are self contained and then can be reused in other programs he wants to create without needing to take the global variables with them

AO3: Evaluation
e.g.

• +ve Local = memory efficient
• +ve Global = easier programming, simpler to follow, easier to debug
• -ve Global = memory inefficient, not good programming technique
• -ve Local = more difficult to trace/debug/follow where the values are passed
• Relatively small program – don’t know about overall plan for it, it might not be memory intensive, unlikely anyone else is going to access/amend e.g. use as a library – therefore global would not waste significant resources

Must cover purpose and name for 2 marks for each pointer.

Look out for variations in representing the queue

AO1: Knowledge and Understanding Indicative contente.g.

• IDE is software that includes an editor, compiler, run-time environment

Creating

• Autocorrect
• Autocomplete
• Pretty printing

Testing

• Breakpoints
• Stepping
• Variable watch window

AO2: Application
e.g.

• Tell you when you make a syntax error
• Allows you to write and run the code in one piece of software
• Suggests code so you don’t have to remember code, or autocorrect spelling mistakes
• Helps you trace the program so you can see what happens when values change

without having to manually insert print statements etc.

• Autogenerate boilerplate code.

AO3: Evaluation
Candidates will need to evaluate the benefits and drawbacks of using IDEs.
e.g.

• Reduce errors through autocorrect and suggestions
• Reduce time to write the program because features help you spot errors before running the code, some errors will be corrected so you don’t have to
• Write and test in one environment so you don’t have to close and run elsewhere, then re-open etc.

7

35

3

7

35

5

7

35

6

Allow other valid interpretations
e.g. conditional while loop … used to compare against swap flag after each pass; counter controlled for loop … used to check adjacent items on each pass

Do not award marks for stating the line number without a valid correction.

The features must relate to debugging code.

Allow other suitable features appropriate to debugging code.

1 Mark for identification and 1 mark for suitable expansion.

AO1: Knowledge and Understanding Indicative content

• Classes, this a template. It will define what attributes and methods an object should have.
• Objects, when you create an instance of a class. Each object that is instantiated from

the same class will share the same attributes and methods.

• Inheritance, when a sub class takes on the attributes and methods from a superclass/parent class. It can also have its own extra attributes/methods.
• Overriding, when a method name is the same in a parent and sub class, then the method in the parent/super class will be overridden
• Encapsulation, this protects attributes of an object by making them private so that they can’t be accessed or altered accidentally by other objects.

AO2: Application

• A class can be used to declare the attributes and methods for the linked list. These will initialise the nodes and join them.

• Objects can then be used be used to instantiate the class each time a new linked list is needed. Each can be given a different identifier by the other programs.

• Further subclasses may be used by other programs. These can therefore take on the attributes and methods from the base class. These can also be changed or overridden depending on the purpose of the other programs.

• Encapsulation can be used by using set and get methods to ensure that the nodes in the linked list are changed in a way that is intended.

AO3: Evaluation

• Use of OPP techniques will allow for code reusability. His linked list can be saved as library and then reused many times leading to less code.
• OOP also allows programs to be easier to modify and maintain.

The underlying implementation of the queue has

not been specified, so allow alternative valid answers.
e.g.
queueHead = 0
queueTail = 2
Location 2: 129
Location 1: 128
Location 0: 127

Note: Accept alternative valid underlying implementation answers e.g. Shifting all elements in queue forward.

Allow equivalent checks / logic

Credit equivalent modulo arithmetic solution

Allow other suitable descriptions that show how the program could be amended.

6.9 3 may or may not be written by candidates, both are acceptable.

Candidates may add the node freed up (node 3) to the start or the end of the free storage. Award marks for both approaches.

Accept

public node(newData, newPointer)
(may also have data stypes for parameters e.g. int newData)

Accept:

this.data = newData
this.pointer = newPointer

or similar

Example solution:

procedure createUsername()
   firstname = input("Enter First
Name")
   surname = input("Enter Surname")
   number = 0
   while unique == false
    number = number + 1
    username = surname +
firstname.substring(0,1) +
str(number)
    unique =
existingUsers(username)
   endwhile
   print("Username is unique")
endprocedure

There are many different ways that this procedure could have been achieved. Therefore other alternative methods should be given credit

(candidates may use substring or mid to access first character of firstname).

Example Solution

do
   enteredPassword=input("Enter
Password")
   if enteredPassword ==
correctPassword then
    check = true
   endif
until check == true

Alternative solution

do
   enteredPassword=input("Enter
Password")
until
enteredPassword==correctPassword

Allow other suitable responses that are appropriate to writing programming code such as automatic syntax analysis, automatic cross- referencing, line numbers and code comments, automated refactoring, automated code generation (e.g. creating templates for common patterns).

Allow other suitable responses.

Response must cover both black box and white box testing for 2 marks.