Data Representation

Analogue vs Digital Data and Why Computers Use Binary

Physical phenomena in the natural world are continuous. Sound waves, ambient temperature and light levels change smoothly across an infinite range of values. In contrast, digital computer systems work with discrete values.

Continuous vs Discrete Data

• Continuous data can take any real numerical value within a given range and cannot be counted as separate individual steps (for example, the exact temperature of a room over time).
• Discrete data consists of distinct, separate, countable values with clear gaps between them (for example, the number of students in a classroom or the count of goals in a match).

Hardware Inputs

• Analogue inputs: Sensors such as a Light Dependent Resistor (LDR) or a thermistor produce a continuously varying electrical voltage.
• Digital inputs: Devices like push buttons or toggle switches produce only two distinct electrical states: open (0 V, logic 0) or closed (3.3 V or 5 V, logic 1).

Analogue-to-Digital Conversion (ADC)

Computers cannot store continuous voltages directly. An Analogue-to-Digital Converter (ADC) measures a varying voltage and turns it into a discrete digital number using two steps:

1. Sampling: The ADC reads the analogue signal at regular, fixed time intervals (for example, 100 times per second).
2. Quantisation: The measured voltage is rounded to the nearest available digital step. Because values between steps are rounded, a tiny amount of precision is lost.

The number of discrete levels depends on the ADC resolution in bits. An ADC with $n$ bits provides $2^n$ unique values, from $0$ up to $2^n - 1$. For example, a 10-bit ADC (such as the analogue pins on a BBC micro:bit) yields $2^{10} = 1024$ possible integers, ranging from 0 to 1023. If a 10-bit pin runs on a 3.3 V supply and returns a reading of 512, the measured input voltage is approximately half the maximum: $3.3 \times (512 / 1023) \approx 1.65\text{ V}$.

Why Computers Use Binary

Processors are built from millions of microscopic transistors that function as electronic switches. Each switch operates reliably in one of two physical states: on (conducting current at high voltage) or off (blocking current at low voltage). We label these states with the binary digits 1 and 0.

Using binary provides three key hardware benefits:

• Reliability and noise tolerance: Distinguishing between two widely separated voltage levels is simple and dependable. Small fluctuations in voltage or electrical noise do not alter a 1 to a 0 unless they cross a wide threshold.
• Hardware simplicity: Designing circuits and logic gates that check for two states requires far fewer components than building circuits that distinguish between ten distinct voltage levels.
• Flawless duplication: Binary data can be read, copied and transmitted across long distances without cumulative signal degradation.

Number Bases and Conversions

The base (radix) of a positional number system tells us how many unique symbols it uses. Digit values are determined by place-value columns that increase by powers of the base from right to left.

• Decimal (Base 10): Uses digits 0–9. Column weights are powers of 10 ($10^0 = 1, 10^1 = 10, 10^2 = 100$, etc.).
• Binary (Base 2): Uses digits 0 and 1. Column weights are powers of 2 ($2^0 = 1, 2^1 = 2, 2^2 = 4, 2^3 = 8, 2^4 = 16, 2^5 = 32, 2^6 = 64, 2^7 = 128$).
• Hexadecimal (Base 16): Uses 16 symbols: 0–9 and A–F (where $\text{A}=10, \text{B}=11, \text{C}=12, \text{D}=13, \text{E}=14, \text{F}=15$). Column weights are powers of 16 ($16^0 = 1, 16^1 = 16, 16^2 = 256, 16^3 = 4096$).

The Bits and Values Rule

A sequence of $n$ bits can represent $2^n$ unique values, from $0$ up to $2^n - 1$.

• 1 nibble (4 bits) gives $2^4 = 16$ values ($0\text{--}15$).
• 1 byte (8 bits) gives $2^8 = 256$ values ($0\text{--}255$).

Binary to Decimal

Multiply each bit by its column place value and sum the products. For the byte 10110100:

Decimal to Binary

Method 1: Place-value subtraction. Compare the decimal value against descending powers of 2 (128 down to 1). If the number is greater than or equal to the column weight, record a 1 and subtract the weight; otherwise, record a 0.

Converting $77_{10}$ into an 8-bit byte:

• $77 \ge 64 \rightarrow 1$ (leaves $77 - 64 = 13$)
• $13 \ge 8 \rightarrow 1$ (leaves $13 - 8 = 5$)
• $5 \ge 4 \rightarrow 1$ (leaves $5 - 4 = 1$)
• $1 \ge 1 \rightarrow 1$ (leaves $1 - 1 = 0$)

Filling all 8 columns: $77_{10} = 01001101_2$.

Method 2: Repeated division by 2. Divide the number by 2 repeatedly, recording the integer quotient and the remainder. Read the remainders from bottom to top.

Converting $121_{10}$ to binary:

Reading bottom to top gives 1111001. This is 7 bits long. Pad with a leading zero to form the full 8-bit byte: 01111001. Check: $64 + 32 + 16 + 8 + 1 = 121$ ✓

