The system of counting we all know and use is called ** base-10** or

```
0 zero
1 one
2 two
3 three
4 four
5 five
6 six
7 seven
8 eight
9 nine
```

To count beyond nine, we need another digit place: the 9 cycles back to our first symbol, 0, and the digit place to the left (which implicitly starts as a 0) cycles from 0 to 1:

```
09 nine
10 ten
```

As we count, each time the right-most digit cycles around from 9 back to 0, the digit to its left cycles to the next symbol in the sequence. Eventually we’ll reach 99, and counting one higher cycles the right-most 9 back to 0, and the digit to its left (the other 9) also cycles back to 0, causing the implicit 0 to its left to cycle to 1:

```
099 ninety-nine
100 one hundred
```

Effectively, any time you have a series of 9’s in the right-most digit places and wish to count one higher, the 9’s all cascade back to 0, and the first non-9 digit from the right cycles once. For example:

```
23999999 twenty-three million, nine hundred ninety-nine thousand, nine-hundred ninety-nine
24000000 twenty-four million
```

The system of counting in which we use just two symbols (0 and 1) is called ** base-2** or

```
0 zero
1 one
```

To count beyond one, we need another digit place: the 1 cycles back to our first symbol, 0, and the digit place to the left (which implicitly starts with a 0) cycles from 0 to 1:

```
01 one
10 two!
```

And here’s where it gets confusing: what looks like ten in decimal is actually two in binary. To help avoid this confusion, you should read binary numbers digit-by-digit, *e.g.* 101 is ‘one zero one’, not ‘one-hundred one’: the quantity represented by binary 101 is what we call five in decimal!

As we count in binary, every time the right most digit cycles around from 1 back to 0, the digit to its left cycles to the next symbol in the sequence: 0 cycles up to 1, and 1 cyclces back around to 0. Just like in decimal, any time our last symbol in the sequence cycles back around, the digit place to its left also cycles. Whereas, in decimal, a series of 9’s in the right-most digits will cascade, we get the same effect in binary when we have a series of 1’s in the right-most digits:

```
10101111 binary one zero one zero one one one one
10110000 binary one zero one one zero zero zero zero
```

So here is counting in binary up to the equivalent of decimal 15:

```
00000 zero
00001 one
00010 two
00011 three
00100 four
00101 five
00110 six
00111 seven
01000 eight
01001 nine
01010 ten
01011 eleven
01100 twelve
01101 thirteen
01110 fourteen
01111 fifteen
10000 sixteen
```

Every binary digit place with a 1 effectively corresponds to a power of two, starting with 1 on the right and increasing to the left:

```
000001 one
000010 two
000100 four
001000 eight
010000 sixteen
100000 thirty-two
```

A binary number is effectively the sum of the powers of two corresponding to each digit-place with a 1:

```
100010 thirty-two + two = thirty-four
```

So this is how we convert from binary to decimal. To go the other way, from decimal to binary, we break a decimal number into a sum of (unique) powers of two. For example, decimal 55 is the sum of 32, 16, 4, 2, and 1.

Because binary numbers are verbose, we generally avoid writing them out as 0’s and 1’s. Instead, we use another counting system, ** base-16**,

It works out that, because 16 is a power of 2, conversion between hex and binary is extremely easy to do, requiring no arithmetic at all. All you need to do is memorize the correspondence between the first 16 binary and hex numbers:

```
0000 binary = 0 hex
0001 binary = 1 hex
0010 binary = 2 hex
0011 binary = 3 hex
0100 binary = 4 hex
0101 binary = 5 hex
0110 binary = 6 hex
0111 binary = 7 hex
1000 binary = 8 hex
1001 binary = 9 hex
1010 binary = A hex
1011 binary = B hex
1100 binary = C hex
1101 binary = D hex
1110 binary = E hex
1111 binary = F hex
```

To convert a hex number into binary, simply replace each hex digit with the four binary digits it corresponds to in this table. For example:

```
3A5F hex = 0011_1010_0101_1111
```

(The underscore separators are there just to make it easier to see the digits in groups of four.)

To go the other way, from binary to hex, replace each group of four binary digits with the hex digit it corresponds to in the table (just be sure to first add padding zeros on the left so that the number of binary digits is a mutiple of four).

```
11011 binary = 0001_1011 binary = 1B hex
```

To avoid confusion between written decimal, binary, and hex numbers, we usually add prefixes or suffixes to binary and hex numbers. Most commonly we denote hex numbers with `0x`

or `0X`

, *e.g.* `0x314`

is ‘hex three one four’. Binary numbers aren’t written out much—again, we usually prefer hex to represent binary—but when they are written out, we typically prefix them with `0b`

or `0B`

.

As you’ve probably guessed by now, we represent positive decimal integers as bits by simply converting to binary. The decimal number 130, for example, has the binary equivalent 10000010 and so can be represented with 8 bits.

An ** unsigned** integer is always positive, never negative. If we use 8 bits to store an unsigned integer, we can represent the values 0 up to 255:

```
0000_0000 (0)
0000_0001 (1)
...
1111_1111 (255)
```