How Bytes and Bits Work *by
Marshall Brain*

If you have used a computer for more than five
minutes, then you have heard the words **bits** and **bytes**. Both RAM
and hard disk capacities are measured in bytes. So are file sizes when you
examine them in a file viewer. For example, you might hear an advertisement that
says "This computer has a **32-bit** Pentium processor with 64
**megabytes** of RAM and 2.1 **gigabytes** of hard disk space."

Decimal Numbers

The
easiest way to understand bits is to compare them to something you know: digits.
A digit is a single place that can hold numerical values between 0 and 9. Digits
are normally combined together in groups to create larger numbers. For example,
6357 has 4 digits. It is understood that in the number 6357 that the 7 is
filling the "1s place", while the 5 is filling the 10s place, the 3 is filling
the 100s place and the 6 is filling the 1000s place. So you could express things
this way if you wanted to be explicit:

- (6 * 1000) + (3 * 100) + (5 * 10) + (7 * 1) = 6000 +
300 + 50 + 7 = 6357

- (6 * 10^3) + (3 * 10^2) + (5 * 10^1) + (7 * 10^0) =
6000 + 300 + 50 + 7 = 6357

That should all feel comfortable - we all work with decimal digits every day and have no problems. The neat thing about number systems is that there is nothing that forces you to have 10 different values in a digit. Our "base-10" number system likely grew up because we have 10 fingers, but if we happened to evolve to have 8 fingers instead we would probably have a base-8 number system. You can have base-anything numbers systems. In fact, there are lots of good reasons to use different bases in different situations.

Bits

Computers happen to
operate using the base-2 number system, also known as the **binary** number
system (just like the base-10 number system is known as the decimal number
system). The reason computers use the base-2 system is because it makes it a lot
easier to implement them with current electronic technology. You could wire up
and build computers that operate in base-10, but they would be fiendishly
expensive right now. On the other hand, base-2 computers are dirt cheap.

So computers use binary numbers, and therefore use binary digits in place of
decimal digits. The word **bit** is a shortening of the words "Binary digIT".
Where decimal digits have 10 possible values ranging from 0 to 9, bits have only
2 possible values: 0 and 1. Therefore a binary number is composed of only 0s and
1s, like this: 1011. How do you figure out what the value of the binary number
1011 is? You do it in the same way we did it above for 6357, but you use a base
of 2 instead of a base of 10. So:

