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.
• Hex to denary: 8C = 8 × 16 + 12 = 140.
• Denary to hex: 200 ÷ 16 = 12 r 8, so C8.

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.
• Underflow: a result too small to represent. Shifting 0000 0001 right one place should give 0.5, which cannot be stored.

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 an arithmetic shift on a positive number.
• If a 1 is pushed off the left end, Eduqas mark schemes call this overflow: the result is too big for the register.

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.

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).
• Left shift: bits move left and 0s fill the right. Each place × 2: 1110 1100 → 1101 1000 (−40).

Binary subtraction

• To work out A − B, add the two's complement of B to A: A + (−B).
• 45 − 18: −18 = 1110 1110 (flip 0001 0010, add 1).
• 0010 1101 + 1110 1110 = 1 0001 1011.
• The carry into a 9th bit is discarded, leaving 0001 1011 = 27.

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.
• Bitmaps are raster graphics. Vector graphics store shapes as maths, so they scale without losing quality.

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.
• 1 petabyte (PB) = 1,024 TB.

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: samples taken per second, in hertz (Hz). Music is often sampled 44,100 times a second.
• Sample 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 sample 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.

How can a file shrink but still open exactly as before?

Why compress?

• Compression makes a file smaller, so it uses fewer bits.
• Smaller files need less storage space.
• They take less time to send or download and use less bandwidth.
• Common cases: streaming video and music, web pages, email attachments, photos on a phone.

Squeezing out repetition

• Data often repeats: a row of 6 white pixels, then 3 black, then 4 white.
• Instead of storing all 13 pixels, store each run as a count and a value: 6 W, 3 B, 4 W.
• The original can be rebuilt exactly, bit for bit. Compression that loses nothing is lossless.
• The more repetition there is, the more the file shrinks.

Lossy and lossless

• Lossy compression permanently removes data, usually detail people are unlikely to notice.
• Example: a photo stored with fewer colours or a song with sounds we barely hear removed.
• Lossy: much smaller files, but lower quality and the original cannot be got back.
• Lossless: the original is rebuilt exactly, but the file is not as small. Use it for text, program files and data.

Compression ratios

• A compression ratio compares the size before with the size after: original : compressed.
• Example: 10 MB compressed to 2 MB has a ratio of 10 : 2 = 5 : 1.
• Size after compression = original size ÷ ratio, e.g. 24 MB at 3 : 1 is 8 MB.
• Ratio needed to fit a space = original size ÷ space available.

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.
• Convert hex to denary with ×16: 8C = 8 × 16 + 12 = 140.
• 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.
• A result too small to represent causes underflow.
• 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); sample resolution = bits per sample. Both raise quality and file size.
• File size (bits) = sample rate x bits per sample x seconds.
• Compression makes files smaller: less storage, faster transfer, less bandwidth.
• Lossless compression rebuilds the original exactly by storing repetition efficiently.
• Lossy compression permanently removes data for much smaller files.