Cambridge O Level Computer Science Syllabus
Cambridge O Level Computer Science Syllabus
Syllabus overview
Assessment overview
All candidates take two components. Candidates will be eligible for grades A* to E.
Assessment objectives
The assessment objectives (AOs) are:
AO1
Demonstrate knowledge and understanding of the principles and concepts of computer science.
AO2
Apply knowledge and understanding of the principles and concepts of computer science to a given context,
including the analysis and design of computational or programming problems.
AO3
Provide solutions to problems by:
• evaluating computer systems
• making reasoned judgements
• presenting conclusions.
AO1 40
AO2 40
AO3 20
Total 100
Paper 1 Paper 2
AO1 60 20
AO2 20 60
AO3 20 20
3 Subject content
This syllabus gives you the flexibility to design a course that will interest, challenge and engage your learners.
Where appropriate you are responsible for selecting resources and examples to support your learners’
study. These should be appropriate for the learners’ age, cultural background and learning context as well as
complying with your school policies and local legal requirements.
Computer Science is a practical subject and a range of practical exercises must be integral to the teaching
of this qualification. It is important that learners develop their computational thinking skills by doing practical
problem-solving and programming using appropriate resources. It is also expected that learners have the
opportunity in class to write their own programs, as well as executing (running), testing and debugging them.
Any equipment and facilities should be adequate for learners to be able to satisfy the requirements of the
syllabus. The hardware facilities needed will depend on the number of learners but must be sufficient for all
learners to have enough time to practise their programming skills. Learners also need to have access to a
system with direct-access file capability on backing store and hardcopy facilities.
Computer systems
1 Data representation
1.1 Number systems
2 Data transmission
2.1 Types and methods of data transmission
2.3 Encryption
3 Hardware
3.1 Computer architecture
4 Software
4.1 Types of software and interrupts
6.2 Robotics
In Paper 2, candidates are expected to write solutions to given problems using the methods and concepts
listed in topics 7 to 10.
Where the solution to a problem involves coding, candidates are required to write solutions in pseudocode.
Solutions written in programming code will not be awarded marks. The exception is the 15-mark scenario
question.
In the 15-mark scenario question, candidates are required to write solutions to the given problem using
pseudocode or their choice of one of the following programming languages: Python, Visual Basic or Java.
Solutions written in other programming languages will not be awarded marks.
8 Programming
8.1 Programming concepts
8.2 Arrays
9 Databases
Candidates should be able to: Notes and guidance
1 Define a single-table database from given data • Including:
storage requirements – fields
– records
– validation
2 Suggest suitable basic data types • Including:
– text/alphanumeric
– character
– Boolean
– integer
– real
– date/time
3 Understand the purpose of a primary key
and identify a suitable primary key for a given
database table
4 Read, understand and complete structured • Limited to:
query language (SQL) scripts to query data – SELECT
stored in a single database table
– FROM
– WHERE
– ORDER BY DESCENDING
– ORDER BY ASCENDING
– SUM
– COUNT
– AND
– OR
• Identifying the output given by an SQL
statement that will query the given contents of a
database table
10 Boolean logic
Candidates should be able to: Notes and guidance
1 Identify and use the standard symbols for logic • See section 4 for logic gate symbols
gates
2 Define and understand the functions of logic • Including:
gates – NOT
– AND
– OR
– NAND
– NOR
– XOR (EOR)
– the binary output produced from all the
possible binary inputs
• NOT is a single input gate
• All other gates are limited to two inputs
3 (a) Use logic gates to create given logic circuits • Circuits must be drawn for the statement given,
from a: without simplification
(i) problem statement • Logic circuits will be limited to a maximum of
(ii) logic expression three inputs and one output
(iii) truth table
(b) Complete a truth table from a: • An example truth table with three inputs, for
(i) problem statement completion:
(ii) logic expression A B C Output
(iii) logic circuit 0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
This question paper consists of short-answer and structured questions set on Topics 1–6 of the subject
content.
All questions are compulsory, and candidates answer on the question paper.
This paper assesses all assessment objectives, AO1, AO2 and AO3, and assesses the full grade range, A* to G.
This question paper consists of short-answer and structured questions set on Topics 7–10 of the subject
content.
All questions are compulsory, and candidates answer on the question paper.
Knowledge of programming language syntax is not examined; in all cases the logic is more important than the
syntax.
This paper assesses all assessment objectives, AO1, AO2 and AO3, and assesses the full grade range, A* to G.
Scenario question
The final question in Paper 2 is a 15-mark unseen scenario question using the methods and concepts listed in
Topics 7-10 of the subject content.
Candidates will be required to write an algorithm using pseudocode or program code for the context provided.
Teachers are advised to familiarise themselves with the updated Paper 2 specimen paper and mark scheme for
first assessment 2023, which provide an example of the scenario question, how it will be marked, and include
an indicative 15-mark response.
Mathematical requirements
Calculators are not permitted in IGCSE Computer Science examinations.
Flowchart symbols
Flow line An arrow represents control passing
between the connected shapes.
NOT
AND
OR
NAND
NOR
XOR (EOR)
Pseudocode
The following information sets out how pseudocode will appear within the examinations of this syllabus. The
numbers and letters that appear at the end of a sub-heading provide a cross reference to the relevant section
of the subject content.
General style
Font style and size
Pseudocode is presented in Courier New. The size of the font will be consistent throughout.
Indentation
Lines are indented by four spaces to indicate that they are contained within a statement in a previous line.
Where it is not possible to fit a statement on one line, any continuation lines are indented by two spaces from
the margin. In cases where line numbering is used, this indentation may be omitted. Every effort will be made to
make sure that code statements are not longer than a line of code, unless this is necessary.
Note that the THEN and ELSE clauses of an IF statement are indented by only two spaces. Cases in CASE
statements are also indented by only two spaces.
Case
Keywords are in upper case, e.g. IF, REPEAT, PROCEDURE.
Identifiers are in mixed case with upper case letters indicating the beginning of new words, e.g.
NumberOfPlayers.
Meta-variables – (symbols in the pseudocode that should be substituted by other symbols) are enclosed in
angled brackets < >.
Example – meta-variables
REPEAT
<Statements>
UNTIL <Condition>
Comments
Comments are preceded by two forward slashes: //. The comment continues until the end of the line. For
multi‑line comments, each line is preceded by //.
Normally the comment is on a separate line before, and at the same level of indentation as, the code it refers
to. Occasionally, however, a short comment that refers to a single line may be at the end of the line to which it
refers.
Example – comments
Literals
Literals of the above data types are written as follows:
• Integer written as normal in the denary system, e.g. 5, –3
• Real always written with at least one digit on either side of the decimal point, zeros being
added if necessary, e.g. 4.7, 0.3, –4.0, 0.0
• Char a single character delimited by single quotes, e.g. ꞌxꞌ, ꞌcꞌ, ꞌ@ꞌ
• String delimited by double quotes. A string may contain no characters (i.e. the empty string),
e.g. “This is a string”, “”
• Boolean TRUE, FALSE
Identifiers
Identifiers (the names given to variables, constants, procedures and functions) are in mixed case using Pascal
case, e.g. FirstName. They can only contain letters (A–Z, a–z) and digits (0–9). They must start with a capital
letter and not a digit. Accented letters and other characters, including the underscore, should not be used.
As in programming, it is good practice to use identifier names that describe the variable, procedure or function
to which they refer. Single letters may be used where these are conventional (such as i and j when dealing
with array indices, or X and Y when dealing with coordinates) as these are made clear by the convention.
Identifiers should be considered case insensitive, for example, Countdown and CountDown should not be
used as separate variables.
Constants (8.1.1)
It is good practice to use constants if this makes the pseudocode more readable, and easier to update if the
value of the constant changes.
Constants are declared by stating the identifier and the literal value in the following format:
CONSTANT <identifier> ← <value>
Only literals can be used as the value of a constant. A variable, another constant or an expression must never
be used.
Assignments
The assignment operator is ←
The identifier must refer to a variable (this can be an individual element in a data structure, such as an array or
an abstract data type). The value may be any expression that evaluates to a value of the same data type as the
variable.
Example – assignments
Counter ← 0
Counter ← Counter + 1
TotalToPay ← NumberOfHours * HourlyRate
Arrays
Declaring arrays (8.2.1)
Arrays are fixed-length structures of elements of identical data type, accessible by consecutive index numbers.
It is good practice to explicitly state what the lower bound of the array (i.e. the index of the first element) is
because this defaults to either 0 or 1 in different systems. Generally, a lower bound of 1 will be used.
1D and 2D arrays are declared as follows (where l, l1, l2 are lower bounds and u, u1, u2 are upper bounds):
StudentNames[1] ← "Ali"
NoughtsAndCrosses[2,3] ← ꞌXꞌ
StudentNames[n+1] ← StudentNames[n]
FOR Index ← 1 TO 30
StudentNames[Index] ← ""
NEXT Index
Common operations
Input and output (8.1.3)
Values are input using the INPUT command as follows:
INPUT <identifier>
The identifier should be a variable (that may be an individual element of a data structure, such as an array).
Several values, separated by commas, can be output using the same command.
INPUT Answer
OUTPUT Score
OUTPUT "You have ", Lives, " lives left"
+ addition
– subtraction
* multiplication
/ division
^ raised to the power of
The integer division operators MOD and DIV can also be used.
DIV(<identifier1>, <identifier2>)
Returns the quotient of identifier1 divided by identifier2 with the fractional part discarded.
MOD(<identifier1>, <identifier2>)
Returns the remainder of identifier1 divided by identifier2
DIV(10, 3) returns 3
MOD(10, 3) returns 1
Multiplication and division have higher precedence over addition and subtraction (this is the normal
mathematical convention). However, it is good practice to make the order of operations in complex expressions
explicit by using parentheses.
= equal to
< less than
<= less than or equal to
> greater than
>= greater than or equal to
<> not equal to
In complex expressions, it is advisable to use parentheses to make the order of operations explicit.
In complex expressions, it is advisable to use parentheses to make the order of operations explicit.
LCASE(<identifier>)
Returns the string/character with all characters in lower case. The identifier should be of data type string or
char.
UCASE(<identifier>)
Returns the string/character with all characters in upper case. The identifier should be of data type string or
char.
RANDOM()
Returns a random number between 0 and 1 inclusive.
Selection
IF statements (8.1.4 (b) and 8.1.5)
IF statements may or may not have an ELSE clause.
IF statements without an ELSE clause are written as follows:
IF <condition>
THEN
<statements>
ENDIF
Note that the THEN and ELSE clauses are only indented by two spaces. (They are, in a sense, a continuation of
the IF statement rather than separate statements.)
When IF statements are nested, the nesting should continue the indentation of two spaces.
It is best practice to keep the branches to single statements as this makes the pseudocode more readable.
Similarly, single values should be used for each case. If the cases are more complex, the use of an IF
statement, rather than a CASE statement, should be considered.
Each case clause is indented by two spaces. They can be considered as continuations of the CASE statement
rather than new statements.
Note that the case clauses are tested in sequence. When a case that applies is found, its statement is
executed, and the CASE statement is complete. Control is passed to the statement after the ENDCASE. Any
remaining cases are not tested.
If present, an OTHERWISE clause must be the last case. Its statement will be executed if none of the preceding
cases apply.
INPUT Move
CASE OF Move
ꞌWꞌ : Position ← Position – 10
ꞌEꞌ : Position ← Position + 10
ꞌAꞌ : Position ← Position – 1
ꞌDꞌ : Position ← Position + 1
OTHERWISE OUTPUT "Beep"
ENDCASE
Iteration
Count-controlled (FOR) loops (8.1.4 (c))
Count-controlled loops are written as follows:
FOR <identifier> ← <value1> TO <value2>
<statements>
NEXT <identifier>
The identifier must be a variable of data type INTEGER, and the values should be expressions that evaluate to
integers.
The variable is assigned each of the integer values from value1 to value2 inclusive, running the statements
inside the FOR loop after each assignment. If value1 = value2, the statements will be executed once, and if
value1 > value2, the statements will not be executed.
The increment must be an expression that evaluates to an integer. In this case the identifier will be
assigned the values from value1 in successive increments of increment until it reaches value2. If it goes
past value2, the loop terminates. The increment can be negative.
Total ← 0
FOR Row ← 1 TO MaxRow
RowTotal ← 0
FOR Column ← 1 TO 10
RowTotal ← RowTotal + Amount[Row, Column]
NEXT Column
OUTPUT "Total for Row ", Row, " is ", RowTotal
Total ← Total + RowTotal
NEXT Row
OUTPUT "The grand total is ", Total
The condition must be an expression that evaluates to a Boolean. The statements in the loop will be executed
at least once. The condition is tested after the statements are executed, and if it evaluates to TRUE, the loop
terminates, otherwise the statements are executed again.
REPEAT
OUTPUT "Please enter the password"
INPUT Password
UNTIL Password = "Secret"
The condition must be an expression that evaluates to a Boolean. The condition is tested before the
statements, and the statements will only be executed if the condition evaluates to TRUE. After the statements
have been executed, the condition is tested again. The loop terminates when the condition evaluates to FALSE.
The statements will not be executed if, on the first test, the condition evaluates to FALSE.
WHIL
E Number > 9 DO
Number ← Number – 9
ENDWHILE
The <identifier> is the identifier used to call the procedure. Where used, param1, param2, etc. are
identifiers for the parameters of the procedure. These will be used as variables in the statements of the
procedure.
CALL <identifier>(Value1,Value2...)
When parameters are used, Value1, Value2... must be of the correct data type as in the definition of the
procedure.
When the procedure is called, control is passed to the procedure. If there are any parameters, these are
substituted by their values, and the statements in the procedure are executed. Control is then returned to the
line that follows the procedure call.
PROCEDURE DefaultLine
CALL LINE(60)
ENDPROCEDURE
IF MySize = Default
THEN
CALL DefaultLine
ELSE
CALL Line(MySize)
ENDIF
The keyword RETURN is used as one of the statements within the body of the function to specify the value to
be returned. Normally, this will be the last statement in the function definition.
Because a function returns a value that is used when the function is called, function calls are not complete
program statements. The keyword CALL should not be used when calling a function. Functions should only
be called as part of an expression. When the RETURN statement is executed, the value returned replaces the
function call in the expression and the expression is then evaluated.
File handling
Handling files (8.3.2)
It is good practice to explicitly open a file, stating the mode of operation, before reading from or writing to it.
This is written as follows:
OPENFILE <File identifier> FOR <File mode>
The file identifier will be the name of the file with data type string. The following file modes are used:
• READ for data to be read from the file
• WRITE for data to be written to the file. A new file will be created and any existing data in the file will be
lost.
Data is read from the file (after the file has been opened in READ mode) using the READFILE command as
follows:
READFILE <File Identifier>, <Variable>
When the command is executed, the data item is read and assigned to the variable.
Data is written into the file after the file has been opened using the WRITEFILE command as follows:
WRITEFILE <File identifier>, <Variable>
When the command is executed, the data is written into the file. Files should be closed when they are no longer
needed using the CLOSEFILE command as follows:
CLOSEFILE <File identifier>
This example uses the operations together, to copy a line of text from FileA.txt to FileB.txt
DECLARE LineOfText : STRING
OPENFILE "FileA.txt" FOR READ
OPENFILE "FileB.txt" FOR WRITE
READFILE "FileA.txt", LineOfText
WRITEFILE "FileB.txt", LineOfText
CLOSEFILE "FileA.txt"
CLOSEFILE "FileB.txt"
Command words
Command words and their meanings help candidates know what is expected from them in the exams. The
table below includes command words used in the assessment for this syllabus. The use of the command word
will relate to the subject context.
Describe state the points of a topic / give characteristics and main features
Explain set out purposes or reasons / make the relationships between things clear / say why
and/or how and support with relevant evidence
Identify name/select/recognise
Suggest apply knowledge and understanding to situations where there are a range of valid
responses in order to make proposals / put forward considerations