Introduction

Computers run on electricity — on or off, 1 or 0. Everything else (images, text, video, sound) boils down to patterns of these bits. Understanding how numbers and data get represented in memory matters if you want to write code that doesn’t break in production.

The choices made decades ago still affect how we write software today. Floating-point math that made sense in the 1960s still produces head-scratching results. Representing negative numbers led to several competing schemes, each with their own quirks.

When to Use This Knowledge

Apply your understanding of data representation when:

• Debugging numerical precision issues in financial or scientific calculations
• Writing code that manipulates binary protocols or file formats
• Interpreting crash dumps and core files
• Working with bitwise operations for flags and masks
• Understanding why 0.1 + 0.2 != 0.3 in floating-point
• Ensuring cross-platform compatibility for integer sizes

Skip the deep dive if:

• You’re exclusively using high-level languages with arbitrary precision libraries
• You never touch network protocols, binary files, or hardware registers

Architecture Diagram

The journey of data through a computer’s representation layers:

flowchart LR
    A[User Input: -123.456] --> B[ASCII Characters]
    B --> C[Binary Encoding]
    C --> D[IEEE 754 Single Precision]
    D --> E[Hexadecimal: 0xC2F6E979]
    E --> F[Memory Layout]
    F --> G[Registers]
    G --> H[ALU Operations]

Core Concepts

Binary: The Foundation

Binary is a base-2 number system using only digits 0 and 1. Each position represents a power of 2, reading right to left: 1, 2, 4, 8, 16, 32, 64, 128, 256, and so forth.

The binary number 1101 equals: 1×8 + 1×4 + 0×2 + 1×1 = 13

Computers use binary because physical circuits naturally have two states: electricity flowing (on) or not flowing (off). It’s easier to build reliable hardware that distinguishes between two clear states than between ten different voltage levels.

Hexadecimal: The Human-Friendly Binary

Hexadecimal (base-16) provides a more compact notation for binary data. Each hex digit represents exactly 4 binary bits, and hex digits 0-9, A-F map to decimal 10-15.

Binary: 1111 0101 1010 0011
Hex:    F    5    A    3

Hex is preferred for:

• Memory addresses (which are often aligned to 4 or 8 bytes)
• Machine code opcodes
• Bit masks and flags
• Color codes in web development (though that uses hex for RGB values)

Signed Integers: Three Competing Visions

Computers need to represent negative numbers. Three schemes exist:

Sign-and-Magnitude — The leftmost bit represents the sign (0 = positive, 1 = negative), and the remaining bits represent the magnitude. In 8 bits, 10000001 would be -1 and 00000001 would be +1. This is intuitive but has two representations of zero (+0 and -0) and makes arithmetic circuits complex.

Two’s Complement — The dominant scheme today. Negative numbers are represented by inverting all bits and adding 1. In 8-bit two’s complement, the range is -128 to +127. This scheme has exactly one zero, and arithmetic circuits can add positive and negative numbers using the same circuitry.

// Two's complement demonstration
#include <stdio.h>
#include <stdint.h>

void print_binary(uint8_t n) {
    for (int i = 7; i >= 0; i--) {
        printf("%d", (n >> i) & 1);
        if (i == 4) printf(" ");  // Separate nibbles
    }
}

int main() {
    uint8_t positive = 42;      // 00101010
    uint8_t negative = -42;     // In two's complement: 11010110

    printf("+42 in binary:  "); print_binary(positive); printf("\n");
    printf("-42 in binary:  "); print_binary(negative); printf("\n");
    printf("+42 + (-42) =   "); print_binary(positive + negative); printf(" (should be 0)\n");

    // Key insight: -42 = ~42 + 1
    printf("~42 + 1 =       "); print_binary((~positive) + 1); printf("\n");

    return 0;
}

Biased Representation — Used for exponents in floating-point numbers. A bias value is subtracted to get the actual exponent. The IEEE 754 single-precision uses a bias of 127 for exponents.

Floating-Point: Approximating the Reals

Real numbers (like pi or the square root of 2) can’t be exactly represented in binary with a finite number of bits. Floating-point provides a practical approximation using scientific notation.

IEEE 754 single-precision (32-bit) format:

• 1 bit: Sign (0 = positive, 1 = negative)
• 8 bits: Exponent (biased by 127)
• 23 bits: Mantissa (fractional part, normalized)