Quick try: Convert 45 to 8-bit binary. Answer: $32 + 8 + 4 + 1 = 00101101_2$.

Python Implementation and Trace

We can write this division algorithm in Python:

def to_binary(n):
    bits = ""
    while n > 0:
        bits = str(n % 2) + bits
        n = n // 2
    return bits.zfill(8)

Here % computes the remainder, // performs integer division, and .zfill(8) pads the string with leading zeros.

Tracing to_binary(77):

The loop terminates. .zfill(8) prepends one leading zero to return "01001101".

Decimal to Hexadecimal

Method 1: Repeated division by 16. Divide the number by 16 and write down the remainder. Keep dividing the quotient by 16 until the quotient is 0. Read the remainders from bottom to top, writing 10–15 as A–F. (For numbers up to 255 this takes just one division: the quotient is the first digit and the remainder is the second.)

Convert $201_{10}$ to hexadecimal:

• $201 \div 16 = 12$ remainder $9$
• In hex, $12 = \text{C}$ and $9 = 9$
• Result: $201_{10} = \text{C}9_{16}$

Quick try: Convert 250 to hexadecimal. $250 \div 16 = 15$ remainder $10$. Since $15 = \text{F}$ and $10 = \text{A}$, the answer is $\text{FA}_{16}$. Check: $(15 \times 16) + 10 = 250$ ✓

Method 2: Convert via binary. Convert the decimal number into binary first, split it into 4-bit nibbles, then convert each nibble to hex.

Hexadecimal to Decimal

Multiply each digit by its power of 16. For $3\text{B}_{16}$:

Quick try: Convert $1\text{A}_{16}$ to decimal. $(1 \times 16) + 10 = 26_{10}$.

Hexadecimal and Binary Relationships

Because $16 = 2^4$, each hexadecimal digit corresponds to exactly four binary bits (one nibble). Hexadecimal is human-friendly shorthand that makes long strings of 1s and 0s easier to read, write and debug. The computer hardware always executes code in pure binary.

Hexadecimal Reference Table

Converting Between Hex and Binary

• Binary to Hexadecimal: Group bits into sets of 4 starting from the right (the least significant bit). Pad the leftmost group with leading zeros if it has fewer than 4 bits. Then replace each nibble with its hex symbol.

Example: 110101110 groups into 0001 1010 1110, which converts to $1\text{AE}_{16}$.

• Hexadecimal to Binary: Replace each hex digit with its 4-bit binary equivalent.

Example: $\text{C}7_{16}$ becomes 1100 0111 in binary.

Common Uses of Hexadecimal

• Web colours (RGB): 24-bit colours are written in CSS as #RRGGBB. Each two-digit hex pair represents an 8-bit channel ($0\text{--}255$). In #0A33F0, Red is $0\text{A}_{16} = 10$, Green is $33_{16} = 51$, and Blue is $\text{F}0_{16} = 240$.
• Memory addresses: RAM locations (such as 0x7FFE04A2) are displayed in hex to keep diagnostic logs and memory dumps compact.
• MAC addresses: Network cards carry permanent 48-bit hardware addresses written as six hex pairs (such as 00:1A:2B:3C:4D:5E).

Binary Addition and Overflow Error

Binary addition follows five basic rules, working right to left from the least significant bit:

• $0 + 0 = 0$
• $1 + 0 = 1$
• $0 + 1 = 1$
• $1 + 1 = 0$, carry $1$ into the next column (since $1 + 1 = 2_{10} = 10_2$)
• $1 + 1 + 1 = 1$, carry $1$ into the next column (since $1 + 1 + 1 = 3_{10} = 11_2$)

Traced Addition: $58_{10} + 29_{10}$

In 8-bit binary: $58_{10} = 00111010_2$ and $29_{10} = 00011101_2$.

Summing the active columns: $64 + 16 + 4 + 2 + 1 = 87_{10}$ ✓

Overflow Error

An overflow error occurs when the result of an arithmetic operation exceeds the maximum value that the allocated bit-width can store. For an 8-bit unsigned byte, the largest possible value is $2^8 - 1 = 255$.

For example, adding $200_{10}$ and $100_{10}$ in an 8-bit system:

Because the byte can hold only 8 bits, the 9th bit (the carry out of the $2^7$ column) is discarded. The stored byte reads 00101100, which equals 44 instead of 300.

In Python, integers have arbitrary precision and expand automatically, so 200 + 100 correctly evaluates to 300. Overflow occurs in environments where the bit-width is fixed by hardware, such as microcontroller registers, C variables, or fixed sensor buffers.

Character Encoding Standards: ASCII and Unicode

Computers store characters as numbers. A character encoding standard maps each character to an agreed numeric code.

Why Character Standards Matter

