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.

Adding three numbers

• Line up all three numbers and add one column at a time from the right.
• Count the 1s in the column, including any carry: 0 → write 0, 1 → write 1, 2 → write 0 carry 1, 3 → write 1 carry 1.
• Example: 0001 0101 + 0000 0110 + 0000 0011 = 0001 1110 (21 + 6 + 3 = 30).

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.

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.
• Image size 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 (b) is a single 0 or 1. A byte (B) is 8 bits.

• Each step up is x 1,000, so divide by 1,000 to go up one unit.
• You may see 1,024 used elsewhere, but AQA uses 1,000.

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

• Sampling rate (or 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 = sampling 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.
• There are different ways to compress data. Two you need are run length encoding and Huffman coding.

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.

Run length encoding

• Run length encoding (RLE) replaces each run of repeated data with a pair: how many times it repeats, then the value.
• These are frequency/data pairs.
• Example: 0000011100000011 becomes 5 0 3 1 6 0 2 1.
• RLE is lossless. With little repetition it can make the data bigger, as every single value gains a count.

Morse code: why is E a single dot?

Codes of different lengths

• 7-bit ASCII gives every character 7 bits, however often it is used.
• Huffman coding gives frequent characters short codes and rare characters longer codes.
• So the whole piece of data needs fewer bits, and nothing is lost: the original can be rebuilt exactly.
• The codes come from a Huffman tree, built from how often each character appears in the data.

Reading a Huffman tree

• Characters sit at the ends of the branches. Each branch is labelled 0 or 1: on this tree, left is 0 and right is 1.
• A character's code is the list of branch labels from the top of the tree down to it.
• Frequent characters sit near the top, so they get short codes.
• No code is the start of another, so a string of bits decodes one way only.

Building a Huffman tree

• List the characters and their frequencies, lowest first.
• Join the two lowest under a new node holding their total.
• Put it back in order and repeat until one node is left: the root.
• Our tree: S 1 + N 1 = 2, then T 2 + 2 = 4, then A 3 + 4 = 7, then E 7 + 7 = 14.
• Frequent characters join last, so they sit nearest the root.

Counting the bits

• Huffman bits: add up frequency x code length for each character.
• Uncompressed bits in 7-bit ASCII: number of characters x 7.
• Bits saved = ASCII bits − Huffman bits.
• Example: NEAT is 1111 0 10 110 = 4 + 1 + 2 + 3 = 10 bits. In 7-bit ASCII it is 4 x 7 = 28 bits, so 18 bits are saved.

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.
• Shift left n places: × 2ⁿ. Shift right n places: ÷ 2ⁿ, rounded down. Bits pushed off the end are lost.
• 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 (kB, MB, GB, TB) is x 1,000.
• A sample is the amplitude of the wave at one point in time, stored in binary.
• Sampling 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.
• RLE stores each run as a count and a value: 0000011100000011 → 5 0 3 1 6 0 2 1.
• Huffman coding gives frequent characters short codes and rare ones longer codes; it is lossless.
• Build the tree by repeatedly joining the two lowest frequencies; read a code by following the 0 and 1 branch labels from the root down.
• Huffman bits = sum of frequency x code length; ASCII bits = characters x 7; saved = the difference.