Sign (1) | Exponent (8) | Mantissa (23)
   S     |   EEEEEEEE   |   MMMM...MMM

The value represented is: (-1)^S × 1.M × 2^(E-bias)

Special values exist:

• Zero: all exponent and mantissa bits are 0 (sign bit determines +0 or -0)
• Infinity: all exponent bits are 1, mantissa is 0
• NaN (Not a Number): all exponent bits are 1, mantissa is non-zero
• Denormals: all exponent bits are 0 but mantissa is non-zero — these are “subnormal” numbers with reduced precision

#!/usr/bin/env python3
"""
Exploring IEEE 754 floating-point behavior
"""

import struct
import sys

def float_to_hex(f: float) -> str:
    """Convert float to its hexadecimal representation"""
    return hex(struct.unpack('<I', struct.pack('<f', f))[0])

def hex_to_float(h: str) -> float:
    """Convert hex string to float"""
    return struct.unpack('<f', struct.pack('<I', int(h, 16)))[0]

def analyze_float(f: float):
    """Break down a float into its IEEE 754 components"""
    packed = struct.pack('<f', f)
    bits = struct.unpack('<I', packed)[0]

    sign = (bits >> 31) & 1
    exponent = (bits >> 23) & 0xFF
    mantissa = bits & 0x7FFFFF

    actual_exponent = exponent - 127
    implicit_one = 1.0 + (mantissa / (2**23))

    print(f"Float: {f}")
    print(f"Hex: {float_to_hex(f)}")
    print(f"Sign: {sign}")
    print(f"Exponent: {exponent} (actual: {actual_exponent})")
    print(f"Mantissa: {mantissa:06x}")
    print(f"Value: (-1)^{sign} × {implicit_one:.10f} × 2^{actual_exponent}")
    print()

if __name__ == "__main__":
    # Classic floating-point gotcha
    print("=== Classic Gotcha ===")
    a, b = 0.1, 0.2
    c = 0.3
    print(f"0.1 + 0.2 = {a + b}")
    print(f"0.3 = {c}")
    print(f"(0.1 + 0.2) == 0.3: {a + b == c}")  # False!
    print()

    print("=== Analyzing Special Values ===")
    analyze_float(0.0)
    analyze_float(-0.0)
    analyze_float(float('inf'))
    analyze_float(-float('inf'))
    analyze_float(float('nan'))

    print("=== Powers of 2 ===")
    for exp in range(-5, 5):
        f = 2.0 ** exp
        analyze_float(f)

Character Encodings: Beyond Numbers

Text requires its own encoding scheme. The history is complicated:

ASCII (American Standard Code for Information Interchange) — 7 bits, 128 characters. Uppercase A-Z is 65-90, lowercase a-z is 97-122, digits 0-9 are 48-57. Control characters (0-31) handle things like newline and carriage return.

ISO-8859-1 (Latin-1) — 8 bits, 256 characters. Adds characters needed for Western European languages. First 128 match ASCII.

Unicode — Aims to represent every character in every language. Code points are written as U+XXXX, ranging from U+0000 to U+10FFFF (over 1.1 million possible characters).

UTF-8 — Variable-width encoding for Unicode. ASCII characters (U+0000 to U+007F) use 1 byte. Other characters use 2-4 bytes. UTF-8 is the dominant encoding on the web and in Linux/Unix systems.

Character | Unicode | UTF-8 bytes
----------|---------|-------------
A         | U+0041  | 41
€         | U+20AC  | E2 82 AC
😀        | U+1F600 | F0 9F 98 80

// Demonstrating character encoding handling in C
#include <stdio.h>
#include <uchar.h>
#include <string.h>

// UTF-8 aware string length
size_t utf8_strlen(const char *s) {
    size_t count = 0;
    const unsigned char *p = (const unsigned char *)s;

    while (*p) {
        // Count characters, not bytes
        if ((*p & 0x80) == 0) {
            // 1-byte character (ASCII)
            p += 1;
        } else if ((*p & 0xE0) == 0xC0) {
            // 2-byte character
            p += 2;
        } else if ((*p & 0xF0) == 0xE0) {
            // 3-byte character
            p += 3;
        } else if ((*p & 0xF8) == 0xF0) {
            // 4-byte character
            p += 4;
        }
        count++;
    }
    return count;
}

