Consider the number 1 in terms of decimal base 10. When we shift the number to the left and insert a 0 as a placeholder for the 1's position, we get 10. Another shift to the left, with another 0 inserted as placeholder for ten's position, we get 100. Shift left again, we get 1000.

```
1
10
100
1000
```

Notice that each shift left is 10 times the previous position in value.

1 X 10 => 10

10 X 10 => 100

100 X 10 => 1000

1000 X 10 => 10000

This pattern repeats itself in all number bases. We can conveniently refer to the example above in examining binary (base 2) numbers, since there are only 1's and 0's.

Shift 1 to the left, we get 2. Shift 2 to the left we get 4, and again we get 8, and finally on the fourth shift left we get 16.

So a shift to the left is a doubling of the number, and a shift to the right is a halving of the number. The smallest number in base 2 is 0, the smallest non-zero number is 1. There are no decimal places in binary.

Now consider the number 9. Can we in one digit represent a larger integer? No. So when we add 1 to nine, the magnitude of the number goes up by 1. In arithmetic we call this a *carry*. In binary it is called a *carry bit*.

There is no way to represent a binary number larger than 15 in only 4-bits. It becomes necessary to introduce a carry bit, hence a 5-bit number.

We normally don't represent binary numbers with leading 0's any more than we would with decimal numbers. The left most bit is known as the *highest order bit* and its right most is the *lowest order bit*. Orders refer to magnitudes, which are exponential.

```
Lowest order bit magnitude => 0
Highest order bit magnitude => 4 (in our example of 16)
```

What gets raised to the order of magnitude? The base, 2. 2^0 is 1. 2^1 is 2, and so on.