Data Representation

Introduction: Everything is Binary

Text, images, music, videos, programs, databases—everything stored on a computer is ultimately represented as sequences of 1s and 0s. This guide explores how abstract concepts like letters, colors, and sounds are encoded into binary data that computers can store and process.

This is perhaps the most profound aspect of digital computing: the same binary foundation that performs arithmetic can also represent a symphony, a photograph, or this very sentence you're reading. The key is encoding—agreed-upon schemes that map real-world information to binary patterns.

Integer Representation

Integers are the simplest data type to represent in binary—it's the natural form of binary numbers. However, there are important details about sizes and byte ordering.

Standard Integer Sizes

Endianness: Byte Order Matters

When a multi-byte integer is stored in memory, which byte comes first? This is called endianness, and different systems make different choices.

    Value: 0x12345678 (4 bytes)

    Big-Endian (most significant byte first):
    Address:   0x00  0x01  0x02  0x03
    Content:    12    34    56    78

    Little-Endian (least significant byte first):
    Address:   0x00  0x01  0x02  0x03
    Content:    78    56    34    12

    Same value, different byte order in memory!
                        

Floating-Point Numbers

Integers can't represent fractions or very large/small numbers efficiently. Floating-point representation solves this using a form of scientific notation in binary.

Why We Need Floating-Point

