Computers use binary because their components have two easily distinguished states:

Each state is represented by a 1 or a 0, and all forms of data — numbers, text, images, sound, instructions — are represented using them.

A circuit could in principle use ten voltage levels to store a denary digit directly. It is not done because distinguishing ten levels reliably is far harder: small fluctuations in voltage, temperature or component quality could push one level into another and corrupt the data.

With only two states there is a huge margin between them, so a circuit can be built cheaply and still be accurate. Binary trades a longer representation for reliability — and reliability is what matters.

Put numbers on it: a typical digital circuit might treat anything below $0.8\text{V}$ as a firm 0 and anything above $2.0\text{V}$ as a firm 1, leaving a wide gap in between that the circuit is never allowed to settle in. Splitting the same $0$–$5\text{V}$ range into ten equal bands for a denary digit would leave barely half a volt per digit and almost no safety margin either side — a small voltage dip caused by a long wire or a warm component could flip a reading from a $6$ into a $7$. With only two widely separated states, the same cheap, imperfect components can be trusted completely.

Two pieces of vocabulary follow: a single binary digit is a bit, and eight bits make one byte.

Every system works the same way: each column is worth the base times the column to its right.

Formally, the column $n$ places from the right (counting the units column as $n=0$) is worth ${\text{base}}^n$. That is why denary columns are powers of ten ($10^0=1$, $10^1=10$, $10^2=100,\dots$), binary columns are powers of two ($2^0=1$, $2^1=2$, $2^2=4,\dots$) and hexadecimal columns are powers of sixteen ($16^0=1$, $16^1=16$, $16^2=256$). Once this pattern is fixed, converting any whole number in any base to denary is the same two-step recipe: multiply each digit by its column's power of the base, then add the results — the method used throughout this chapter is really only ever this one idea applied three times.

Hexadecimal needs sixteen different digits, but only ten symbols exist, so letters are used for the remaining six:

Note that F is 15, not 16. Counting starts at zero, so the sixteen digits run from $0$ to $15$ — the commonest error in hex conversion.

Write the place values above the digits and add up the values where there is a 1.

Add the place values above the columns containing 1: $128+16+8+4=156$.

Work from the largest place value downwards. At each column ask: does this value fit into what is left?

The remainder must reach exactly zero by the end. If it does not, an error has been made somewhere — a useful built-in check.

Answers should normally be given as 8 bits, padding with leading zeros if necessary: $12$ is $00001100$, not $1100$.

Multiply each digit by its place value and add.

Divide by 16. The quotient is the first digit and the remainder is the second.

Remember to convert any remainder of $10$ or more into its letter. A remainder of $12$ is written C, not $12$.

This is the easiest conversion of the three, because one hexadecimal digit is exactly four binary digits. There is no arithmetic — only substitution.

Split from the right, and pad the leftmost group with leading zeros if it is short. $110101$ splits as $00110101$, giving $35$ — splitting from the left would give the wrong answer.

Because hex and binary convert so easily, awkward denary-to-binary conversions can be routed through hex:

For a large value this is often quicker and less error-prone than working down eight binary place values.

The examinable idea is that hexadecimal is used for the benefit of people, not machines. The computer still works entirely in binary; hex is simply a shorthand for displaying that binary to a human.

So the strongest answer pairs the two facts: hex is shorter and less error-prone to read and write, and it converts to binary trivially because each digit maps to exactly four bits.

You meet this every day without necessarily noticing. A web colour written #2E86C1 is three hexadecimal byte values placed side by side — $\text{2E}$, $\text{86}$ and $\text{C1}$ — giving the red, green and blue brightness of a shade of blue, each running from $\text{00}$ (none) to $\text{FF}$ (full, $255$ in denary). A crash report or debugger showing a memory address such as 0x7FFE2A10 is doing the same job: a 32-bit binary address compressed into eight readable hex digits instead of thirty-two error-prone binary ones.

Work from right to left, exactly as in denary addition, carrying into the next column.

With 8 bits the largest value that can be stored is $11111111$, which is 255. Adding two 8-bit numbers whose total exceeds 255 produces a ninth bit, and there is nowhere to put it.

The consequence matters: the stored result is not merely inaccurate, it is completely wrong — $267$ becomes $11$. This is why programs must check for overflow rather than trusting the result.

To state the cause in an exam: overflow occurs because the result requires more bits than the register has available, so the extra bit is lost.

