Web colours look like #FF8C00. Why letters and numbers?

Everything is binary

• A computer is built from billions of tiny switches, each off or on. So it stores and processes everything in binary: 0s and 1s.
• Numbers, text, images, sound and program instructions are all binary patterns.
• One pattern can mean a number, a letter or a colour.
• A bit is a single 0 or 1.

Binary place values

• Denary (base 10) columns go 1, 10, 100. Binary (base 2) columns double: 1, 2, 4, 8…
• Add columns holding 1: 0110 1001 = 64 + 32 + 8 + 1 = 105.
• Leftmost bit: most significant bit (MSB). Rightmost: least significant bit (LSB).
• Each extra bit doubles the patterns: 8 bits give 256 (0 to 255).
• Leading zeros change nothing: 11010 = 0001 1010.

Hexadecimal

• Hexadecimal (base 16) has sixteen digits: 0–9, then A–F for 10–15.
• One hex digit is exactly 4 bits (a nibble), as 4 bits give 16 patterns.
• Binary to hex: split into nibbles from the right: 1101 0111 → D7.
• Hex to binary: each digit becomes 4 bits: 3F → 0011 1111.

Why use hex?

• Computers never store hex. It is a shorthand for binary for humans.
• Hex is much shorter: 8 bits become 2 hex digits.
• It is easier to read, remember and copy without mistakes than long strings of 0s and 1s.
• Converting hex to binary is quicker than converting denary to binary, because each digit maps to 4 bits.
• Uses: colour codes in web pages, MAC addresses, memory addresses and error codes.

How can a computer multiply by 8 without doing any multiplying?

Adding in binary

• Add column by column from the right, carrying like denary addition.
• 0 + 0 = 0 · 0 + 1 = 1 · 1 + 1 = 10 (write 0, carry 1) · 1 + 1 + 1 = 11 (write 1, carry 1).
• Example: 0100 1011 + 0010 0110 = 0111 0001 (75 + 38 = 113).
• Check by converting each number to denary.

Overflow

• A register has a fixed number of bits: 8 bits hold at most 255.
• A result that needs more bits than are available causes an overflow error.
• 1111 0000 + 0010 0000 = 1 0001 0000 (272). The 9th bit is lost, leaving 0001 0000 = 16.

Binary shifts

• Binary columns double in value from right to left.
• A binary shift slides every bit left or right. Bits pushed off the end are lost; gaps fill with 0.
• Left 1 place: × 2. Right 1 place: ÷ 2, remainder lost. Use: fast × or ÷ by 2, 4, 8.
• 0000 1101 (13) shifted left 1 → 26; right 1 → 6.
• This is a logical shift.

A one-byte thermometer must show −20 °C. Where does the minus sign go?

A bit for the sign

• 8 bits counting up from 0 hold 0 to 255: unsigned integers, with no minus sign.
• A signed integer gives the most significant bit (MSB) a new job: the sign. 0 = positive, 1 = negative.
• Sign and magnitude: sign bit, then 7 bits of size. +53 = 0011 0101, −53 = 1011 0101.
• Range −127 to +127, with two zeros: 0000 0000 and 1000 0000.
• Computers mostly use two's complement.

Two's complement

• In two's complement the MSB is worth −128. Other columns keep their values.
• 1111 1011 = −128 + 64 + 32 + 16 + 8 + 2 + 1 = −5.
• Positive numbers look the same as unsigned: +5 = 0000 0101.
• To make a negative: write the positive, flip every bit, add 1: 0000 0101 → 1111 1010 → 1111 1011.
• 8-bit range: −128 to +127.

Range and reading back

• 8-bit two's complement holds −128 to +127: 1000 0000 = −128, 1111 1111 = −1, 0111 1111 = +127.
• If the MSB is 1, the number is negative.
• To read it, add −128 to the other place values. Or flip every bit, add 1, and put a minus sign on the result.

Arithmetic shifts

• An arithmetic shift keeps the sign of a two's complement number.
• Right shift: bits move right and copies of the MSB fill the gaps. Each place ÷ 2.
• 1110 1100 (−20) right 1 → 1111 0110 (−10).
• A logical shift right would put in a 0: 0111 0110 = +118, wrong sign.
• Left shift: bits move left and 0s fill the right. Each place × 2: 1110 1100 → 1101 1000 (−40).

How does a computer store the letter A if it can only store numbers?

Characters as codes

• Each character (letter, digit, symbol, space) is stored as a binary number: its character code.
• A character set is the agreed list of characters a computer can use, each with its own code.
• Using a standard character set means text keeps its meaning when it moves between programs and devices.
• Typing A sends A's code; the screen looks up the code to draw the A.

ASCII