Consider representing 0.1 in binary. There's no exact finite representation—it's a repeating fraction! And how would you represent both 0.0000001 and 100000000 in a fixed number of bits? Fixed-point fails; we need floating-point.

    Decimal Scientific Notation:
    6.022 × 10²³  (Avogadro's number)

    Components:
    - Sign: positive
    - Mantissa (significand): 6.022
    - Base: 10
    - Exponent: 23

    Binary Floating-Point:
    1.101 × 2^5 = 1.625 × 32 = 52

    Same concept, base 2 instead of 10!
                        

IEEE 754 Standard

The IEEE 754 standard defines how floating-point numbers are stored. It's used by virtually all modern CPUs.

    Bit:  31 30--------23 22-----------------------0
          S  EEEEEEEE     MMMMMMMMMMMMMMMMMMMMMMM

    S = Sign (0 = positive, 1 = negative)
    E = Exponent (8 bits, biased by 127)
    M = Mantissa (23 bits, with implicit leading 1)

    Example: -13.625 in 32-bit float

    1. Convert to binary: 13.625 = 1101.101
    2. Normalize: 1.101101 × 2³
    3. Sign: 1 (negative)
    4. Exponent: 3 + 127 = 130 = 10000010
    5. Mantissa: 10110100000000000000000 (drop leading 1)

    Result: 1 10000010 10110100000000000000000
            = 0xC1590000
                        

Special Values: Infinity and NaN

IEEE 754 reserves certain bit patterns for special values:

Precision and Rounding Errors

Floating-point numbers cannot represent all real numbers exactly. This leads to rounding errors that can accumulate:

    In most programming languages:
    0.1 + 0.2 = 0.30000000000000004

    Why? 0.1 in binary is:
    0.0001100110011001100110011... (repeating)

    It can't be stored exactly in finite bits!

    This affects all binary floating-point systems.
    Solutions: Use integers (cents instead of dollars),
               or decimal floating-point libraries.
                        

Text and Character Encoding

Text is represented by assigning numeric codes to characters. The history of character encoding is a journey from simple 7-bit codes to the universal Unicode standard.

ASCII: The Foundation

ASCII (American Standard Code for Information Interchange) dates to 1963 and uses 7 bits to encode 128 characters:

    Useful ASCII relationships:

    'A' = 65 = 0x41 = 01000001
    'a' = 97 = 0x61 = 01100001
    Difference: 32 (bit 5)

    'a' - 'A' = 32
    To uppercase: char & 0xDF (clear bit 5)
    To lowercase: char | 0x20 (set bit 5)

    '0' = 48 = 0x30
    '9' = 57 = 0x39
    Character to digit: char - '0'
    Digit to character: digit + '0'
                        

Extended ASCII and Code Pages

The 8th bit allows 128 more characters (128-255), but different systems used this differently:

• ISO-8859-1 (Latin-1): Western European characters (é, ñ, ü)
• ISO-8859-5: Cyrillic characters
• Windows-1252: Microsoft's Western European encoding
• Code Page 437: DOS box-drawing characters

This created a mess: the same byte could represent different characters on different systems!

Unicode: The Universal Standard

Unicode assigns a unique code point to every character in every writing system. Currently over 149,000 characters from 161 scripts.

    Format: U+XXXX (hexadecimal)

    U+0041 = A (Latin uppercase A)
    U+03B1 = α (Greek lowercase alpha)
    U+4E2D = 中 (Chinese character "middle")
    U+1F600 = 😀 (grinning face emoji)
    U+1F4BB = 💻 (laptop emoji)

    Unicode planes:
    U+0000 - U+FFFF   = BMP (Basic Multilingual Plane)
    U+10000 - U+10FFFF = Supplementary planes (emoji, etc.)
                        

UTF-8: The Web's Encoding

UTF-8 is a variable-length encoding that stores Unicode code points in 1-4 bytes. It's backwards-compatible with ASCII and is the dominant encoding on the web.

    € = U+20AC

    1. Convert to binary: 0010 0000 1010 1100

    2. U+20AC is in range U+0800-U+FFFF, so 3 bytes

    3. Pattern: 1110xxxx 10xxxxxx 10xxxxxx

    4. Fill in the bits:
       0010 0000 1010 1100
       xxxx xxxxxx xxxxxx

       1110 0010  10 000010  10 101100
         E    2      8    2     A    C

    5. UTF-8 encoding: E2 82 AC (3 bytes)
                        

UTF-16 and UTF-32

Image Representation

Digital images are grids of tiny colored dots called pixels. Each pixel's color is stored as binary data.

Raster Images: Pixels and Color

A raster image is a 2D array of pixels. Each pixel has a color value:

    Each pixel: 3 bytes (24 bits)

    Red:   8 bits (0-255)
    Green: 8 bits (0-255)
    Blue:  8 bits (0-255)

    Example: Bright orange pixel
    R=255, G=165, B=0
    Hex: FF A5 00
    Binary: 11111111 10100101 00000000

    Total colors: 256 × 256 × 256 = 16,777,216

    Image size calculation:
    1920 × 1080 × 3 bytes = 6,220,800 bytes ≈ 6 MB uncompressed
                        

Color Depth and Palettes

Image Compression

Audio Representation

Sound is a continuous wave of pressure changes. To store it digitally, we must convert it to discrete samples.

Sampling and Quantization

    Sample Rate: How often we measure the wave
    - CD quality: 44,100 Hz (44.1 kHz)
    - DVD audio: 48,000 Hz
    - High-res: 96,000 Hz or 192,000 Hz

    Bit Depth: Precision of each sample
    - CD quality: 16-bit (65,536 levels)
    - Professional: 24-bit (16.7 million levels)

    Channels:
    - Mono: 1 channel
    - Stereo: 2 channels
    - 5.1 Surround: 6 channels

    CD Audio data rate:
    44,100 samples/sec × 16 bits × 2 channels
    = 1,411,200 bits/sec ≈ 176 KB/sec
    = 10.6 MB/minute uncompressed
                        

Audio Formats

Video Representation

Video is a sequence of images (frames) displayed rapidly, typically with synchronized audio.

    1080p video at 30 fps:

    Per frame: 1920 × 1080 × 3 bytes = 6.2 MB
    Per second: 6.2 MB × 30 = 186 MB
    Per minute: 186 × 60 = 11.2 GB
    Per hour: 11.2 × 60 = 672 GB

    This is why video compression is essential!

    H.264 compressed 1080p:
    ~5 Mbps = 0.625 MB/sec = 37.5 MB/min
    Compression ratio: ~300:1
                        

Video Compression Techniques

• Intra-frame (I-frames): Complete images, compressed like JPEG
• Predictive (P-frames): Store differences from previous frame
• Bidirectional (B-frames): Differences from both previous and next
• Motion compensation: Track moving objects between frames

Structured Data Formats

Beyond primitive data types, complex data structures are also stored as binary (or text-based) formats.

Binary Formats

• Protocol Buffers (protobuf): Google's efficient binary serialization
• MessagePack: Like JSON but binary, smaller and faster
• BSON: Binary JSON, used by MongoDB
• SQLite: Self-contained database in a single file

Text Formats

• JSON: Human-readable, widely used for APIs
• XML: More verbose, supports schemas
• YAML: Human-friendly configuration files
• CSV: Simple tabular data

    Data: {name: "Alice", age: 30, active: true}

    JSON (35 bytes):
    {"name":"Alice","age":30,"active":true}

    MessagePack (22 bytes):
    83 A4 6E 61 6D 65 A5 41 6C 69 63 65
    A3 61 67 65 1E A6 61 63 74 69 76 65 C3

    Protocol Buffers (~15 bytes):
    Depends on schema, very compact

    Trade-off: Binary is smaller/faster,
    text is human-readable/debuggable.
                        

Practice Problems

    Little-endian stores least significant byte first:

    Address:   0    1    2    3
    Content:  78   56   34   12

    The bytes are reversed compared to how we write the number.
                            

    'H' = U+0048 = ASCII 72 = 0x48
    'i' = U+0069 = ASCII 105 = 0x69

    Both are under U+007F, so 1 byte each:

    UTF-8: 48 69 (2 bytes)
    Binary: 01001000 01101001
                            

    48,000 samples/sec × 24 bits × 2 channels × 60 sec
    = 48,000 × 3 bytes × 2 × 60
    = 17,280,000 bytes
    = 17.28 MB uncompressed
                            

    0.1 in binary is a repeating fraction:
    0.0001100110011001100... (repeats forever)

    Like 1/3 in decimal = 0.333... can't be exact,
    0.1 in binary can't be stored exactly.

    When you add two approximations:
    ≈0.1 + ≈0.2 ≈ 0.30000000000000004

    The tiny errors compound.