This is not just an exam abstraction — fixed-width overflow has caused real, well-documented failures. The Ariane 5 rocket's guidance software famously failed $37$ seconds after launch in 1996 when a value too large for the 16-bit space allocated to it could not be converted, triggering a shutdown that destroyed the rocket. On a smaller scale, any fixed-width counter — a ticket-sale total, an old odometer — will silently wrap back towards zero once its maximum value is passed, unless the software explicitly checks for it. Choosing how many bits to give a register is really choosing the largest number the system can ever safely represent.

A logical shift moves every bit a given number of places left or right. Bits shifted off the end are lost, and zeros are shifted in at the other end.

This is exactly why shifting is used: multiplying or dividing by a power of two is a single fast operation in hardware, much cheaper than a general multiply.

Two consequences to note. Shifting right loses any remainder — $22$ shifted right twice gives $5$, not $5.5$. And shifting left can push a 1 off the end, losing it entirely and giving a badly wrong answer. In the example above, one more left shift would drop the leading 1.

This is why shifts appear so often behind the scenes: when a compiler translates code that multiplies an integer variable by a power of two, it will often silently replace the multiplication with a shift, because a processor completes a shift in a single clock cycle while a general multiplication can take several. The programmer never sees this substitution — it is one of the simplest examples of a compiler making code faster without changing what it does.

Two's complement allows both positive and negative integers to be stored in 8 bits. The key change is that the leftmost bit is worth $-128$ instead of $+128$.

For the positive value, $64+32+4=100$. For the negative value, $-128+16+8+4=-100$.

There are two standard methods, and both give the same answer:

Method 1 is quicker and works in either direction — applying it to a negative number gives back the positive. Method 2 is a useful check, and makes clear why the pattern is what it is.

Making the top bit worth $-128$ looks arbitrary, but it has a valuable consequence: ordinary binary addition then works correctly on negative numbers, with no special handling.

Adding $+100$ and $-100$ in two's complement gives $00000000$ once the carry out is discarded — the right answer, from the same adder circuit used for positive numbers. That is why two's complement is used in practice rather than simply reserving a sign bit.

The logical shift from Section 9 always fills the vacated end with zero. That is fine for a positive or unsigned value, but it breaks a negative two's complement value: shifting $11110000$ ($-16$) one place right logically gives $01111000$, which is $+120$ — the sign has flipped and the answer is nonsense.

An arithmetic shift fixes this. On a right shift, it copies the sign bit into each vacated position instead of using zero, so a negative number stays negative and is correctly divided by a power of two:

An arithmetic left shift is identical to a logical left shift — zero is still shifted in at the right-hand end, since there is no sign bit to protect at that end. The distinction only ever matters for a right shift.

So the rule is: use a logical shift on an unsigned value, and an arithmetic shift on a two's complement (signed) value. Applying a logical shift to a negative number by mistake is a common source of error.

The most obvious way to store a negative number is to keep the leftmost bit purely as a plus/minus sign (0 for positive, 1 for negative) and store the number's size in the remaining seven bits, exactly as in ordinary written arithmetic. This is called sign-and-magnitude.

Positive values look the same under both schemes, but the two disagree completely on negative ones. Sign-and-magnitude looks simpler, but it has two serious weaknesses that explain why two's complement is used instead:

Question. (a) Convert the denary number $203$ to 8-bit binary. (b) Convert your answer to hexadecimal. (c) Convert the hexadecimal value $\text{2F}$ to denary.

Marking. 1 mark per point. Give binary answers as 8 bits, and remember that F is 15, not 16.

Question. Add the 8-bit binary integers $10110101$ and $01011010$. (a) Show the addition. (b) State the denary values of both numbers and of the result. (c) State whether overflow occurs and explain.

Marking. 1 mark per point. The explanation must refer to the result needing more bits than are available — 'the number is too big' alone is weak.

Question. An 8-bit register contains $00101100$. (a) State its denary value. (b) Perform a logical shift left of 2 places and give the new denary value. (c) State the effect of this shift on the value. (d) State one problem that can occur with a left shift.

Marking. 1 mark per point. Zeros are shifted in at the vacated end — a shift never wraps around.

Question. (a) Give the 8-bit two's complement representation of $-45$. (b) State the denary value of $11101100$ in two's complement. (c) State the range of an 8-bit two's complement number.

Marking. 1 mark per point. Check (a) by adding $00101101$ and $11010011$: the result is zero once the carry out is discarded.