Top Mistakes IGCSE Computer Science Students Make (and How to Avoid Them)

Why common mistakes matter more than missing knowledge

In Cambridge IGCSE Computer Science, the difference between a grade B and a grade A often has less to do with what a candidate knows and more to do with what a candidate does incorrectly under exam conditions. Examiner reports for syllabus 0478 consistently highlight the same recurring errors, year after year, across programming, algorithm design, number systems, and written theory. The pattern is clear: candidates who learn to recognise and eliminate these predictable mistakes gain a significant advantage over those who simply revise more content.

This article catalogues the most consequential errors that appear in IGCSE Computer Science exams, organised by topic area. For each mistake, the wrong approach is shown first, followed by an explanation of why it loses marks, and then the correct technique. The goal is not to list every possible error but to focus on those that cost the most marks most frequently.

Programming mistakes

Programming questions carry substantial marks on Paper 2, and the errors that appear in candidate responses tend to fall into a small number of recurring categories. Eliminating even two or three of these can recover several marks per paper.

Failing to initialise variables before use

One of the most persistent errors in IGCSE Computer Science exams is using a variable in a calculation before assigning it an initial value. This occurs most often with counters and running totals inside loops.

The left version references Total in the expression Total + Number before Total has been set to anything. In a real programming environment, this produces an undefined or garbage value. In an exam, the mark scheme typically awards a dedicated mark for correct initialisation, and omitting it means that mark is lost regardless of whether the rest of the logic is sound. The fix is straightforward: before any loop that accumulates a value, set the accumulator to its starting value (usually 0 for sums, or an empty string for concatenation).

Creating infinite loops

An infinite loop occurs when the condition controlling a WHILE or REPEAT loop never changes in a way that allows the loop to terminate. This is particularly common when candidates write condition-controlled loops but forget to include a statement inside the loop body that modifies the tested variable.

The left version checks whether Password equals "abc123" but never provides the user with an opportunity to enter a new value. The loop repeats indefinitely. The mark scheme penalises this because the algorithm does not function as intended. When writing any condition-controlled loop, verify that at least one statement inside the loop body modifies a variable that appears in the loop condition.

Off-by-one errors in loops

Off-by-one errors occur when a loop iterates one time too many or one time too few. In IGCSE Computer Science, this most commonly surfaces with FOR loops that use incorrect start or end values, or with array indexing that begins at the wrong position.

When a question states "repeat this process 5 times," candidates sometimes write FOR i = 0 TO 5, which actually runs 6 times (0, 1, 2, 3, 4, 5). The correct version is either FOR i = 1 TO 5 or FOR i = 0 TO 4. Before writing any FOR loop, count the iterations on your fingers if needed. It takes two seconds and prevents a mark loss that is entirely avoidable.

Using the wrong data type

Data type errors occur when a candidate stores a value in an inappropriate format. The most frequent case is treating numeric input as a string, or vice versa. For example, if a question asks for a calculation using a number entered by the user, storing that input as a string and attempting arithmetic on it is logically invalid.

The mark scheme awards marks for correct declarations. If a variable must hold decimal values, it should be declared as REAL (or FLOAT in Python terms), not INTEGER. If it holds text, it should be STRING. The rule of thumb: determine what operations will be performed on the variable, and choose the type that supports those operations.

Confusing assignment with comparison

In Cambridge pseudocode, the assignment operator is a left-pointing arrow (←) and the comparison operator is a single equals sign (=). In many programming languages, assignment uses = and comparison uses ==. Candidates who answer in Python sometimes write if x = 5 (assignment) when they mean if x == 5 (comparison), or those writing pseudocode use the wrong symbol in conditional statements.

Algorithm design mistakes

Algorithm design questions test whether a candidate can translate a problem description into a structured, logical solution. The errors in this category tend to be methodological rather than syntactic: candidates write code before they have understood the problem, or they produce solutions that work in principle but do not match what the question actually asks.

Writing code without decomposing the problem first