int main() {
    const char *text = "Hello, world! 😀";
    printf("String: %s\n", text);
    printf("Bytes: %zu\n", strlen(text));
    printf("Characters: %zu\n", utf8_strlen(text));

    return 0;
}

Production Failure Scenarios

Scenario 1: The Integer Overflow in Space

What happened: On June 4, 1996, the Ariane 5 rocket flight 501 exploded 37 seconds after liftoff. The inertial reference system attempted to convert a 64-bit floating-point number to a 16-bit signed integer. The value was larger than 32,767 (the maximum for a 16-bit signed integer), causing an overflow.

Root cause: The Ariane 5 used the same software from Ariane 4, but the horizontal velocity of the larger rocket exceeded the range representable in 16 bits.

Mitigation: Always validate integer conversions. Use language features that trap overflow (like -ftrapv in GCC), or use saturation arithmetic for values that shouldn’t overflow. For critical systems, formal methods can prove overflow absence.

// Safe integer conversion with overflow checking
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>

bool safe_int32_from_int64(int64_t val, int32_t *out) {
    if (val > INT32_MAX) {
        fprintf(stderr, "Overflow: %ld > INT32_MAX\n", val);
        return false;
    }
    if (val < INT32_MIN) {
        fprintf(stderr, "Underflow: %ld < INT32_MIN\n", val);
        return false;
    }
    *out = (int32_t)val;
    return true;
}

Scenario 2: Floating-Point Precision in Financial Calculations

What happened: A penny-counting stock trading system accumulated rounding errors over millions of transactions, eventually causing a $500,000 loss.

Root cause: Using IEEE 754 double precision for currency. While 0.1 can’t be exactly represented in binary, the tiny errors accumulated over millions of operations.

Mitigation: Use integer arithmetic for monetary values (store cents, not dollars), or use decimal floating-point libraries like IEEE 754 decimal128 where appropriate.

Scenario 3: The Year 2038 Problem

What happened: 32-bit Unix systems use signed 32-bit integers for time_t (seconds since January 1, 1970). On January 19, 2038, this value overflows to negative, representing dates in 1901.

Root cause: The choice of 32-bit signed integer for time_t made sense in 1971 but will break in 2038.

Mitigation: Migrate to 64-bit systems where time_t is 64 bits. Some systems use --enable-64-bit compilation flags. Some use a dual-date approach where pre-2038 and post-2038 routines coexist.

Trade-off Table

Implementation Snippets

Bit Manipulation for Flags

#!/usr/bin/env python3
"""
Bit manipulation utilities for flags and masks
"""

from typing import Callable

def set_bit(value: int, bit: int) -> int:
    """Set a specific bit to 1"""
    return value | (1 << bit)

def clear_bit(value: int, bit: int) -> int:
    """Set a specific bit to 0"""
    return value & ~(1 << bit)

def toggle_bit(value: int, bit: int) -> int:
    """Toggle a specific bit"""
    return value ^ (1 << bit)

def get_bit(value: int, bit: int) -> int:
    """Get the value of a specific bit (0 or 1)"""
    return (value >> bit) & 1

def is_power_of_two(n: int) -> bool:
    """Check if n is a power of two using bit trick"""
    return n > 0 and (n & (n - 1)) == 0

def count_set_bits(n: int) -> int:
    """Count the number of set bits (population count)"""
    count = 0
    while n:
        n &= n - 1  # Clear lowest set bit
        count += 1
    return count

# Example: File permission flags
READ = 0b100  # 4
WRITE = 0b010  # 2
EXECUTE = 0b001  # 1

def add_permission(perms: int, new_perm: int) -> int:
    """Add a permission using bitwise OR"""
    return perms | new_perm

def remove_permission(perms: int, rem_perm: int) -> int:
    """Remove a permission using bitwise AND with complement"""
    return perms & ~rem_perm

def has_permission(perms: int, check_perm: int) -> bool:
    """Check if a permission is set"""
    return (perms & check_perm) != 0

# Demonstration
perms = READ | WRITE  # 0b110 = 6
print(f"Initial permissions: {perms:#o} (octal), {perms:#06b} (binary)")

perms = add_permission(perms, EXECUTE)
print(f"After adding EXECUTE: {perms:#o}")

