Binary (Base₂ )

Why learn the Binary (Base₂ ) number system?

While humans use the decimal number system based on the ten digits or fingers of the hands, computer systems use the binary number system based on the two states of on/off switches. These two states, off (0) and on (1), provide the foundation for understanding how computer systems and networks work.

A binary digit is called a bit (from the combined abbreviation of binary digit). Bits can have the value of off (0) or on (1). Although bits are the smallest storage unit in a computer system, most storage on computer systems is referenced by an eight bit unit called a byte. Here are some ways in which bits and bytes are referenced in computer and network systems:

What is the Binary (Base₂ ) number system?

The binary base₂ number system consists of two elements:

1. Only two digits are used in the number system (i.e., 0 and 1).
2. Each column represents a value based on a factor of 2.

How does the Binary (Base₂ ) number system work?

Counting in Binary (Base₂)

The standard unit of storage in computing is a byte. A byte consists of 8 bits. A byte can contain the decimal values 0-255 for a total of 256 different numbers or bit combinations. Below is a table that counts through all the possible bit combinations in a byte (decimal values 0-255).

*To count in binary using your fingers, try this web page.

Column Values in Binary (Base₂)
For the base₂ binary number system, the 1st eight columns look like the following (note that these eight columns also represent eight bits or one byte):

For the value of the 1st column, the base is raised to the power of zero (i.e., 2⁰). To get the next column value, one is added to the power of the current column (i.e., 2¹ for the 2nd column, 2² for the 3rd column, etc.). Powers or exponents simply determine how many times the number should be multiplied by itself (note that the powers of zero and one are an exception).

2⁰ = 1, any number raised to the power of zero is 1
2¹ = 2, any number raised to the power of one is the number itself
2² = 2 x 2 = 4
2³ = 2 x 2 x 2 = 8
2⁴ = 2 x 2 x 2 x 2 = 16
2⁵ = 2 x 2 x 2 x 2 x 2 = 32
2⁶ = 2 x 2 x 2 x 2 x 2 x 2 = 64
2⁷ = 2 x 2 x 2 x 2 x 2 x 2 x 2 = 128

The decimal equivalent of the base₂ binary number 10101010₂ is:
(1x128)+(0x64)+(1x32)+(0x16)+(1x8)+(0x4)+(1x2)+(0x1) = 170

In any base system, the next column value to the left can be found by multiplying the current column value by the base number. This works because one is being added to the exponent for the next column. Adding one to the exponent means that the base should be multiplied by itself one more time. In the base₂ binary number system, to get the column value of the next column, just multiply the current column value by 2.

It's easy to extend the column values of a binary number by either adding one to the power of the current column or multiplying the current column by two. Here's what the column values are for a 16-bit or 2-byte binary number.

Because the column values begin to get quite large, it makes sense to begin using a shorthand to indicate these larger values. The number 1024 can be represented by Kilo (K). Using this shorthand makes the multiples of 1024 much easier to remember. Below is the same table using K to represent 1024.

Here's what 1K and above mean:
1K = 1 x 1024 = 1024
2K = 2 x 1024 = 2048
4K = 4 x 1024 = 4096
8K = 8 x 1024 = 8192
16K = 16 x 1024 = 16384
32K = 32 x 1024 = 32768

Often in computing, K is rounded to 1,000. Although this isn't quite accurate, it does make it easier to compare numbers when rough values are all that's needed. Note that many numeric shorthand letters in computing are based on the same concept as K (i.e., 1024K = 1Meg or 1M or roughly 1 million, 1024M = 1Gig or 1G or roughly 1 billion).

The decimal equivalent of the 16-bit or 2-byte base₂ binary number 1010101010101010₂ is:
(1x32K)+(0x16K)+(1x8K)+(0x4K)+(1x2K)+(0x1K)+(1x512)+(0x256)+
(1x128)+(0x64)+(1x32)+(0x16)+(1x8)+(0x4)+(1x2)+(0x1) = 43,690

Converting from Binary (Base₂) to Decimal (Base₁₀)

Determining the decimal value of a binary number is simply a matter of adding up the decimal values of each column that contains a "1". For example, the decimal equivalent of the base₂ binary number 10011001₂ is:
128+16+8+1 = 153

The trick is in knowing what decimal value each column represents. There are two basic methods for determining the decimal value of a column.

Method 1: Determine the exponent or power value of a column by counting to the left starting with zero in the rightmost column, then add the column values containing "1" in the binary number.