• ASCII (American Standard Code for Information Interchange) uses 7 bits per character.
• 7 bits give 2⁷ = 128 codes (0 to 127): English letters, digits, punctuation, space and control codes such as Enter.
• More bits per character means more possible characters.

Codes run in order

• Codes are grouped and run in sequence: A = 65, B = 66, C = 67 … Z = 90.
• Lower case runs on from a = 97; the digits from '0' = 48.
• Know one code and you can work out its neighbours: 'C' = 65 + 2 = 67.
• The character '7' has code 55. It is not the number 7.

Unicode

• ASCII's 128 codes cannot cover other alphabets. Unicode aims to code every writing system, plus symbols and emoji: about 160,000 characters so far.
• Unicode uses more bits per character than ASCII, so text takes more storage.
• Its first 128 codes are the same as ASCII: 'A' is 65 in both.

Double a photo's width and height: how much bigger is the file?

Pictures made of dots

• A pixel (picture element) is a single point in an image.
• A bitmap is a grid of pixels. Each pixel's colour is stored as a binary code.
• Resolution is the number of pixels, written width x height, e.g. 800 x 600.
• More pixels: more detail, but more data to store.

Colour depth

• Colour depth is the number of bits used to store each pixel's colour.
• n bits give 2ⁿ colours: 1 bit gives 2, 8 bits 256, 24 bits about 16.7 million.
• In a 1-bit image, 1 could mean black and 0 white: each row is a bit pattern, and a bit pattern can be drawn back as pixels.
• Higher colour depth: more colours and better quality, but a bigger file.

Working out file size

• File size in bits = width x height x colour depth. Divide by 8 for bytes.
• Example: 800 x 600 pixels at 24 bits is 800 x 600 x 24 = 11,520,000 bits = 1,440,000 bytes.
• No calculator? Write the whole expression, then cancel before multiplying.

Units of data

• A bit is a single 0 or 1. A nibble is 4 bits. A byte is 8 bits.

• Each step up is x 1,024 (2¹⁰), so divide by 1,024 to go up one unit.
• Decimal units also exist: 1 kilobyte (kB) = 10³ bytes, MB = 10⁶, GB = 10⁹, TB = 10¹². Check which one a question uses.

How can a list of numbers turn into a song?

Sound is analogue

• Sound is a wave that changes smoothly and continuously: it is analogue.
• A computer can only store binary, so the sound must be converted to digital form.
• To do this, the wave's height (amplitude) is measured at regular moments. Each measurement is a sample: the amplitude at a point in time.
• Each sample is stored as a binary number.

Sample rate and bits per sample

• Sample rate (or sampling frequency): samples taken per second, in hertz (Hz). Music is often sampled 44,100 times a second.
• Resolution (or bit depth): bits used to store each sample.
• Raise either one: the sound is closer to the original, but the file is bigger.

Working out sound file size

• File size in bits = sample rate x resolution x length in seconds.
• Divide by 8 to get bytes.
• Example: 1 second at 44,100 Hz and 16 bits is 44,100 x 16 = 705,600 bits.
• Without a calculator, write the whole expression first, then cancel before you multiply.
• These questions assume one channel (mono) unless they say otherwise.

Big ideas

• Computers store all data and instructions as binary. Binary place values double: 1, 2, 4 … 128, so 8 bits hold 0 to 255.
• One hex digit = 4 bits (a nibble). Hex digits A–F mean 10–15.
• Hex is a shorthand for humans: shorter, easier to read and fewer copying mistakes.
• Binary addition: 1 + 1 = 10 and 1 + 1 + 1 = 11, so write the right digit and carry the left.
• A result too big for the bits available causes an overflow error.
• Shift left n places: × 2ⁿ. Shift right n places: ÷ 2ⁿ, rounded down. Bits pushed off the end are lost.
• A signed integer uses the MSB for the sign: 0 positive, 1 negative.
• Two's complement: the MSB is worth −128; to negate, flip every bit and add 1. 8-bit range −128 to +127.
• Sign and magnitude: sign bit plus 7-bit size; range −127 to +127 with two zeros.
• An arithmetic shift right copies the sign bit into the gaps, so negatives stay negative.
• A character set is an agreed list of characters with a binary code for each. Codes run in order, so B is one more than A.
• ASCII uses 7 bits: 128 characters, enough for English.
• Unicode uses more bits per character to cover far more characters, including other alphabets and emoji; its first 128 codes match ASCII.
• A bitmap is a grid of pixels; colour depth is the bits per pixel, and n bits give 2ⁿ colours.
• File size (bits) = width x height x colour depth; divide by 8 for bytes.
• Each unit up is x 1,024.
• A sample is the amplitude of the wave at one point in time, stored in binary.
• Sample rate = samples per second (Hz); resolution = bits per sample. Both raise quality and file size.
• File size (bits) = sample rate x bits per sample x seconds.