perms = remove_permission(perms, WRITE)
print(f"After removing WRITE: {perms:#o}")

print(f"Has READ? {has_permission(perms, READ)}")
print(f"Has WRITE? {has_permission(perms, WRITE)}")

Converting Between Bases

#!/usr/bin/env python3
"""
Number base conversion utilities
"""

def int_to_hex(n: int, width: int = 0) -> str:
    """Convert integer to hexadecimal string with optional zero-padding"""
    hex_chars = "0123456789ABCDEF"
    if n == 0:
        result = "0"
    else:
        result = ""
        while n > 0:
            result = hex_chars[n % 16] + result
            n //= 16
    return "0x" + result.zfill(width) if width > 0 else "0x" + result

def int_to_binary(n: int, width: int = 0) -> str:
    """Convert integer to binary string with optional zero-padding"""
    if n == 0:
        result = "0"
    else:
        result = ""
        while n > 0:
            result = str(n % 2) + result
            n //= 2
    return "0b" + result.zfill(width) if width > 0 else "0b" + result

def hex_to_int(hex_str: str) -> int:
    """Convert hexadecimal string to integer"""
    hex_str = hex_str.removeprefix("0x").removeprefix("0X")
    return int(hex_str, 16)

def binary_to_int(bin_str: str) -> int:
    """Convert binary string to integer"""
    bin_str = bin_str.removeprefix("0b").removeprefix("0B")
    return int(bin_str, 2)

def float_to_ieee754(value: float) -> tuple[int, int, int]:
    """Break down float into IEEE 754 components"""
    import struct

    packed = struct.pack('>f', value)
    bits = int.from_bytes(packed, 'big')

    sign = (bits >> 31) & 1
    exponent = (bits >> 23) & 0xFF
    mantissa = bits & 0x7FFFFF

    return sign, exponent, mantissa

# Demonstration
print("=== Base Conversions ===")
print(f"255 in hex: {int_to_hex(255)}")
print(f"255 in binary: {int_to_binary(255)}")
print(f"0xFF in decimal: {hex_to_int('0xFF')}")
print(f"0b1010 in decimal: {binary_to_int('0b1010')}")

print("\n=== IEEE 754 Analysis ===")
sign, exp, mant = float_to_ieee754(3.14159)
print(f"π (3.14159): sign={sign}, exponent={exp}, mantissa={mant:06x}")
print(f"Hex representation: {int_to_hex(sign << 31 | exp << 23 | mant, 8)}")

Observability Checklist

When debugging data representation issues:

• Integer overflow detection — Enable compiler overflow flags (-ftrapv, -fsanitize=integer)
• Floating-point exception flags — Check FE_DIVBYZERO, FE_INVALID, FE_OVERFLOW after calculations
• NaN propagation — Use isnan() and isinf() to detect special values
• Character encoding validation — Verify strings are valid UTF-8 using iconv or similar
• Endianness checks — Use union or struct tricks to detect little vs big endian
• Precision loss tracking — Log when double is coerced to float

Useful diagnostic commands:

# Check for NaN and infinity in a running process
# Attach with GDB and call: isnan(), isinf()

# Hexdump to see raw memory representation
hexdump -C your_file.bin | head -20

# Check floating-point environment
python3 -c "import sys; print(sys.float_info)"

Common Pitfalls / Anti-Patterns

Integer Overflow to Buffer Overflow — Attackers exploit integer overflows that cause buffer lengths to wrap, leading to memory corruption. Always validate integer inputs before using them for allocation or indexing.

Format String Vulnerabilities — Using printf with a user-controlled format string allows reading arbitrary memory (%x, %s) or writing arbitrary values (%n). Always use literal format strings: printf("%s", user_input) not printf(user_input).

Endianness and Network Protocols — Network byte order is big-endian. Different architectures may use different byte orders. Always use htons(), htonl(), ntohs(), ntohl() for network protocol handling.

Unicode Normalization Attacks — Different Unicode sequences can represent the same string. Attackers exploit this for phishing (é vs e combined with acute accent) or to bypass validation. Normalize using NFC or NFD before comparison.

Common Pitfalls / Anti-patterns

Pitfall: Assuming int is 32 bits In C, int is implementation-defined. Write int32_t or int64_t when you need specific sizes. Embedded systems might have 16-bit int.

