Introduction
No transmission medium is perfectly reliable — electrical noise, interference, and signal attenuation can flip bits in transit. Error detection and correction techniques let a receiver determine whether a received frame is corrupted and, in some schemes, even fix the corruption without retransmission. It's important to distinguish detection-only techniques (parity, checksum, CRC) from correction-capable techniques (Hamming codes).
Cricket analogy: A grainy stadium replay can make an umpire misread a run-out, so DRS review is like error detection - it flags doubt, but only Hawk-Eye's ball-tracking reconstruction, like a Hamming code, actually corrects the call.
Explanation
Parity bit checking is the simplest technique: a single extra bit is added so the total number of 1-bits (including the parity bit) is even (even parity) or odd (odd parity). It can detect a single-bit error but cannot correct it and fails if an even number of bits flip simultaneously.
Cricket analogy: Adding a single run-tally check digit after each over can catch if one run was miscounted, but if two errors cancel out, like a leg-bye wrongly added and a run wrongly missed, the parity check won't notice.
A checksum, such as the Internet checksum used in IP, UDP, and TCP headers, sums up the data (typically as 16-bit words) and stores the one's-complement of the sum. The receiver performs the same sum, including the checksum field, and if the result is all 1s (i.e. the total, after folding carries, equals 0xFFFF), the data is presumed error-free. Checksums detect most common errors but are weaker than CRC against certain error patterns.
Cricket analogy: A scorer who totals all batsmen's runs and compares against the team total can catch most bookkeeping slips, but subtle compensating errors, like Virat Kohli's runs misattributed to a partner, can still pass the total check.
Cyclic Redundancy Check (CRC) treats the message as a binary polynomial and divides it by a fixed generator polynomial using modulo-2 (XOR-based) division; the remainder becomes the CRC value appended to the message. The receiver performs the same division on the received bits (message + CRC); a zero remainder indicates no detected error. CRC is much stronger than parity or simple checksums at catching burst errors, and is used in Ethernet frames (as the Frame Check Sequence).
Cricket analogy: Wagon-wheel software that runs a pre-agreed pattern check across every ball of an over catches even a burst of consecutive wides being logged wrong, unlike a simple run total that would miss a cluster of errors.
All three techniques above — parity, checksum, and CRC — are detection-only: they tell the receiver an error occurred, but the receiver must request retransmission to recover the correct data. Hamming codes are different: they add multiple parity bits at specific bit positions (powers of 2) such that the pattern of which parity checks fail directly identifies the position of a single-bit error, allowing the receiver to flip that bit and correct the error without retransmission. This is called Forward Error Correction (FEC).
Cricket analogy: A third umpire flagging a stumping as unclear forces a full re-review, whereas a system with sensors at specific stump positions could pinpoint exactly which bail moved and rule instantly without a re-review.
Example
# CRC example: message bits 1101011011, generator polynomial 10011 (CRC-4, degree 4)
# We append 4 zero bits to the message before dividing (degree of generator - 1...
# here generator has 5 bits so we append 4 zero bits).
def xor_div_remainder(dividend_bits, generator_bits):
dividend = list(dividend_bits)
gen_len = len(generator_bits)
for i in range(len(dividend) - gen_len + 1):
if dividend[i] == '1':
for j in range(gen_len):
dividend[i + j] = str(int(dividend[i + j]) ^ int(generator_bits[j]))
return ''.join(dividend[-(gen_len - 1):])
message = "1101011011"
generator = "10011"
augmented = message + "0" * (len(generator) - 1) # "11010110110000"
remainder = xor_div_remainder(augmented, generator)
print("CRC remainder (to append):", remainder) # step-by-step XOR division result
transmitted = message + remainder
print("Transmitted frame:", transmitted)
# Receiver check: divide the full transmitted frame by the generator again.
check_remainder = xor_div_remainder(transmitted, generator)
print("Receiver remainder (should be all zeros if no error):", check_remainder)Analysis
Running the code above, the modulo-2 division of "11010110110000" by generator "10011" produces a specific 4-bit remainder that gets appended to the original message to form the transmitted frame. When the receiver divides the full transmitted frame (message + CRC) by the same generator, the remainder comes out as all zeros, confirming no detected error — this is the defining property of CRC. If even a single bit flips during transmission, the receiver's division will almost certainly produce a non-zero remainder, signaling an error. The key exam distinction: parity, checksum, and CRC can only detect errors (the receiver must ask for retransmission), while Hamming codes use redundant parity bits placed at calculated positions to both detect and correct single-bit errors on the receiving end, at the cost of more overhead bits.
Cricket analogy: Walking through a full DRS review step by step, ball tracking, snickometer, and stump-mic, shows detection tools only confirm an edge happened, while an instant-replay correction system would need extra camera angles, more overhead, to fix the call outright.
Key Takeaways
- Parity bit: detects single-bit errors only (fails on even-numbered bit flips); cannot correct errors.
- Checksum (e.g. Internet checksum): sums data words and checks the one's-complement result; detection-only.
- CRC: uses modulo-2 polynomial division; strong at detecting burst errors; detection-only (used as Ethernet's Frame Check Sequence).
- Hamming code: places parity bits at calculated positions so the receiver can identify and correct a single-bit error without retransmission — this is error correction (FEC), not just detection.
Practice what you learned
1. Which of these techniques is capable of correcting a detected error without retransmission?
2. In CRC, how does the receiver verify that a received frame (message + CRC) has no detected error?
3. What is a key weakness of a simple parity bit scheme?
4. Which statement correctly distinguishes error detection from error correction?
Was this page helpful?
You May Also Like
Data Link Layer Basics
How raw bits are organized into frames for reliable node-to-node delivery on the same network segment.
Ethernet Standards
Common Ethernet naming and speeds (10BASE-T to Gigabit and beyond) and why CSMA/CD is largely obsolete on modern switched networks.
Network Troubleshooting Tools
Learn how ping, traceroute, netstat/ss, and nslookup/dig work under the hood to diagnose connectivity, routing, and DNS issues.
Common Networking Pitfalls
Frequent mistakes and misconceptions in networking, explained so you can recognize and avoid them.