The most common pattern in weak algorithm design answers is that the candidate begins writing code immediately after reading the question. The result is a tangled solution that addresses some requirements but misses others, and that is difficult for the candidate to debug or extend. The mark scheme for a 6-mark algorithm question typically awards marks for individual components: correct input, correct loop structure, correct conditional logic, correct output, and so on. A candidate who jumps straight into coding often produces a monolithic block that earns some marks but misses others because the structure is confused.

The correct approach is to spend 60 to 90 seconds before writing any code. Read the question twice. List the inputs, the processing steps, and the required outputs. Identify whether a loop is needed and what type. Only then begin writing the algorithm. This small investment of time consistently produces cleaner answers that earn more marks.

Trace table errors from not updating all variables

When completing a trace table, candidates must record the value of every variable at each step of execution. The most frequent error is updating the variable that changes but neglecting to carry forward the values of variables that remain the same. In many mark schemes, each row of the trace table is marked independently, and a blank cell where a value should appear (even if that value has not changed) loses the mark for that row.

In the example above, the candidate correctly updates x in iteration 2 but leaves y blank because it did not change. Depending on the mark scheme, this blank cell may cost the mark for that row. The safer practice is to fill in every cell, every iteration, even when repeating a previous value.

Flowchart errors

Flowchart questions test whether candidates understand the visual representation of algorithmic logic. Three errors recur frequently in examiner reports:

• Using the wrong symbol. Process steps must be in rectangles, decisions in diamonds, and inputs/outputs in parallelograms. Placing a decision inside a rectangle, or an output inside a diamond, loses the mark for that box even if the text inside it is correct.
• Missing arrows or flow lines. Every box must have at least one arrow leading into it and one leading out. Decision diamonds must have exactly two labelled exits (typically Yes and No). An unlabelled exit or a missing arrow breaks the flow and costs marks.
• Omitting terminators. Every flowchart must begin and end with an oval (terminator) symbol. Candidates who begin with a process box or end with an output lose the terminator mark.

Code that works but does not match the question

This is a subtle and frustrating error. The candidate writes an algorithm that would function correctly if executed, but it does not do what the question asked. For example, a question might ask the candidate to output the highest value from a list. The candidate instead outputs all values that are above the average. The code runs, produces output, and demonstrates programming competence, but it answers a different question. The mark scheme awards marks for meeting specific requirements, not for general programming ability. Reading the question carefully and checking each requirement against your answer before moving on is the only reliable prevention.

Number systems mistakes

Number systems questions appear on Paper 1 and test candidates on binary, denary, and hexadecimal conversions. The errors here tend to be mechanical, arising from place value mistakes or incomplete working.

Binary to denary conversion errors

The standard method is to write out the binary place values (128, 64, 32, 16, 8, 4, 2, 1 for an 8-bit number) and add the values where a 1 appears. The most common error is misaligning the digits with their place values, particularly when the binary number has leading zeros.

For 01101101: 64 + 32 + 8 + 4 + 1 = 109. A candidate who accidentally shifts the digits one column to the left would calculate 128 + 64 + 16 + 8 + 2 = 218, an entirely different answer. Always write the place values first, then align digits right-to-left, starting from the 1s column. Show your working, because even if the final answer is wrong, intermediate marks are often available for a correct method.

Forgetting overflow in 8-bit binary addition

When adding two 8-bit binary numbers, the result may exceed 8 bits. For example, 11000000 + 11000000 in binary produces a 9-bit result. In an 8-bit register, the ninth bit is lost, and this is called overflow. Candidates frequently perform the addition correctly but then write a 9-bit answer without noting that overflow has occurred.

Hexadecimal conversion slips

Hexadecimal uses digits 0-9 and letters A-F, where A = 10, B = 11, C = 12, D = 13, E = 14, and F = 15. The most common error is misremembering these letter-to-value mappings, particularly under time pressure. A candidate who converts the hex digit C as 11 instead of 12 will produce an incorrect denary value and an incorrect binary equivalent.

