Binary Arithmetic
At their lowest level, computers cannot subtract, multiply, or divide. Neither can calculators. The world's largest and fastest supercomputer can only add—that's it. It performs the addition at the bit level. Binary arithmetic is the only means by which any electronic digital computing machine can perform arithmetic.
Suppose you want the computer to add seven 6s together. If you asked the computer (through programming) to perform the calculation
6 + 6 + 6 + 6 + 6 + 6 + 6
the computer would zing the answer, 42, back to you before you could say bit bucket. The computer has no problem performing addition. The problems arise when you request that the computer perform another type of calculation, such as this one:
42 – 6 – 6 – 6 – 6 – 6 – 6 – 6
Because the computer can only add, it cannot do the subtraction. However, the computer can negate numbers. That is, the computer can take the negative of a number. Therefore, it can take the negative of 6 and represent (at the bit level) negative 6. Once it has done that, it can add –6 to 42 seven times. In effect, the internal calculation becomes this:
42 + (–6) + (–6) + (–6) + (–6) + (–6) + (–6) + (–6)
Adding seven –6s produces the correct result of 0. This may seem like a copout to you. After all, the computer is really subtracting, right? In reality, the computer is not subtracting. At its bit level, the computer can convert a number to its negative through a process known as 2's complement. A number's 2's complement is the negative of its original value at the bit level. The computer has in its internal logic circuits the capability to convert a number to its 2's complement and then carry out the addition of negatives, thereby seemingly performing subtraction.
Once the computer can add and simulate subtraction, it can simulate multiplying and dividing. To multiply 6 times 7, the computer actually adds 6 together seven times and produces 42. Therefore
6 x 7
becomes this:
6 + 6 + 6 + 6 + 6 + 6 + 6
To divide 42 by 7, the computer subtracts 7 from 42 (well, it adds the negative of 7 to 42) until it reaches zero and counts the number of times (6) it took to reach zero, like this:
42 + (–7) + (–7) + (–7) + (–7) + (–7) + (–7)
The computer represents numbers in a manner similar to characters. As Table 3.2 shows, numbers are easy to represent at the binary level. Once numbers reach a certain limit (256 to be exact), the computer will use more than one byte to represent the number, taking as many memory locations as it needs to represent the number. After it is taught to add, subtract, multiply, and divide, the computer can then perform any math necessary as long as a program is supplied to direct it.
Table 3.2 All Numbers Can Be Represented as Binary Numbers
Number 
Binary Equivalent 
0 
00000000 
1 
00000001 
2 
00000010 
3 
00000011 
4 
00000100 
5 
00000101 
6 
00000110 
7 
00000111 
8 
00001000 
9 
00001001 
10 
00001010 
11 
00001011 
12 
00001100 
13 
00001101 
14 
00001110 
15 
00001111 
16 
00010000 
17 
00010001 
18 
00010010 
19 
00010011 
20 
00010100 
To see an example of what goes on at the bit level, follow this example to see what happens when you ask the computer to subtract 65 from 65. The result should be zero and, as you can see from the following steps, that is exactly what the result is at the binary level.
TIP
The first 255 binary numbers overlap the ASCII table values. That is, the binary representation for the letter A is 01000001, and the binary number for 65 is also 01000001. The computer knows by the context of how your programs use the memory location whether the value is the letter A or the number 65.
 Suppose you want the computer to calculate the following:
65 – 65

The binary representation for 65 is 01000001, and the 2's
complement for 65 is 10111111 (which is –65 in computerese). Therefore, you
are requesting that the computer perform this calculation:
01000001 + 10111111

Because a binary number cannot have the digit 2 (there are only 0s and
1s in binary), the computer carries 1 anytime a calculation results in a value
of 2; 1 + 1 equals 10 in binary. Although this can be confusing, you can make an
analogy with decimal arithmetic. People work in a base 10 numbering system.
(Binary is known as base 2.) There is no single digit to represent ten; we have
to reuse two digits already used to form ten: 1 and 0. In base 10, 9 + 1 is 10.
Therefore, the result of 1 + 1 in binary is 10 or "0 and carry 1 to the
next column."
01000001
+10111111
100000000

Because the answer should fit within the same number of bits as the two original numbers (at least for this example—your computer may use more bits to represent numbers), the ninth bit is discarded, leaving the zero result. This example shows that binary 65 plus binary negative 65 equals zero as it should.
TIP
The good thing about all this binary arithmetic is that you don't have to understand a bit of it (pun intended) to be an expert programmer. Nevertheless, the more you know about what is going on under the hood, the better you will understand how programming languages work and the faster you will master new ones by seeing similarities between them.