Bits and Bytes

What is a Bit?

A bit is the smallest possible unit of data in a computer.

One bit holds a value of either 0 or 1.

Bits are stored in different ways:

• In computer memory, a bit is stored as electrical voltage, where a voltage above a certain threshold represents a 1, and a voltage below that threshold represents a 0.
• In hard disk drives, a bit is stored as magnetism, where an area magnetized in one orientation represents a 1, and a magnetized area in the opposite orientation represents a 0.
• In CDs, DVDs, and Blu-ray discs, a bit is stored as either a pit, or a flat area. A pit is an area where the surface is lower than the surrounding surface, and that represents a 1. A flat area is when there is no pit, and that represents a 0.

But simply storing just one bit is not very useful. We need to store more bits together to represent larger amounts of data.

What is a Byte?

A byte is a group of 8 bits, like 10001011 for example.

Each bit can be either 0 or 1, and with 8 bits in a byte, there are 2⁸ = 256 different values a byte can have.

Using one byte, we can store:

• A pixel with one out of 256 different colors.
• An unsigned number from 0 to 255.
• A signed number from -128 to 127.
• A character from the ASCII table.

This means that the specific byte 10001011 could be:

• A pixel with a specific color.
• The unsigned number 139.
• The signed number -117 (the leftmost bit is 1, which means it is a negative number).
• The character <, from the extended ASCII table ISO-8859-1.

But normally, modern computers use more than one byte to store a single character, number or color.

Storing Groups of Bytes

Like we have seen, it is possible to use a single byte to store a single character, a number, or a color.

But normally, modern computers use more than one byte to store something.

Colors

This blue color for example, is created with CSS code rgb(0,153,204), and is stored using 3 bytes:

• 00000000 (0) for red color
• 10011001 (153) for green color
• 11001100 (204) for blue color

Color codes for other colors can be found using this color picker.

Using 3 bytes, we can store 2²⁴ = 16,777,216 different colors.

Characters

Storing characters using UTF-8 encoding, a single character can be stored in 1 to 4 bytes.

In UTF-8, the letter g is stored using 1 byte as 01100111, and the smiley emoji 😊 is stored using 4 bytes as 11110000 10011111 10011000 10001010.

Using 1 to 4 bytes, we can store 1,112,064 different characters.

Numbers

Storing numbers that are either very large or in need of high precision, or both, requires a lot of data storage.

For example, storing the mathematical number pi 𝜋 = 3.141592... in Python or JavaScript, requires 64 bits (following the IEEE 754 standard).

Using 64 bits to store numbers makes it possible to store large numbers, and numbers with a high precision, and that allows us to do very precise calculations.

Data Storage Units

When storing data, we can use different units to measure the size of the data.

In data measurement units, the capital letter "B" is used to represent "byte", and the lower case letter "b" is used to represent "bit".

Storing many bytes, we use units:

• Bytes (B)
• Kilobytes (kB)
• Megabytes (MB)
• Gigabytes (GB)
• Terabytes (TB)

The International System of Units (SI) defines the prefixes:

• kilo- (k), meaning 1 000
• mega- (M), meaning 1 000 000
• giga- (G), meaning 1 000 000 000
• tera- (T), meaning 1 000 000 000 000

So, 1 kilobyte is 1 000 bytes, 1 megabyte is 1 000 000 bytes, 1 gigabyte is 1 000 000 000 bytes, and 1 terabyte is 10¹² bytes.

When storing data, we use these units to measure the size of the data.

For example, storing the 500x300 pixel tiger image below, with 3 bytes per pixel to store the color (24 bit color depth), requires 500 * 300 * 3 = 450 000 bytes.

The image above is 450 000 bytes, or 450 kB (kilobytes).

But in computing, using binary numbers instead of the decimal system, measuring data storage units can be a bit confusing, because 1 kilobyte some times refers to 2¹⁰ = 1024 bytes instead of 1 000 bytes, and 1 megabyte is some times 2²⁰ = 1024 * 1024 bytes instead of 1 000 000 bytes, and so on.

Using this kind of measuring, the image above is 450 000 / 1024 = 441 kB, so almost the same as before, but not quite.

To avoid this confusion, the International Electrotechnical Commission (IEC) has defined the following units:

• kibi- (Ki), meaning 1024
• mebi- (Mi), meaning 1024 * 1024
• gibi- (Gi), meaning 1024 * 1024 * 1024

So, to be absolutely clear and correct, we should say that the image above is either 450 kB, or 441 KiB.

Data Transfer Units

Measuring data transfer speeds is just like measuring data storage units, but with the "per second" at the end.

The unit for data transfer speeds in bits is "bits per second" (bps or b/s), and the unit for data transfer speeds in bytes is "bytes per second" (Bps or B/s).

When larger amounts of data are transferred, we use prefixes:

• kilobits per second (kbps)
• megabits per second (Mbps)
• gigabits per second (Gbps)

With kilo-, mega- and giga- referring to 1000, 1 000 000 and 1 000 000 000, respectively.

And the same prefixes are used for transfer speeds in bytes.

Just like with data storage units, the prefixes kibi-, mebi- and gibi- should be used to refer to 1024, 1024 * 1024 and 1024 * 1024 * 1024, respectively.