6 Data Representation

Bits, Bytes, and Meaning

Computers store every kind of data as a pattern of bits. A bit has the value $0$ or $1$, and a byte contains eight bits. The bits do not inherently mean “number,” “letter,” or “instruction”; software supplies the interpretation.

A byte therefore has $2^8 = 256$ possible patterns. For example, the pattern $\mathtt{01000001}$ can represent the unsigned integer $65$, the ASCII character A, or part of another data structure. This is the central idea of data representation: the same physical bits can acquire different meanings under different rules.

Takeaway: Storage consists of bit patterns; meaning comes from the rules used to interpret those patterns.

Binary Numbers and Byte Order

Binary uses base $2$, so each position represents a power of two. In the eight-bit pattern $\mathtt{00101101}$, the positions containing $1$ contribute $32$, $8$, $4$, and $1$:

More generally, an $n$-bit pattern can represent $2^n$ distinct combinations. When the pattern is treated as an unsigned integer, the largest value is $2^n - 1$. Thus, eight unsigned bits cover $0$ through $255$, while sixteen unsigned bits cover $0$ through $65{,}535$.

A nibble is four bits. Larger values are commonly grouped into sixteen-, thirty-two-, or sixty-four-bit quantities. When a value occupies multiple bytes, endianness determines their order: big-endian places the most significant byte first, whereas little-endian places the least significant byte first.

Takeaway: Binary place values explain numerical conversion, while byte order determines how multi-byte values are laid out.

Integers and Fractional Values

An unsigned integer represents zero and positive whole numbers. With eight bits, $\mathtt{00000000}$ represents $0$, $\mathtt{00000001}$ represents $1$, and $\mathtt{11111111}$ represents $255$. The general maximum is:

Signed integers must also represent negative values. Two’s-complement representation is commonly used because ordinary binary addition can then work for both positive and negative integers. To create $-5$ in eight bits, begin with $\mathtt{00000101}$, invert the bits to obtain $\mathtt{11111010}$, and add $1$, producing $\mathtt{11111011}$.

For an eight-bit signed two’s-complement value, the usual range is $-128$ through $127$. One bit pattern cannot be used to represent every possible integer: if a result exceeds the available range, a language or operation may wrap around, report an error, or use a larger representation.

Fractional values require another approach. Floating-point representation stores a sign, a significant portion, and a scale or exponent. It can cover a wide range, but its precision is limited, so a decimal value such as $0.1$ may not have an exact binary representation and calculations can produce small rounding errors. Fixed-point representation instead keeps the binary-point position fixed.

Takeaway: Integer formats trade range against the number of bits, while floating-point formats trade exact precision for range and flexibility.

Logical Values and Data Types

A Boolean value represents a logical condition with two states: true and false. It may be stored as one bit, commonly using $0$ for false and $1$ for true, although a programming language or file format may use a whole byte or another fixed-size unit.

A program can use Boolean values in decisions, such as testing whether a user is logged in or has permission. The stored pattern alone does not guarantee a Boolean interpretation; the program must apply a rule that defines how the value is used.

A data type connects a stored pattern with valid operations. Common data types include integers, floating-point numbers, Booleans, characters, strings, and raw byte sequences. The type determines whether software should perform arithmetic, logical tests, character processing, or some other operation.

Takeaway: A data type is an interpretation contract: it identifies the kind of value and the operations that make sense for it.

Characters, Unicode, and Text

A character is an abstract symbol such as A, 7, ?, or é; a string is an ordered sequence of characters. Computers store numeric codes rather than letters directly. A character encoding defines how character identities become bytes.

ASCII assigns codes to common English letters, digits, punctuation, and control characters. For example, uppercase A has decimal code $65$, which is binary $\mathtt{01000001}$. ASCII does not provide enough codes for all writing systems and symbols used around the world.

Unicode supplies a shared repertoire and assigns each character a code point. Encodings such as UTF-8, UTF-16, and UTF-32 specify how those code points are represented in bytes. UTF-8 is variable-length: characters in the ASCII range use one byte, while other characters use two, three, or four bytes. Consequently, a string’s number of characters is not always equal to its number of bytes.

If bytes encoded as UTF-8 are incorrectly interpreted using another encoding, the result can be unreadable text called mojibake. The sender and receiver must therefore agree on the encoding when text is saved or transmitted.

Takeaway: Characters, code points, encodings, and bytes are related but distinct: a character is the symbol, a code point identifies it, and an encoding determines its byte representation.

From Stored Bits to Interpreted Data

A typical data-handling process connects four stages:

1. Representation: A value is converted into a pattern of bits.

2. Storage: The bits are placed in memory, a file, or another storage device.

3. Transmission: The pattern may be sent between components or across a network.

4. Interpretation: Software applies a data type, encoding, or file format to determine what the bits mean.

For example, $\mathtt{01000001}$ can be interpreted as the unsigned integer $65$ or as the ASCII character A. It could also be part of image data or part of a machine instruction, depending on the surrounding rules. The pattern itself does not decide which interpretation is correct.

This principle explains why formats and protocols are necessary. Text requires an agreed encoding; an image requires rules for colors and pixel arrangement; and program data requires rules for distinguishing instructions from values. Fixed-size formats also impose limits: an eight-bit unsigned value cannot represent a result greater than $255$ without more bits or a different handling rule.

Takeaway: Correct interpretation depends on shared context, including the type, encoding, format, and storage conventions.