Bits and Bytes

Bits

You may be familiar with the saying “Computers speak in 1s and 0s”, but have you ever grappled with what that means? It’s amazing to think how much they are capable of doing with just two symbols.

In our counting system, we use 10 symbols:

$$0,1,2,3,4,5,6,7,8,9$$

In the binary system—the language of the computer—we only have two symbols: 0 and 1, which we call bits. We say that our counting system is base-10, or decimal, and the binary system is base-2. Base-2 number systems have a few interesting properties that make them suited for digital use. Among them, the fact that they are very easy to represent physically. For example, a light switch can be either on or off, which can be represented by $1$ or $0$, respectively. This is the basis for binary logic.

But if, then, we only have two symbols, how are computers able of representing so much information? How are long strings of $1$s and $0$s converted into the letters and symbols we see on our screen?

Bytes

Let us consider one bit. It can either be on ($1$) or off ($0$). What if we add another bit? We can now represent four different states:

First Bit	Second Bit	Decimal Value
$0$	$0$	$0$
$0$	$1$	$1$
$1$	$0$	$2$
$1$	$1$	$3$

We can keep on adding bits, and the number of states we can represent grows exponentially. For example, with $2$ bits, we can represent $2^2=4$ states, with $3$, $2^3=8$ states, 4 bits, $2^4=16$ states, and so on. With only $8$ bits, we can represent $2^8=256$ states. We call this a byte.

This pattern of powers of $2$ yields insight into how we can interpret (or, “read”) binary. Consider the byte string: 10110111.

$$\begin{array}{rlrlrlrl}1& 0& 1& 1& 0& 1& 1& 1\\ \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow & \downarrow \\ 2^7& 2^6& 2^5& 2^4& 2^3& 2^2& 2^1& 2^0\end{array}$$ $$2^7+2^5+2^4+2^2+2^1+2^0$$ $$\boxed{128+32+16+4+2+1=183}$$

For the more math-inclined reader, we can make this more formal. Let $\lambda$ be a binary string of length $n$, and let ${\lambda }_i$ be the $i$th bit of $\lambda$ (read from right to left; i.e., ${\lambda }_0$ is the rightmost bit, called the least significant bit since it has the least value $2^0$). Then we can convert $\lambda$ to decimal as follows:

$$\begin{array}{rl}\mathbf{BinToDec}(\lambda )& =\sum _{i=0}^{n-1}{\lambda }_i\cdot 2^i\\ & ={\lambda }_0\cdot 2^0+{\lambda }_1\cdot 2^1+{\lambda }_2\cdot 2^2+\dots +{\lambda }_{n-1}\cdot 2^{n-1}\end{array}$$

Signed and Unsigned Values

It is important that we make the distinction here between positive and negative values. In the binary system, we have the concept of signed and unsigned values. Recall that a byte has $2^8=256$ states. If we use all $8$ bits to represent a positive number (unsigned), we can represent values from $0$ to $255$. However, if we wish to allow for negative values (signed), we can only represent values in the range $-128$ to $127$.

This changes the way we interpret the bits. For example, if we have the unsigned byte 11111111, we interpret it $255$. If we considered it a signed byte, we would interpret it as $-1$. We won’t get into the nitty gritty of this here, but I’d encourage you to look up two's complement.