• Interoperability: Text created on one computer must appear identically on any other device, operating system or software program. This requires universal agreement on which number represents which character.
• Preventing corrupted text: When sender and receiver use different encodings, characters display as garbled symbols (known as mojibake, such as á replacing á).
• Global communication: A shared worldwide standard allows software to display multiple languages (Irish, Arabic, Chinese) and modern symbols in the same document.

ASCII (American Standard Code for Information Interchange)

Standard ASCII uses 7 bits to represent 128 characters (codes 0 to 127):

• Uppercase letters: 'A' = 65 through 'Z' = 90
• Lowercase letters: 'a' = 97 through 'z' = 122
• Digit characters: '0' = 48 through '9' = 57 (the character '7' is code 55, not value 7)
• Control characters: Enter (13), Backspace (8), Escape (27)

ASCII characters are stored inside an 8-bit byte with the most significant bit set to 0. A lowercase letter's code is always 32 higher than its capital ('a' - 'A' = 97 - 65 = 32).

Extended ASCII uses all 8 bits ($2^8 = 256$ characters). Codes 128–255 include accented vowels (like Irish fadas: á, é, í, ó, ú). However, different countries used conflicting extended code pages, making international file sharing unreliable.

Decoding an ASCII Message

To decode a binary ASCII stream, split the bits into 8-bit bytes, convert each byte to decimal, and look up the character.

Decode 01001000 01101001:

• First byte: 01001000 $= 64 + 8 = 72 \rightarrow \text{'H'}$
• Second byte: 01101001 $= 64 + 32 + 8 + 1 = 105 \rightarrow \text{'i'}$
• Result: "Hi"

Unicode and UTF-8

Unicode is a character set that assigns every character across every human writing system a unique identification number called a code point. Code points are written in hexadecimal prefixed by U+:

• 'A' = U+0041 ($65_{10}$, identical to ASCII)
• 'á' = U+00E1 ($225_{10}$)
• 👍 = U+1F44D ($128077_{10}$)

UTF-8 is the variable-length encoding format used to store those code points in memory as bytes:

Exam Comparison: ASCII vs Unicode

• Memory Usage: ASCII uses a fixed 7 or 8 bits per character, making it compact but limited to 128 (or 256) characters. Unicode (UTF-8) uses a variable width of 1 to 4 bytes per character. English text uses the same memory as ASCII (1 byte), but other languages and emojis consume more memory (2–4 bytes per character).
• Compatibility: Unicode is backward-compatible with ASCII because its first 128 characters are identical to ASCII. A plain ASCII file is directly readable as UTF-8. Unicode provides global compatibility by supporting all writing systems.

Data Types and Practical Python Operations

High-level programming languages provide abstract data types so programmers do not have to manage raw memory bits directly.

Standard Data Types and Python Equivalents

Type Conversion (Casting) in Python

In Python, the input() function always returns a string. Mixing raw input with a number, such as age_text + 1, causes a TypeError. Adding two raw inputs does not cause an error: it joins them as text ('5' + '3' gives '53'). Convert with int() or float() before doing arithmetic. Variables must be explicitly cast to the appropriate type:

age_text = input("Enter your age: ")
age = int(age_text)  # explicit casting to integer
next_year = age + 1

Storing values in the wrong data type (such as recording a price as '€10' instead of a numeric float 10.00) causes data inconsistencies and stops algorithms from performing calculations.

Built-in Python Conversion Tools

• ord('A') returns 65 (gets the integer code for a character).
• chr(97) returns 'a' (gets the character for an integer code).
• bin(77) returns '0b1001101' (converts decimal integer to binary string).
• hex(201) returns '0xc9' (converts decimal integer to hexadecimal string).
• int('C9', 16) returns 201 (converts a hex string to base 10).
• int('01111001', 2) returns 121 (converts a binary string to base 10).
• format(121, '08b') returns '01111001' (formats an integer as an 8-bit binary string padded with leading zeros).

Key terms

Bit

The smallest unit of data in computing, holding a single binary state of 0 or 1.

Byte

A group of 8 bits capable of representing 256 distinct values ($2^8$).

Nibble

A group of 4 binary bits, which corresponds to exactly one hexadecimal digit.

Hexadecimal

A base-16 positional number system using digits 0–9 and letters A–F, used as a human-readable shorthand for binary.

Overflow Error

An error that occurs when an arithmetic calculation produces a result exceeding the maximum value that the allocated bit-width can hold.

ASCII

A 7-bit character encoding system assigning numbers from 0 to 127 to English letters, digits, punctuation and control codes.

Unicode

A universal character set that assigns a unique hexadecimal code point to every character across all human writing systems and emojis.

UTF-8

A variable-length encoding format using 1 to 4 bytes per character to store Unicode code points, fully backward-compatible with ASCII.

Continuous Data

Data that can take any real value within a continuous range, such as temperature, sound or analogue voltage.

Discrete Data

Data that consists of separate, distinct, countable values with clear steps between them.

Analogue-to-Digital Converter (ADC)

A hardware component that samples a continuously varying analogue voltage and converts it into a discrete digital number.