Launching your learning experience…
Detailed notes on Data Transmission for Cambridge IGCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.
Parity, checksums, check digits, echo checks, and ARQ. Five techniques that detect (and sometimes correct) data-transmission errors. Each is examined.
Mapped to the Cambridge IGCSE 0478 syllabus (2026-2028).
Add one bit to make the total count of 1s even (or odd).
Parity bit is an extra bit appended to a byte to make the total number of 1s either EVEN (even parity) or ODD (odd parity).
How it's used:
Worked example. Data 1011010 with EVEN parity:
Worked example. Receiver gets 10101011, even parity expected:
Limitations.
Cambridge tip. Mark schemes for parity questions ALWAYS expect (a) the convention (even/odd) stated, (b) the count, (c) the conclusion. Top-band candidates also note the multi-bit limitation.
See the full worked example for methods of error detection →
Sum the bytes; compare. Stronger than parity.
Checksum: a value calculated from the data (typically by summing the bytes) and transmitted alongside it. The receiver re-calculates the checksum and compares.
How it works:
Worked example. Data: 110, 45, 200. Checksum (sum mod 256) = 355 mod 256 = 99.
If transmission is clean, receiver sums the same bytes, gets 355 mod 256 = 99, matches the transmitted checksum. ✓
If a byte is corrupted (110 → 113), receiver computes 113+45+200 = 358 mod 256 = 102. 102 ≠ 99 → error detected.
Stronger than parity because it's sensitive to each byte's value, not just bit counts.
Used in: IP packets (header checksum), TCP, file transfers, archive formats.
Limitation. Coincidental cancellation can still occur — extremely rare in practice for any non-trivial checksum.
Extra digit verifying that long numbers were transcribed correctly.
Check digits are extra digits appended to long numbers (barcodes, ISBNs, credit-card numbers). They're calculated by an algorithm from the other digits.
How it works:
Examples:
Why it matters. Humans regularly enter long numbers and make typos. Check digits make these typos detectable BEFORE the wrong number is acted on (e.g., before charging the wrong credit card).
Cambridge tip. Mark schemes don't usually require the algorithm itself — just the concept (extra digit, computed from data, used for validation) and an example.
Receiver sends back what it got; sender compares.
Echo check: the receiver sends the data BACK to the sender, who compares it to the original.
Process:
Pros: Simple to implement.
Cons: Doubles the bandwidth used (every transmission travels each way). And: if the transmission is corrupted in BOTH directions in compatible ways, the error may go undetected.
Used: rarely in modern systems, replaced by checksums + ARQ. But appears in 0478 syllabus as a textbook concept.
Cambridge tip. Echo check is the easiest method to describe but the worst at scale. Memorise the bandwidth-cost criticism for evaluation marks.
ACK + timeout + retransmit. The basis of reliable internet protocols.
ARQ is a protocol that combines error detection with automatic retransmission.
Process:
Why timeouts matter. ACKs themselves can be lost. Without a timeout, sender would wait forever for an ACK that won't come.
Where ARQ is used:
Variants.
Cambridge tip. Mark scheme for ARQ questions explicitly expects mention of (a) ACK / NACK, (b) TIMEOUT, (c) retransmission. Top-band answers also reference TCP as a real-world example.
See the full worked example for methods of error detection →
Verbatim phrases and definitions Cambridge mark schemes credit.
Error-detection appears regularly on Paper 1 (4-8 marks). Parity calculations and ARQ explanations are most common. Examiner reports flag candidates who say parity 'detects all errors' (it doesn't) and who explain ARQ without mentioning timeouts.
Sources: Cambridge IGCSE Computer Science 0478 syllabus (2026-2028); 0478 Examiner Reports 2022-2024; 0478/12 May/Jun 2024 question paper and mark scheme. Last reviewed 2026-05-09.
Step-by-step solutions to past-paper-style questions on methods of error detection, written exactly the way a tutor would explain them at the board.
Question
A 7-bit data value 1011010 is to be transmitted using EVEN parity. State the value of the parity bit. (2 marks)
Step-by-step solution
Step 1
Count the 1s in the data (1 mark). 1011010 contains 1+0+1+1+0+1+0 = 4 ones.
Step 2
Apply the even-parity rule (1 mark). Even parity means the TOTAL number of 1s (data + parity bit) must be even. 4 is already even, so the parity bit must be 0 to keep the count even.
Answer
Parity bit = 0. Transmitted byte = 10110100 (parity bit at the end).
Examiner tip
Count carefully and state your convention (parity bit at start or end). Odd parity reverses the rule — the total number of 1s must be ODD.
Question
A 7-bit data value 1100110 is to be transmitted using ODD parity. State the value of the parity bit. (2 marks)
Step-by-step solution
Step 1
Count the 1s in the data (1 mark). 1100110 contains 1+1+0+0+1+1+0 = 4 ones.
Step 2
Apply the odd-parity rule (1 mark). Odd parity means the TOTAL number of 1s must be ODD. There are currently 4 (even), so the parity bit must be 1 to make the total 5, which is odd.
Answer
Parity bit = 1. Transmitted byte = 11001101.
Examiner tip
A common slip is to set the parity bit to the count's parity rather than to whatever value makes the TOTAL match the required parity. Always check: data 1s + parity bit = required parity.
Question
A byte is transmitted using EVEN parity. The received byte is 10101011. State whether an error has occurred and justify your answer. (3 marks)
Step-by-step solution
Step 1
State the rule (1 mark). Even parity requires the total number of 1s in the received byte to be even.
Step 2
Count the 1s (1 mark). 10101011 has 1+0+1+0+1+0+1+1 = 5 ones.
Step 3
Compare and conclude (1 mark). 5 is ODD, but even parity requires an even count → the parity is wrong → an error has occurred during transmission.
Answer
Yes — an error has occurred. Even parity requires an EVEN number of 1s, but the received byte contains 5 (odd).
Examiner tip
Top-band answers add that a parity check detects single-bit errors but NOT an even number of flipped bits (e.g. two bits flipped leaves the parity unchanged, so the error goes undetected).
Question
A data block contains the three byte values (in denary) 95, 60 and 102. A checksum is calculated by adding the byte values and taking the result modulo 256. Calculate the checksum, then explain how the receiver uses it to detect an error. (4 marks)
Step-by-step solution
Step 1
Add the byte values (1 mark). 95 + 60 + 102 = 257.
Step 2
Apply modulo 256 (1 mark). 257 mod 256 = 257 − 256 = 1, so the checksum = 1. This single value is sent with the data block.
Step 3
Receiver recalculates (1 mark). The receiver adds the received byte values using the SAME algorithm (sum mod 256) to produce its own checksum.
Step 4
Compare (1 mark). If the receiver's checksum matches the transmitted checksum (1), the data is assumed correct. If they DIFFER, an error has occurred and retransmission can be requested.
Answer
Checksum = 1 (since 95+60+102 = 257 and 257 mod 256 = 1). The receiver recalculates the checksum from the received data and compares it with the transmitted value; a mismatch indicates a transmission error.
Examiner tip
The exact checksum algorithm varies — any correct algorithm stated by the candidate is accepted as long as the recalculate-and-compare logic is described. Marks come from the method, not just the number.
Question
A parity block uses EVEN parity. A parity bit P is added to each byte (row) and a parity byte (bottom row) is added for each column. After transmission the block is received as below. Identify the byte (row) and bit (column) of the corrupted bit, and state its correct value.
c1 c2 c3 c4 c5 c6 c7 P
Byte1 1 0 1 1 0 0 1 0
Byte2 0 1 1 0 1 0 0 1
Byte3 1 1 1 1 0 1 0 0
Byte4 0 0 1 1 1 1 0 0
Parity 0 0 1 1 0 0 1 1
(5 marks)
Step-by-step solution
Step 1
Check each ROW against even parity (1 mark). Byte1: 1+0+1+1+0+0+1+0 = 4 ✓. Byte2: 0+1+1+0+1+0+0+1 = 4 ✓. Byte3: 1+1+1+1+0+1+0+0 = 5 ✗ (odd). Byte4: 0+0+1+1+1+1+0+0 = 4 ✓. The faulty ROW is Byte3.
Step 2
Check each COLUMN against even parity (1 mark). Sum each column over Byte1–4 plus the bottom Parity row. c1: 1+0+1+0+0 = 2 ✓. c2: 0+1+1+0+0 = 2 ✓. c3: 1+1+1+1+1 = 5 ✗ (odd). c4: 1+0+1+1+1 = 4 ✓. c5: 0+1+0+1+0 = 2 ✓. c6: 0+0+1+1+0 = 2 ✓. c7: 1+0+0+0+1 = 2 ✓.
Step 3
Identify the faulty COLUMN (1 mark). Only column c3 fails even parity (5 ones, odd). Every other column is even, so the single corrupted bit lies in column c3.
Step 4
Locate the bit by intersection (1 mark). The corrupted bit is at the intersection of the faulty row and the faulty column: Byte3, column c3.
Step 5
State the correct value (1 mark). The received bit at Byte3/c3 is 1; flipping it to 0 restores even parity in both Byte3's row (4 ones) and column c3 (4 ones). So the correct value is 0.
Answer
The corrupted bit is at Byte3, column c3 (the only row and the only column that fail even parity). It was received as 1 and should be 0; flipping it restores even parity in both the row and the column.
Examiner tip
A parity block locates AND corrects a single-bit error: the faulty row is the byte with wrong parity, the faulty column is the bit position with wrong parity, and their intersection is the corrupted bit. Always identify BOTH a row and a column to score the location marks.
Question
Explain how Automatic Repeat reQuest (ARQ) is used to ensure data is transmitted without error. Refer to acknowledgements and timeouts. (6 marks)
Step-by-step solution
Step 1
Sender transmits a data packet (1 mark). Each packet includes an error-detection code (e.g. parity, checksum or CRC) so the receiver can check it.
Step 2
Receiver checks for errors (1 mark). Using the error-detection code. If the packet is correct it returns a positive acknowledgement (ACK); if an error is found it returns a negative acknowledgement (NACK) or no acknowledgement.
Step 3
A timeout is started (2 marks). When the sender transmits, it starts a TIMEOUT timer. If no ACK is received before the timeout expires, the sender assumes the packet (or its acknowledgement) was lost or corrupted.
Step 4
Automatic retransmission (1 mark). On timeout (or on receiving a NACK), the sender automatically resends the packet. This repeats until a valid ACK is received or a maximum number of retries is reached.
Step 5
Real-world context (1 mark). ARQ is used in TCP (the internet stack) and in many reliable wireless protocols to guarantee reliable delivery.
Answer
The sender transmits a packet with an error-detection code and starts a timeout. The receiver checks the packet and returns an ACK if correct or a NACK/nothing if an error is found. If the sender receives no ACK before the timeout expires (or receives a NACK), it automatically retransmits the packet, repeating until an ACK arrives or the retry limit is reached. Used in TCP/IP and reliable wireless protocols.
Examiner tip
Both the ACK mechanism AND the timeout must appear to reach full marks — without a timeout the sender would wait forever for an acknowledgement that may have been lost.
High-scoring sample answers for methods of error detection on the Cambridge IGCSE 0478 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.
State what is meant by a parity bit. [1]
Model answer
A parity bit is an extra bit added to a binary value (byte) to make the total number of 1s either even or odd, so that single-bit transmission errors can be detected.
Why this scores
1 mark (AO1 recall) for identifying it as an extra bit added to make the total number of 1s even/odd / to allow error detection. A bare 'extra bit' with no purpose does not score.
A 7-bit data value 0110101 is transmitted using even parity. State the value of the parity bit and the complete byte that is transmitted. [2]
Model answer
The data 0110101 contains four 1s (0+1+1+0+1+0+1 = 4). Four is already even, so for even parity the parity bit must be 0. The transmitted byte (parity bit appended at the end) is 0110101 0 → 01101010.
Why this scores
1 mark (AO2) for the correct parity bit (0); 1 mark for the complete 8-bit byte 01101010. Accept the parity bit placed at the start (00110101) if the candidate states that convention.
A block of data is sent with a checksum. Describe how the checksum is used to detect a transmission error. [3]
Model answer
Before transmission, a checksum value is calculated from the data block using an agreed algorithm (e.g. adding the byte values together / sum modulo 256) and is sent along with the data. When the data arrives, the receiver recalculates the checksum from the received data using the SAME algorithm. The receiver then compares its calculated checksum with the transmitted checksum: if the two values are equal the data is assumed correct, but if they differ an error has occurred during transmission and retransmission can be requested.
Why this scores
3 marks (AO1/AO2): 1 for checksum calculated from the data and sent with it; 1 for receiver recalculating using the same method; 1 for comparing and concluding (match = OK, mismatch = error). Order can vary.
A byte is transmitted using even parity. The received byte is 11010001. State whether the byte has been received correctly, justify your answer, and give one limitation of using a parity check. [4]
Model answer
Counting the 1s in the received byte 11010001: 1+1+0+1+0+0+0+1 = 4 ones. Four is even, and even parity requires an even number of 1s, so the parity check is satisfied and no error is detected — the byte appears to have been received correctly.
Limitation: a parity check only detects an ODD number of flipped bits. If an EVEN number of bits is corrupted (e.g. two bits flipped), the total number of 1s stays even, the parity still appears correct, and the error goes UNDETECTED.
Why this scores
4 marks (AO2/AO3): 1 for correctly counting the 1s (4); 1 for stating even parity needs an even count; 1 for concluding no error is detected; 1 for a valid limitation (even number of errors undetected / cannot identify which bit / cannot correct the error).
A parity block uses even parity, with a parity bit P on each byte (row) and a parity byte (bottom row) for each column. The block is received as below. Identify the row and column of the corrupted bit and state its correct value. [5]
c1 c2 c3 c4 c5 c6 c7 P
Byte1 1 0 0 1 0 1 1 0
Byte2 0 1 1 0 0 0 1 0
Byte3 1 1 0 0 0 1 0 1
Byte4 0 0 1 1 1 0 1 0
Parity 0 0 0 0 0 0 1 1
Model answer
Check each row for even parity:
The faulty row is Byte2.
Check each column (data rows + parity row) for even parity:
The faulty column is c5.
Locate and correct: The corrupted bit is at the intersection of the faulty row and column — Byte2, c5. It was received as 0; flipping it to 1 makes Byte2 have 4 ones (even) and column c5 have 2 ones (even). The correct value is 1.
Why this scores
5 marks (AO2/AO3): up to 2 for correctly testing the rows (faulty row Byte2), up to 2 for correctly testing the columns (faulty column c5), and 1 for naming the intersection bit and giving its corrected value (1). Naming only the row or only the column caps the location marks.
Describe how Automatic Repeat reQuest (ARQ) detects and recovers from transmission errors, and explain one advantage it has over an echo check. [6]
Model answer
How ARQ works: The sender transmits a data packet that includes an error-detection code (such as a checksum or parity). The receiver uses this code to check the packet for errors. If the packet is correct, the receiver sends a positive acknowledgement (ACK) back to the sender; if an error is found, it sends a negative acknowledgement (NACK) or sends nothing. When the sender transmits, it starts a timeout timer. If no ACK is received before the timeout expires — or a NACK is received — the sender automatically retransmits the packet. This repeats until a valid ACK is received or a maximum retry limit is reached, ensuring the data eventually arrives error-free.
Advantage over echo check: An echo check sends the received data back to the sender so the sender can compare it with the original, which roughly DOUBLES the amount of data on the network and requires the sender to keep and compare the original. ARQ only sends a small acknowledgement (ACK/NACK) rather than echoing the whole message back, so it uses far less bandwidth, and because the receiver itself checks for errors the recovery (retransmission) is automatic without the sender having to compare the full data.
Why this scores
6 marks (AO1/AO2/AO3). ARQ description (up to 4): packet sent with error-detection code; receiver checks and returns ACK/NACK; sender uses a timeout; sender automatically retransmits on timeout/NACK. Comparison (up to 2): a valid advantage such as echo check doubling network traffic / ARQ using only small acknowledgements / ARQ recovering automatically.
Definitions to memorise and the exact keywords mark schemes credit for methods of error detection answers — sharpened from recent examiner reports for the 2026 0478 sitting.
An extra bit added to a binary string to make the total number of 1s either even (even parity) or odd (odd parity). Used to detect single-bit transmission errors.
Convention where the total number of 1s (including the parity bit) must be EVEN.
Convention where the total number of 1s must be ODD.
A set of bytes transmitted together with a parity bit on each byte (row) AND an extra parity byte (column parity) at the end. A single corrupted bit is located at the intersection of the row and column that fail their parity check, allowing the error to be corrected.
A value calculated from the data (e.g. sum of bytes, often modulo 256) and transmitted alongside it. The receiver recalculates it with the same algorithm and compares; a mismatch indicates an error.
An extra digit at the end of a number (barcode, ISBN, credit card) calculated from the other digits. Used to verify the number was entered or transmitted correctly.
Protocol where the receiver acknowledges good packets (ACK) and the sender retransmits if no acknowledgement is received within a timeout (or a NACK is received).
Receiver returns the received data to the sender; the sender compares it to the original. If they differ, an error occurred. Doubles network traffic and cannot tell whether the error happened on the way out or on the way back.
A short message sent by the receiver in ARQ: a positive acknowledgement (ACK) confirms a packet arrived correctly, while a negative acknowledgement (NACK) reports an error and triggers retransmission.
The traps other students keep falling into on methods of error detection questions — taken from recent Cambridge IGCSE 0478 examiner reports and mark schemes — and how to avoid them.
0478 Examiner Reports 2022-2024
Why it happens
Parity sounds comprehensive.
How to avoid it
A parity check detects ANY ODD NUMBER of bit flips. An even number (2 bits flipped, 4 bits flipped) leaves parity unchanged → undetected. Top-band answers mention this limitation.
Why it happens
Students copy the count's even/odd state rather than working out what value forces the total to the required parity.
How to avoid it
Always finish with: data 1s + parity bit = required parity. For even parity an even count gives parity 0 and an odd count gives parity 1; for odd parity it is reversed.
Why it happens
Both transform data.
How to avoid it
Checksums DETECT errors; they don't HIDE data. Encryption hides data but doesn't detect transmission errors. Different purposes.
Why it happens
Focusing on ACKs only.
How to avoid it
The mark scheme expects mention of a TIMEOUT. Without it, the sender would wait forever for an ACK that may have been lost. Always include the timeout in the explanation.
Why it happens
Students stop once the first odd parity total is found.
How to avoid it
A parity block locates a single-bit error at the INTERSECTION of the faulty row and the faulty column. You must identify BOTH and give the corrected bit value to score the location marks.
The things students keep getting wrong in this sub-topic, answered.