For example, in trying to determine the decimal value of the binary number 1001₂:
The first "1" is located in the rightmost or 0 column which has the value 2⁰, 2⁰ = 1.
Counting from 0 to the left, the next "1" is located in the 3 column which has the value 2³, 2³ = 2 x 2 x 2 = 8.
The decimal value of binary number 1001₂ = 8 + 1 = 9.

Method 2: Write out all column values by starting with 1 in the rightmost column and doubling each column to the left, then add the column values containing "1" in the binary number.

For example, in trying to determine the decimal value of the binary number 1001₂:
There are four columns.
The rightmost column has a decimal value of 1.
The next column to the left has double that value or 2 x 1 = 2.
The next column to the left has double that value or 2 x 2 = 4.
The next column to the left has double that value or 2 x 4 = 8.
Write out the column values over the binary number, then add up the column values where there is a "1".
The decimal value of binary number 1001₂ = 8 + 1 = 9.

As you work with binary numbers more and more, you'll probably begin to memorize the column values for the 1st eight columns. This is because eight binary columns represent eight binary digits or eight bits or one byte. The byte is the most common grouping of bits you'll see when working with computer systems and networks. It's probably a good idea to memorize the column values of a binary byte from the start.

Converting from Decimal (Base₁₀) to Binary (Base₂)

There are two basic methods to convert from a decimal number to a binary number. One method involves division, the other method involves column value comparison and subtraction.

Method 1: Divide the decimal number to be converted to binary by 2 resulting in an integer with a remainder (0 or 1), then divide the resulting integer by 2 resulting in another integer with a remainder (0 or 1). Continue dividing the resulting integers by 2 until the resulting integer is 0. The binary equivalent of the decimal number is the list of remainders in reverse order.
Note: This method also works for converting decimal to any base by dividing by that base instead of 2 (e.g., 16 for hexadecimal, 8 for octal, etc.).

For example, to convert the decimal number 170 to binary:

Listing the remainders in reverse order produces 10101010.
Thus, the decimal number 170 equals 10101010₂ in binary.

Method 2: Find the largest binary column value that will fit in the decimal number and place a "1" in that column. Subtract the decimal number from that column value. Find the largest binary column value that will fit in the result from the subtraction and place a "1" in that column. If needed, place a "0" in all columns between the last "1" and the "1" just placed. Subtract the decimal number from that column value. Repeat this process using the result from the subtraction until the result is 0, then place a "0" in all remaining columns.
Note: This method requires a reference to the binary column values unless of course you've memorized the values.

For example, to convert the decimal number 170 to binary:

The largest column value that will fit in 170 is 128.
Place a "1" in the 128 column.

170 - 128 = 42
The largest column value that will fit in 42 is 32.
Place a "0" in all columns between the last "1" and the 32 column.
Place a "1" in the 32 column.

42 - 32 = 10
The largest column value that will fit in 10 is 8.
Place a "0" in all columns between the last "1" and the 8 column.
Place a "1" in the 8 column.

10 - 8 = 2
The largest column value that will fit in 2 is 2.
Place a "0" in all columns between the last "1" and the 2 column.
Place a "1" in the 2 column.

2 - 2 = 0
With 0 as the result, there are no more columns needed.
Place a "0" in all remaining columns.

Here's another way to look at method 2. Let's convert decimal 170 to binary again using method 2 and referencing the table below.

So we end up with the binary number 10101010₂.

In addition to the methods described above for converting from decimal-to-binary and binary-to-decimal, there are calculators available that will convert between different base number systems. The most readily available calculator that will do this can be found in Microsoft Windows under Start → Programs → Accessories. When in the calculator, you may need to change the "View" option from "Standard" to "Scientific".

Determining the number of bits needed to represent a given number of possible values

There are times when working with computer systems and networking that you'll need to determine how many bits are needed to represent a given number of possibilities. For example, if ten different values need to be represented in binary, the values 0-9 can be used. In binary, 0-9 are represented by 0000₂ through 1001₂. So, four bits would be needed to represent ten different binary values.

Note that the decimal values 10 through 15 or binary values 1010₂ through 1111₂ would not be used because they are not needed. Even though representing ten different values requires at least four bits, some of those values will not be used. Five or more bits could be used to represent ten different values, but that would mean even more values would go unused and the extra bits are not needed. Often when trying to determine the number of bits needed to represent a given number of possibilities, it's best to use the minimum number of bits rather than waste bits which can be used for other purposes.

The simplest method for determining the minimum number of bits needed to represent a given number of possibilities is to shift the binary column values to the right dropping the 1st column value. Those column values then represent the number of possible values for each extra column or bit.

