By Joshua Erdman

Digital Foundation

Binary is the way of the computer. All commands, memory storage, input, and output are done using binary in the computer. Computers think and communicate in binary, the same goes for computer addresses. To really get a handle on network addressing and other important computer theories, we need to be able to use binary.

Not really, for computers to register a 1 or a 0 it needs a signal for each. In other words, it is not as simple as if there is a signal, it is a 1 and the lack of a signal represents a 0. The way binary works is by registering a high signal and a low signal.

A bit is a single binary digit. This is a useless amount of information but when you group them together nd have 8 bits, this makes one byte. A single byte can have up to 256 different combinations of 1s and 0s. Typically information is broken up into bytes to be stored, calculated, or transmitted.

The way we are all used to counting is by using the numbers 0 through 9. Then when we start all over again, we put a 1 for the first digit and increment the second digit from 0 to 9 again. The same goes for binary, except that we can only use the numbers 0 through 1. Check out the counting below:

Decimal Binary 0 0 1 1 2 10 3 11 4 100 5 101 6 110 7 111 8 1000 9 1001

Ok so I know this is looking pretty wierd by now but you can probably see the pattern and can guess what the number 10 is in binary. It is 1010 (the fact that there is 2 tens in a row is a coincidence.

But there has to be a better way to convert decimal numbers to and from binary. With the table above onmly goes to 9 in decimal and it is already quite large. The solution to that problem is pretty easy with a few observations. Look back at the example. The number 1 is the same in both columns. Then look at number 2, in the binary column it is a 1 followed by a zero, then look at 4 and 8, these are also a 1 followed by zeros. The same goes for 16, 32, and so forth. And the relationship between, 1, 2, 4, 8, and 16 is they are all powers of 2. (2 to the power of zero is 1 - in case if you were wondering).

**Clue:** The decimal equivalent to each binary digit is by
powers of 2. (Example: The third binary digit's decimal equivalent is 2 to the
3rd power. The fourth binary digit's equivalent value is 2 to the 4th power, and
so on.)

First you must create a line listing the powers of two to just beyond the number you want to convert. In other words, if you want to convert 237 to binary, list all the powers of two until you reach 256. This will ensure you have all the binary bits available to you. Check out the example:

256 128 64 32 16 8 4 2 1

Now flag each digit needed to add up to 237 starting from the left. So we would not flag 256 since that is too big, the first power of two we will flag is 128. Then 64 and 32. So far this adds up to 224. So we cannot flag 16 because that will put us over 237. The next digit to flag is 8, we skip 4, and flag the 2 and 1. So our flagging should look like this:

256 128 64 32 16 8 4 2 1 ----------------------------------------- 1 1 1 1 1 1

Notice I flagged each digit I needed with a 1. By now I am sure you have figured out that the digits I do not need will be flagged with a 0. See below:

256 128 64 32 16 8 4 2 1 ----------------------------------------- 0 1 1 1 0 1 1 0 1

Now just as with our normal counting, we do not have any number prefixed with a zero. In other words if I was to display the digits for nine hundred fifty seven I would not write 0957. It would only be the digits that are significant, 957. So that is it, the binary version of 237 is: 11101011.

**Clue:** Just was with decimal numbers, the largest most
significant number is on the left and the digit with the smallest numberical
value is on the right.

Now that we know the decimal value of each binary digit, converting back to decimal is a piece of cake. Again just write out your decimal equivalents for each binary digit. So if you were given the binary number 1101011001 you would count the number of digits, 10, and then write out the first 10 powers of two (starting from right to left):

512 256 128 64 32 16 8 4 2 1

Then write your binary number under the values.

512 256 128 64 32 16 8 4 2 1 ------------------------------------ 1 1 0 1 0 1 1 0 0 1

Finally add up each binary value that is flagged with a 1.

512 256 64 16 8 + 1 ___ 857