- (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (1 * 2^0) = 8 +
0 + 2 + 1 = 11

0 = 0 1 = 1 2 = 10 3 = 11 4 = 100 5 = 101 6 = 110 7 = 111 8 = 1000 9 = 1001 10 = 1010 11 = 1011 12 = 1100 13 = 1101 14 = 1110 15 = 1111 16 = 10000 17 = 10001 18 = 10010 19 = 10011 20 = 10100When you look at this sequence, 0 and 1 are the same for decimal and binary number systems. At the number 2 you see carrying first take place in the binary system. If a bit is 1, and you add 1 to it, the bit becomes zero and the next bit becomes 1. In the transition from 15 to 16 this effect roles over through 4 bits, turning 1111 into 10000.

Bytes

Bits are rarely
seen alone in computers. They are almost always bundled together into 8-bit
collections, and these collections are called **bytes**. Why are there 8 bits
in a byte? A similar question is, "Why are there 12 eggs in a dozen?" The 8-bit
byte is something that people settled on through trial and error over the past
50 years.

With 8 bits in a byte, you can represent 256 values ranging from 0 to 255, as shown here:

0 = 00000000 1 = 00000001 2 = 00000010 ... 254 = 11111110 255 = 11111111In the

0 = 0000000000000000 1 = 0000000000000001 2 = 0000000000000010 ... 65534 = 1111111111111110 65535 = 1111111111111111Bytes are frequently used to hold individual characters in a text document. In the ASCII character set, each binary value between 0 and 127 is given a specific character. Most computers extend the ASCII character set to use the full range of 256 characters available in a byte. The upper 128 characters handle special things like accented characters from common foreign languages.

The table at the right shows the 127 standard ASCII codes. Computers store
text documents, both on disk and in memory, using these codes. For example, if
you use Notepad in Windows 95/98 to create a text file containing the words,
"Four score and seven years ago", Notepad would use one byte of memory per
character (including one byte for each space character between the words (ASCII
value 32)). When Notepad stores the sentence in a file on disk, the file will
also contain one byte per character and space. Try this experiment: open up a
new file in Notepad and insert the sentence, "Four score and seven years ago" in
it. Save the file to disk under the name **getty.txt**. Then use the explorer
and look at the size of the file. You will find that the file has a size of 30
bytes on disk: one byte for each character. If you add another word to the end
of the sentence and re-save it, the file size will jump to the appropriate
number of bytes. Each character consumes a byte.

If you were to look at the file as a computer looks at it, you would find that each byte contains not a letter but a number. The number is the ASCII code corresponding to the character. So on disk The numbers for the file look like this:

F o u r a n d s e v e n ... 70 111 117 114 32 97 110 100 32 115 101 118 101 110 32 ...By looking in the ASCII table you can see a one-to-one correspondence between each character and the ASCII code used. Note the use of 32 for a space - 32 is the right ASCII code for a space. We could expand these decimal numbers out to binary numbers (so 32 = 00100000) if we wanted to be technically correct - that is how the computer really deals with things.

Lots of Bytes

When you
start talking about lots of bytes, you get into prefixes like Kilo, Mega and
Giga, as in Kilobyte, Megabyte and Gigabyte (also shortened to K, M and G, as in
Kbytes, Mbytes and Gbytes or KB, MB and GB). The following table shows the
multipliers:

Name abbrev Size ---- ------ ---- Kilo K 2^10 = 1,024 Mega M 2^20 = 1,048,576 Giga G 2^30 = 1,073,741,824 Tera T 2^40 = 1,099,511,627,776 Peta P 2^50 = 1,125,899,906,842,624 Exa E 2^60 = 1,152,921,504,606,846,976 Zetta Z 2^70 = 1,180,591,620,717,411,303,424 Yotta Y 2^80 = 1,208,925,819,614,629,174,706,176You can see in this chart that kilo is about a thousand, mega is about a million, giga is about a billion, and so on. So when someone says "this computer has a 2 gig hard drive", what he/she means is "2 gigabytes", which means approximately 2 billion bytes, and means exactly 2,147,483,648 bytes. How could you possibly need 2 gig of space? When you consider that one CD holds 650 meg, you can see that just 3 CDs worth of data will fill the whole thing! Terabyte database are fairly common these days, and there are probably a few petabyte databases floating around the Pentagon by now.

Binary Math

Binary math
works just like decimal math, except that the value of each bit can be only 0 or
1. To get a feel for binary math, let's start with decimal addition and see how
it works. Assume we want to add 452 and 751:

452 + 751 --- 1203To add these 2 numbers together you start at the right. 2 + 1 = 3. No problem. 5 + 5 = 10, so you save the zero and carry the 1 over to the next place. 4 + 7 + 1 (because of the carry) = 12. You save the 2 and carry the 1. 0 + 0 + 1 = 1. So the answer is 1203.

Binary addition works exactly the same way:

010 + 111 --- 1001Starting at the right, 0 + 1 = 1 for the first digit. No carrying there. 1 + 1 = 10 for the second digit, so save the 0 and carry the 1. 0 + 1 + 1 = 10 for the third digit. So save the zero and carry the 1. 0 + 0 + 1 = 1. So the answer is 1001. If you translate everything over to decimal you can see it is correct: 2 + 7 = 9.

Recapping

So to recap:

- We have bits, or binary digits. A bit can hold the value 0 or 1.
- We have bytes, made up of 8 bits.
- Binary math works just like decimal math, but each bit can have a value of only 0 or 1.

Here's a very simple description of binary arithmetic.

Decimal 1 is binary 0001

Decimal 3 is binary 0011

Decimal 6 is binary
0110

Decimal 9 is binary 1001

Each digit "1" in a binary number represents a power of two, and each "0" represents zero:

0001 is 2 to the zero power, or 1

0010 is 2 to the 1st power, or 2

0100 is 2 to the 2nd power, or 4

1000 is 2 to the 3rd power, or 8.

When you see a number like "0101" you can figure out what it means by adding the powers of 2:

0101 = 0 + 4 + 0 + 1 = 5

1010 = 8 + 0 + 2 + 0 = 10

0111 = 0 + 4 + 2 +
1 = 7

0001 + 0100 ---- 0101 (no carries to get this)

0001 + 0001 ---- 0010 (1 plus 1 is 10, carry the 1 to the next column)

0011 + 0011 ---- 0110 (1 + 1 = 10, so carry; then 1 + 1 + 1 = 11, so carry again)

0011 + 0101 ---- 1000 (carry in every column here)Subtraction is harder. Don't worry about it.

0000 = 0

0001 = 1

0010 = 2

0011 = 3

0100 = 4

0101 = 5

0110 = 6

0111 = 7

1000 = 8

1001 = 9

1010 = 10

1011 = 11

1100 = 12

1101 = 13

1110 = 14

1111 = 15

To represent bigger whole numbers (integers), you need more bits -- more places in the binary number:

10000101 = 128 + 0 + 0 + 0 + 0 + 4 + 0 + 1 = 133.

That was 8 bits:

- 8 bits is usually called a "byte", and it's the size usually used to represent an alphabetic character -- "A" is 65, or 01000001
- a "nybble" (a term seldom used) is 4 bits;
- a "word" depends on the computer but is often 16 or 32 bits.

- kilobyte, which is 1024 bytes (1024 is 2 to the 10th power)
- megabyte, which is roughly a million bytes.

To represent real numbers, fractions, or very large numbers, binary systems use "floating point arithmetic." That's another topic.

- They are simple to work with -- no big addition tables and multiplication tables to learn, just do the same things over and over, very fast.
- They just use two values of voltage, magnetism, or other signal, which makes the hardware easier to design and more noise resistant.

To convert a decimal number to binary, first subtract the largest possible power of two, and keep subtracting the next largest possible power form the remainder, marking 1s in each column where this is possible and 0s where it is not.

Example 1 - (Convert Decimal 44 to Binary)

Example 2 - (Convert Decimal 15 to Binary)

Example 3 - (Convert Decimal 62 to Binary)

**Another description
of the binary number system**