The conversion method itself is mechanical: split the hex number into individual digits, convert each to its 4-bit binary equivalent, then concatenate. For hex to denary, multiply each digit by its place value (16, 1 for a two-digit hex number) and add the results. Memorise the A-F mappings until they are automatic. There is no shortcut for this; it simply requires familiarity through practice.

General exam technique mistakes

Beyond topic-specific errors, IGCSE Computer Science candidates lose marks through weaknesses in exam technique that apply across the entire paper. These are arguably the easiest marks to recover, since they require no additional subject knowledge, only more disciplined reading and writing habits.

Misreading command words

Cambridge uses specific command words that define the depth and type of answer required. Treating them as interchangeable is a consistent source of lost marks.

If a question says "Explain why a compiler is used," an answer that merely states "A compiler translates code" earns little credit. The word "explain" demands a reason: "A compiler translates the entire source code into machine code before execution, which means the program runs faster because translation does not need to occur each time the program is run." That single expansion from "what" to "why" is frequently the difference between zero marks and full marks on a 2-mark question.

Not using technical terminology

IGCSE Computer Science mark schemes are written using precise technical language, and answers that use vague or informal phrasing often fail to hit the required marking points. For instance, a question about data validation might have a mark point for "range check." A candidate who writes "checking if the number is too big or too small" has the right idea but has not used the accepted term, and whether this earns the mark depends on how generously the examiner interprets it.

Vague cyber security answers

Cyber security is a high-weight topic on Paper 1, yet examiner reports consistently note that candidates give superficial answers. The most common form of this is listing security measures without explaining how or why they work.

The pattern is consistent: name the measure, explain the mechanism, and state the protective effect. A three-part structure like this aligns with how mark schemes for 2- and 3-mark cyber security questions are typically constructed.

Confusing similar concepts

Certain pairs of concepts in IGCSE Computer Science are closely related but distinct, and candidates who conflate them lose marks reliably. The following are the most frequently confused pairs, along with their key differences:

When a question asks a candidate to "compare a compiler and an interpreter," the mark scheme expects explicit points of contrast. An answer that accurately describes a compiler but says nothing about an interpreter, or that describes both without stating how they differ, will not earn comparison marks.

A systematic approach to eliminating mistakes

Recognising these errors in the abstract is useful, but building the habit of avoiding them requires a structured approach during revision and practice.

1. Keep an error log. After every practice paper, write down every mistake you made and classify it: programming error, number systems slip, command word misread, missing terminology, or vague explanation. After three or four papers, patterns will emerge. Those patterns are your priority revision targets.
2. Use a pre-submission checklist for programming questions. Before moving on from any coding answer, ask: Have I initialised all variables? Does my loop terminate? Does my output match the question exactly? Is my indentation clear? This takes less than a minute and catches the four most common programming errors.
3. Practise number conversions daily. Spend five minutes each day converting three binary numbers to denary, three denary numbers to binary, and three hex numbers to binary. Repetition builds the speed and accuracy that prevent mechanical slips under timed conditions.
4. Read examiner reports. Cambridge publishes these for every exam session. They describe, in the examiners' own words, exactly where candidates struggled and why. Each report effectively tells you what not to do. The time spent reading two or three reports is among the most efficient revision you can undertake for IGCSE Computer Science.

Test yourself

Before closing this article, use the following questions to check whether you can spot and correct the errors discussed above.

1. A candidate writes the following pseudocode to count how many numbers in a list of 20 are greater than 50:
   FOR i = 1 TO 20
  INPUT Number
  IF Number > 50 THEN
    Count = Count + 1
  ENDIF
NEXT i
OUTPUT Count
   What error has been made, and how would you fix it?
2. Convert the hexadecimal number 3F to denary. Show your working.
3. A question asks: "Explain one reason why data is encrypted before being sent over a network." A candidate writes: "So hackers cannot read it." Why would this answer likely receive zero marks, and how would you improve it?
4. A candidate writes FOR i = 0 TO 10 to iterate through a 10-element array in Cambridge pseudocode. What mistake have they made?
5. What is the difference between verification and validation? Give one example of each.