Pitfall: Comparing floats for equality 0.1 + 0.2 == 0.3 is false. Use fabs(a - b) < epsilon for approximate equality, where epsilon is your tolerance (like 1e-9 for double).

Pitfall: Assuming char is signed Whether char is signed or unsigned is implementation-defined. Cast to unsigned char when you need to ensure the range 0-255.

Pitfall: Forgetting byte order in serialization Writing int directly to a file and reading on a different architecture will corrupt data. Use explicit serialization with defined byte order.

Pitfall: Assuming sizeof(char) == 1 Technically sizeof(char) is always 1, but char might be 9, 16, or 32 bits on unusual architectures. For bytes, use uint8_t.

Quick Recap Checklist

• Binary (base-2) uses powers of 2; each bit represents an increasing power of 2
• Hexadecimal (base-16) compactly represents 4 binary bits per hex digit
• Two’s complement is the standard for signed integers; it has one zero and symmetric range
• IEEE 754 floating-point approximates real numbers with sign, exponent, and mantissa
• Special floating-point values: zero, infinity (positive/negative), NaN, denormals
• ASCII defines 128 characters; Unicode extends to millions; UTF-8 is variable-width
• Integer overflow wraps silently in C; use overflow-checking modes or explicit checks
• Floating-point precision errors accumulate; use decimal types for financial calculations
• Always validate integer conversions and array bounds before use
• Bit manipulation is powerful for flags, masks, and optimized code

Interview Questions

int len = (int)large_count;  // -1 due to overflow
char* buf = malloc(len);          // malloc(-1) allocates small buffer
memcpy(buf, data, len);           // Overflow!

Decimal  Binary   Grey Code
0        000     000
1        001     001
2        010     011
3        011     010
4        100     110
5        101     111
6        110     101
7        111     100

cat /sys/class/misc/mem/cdev  # If this exists and shows memory devices

file /bin/ls  # Shows architecture - might hint at endianness

python3 -c "import struct; print('Big' if struct.pack('H', 1) == b'\\x00\\x01' else 'Little')"

getconf LONG_BIT  # Returns 32 or 64 (but doesn't determine endianness)
# Or check via sysctl
sysctl -n hw.byteorder

uint8_t u = 255;  // Binary: 11111111
int8_t s = (int8_t)u;  // s = -1
// But:
printf("%d", s);  // prints -1
// And:
printf("%u", (uint8_t)s);  // prints 255

int8_t x = -1;
int8_t y = 2;
int result = x + y;  // result = 1 (correct)
// But:
uint8_t ux = (uint8_t)x;  // 255
uint8_t uy = (uint8_t)y;  // 2
uint8_t ur = ux + uy;     // ur = 1 (255 + 2 = 257, truncated to uint8_t = 1)

// Safe: Use unsigned for bit operations
uint32_t safe_shift(uint32_t x, int bits) {
    return x << bits;  // Well-defined for unsigned
}
// Check before shift if signed:
int safe_left_shift(int x, int bits) {
if (x > (INT_MAX >> bits)) {
// Overflow would occur
return -1; // Or handle error
}
return x << bits;
}

Further Reading

• IEEE 754 Floating-Point Standard — The official IEEE 754-2019 standard
• What Every Computer Scientist Should Know About Floating-Point — David Goldberg’s seminal paper
• Two’s Complement arithmetic — Cornell lecture notes on two’s complement
• Unicode Consortium — Official Unicode standard and character database
• The Art of Assembly Language — Randall Hyde’s comprehensive x86 assembly text

Conclusion

Number systems and data representation form the bedrock of all digital computation. From the binary nature of electronic circuits to the complex IEEE 754 floating-point standard, these representation choices ripple through every layer of the system stack. The decisions made decades ago—two’s complement for signed integers, IEEE 754 for floating-point, UTF-8 for text—continue to shape how we build software today.

Understanding these representations isn’t just academic—it directly impacts how you debug numerical issues, design protocols, and write robust code. The integer overflow that destroyed the Ariane 5 rocket, the floating-point precision that causes unexpected test failures, and the endianness bugs that corrupt network packets—all stem from a deep understanding of how data is represented.

Continue your exploration of low-level concepts by studying boolean logic and gates to understand how these representations are manipulated by hardware, or move on to instruction set architecture to see how these data types are consumed by a processor.