1.1 Number systems
Cambridge IGCSE Computer Science 0478 · Topic 1: Data representation · Paper 1
2.2 Methods of error detection
Cambridge IGCSE Computer Science 0478 · Topic 2: Data transmission · Paper 1
3.1 Computer architecture
Cambridge IGCSE Computer Science 0478 · Topic 3: Hardware · Paper 1
Say each word, then read what it means. Every one is in the glossary too.
Read it here, or open the study page below to go one step at a time with things to try.
Computer Science has two written papers. Both count the same.
| Paper | What it tests | Time | Marks | Share of the grade |
|---|---|---|---|---|
| Paper 1 Computer Systems | Topics 1 to 6 | 1 hour 45 minutes | 75 | 50% |
| Paper 2 Algorithms, Programming and Logic | Topics 7 to 10 | 1 hour 45 minutes | 75 | 50% |
Each question shows its marks in brackets, like [3].
You cannot use a calculator in either paper. Show every step of a calculation, with units.
A 3-mark question needs three separate, correct points. One long sentence often earns only one mark.
Describe how a firewall protects a network. [3] • It monitors the traffic coming in and going out. • It checks the traffic against a set of rules. • It blocks any traffic that does not meet the rules.
Look at the marks before you write. They tell you how many points the examiner wants.
| Colour | It means | What to do next |
|---|---|---|
| Red | I lost most of the marks, or I do not understand it yet. | Study page, key terms, quiz, then one past-paper question. |
| Amber | I got some marks, but there are gaps. | Past-paper questions on that point, marked with the scheme. |
| Green | I got full marks. | A short quiz every few weeks so you keep it. |
Why write out the missing point?
You learn the exact words the examiner wanted. Next time you can use them.
A computer is made of billions of tiny switches called transistors. Each switch is either off or on.
We write off as 0 and on as 1. A number system with only two digits is called binary.
One binary digit is a bit. Eight bits together make a byte.
Every extra bit doubles the number of different patterns you can make.
Two states are very reliable. A switch is clearly on or clearly off, so the computer rarely misreads a value.
Denary is our everyday number system. It has ten digits, 0 to 9, and each column is worth 10 times the column to its right.
Binary works the same way, but each column is worth 2 times the column to its right.
For 8 bits the column values, from left to right, are 128, 64, 32, 16, 8, 4, 2, 1.
To turn binary into denary, add up the column values that have a 1 under them.
Try the toy: switch on the 128 bit. What happens to the denary value? Now make 255.
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|
| 0 | 1 | 0 | 1 | 1 | 0 | 1 | 0 |
Always write the column values above the bits first. Most mistakes come from adding the wrong column.
There is something to try for this step in the IGCSE library.
Start at the left column, 128. Ask: does 128 fit into my number?
If it fits, write 1 and take 128 away. If it does not fit, write 0.
Move to the next column and repeat with what is left. Stop when you reach the 1 column.
Always write all 8 bits, including the 0s at the front.
Each column is used once at most, so taking away the biggest column first always gives the right pattern.
With n bits you get 2ⁿ patterns. One of those patterns is 0.
So the biggest number is one less than the number of patterns: 2ⁿ − 1.
8 bits hold 0 to 255. 16 bits hold 0 to 65,535.
A register is a small store inside the processor. An 8-bit register cannot hold anything bigger than 255.
8 bits give 256 different values, but the largest value is 255, because counting starts at 0.
Hexadecimal (hex) has sixteen digits. It uses 0 to 9, then the letters A to F for 10 to 15.
Each hex column is worth 16 times the column to its right. Two-digit hex has columns 16 and 1. Three digits add a 256 column.
One hex digit stands for exactly four bits. Four bits are called a nibble.
| Denary | Binary (nibble) | Hex |
|---|---|---|
| 0 | 0000 | 0 |
| 1 | 0001 | 1 |
| 2 | 0010 | 2 |
| 3 | 0011 | 3 |
| 4 | 0100 | 4 |
| 5 | 0101 | 5 |
| 6 | 0110 | 6 |
| 7 | 0111 | 7 |
| 8 | 1000 | 8 |
| 9 | 1001 | 9 |
| 10 | 1010 | A |
| 11 | 1011 | B |
| 12 | 1100 | C |
| 13 | 1101 | D |
| 14 | 1110 | E |
| 15 | 1111 | F |
16 is 2 × 2 × 2 × 2. That is why one hex digit matches four bits exactly, with nothing left over.
Hex to denary: multiply each digit by its column value, then add. Change letters to numbers first (B = 11, F = 15).
Denary to hex: divide by 16. The whole-number answer is the left digit. The remainder is the right digit.
Change any digit from 10 to 15 into its letter.
A remainder of 10 to 15 must be written as a letter. Writing "128" for C8 is a common slip.
Binary to hex: split the binary into groups of 4 bits, starting from the right. Change each group into one hex digit.
Hex to binary: change each hex digit into its 4-bit nibble. Write them side by side.
Each nibble uses the small column values 8, 4, 2, 1. This keeps the sums easy.
The fastest route between denary and hex is often through binary.
Always group from the right. If the left group is short, add 0s at its front. Keep the leading 0s when you change hex to binary, so each digit gives four bits.
Computers do not use hex. Inside, everything is still binary. Hex is for people.
Hex is shorter: 8 bits become 2 hex digits. It is easier to read, remember and type.
People make fewer mistakes copying hex than long strings of 0s and 1s.
It converts to binary very easily, because each digit is one nibble.
| Use | Real example | What the hex means |
|---|---|---|
| MAC address | 00:1A:2B:3C:4D:5E | The unique number of a network card. 12 hex digits instead of 48 bits. |
| HTML colour code | #FF8800 | Red FF = 255, green 88 = 136, blue 00 = 0. This is orange. |
| Error codes | 0x80070005 | A Windows error code (access denied). The 0x means "hex follows". |
| URLs | my%20file.html | %20 is hex 20 = denary 32, the code for a space. |
| Memory dumps | 3F A7 00 B6 | The contents of memory shown for a programmer finding a bug. |
| IPv6 addresses | 2001:0db8::7334 | Long network addresses written in hex groups. |
Do not write "hex takes up less memory". It does not. The computer stores the same binary. Hex is only a shorter way for humans to write it.
You add binary in columns, from right to left, like denary addition.
In binary, 1 + 1 makes 2, and 2 is written 10. So you write 0 and carry 1 to the next column.
If a column has 1 + 1 plus a carry of 1, the total is 3. Three is 11: write 1 and carry 1.
Try the toy: it starts with 91 + 54. Press Step to add one column at a time and watch where each carry goes. Then press Overflow example.
| Column adds up to | Denary total | Write | Carry |
|---|---|---|---|
| 0 + 0 | 0 | 0 | 0 |
| 0 + 1 or 1 + 0 | 1 | 1 | 0 |
| 1 + 1 | 2 | 0 | 1 |
| 1 + 1 + carry 1 | 3 | 1 | 1 |
There is something to try for this step in the IGCSE library.
Write the two numbers one under the other, with the column values on top.
Write each carry above the next column on the left. Then add that column, including the carry.
Check your answer by changing everything to denary.
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | |
|---|---|---|---|---|---|---|---|---|
| Carry | 1 | 1 | 1 | 1 | 1 | |||
| 109 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 1 |
| + 54 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 0 |
| = 163 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 1 |
Show your carries in the exam. A wrong answer with clear carries can still earn a working mark.
An 8-bit register can hold 0 to 255. Sometimes an addition gives more than 255.
Then the last column makes a carry that has nowhere to go. It would need a 9th bit.
This is called an overflow error. The 9th bit is lost, so the stored answer is wrong.
The processor sets an overflow flag so the program can deal with it.
| Lost | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | |
|---|---|---|---|---|---|---|---|---|---|
| Carry | 1 | 1 | |||||||
| 200 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | |
| + 100 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | |
| Stored | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 |
A register has a fixed number of bits. Anything that does not fit is lost, so the computer cannot store a value above 2ⁿ − 1.
A logical shift moves every bit left or right by a number of places.
In a left shift, bits fall off the left end and are lost. 0s fill the gaps on the right.
Each place shifted left multiplies the number by 2. Two places is × 4. Three places is × 8.
If a 1 falls off the left end, the answer is wrong. This is a kind of overflow.
Try the toy: load 22 (00010110), choose 2 places and press Shift left. Then load 53 (00110101) and shift it left 3 places. Which answer is wrong?
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | Denary | |
|---|---|---|---|---|---|---|---|---|---|
| Before | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 22 |
| Left 2 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 88 |
Moving a bit one column left puts it in a column worth twice as much. So the whole number doubles.
There is something to try for this step in the IGCSE library.
In a right shift, bits fall off the right end and are lost. 0s fill the gaps on the left.
Each place shifted right divides the number by 2. Two places is ÷ 4. Three places is ÷ 8.
If a 1 falls off the right end, the remainder is lost. The answer is rounded down, so accuracy is lost.
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | Denary | |
|---|---|---|---|---|---|---|---|---|---|
| Before | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 22 |
| Right 2 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 5 |
In a logical shift the new bits are always 0. Do not copy the old end bit back in, and do not wrap bits round to the other end.
So far 8 bits only held positive numbers, 0 to 255. Two's complement is a way to store negative numbers too.
The only change: the leftmost column is worth −128 instead of 128. All other columns stay the same.
If the leftmost bit is 0, the number is positive. If it is 1, the number is negative.
8-bit two's complement holds −128 to +127.
Try the toy: press Smallest (−128) so only the −128 bit is on. Then tap the 64 bit. Watch the value climb towards 0.
| −128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | Denary |
|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 64 + 8 + 4 + 1 = 77 |
| 1 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | −128 + 32 + 16 + 4 + 2 = −74 |
| 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | −128 + 127 = −1 |
With a −128 column, normal binary addition still works for negative numbers. The processor needs only one adding circuit.
There is something to try for this step in the IGCSE library.
Positive number: write it in normal 8-bit binary. The leftmost bit will be 0.
Negative number, method 1: write the positive version in binary. Flip every bit (0 becomes 1, 1 becomes 0). Then add 1.
Negative number, method 2: start with −128. Work out what you must add to reach your number. Put that in the other 7 columns.
Use one method and check with the other, or check by adding the column values.
+45 and −45 are not the same pattern with a different first bit. 10101101 is −83, not −45. Always flip and add 1, or use the −128 method.
Bits travel as electrical pulses, light or radio waves. These can be disturbed on the way.
Interference is unwanted signal from outside, such as from a motor, a microwave oven or lightning.
Because of interference, data can suffer data loss (bits go missing), data gain (extra bits appear) or data change (a 1 becomes a 0, or a 0 becomes a 1).
One wrong bit can change a whole number. If 01000001 (65) becomes 01000011 (67), a bank amount or a letter changes. So the receiver must be able to spot errors.
A parity check adds one extra bit, the parity bit, to each byte. Usually it is the leftmost bit.
In even parity, the total number of 1s in the byte must be even. In odd parity, the total must be odd.
The sender and receiver agree the type first. The receiver counts the 1s. If the count is wrong, there is an error.
Parity cannot find an error if two bits flip. The count changes by 2, so it stays even (or odd). It also cannot say which bit is wrong.
There is something to try for this step in the IGCSE library.
To find which bit is wrong, we send a block of bytes, each with its own parity bit.
Then we add a parity byte at the end. Each bit of the parity byte gives parity for one column.
If one bit flips, one row fails and one column fails. The wrong bit is where they cross, so the receiver can even correct it.
Rows and columns work like grid references on a map. One wrong row plus one wrong column points to a single square.
A checksum is a value calculated from all the data in a block, using an agreed method.
The sender calculates the checksum and sends it with the data.
The receiver calculates the checksum again from the data it received. If the two values match, the data is probably correct. If not, it asks for the data again.
Cambridge does not ask for one exact checksum method. In the exam, describe the process: calculate at the sender, send, recalculate at the receiver, compare.
In an echo check, the receiver sends a copy of the data straight back to the sender.
The sender compares the copy with the original. If they are the same, the data arrived correctly. If not, the sender sends it again.
An echo check doubles the traffic. Also, if the copies differ, you cannot tell if the error happened on the way there or on the way back.
A check digit is an extra digit added to the end of a number, such as an ISBN (book number) or a supermarket barcode.
It is calculated from the other digits. It catches data entry errors: a digit typed wrongly, or two digits swapped (transposed).
This is different from parity and checksums. Those catch errors in transmission; a check digit catches human errors when a number is typed or scanned.
The weights 1 and 3 mean that swapping two neighbouring digits usually changes the total. So swaps are caught as well as wrong digits.
If the remainder in step 3 is 0, the check digit is 0, not 10. That is why the rule is (10 − remainder) MOD 10.
There is something to try for this step in the IGCSE library.
ARQ uses an error check (such as a checksum) plus messages back to the sender.
If the data arrives correctly, the receiver sends a positive acknowledgement. If it finds an error, it sends a negative acknowledgement and the sender sends the data again.
The sender also starts a timeout: a set time to wait. If no acknowledgement arrives before the time runs out, the sender re-sends the data automatically.
The timeout handles the case where the data, or the acknowledgement, is lost completely. Without it, the sender would wait forever.
The CPU (central processing unit) is the part of the computer that processes instructions and data. It carries out the instructions of every program.
It does this by fetching an instruction from memory, decoding it, then executing it. Then it repeats, billions of times a second.
A microprocessor is a CPU built as an integrated circuit on a single chip. An integrated circuit is a whole electronic circuit made on one small piece of silicon.
Most computers follow the von Neumann architecture. Its key idea is the stored program: instructions and data are both stored in the same main memory.
The CPU has a control unit (CU). The CU manages the fetch–decode–execute cycle. It decodes instructions and sends control signals to the other parts.
The CPU has an arithmetic logic unit (ALU). The ALU does calculations (such as add and subtract) and logic operations (such as comparing two numbers).
The CPU also has registers: very small, very fast stores inside the CPU. The CPU is joined to memory by three buses (sets of wires).
Keeping instructions and data in one memory means the computer can run any program you load. Change the program in memory and the same hardware does a new job.
There is a diagram for this step in the IGCSE library.
A register holds one item at a time: an address, an instruction or a piece of data.
An address is the number of a location in memory, like a locker number in a school corridor.
| Register | Full name | What it holds |
|---|---|---|
| PC | Program counter | The address of the next instruction to be fetched |
| MAR | Memory address register | The address of the memory location about to be read from or written to |
| MDR | Memory data register | The data or instruction that has been fetched from memory, or about to be written to memory |
| CIR | Current instruction register | The instruction that is being decoded and executed right now |
| ACC | Accumulator | The result of calculations done by the ALU |
PC and MAR hold addresses. MDR and CIR hold instructions or data. Mixing these up is the most common error in FDE answers.
The address bus carries addresses from the CPU (the MAR) to memory. It is one-way (unidirectional), because only the CPU chooses addresses.
The data bus carries data and instructions between the CPU (the MDR) and memory. It is two-way (bidirectional), because data is both read and written.
The control bus carries control signals from the control unit, such as 'read', 'write' and the clock signal. It is two-way, because devices also send signals back.
Exam answers often say 'the address bus carries data'. It carries addresses only. Data and instructions travel on the data bus.
Every instruction goes through the same three stages. Learn the fetch stage in order: it is worth most marks.
Fetch: the address in the PC is copied to the MAR, using the address bus. The PC is incremented (1 is added), so it points to the next instruction. The instruction at that address is sent along the data bus to the MDR. It is then copied from the MDR to the CIR.
Decode: the control unit decodes the instruction in the CIR. It works out what the instruction means and what needs to happen.
Execute: the instruction is carried out. The control unit sends signals on the control bus. If there is a calculation, the ALU does it and the result goes in the ACC. Then the cycle starts again.
The PC is incremented during fetch, so the CPU always knows where the next instruction is, even while it is busy with the current one.
There is something to try for this step in the IGCSE library.
An instruction set is the list of all the instructions (commands) that a particular CPU can understand and carry out.
Each instruction is a binary code, called machine code. Examples are load, add, store, compare and jump.
The CU decodes instructions using this set. Different CPU families have different instruction sets.
Clock speed is the number of fetch–decode–execute cycles the CPU can do per second, measured in hertz (Hz). A 3.5 GHz CPU has 3,500,000,000 clock ticks per second. Higher clock speed means more instructions per second.
Cache is a small amount of very fast memory inside or next to the CPU. It stores instructions and data that are used often, so the CPU does not have to wait for slower RAM. More cache means fewer slow trips to RAM.
A core is a complete processing unit (with its own ALU, CU and registers). A quad-core CPU has four cores, so it can process four instructions at the same time.
All three let the CPU get through more instructions in a given time. That is what 'better performance' means.
Doubling the cores does not double the speed. Cores must communicate with each other, and some programs cannot be split into parts. Raising clock speed also makes the CPU hotter, and cache is expensive, so there are limits.
An embedded system is a small computer system built inside a larger device, to do one dedicated job.
It uses a microprocessor (or a microcontroller) and usually runs one fixed program stored in ROM.
A general-purpose computer, like a laptop, can run many different programs and do many jobs.
| Embedded system examples | What it controls |
|---|---|
| Washing machine | Water level, temperature, drum speed for each wash programme |
| Microwave oven | Timer and power level |
| Central heating | Turns the boiler on and off using a temperature sensor |
| Car engine management | Fuel and air mix, using many sensors |
| Traffic lights | The light sequence and timing |
Embedded systems are small, cheap to mass-produce and use very little power, because they only do one job. The drawbacks: they are hard to update or change, and they can only do the task they were built for.
Open the study page and go one step at a time.
Step by step, with exam questions and a quiz.
Computer Science topic 1Step by step, with exam questions and a quiz.
Computer Science topic 2Step by step, with exam questions and a quiz.
Computer Science topic 3Step by step, with exam questions and a quiz.
Topic 3 · Year 8Computers store numbers in binary (base 2). We use denary (base 10). Programmers use hex (base 16) as a short way to write binary. All three use place value.
Topic 15 · Year 7A network is computers connected to share data. The internet is a network of networks. Data travels in small packets, following rules called protocols.
Topic 8 · Year 8The CPU does the work, RAM holds what it's using now, and storage keeps everything long-term. The CPU repeats one loop: fetch, decode, execute.
One question at a time. The reason shows after each answer.