The table below is used to determine the decimal value of a given binary number.

If the column values are shifted to the right, with the rightmost value dropped, the new table will now show how many possibilities exist for each number of bits. Note that the exponent indicates the number of bits (i.e., 2¹ for 1 bit, 2² for two bits, etc.) as well as the possibilities for that many bits (i.e., 2¹ = 2 possibilities, 2² = 4 possibilities, etc.).

To illustrate this:
With one bit (2¹) there are two possible values - 0 and 1
With two bits (2²) there are four possible values - 00, 01, 10 and 11
With three bits (2³) here are eight possible values - 000, 001, 010, 011, 100, 101, 110 and 111
etc.

Now to find the number of bits needed for a given number of possible values, simply find the column value just large enough to contain the given number of possible values. For example, if ten values are needed, then the column value 16 is just large enough to hold the 10 values. This means 4 bits are needed to represent 10 possibilities. While 5 bits representing 32 possible values will work to represent 10 values, it's not the most efficient use of bits because the 5th bit is not needed.

Masking binary numbers

Binary masks are used in networking to separate binary numbers into two portions, and in the process, mask over the irrelevant portion of the number. The process used for binary masking is called ANDing.

The two digits available in binary are 0 and 1. 0 and 1 can be used to represent any either/or values, also called boolean logic values. Here are some examples.

Logical ANDing compares two conditions where each condition is either TRUE or FALSE. It requires that both conditions evaluate to TRUE (i.e., TRUE AND TRUE) in order for the final result to be TRUE. The binary digit 0 represents FALSE and 1 represents TRUE. Therefore only 1 AND 1 (or TRUE AND TRUE) will result in 1 (or TRUE) when comparing using logical ANDing. The logical ANDing table below explores all four possibilities using binary 0 and 1.

 The way ANDing works with binary numbers involves comparing a binary number with a mask to determine which bits in the resulting binary number are 0 and 1. It's important to note that the purpose of the mask is to transform the original binary number into the resulting or ANDed binary number.

Suppose our original binary number is 10101010₂ and our binary mask is 11110000₂. Let's AND these and see the result.

10101010₂ original binary number
11110000₂ binary mask
10100000₂ result from ANDing

The way we come up with the result is by ANDing each column of the original number and the mask.

Notice two points from this ANDing process:

1. Wherever there is a binary 1 in the mask, the corresponding bit (same column position) in the original binary number ended up in the result.
2. Wherever there is a binary 0 in the mask, the corresponding bit (same column position) in the result is 0 no matter what value was in that same bit (same column position) in the original number.

Binary masks often have one set of contiguous ones followed by one set of contiguous zeros, which means that one side of the mask is all ones and the other side of the mask is all zeros. In other words, once the ones change to zeros, they don't change back again.

11110000₂   has one set of contiguous ones followed by one set of contiguous zeros
11101110₂   does NOT have one set of contiguous ones followed by one set of contiguous zeros

With this contiguous ones followed by contiguous zeros mask, seen in network addressing, the binary number is effectively separated into two portions: the portion ANDed through the ones and the portion ANDed through the zeros. The result of the bits ANDed through the one bits of the mask remains the same as the bits in the original binary number, while the result of the bits ANDed through the zero bits of the mask end up zero. The result from the ones portion of the mask remain significant, but the results from the zeros portion of the mask are masked to zeros and become irrelevant.

In networking, you will often find that addresses and masks expressed in bytes are entered in decimal notation. It is important to be able to see these decimal numbers in their binary representation to understand how the addressing works. Fortunately, because address masks are generally one set of contiguous ones followed by one set of contiguous zeros, there are only eight byte values to remember.

Because binary network addresses and masks are often expressed in decimal, the additional steps of converting from decimal-to-binary and binary-to-decimal are introduced to the binary ANDing process. For example, the decimal value of 48 and the decimal mask value of 224 produces the ANDed decimal result of 32. Here's how:

First convert the decimal value 48 and the decimal mask value 224 to binary so that binary ANDing can be performed.

Next, perform binary ANDing of the the converted decimal values producing the binary value 00100000.

00110000₂ Decimal value 48 in binary
11100000₂ Decimal mask value 224 in binary
00100000₂ result from ANDing

Finally, convert the binary ANDed result to decimal producing the decimal value 32.

Decimal 48 ANDed through the decimal mask 224 produces the decimal value 32.
Note: The ANDing process takes place in binary.

Back to Understanding and Converting Base Number Systems