1 Binary Representation and Data

Bits: the building blocks

Computers store information as patterns of bits, each of which is either $0$ or $1$. A bit is one binary digit, and a byte groups $8$ bits together. A bit pattern does not have an inherent meaning: a program or data format must interpret it.

Reading binary and hexadecimal

The binary number system is base $2$. Each position in a binary number represents a power of $2$, just as each decimal position represents a power of $10$. For example:

The hexadecimal number system is base $16$, using digits $0$–$9$ and letters A–F, where A–F represent $10$–$15$. Each hexadecimal digit corresponds to exactly four bits, so binary can be converted by grouping bits into chunks of four:

• $\texttt{1101\ 1010}_2 = \texttt{DA}_{16} = 218_{10}$.

• $\texttt{0010\ 1111}_2 = \texttt{2F}_{16}$.

Hexadecimal is therefore a compact way to write binary patterns. The prefix $\texttt{0x}$ is often used to indicate a hexadecimal value, as in $\texttt{0x2F}$.

Takeaway: binary place values are powers of $2$, and each hexadecimal digit neatly summarizes four binary bits.

Interpreting integer bit patterns

The same number of bits can represent different numerical ranges depending on the convention. An unsigned integer uses all bit positions for nonnegative place values. For $n$ bits, its range is:

Thus, an $8$-bit unsigned integer ranges from $0$ to $255$.

Computers commonly use two’s complement to represent signed integers. In an $n$-bit two’s-complement pattern, the leftmost bit has place value $-2^{n-1}$, while the other positions retain positive powers of $2$. The range is:

For $8$ bits, that range is $-128$ to $127$. For example, the pattern $\texttt{11111011}$ represents $-5$:

A common way to form a negative value in two’s complement is to invert the bits of its positive counterpart and add $1$. In this way, $\texttt{00000101}$, representing $5$, becomes $\texttt{11111011}$, representing $-5$.

The pattern $\texttt{11111111}$ illustrates why the interpretation convention matters: it represents $255$ as an unsigned $8$-bit integer and $-1$ as an $8$-bit two’s-complement integer.

Takeaway: a bit pattern alone does not determine a number; the signed or unsigned representation convention does.

Representing text

Text is stored by assigning numeric values to characters and encoding those values as bits. ASCII assigns values to a limited set of characters; uppercase A has the value $65$, written in hexadecimal as $\texttt{0x41}$.

Unicode assigns code points to characters. A code point is written in forms such as $\texttt{U+0041}$ for uppercase A. The code point identifies the character, but an encoding form determines the bytes or units used to store or transmit it.

For example, UTF-8 uses between $1$ and $4$ bytes per code point. UTF-16 uses one or two $16$-bit code units, while UTF-32 uses one $32$-bit code unit. UTF-8 preserves the ASCII byte values for the first $128$ code points, so A is encoded as the single byte $\texttt{0x41}$.

Takeaway: a Unicode code point identifies a character; its UTF encoding determines its stored representation.

From bit patterns to data

A data format gives stored patterns their meaning. The same $8$ bits might represent an unsigned integer, a signed integer, or a character, depending on how they are interpreted. Other data types follow their own conventions: a Boolean value may indicate false or true, while image and audio data can be represented by numerical pixel or sound samples. Some formats also specify the order in which multiple bytes are stored or transmitted.

Key idea: bits are the physical representation; the agreed encoding or data type assigns meaning to the pattern.