OCR Exam Reference Language

Exam Reference Language is the notation OCR uses to print program code in exam papers. It exists so a code question reads the same whether a school teaches Python, C# or VB.NET. The GCSE J277 specification puts it flatly: all programming code given in examination papers will be presented using the OCR Exam Reference Language.

Three naming facts cause most of the confusion online, and they are worth getting straight before you revise from anything.

It used to be called the OCR Pseudocode Guide. The J277 specification's own summary of updates lists “OCR Pseudocode guide is now the OCR Exam Reference Language”, and explains the format was changed to be easier to read with more examples included. So a page about the OCR Pseudocode Guide is about this, just under the old name.

OCR's A-Level specifications still say Pseudocode. This one is genuinely untidy on OCR's part. Search the H446 and H046 specifications for the phrase “Exam Reference Language” and you will not find it: both call the appendix Pseudocode. The new name landed at GCSE and has not reached the A-Level documents. Same notation family, two live names.

And OCR is now Cambridge OCR. The H446 specification states that as of September 2025 the board's name is Cambridge OCR, and that students who sat exams in summer 2025 receive Cambridge OCR branded certificates. Older resources keep the OCR or Oxford Cambridge and RSA name. This is not Cambridge International: see the last question below, because the two boards are now easy to confuse and their pseudocode notations are not compatible.

One practical consequence of all this. The GCSE specification names Exam Reference Language but only prints the operator table. The fullest published definition of the syntax sits in the A-Level H446 specification appendix. I checked it line by line against the 2015 GCSE Pseudocode Guide and the constructs are identical, which is why the A-Level appendix is a safe reference for a GCSE student. Everything below comes from those documents.

Assignment is a single =. A variable is declared the first time it is assigned, and it takes the data type of the value it is given, so there is no separate declaration line and no type keyword. This is the biggest single difference from Cambridge International notation, which requires an explicit DECLARE.

x = 3
name = "Bob"

Scope is implicit and follows the subroutine boundary. Variables declared inside a function or procedure are local to it. A variable in the main program is made global with the global keyword.

global userid = 123

Casting uses three functions, named exactly as Python names them, which is convenient and also a trap worth noting in section 13.

str(3)        // returns "3"
int("3")      // returns 3
float("3.14") // returns 3.14

Two forms: if with elseif, and switch with case. Both have their own closing keyword, and mixing them up is a free mark lost in a code-completion question.

if entry == "a" then
    print("You selected A")
elseif entry == "b" then
    print("You selected B")
else
    print("Unrecognised selection")
endif

switch entry:
    case "A":
        print("You selected A")
    case "B":
        print("You selected B")
    default:
        print("Unrecognised selection")
endswitch

The comparison and boolean operators are the only part of the notation the GCSE specification itself prints, in section 3c. Note that assignment is = and equality is ==, exactly as in Python.

MOD, DIV and ^ are the three that catch people. In Python they are %, // and **, so a student who has only ever typed Python meets three unfamiliar symbols in a paper that also expects them to be quick.

Arrays are declared with the array keyword and are 0-based. The number in the declaration is the number of elements, so valid indices run from 0 to one less than that.

array names[5]
names[0] = "Ahmad"
names[1] = "Ben"
names[2] = "Catherine"
names[3] = "Dana"
names[4] = "Elijah"

print(names[3])

Two-dimensional arrays use one pair of brackets with a comma, not two pairs.

array board[8,8]
board[0,0] = "rook"

Files open in one of two modes and are handled through methods on the returned object. Reading uses openRead and readLine; writing uses openWrite and writeLine. Both close with close.

myFile = openRead("sample.txt")
x = myFile.readLine()
myFile.close()

myFile = openRead("sample.txt")
while NOT myFile.endOfFile()
    print(myFile.readLine())
endwhile
myFile.close()

myFile = openWrite("sample.txt")
myFile.writeLine("Hello World")
myFile.close()

Comments are // to end of line, as in C or JavaScript, not # as in Python.

print("Hello World") // This is a comment

Exam Reference Language is close enough to Python to feel familiar and different enough to catch you out. Since most OCR students learn Python and are allowed to answer in it, the useful skill is knowing precisely where the two diverge. Here is the same program in both.

global total = 0
array scores[4]
scores[0] = 12
scores[1] = 7
scores[2] = 20
scores[3] = 3

for i = 0 to 3
    if scores[i] MOD 2 == 0 then
        total = total + scores[i]
    endif
next i

print("Even total: " + str(total))

total = 0
scores = [12, 7, 20, 3]

for i in range(4):
    if scores[i] % 2 == 0:
        total = total + scores[i]

print("Even total: " + str(total))

Reading the specifications closely, a few things are genuinely underspecified. Worth knowing so you do not waste time hunting for an answer that is not published.

Object creation is never shown. The A-Level appendix defines a constructor as a procedure called new and then calls player.setAttempts(5) on an object named player, without ever showing how player came into existence. There is no published line for instantiating an object. In an exam this does not matter much, since your logic is what is being read, but it means any tutorial confidently showing you “the” OCR instantiation syntax is inventing it.

The guide contradicts itself on substring capitalisation. The definition is written stringname.subString(...) with a capital S, and the worked example immediately below writes someText.substring(3,3) with a lowercase s. Both appear in the same section of the same document. Nothing to worry about, since either will be read correctly, but if you were wondering which is right: OCR has not decided.

There is no append mode for files, and no error handling at all. openWrite overwrites. There is no documented equivalent of try or catch, no exception model, and no way to express a failed file open. If a question needs that, it will be asked in natural English.

And the full GCSE syntax is not in the GCSE specification. J277 names Exam Reference Language and prints only the operator table. Everything else on this page had to come from the A-Level appendix and the legacy guide. That is a documentation gap on OCR's side, and it is most of the reason a page like this needed writing.