Every piece of digital information you've ever encountered — every text message, every photograph, every video stream, every program, every database record — is ultimately composed of the same fundamental unit: the bit.

Bits are to computing what atoms are to chemistry. Just as all matter is composed of atoms, all digital information is composed of bits. Understanding bits and their organized groupings (bytes, words, etc.) is essential for understanding how computers represent, store, and process anything and everything.

In the previous page, we learned why computers use binary. Now we'll explore how binary data is structured — the units we use to measure it, organize it, and reason about it. This knowledge is foundational for understanding memory, storage, data types, and algorithm complexity.

A bit (short for binary digit) is the smallest unit of data in computing. It represents a single binary value: either 0 or 1.

The Dual Nature of a Bit:

A bit is simultaneously a physical entity and an abstract concept:

Physically, a bit is:

• A voltage level in a circuit (high ≈ 1, low ≈ 0)
• A magnetic orientation on a hard drive (north ≈ 1, south ≈ 0)
• A charge level in flash memory (charged ≈ 1, uncharged ≈ 0)
• A light pulse in fiber optics (light ≈ 1, no light ≈ 0)

Abstractly, a bit is:

• The answer to any yes/no question
• The distinction between two possible states
• The minimum unit of information

Information Theory Perspective:

In Claude Shannon's information theory, a bit is formally defined as the amount of information required to distinguish between two equally probable outcomes. If you flip a fair coin, you need exactly 1 bit of information to record whether it landed heads or tails.

What Can a Single Bit Represent?

With just one bit, you can represent any distinction between two states:

The power of bits isn't in what a single bit can represent — it's in how multiple bits combine to represent exponentially more states.

Here's the fundamental mathematical truth that makes digital computing possible: n bits can represent 2ⁿ distinct values.

This exponential relationship is crucial. Let's trace it:

The Exponential Explosion:

Notice how quickly the numbers grow. Adding just one bit doubles the range. This is why computers can represent virtually anything with enough bits:

• 10 bits: 1,024 values (≈ 1 thousand)
• 20 bits: 1,048,576 values (≈ 1 million)
• 30 bits: 1,073,741,824 values (≈ 1 billion)
• 40 bits: 1,099,511,627,776 values (≈ 1 trillion)

This exponential growth is the fundamental reason digital systems can represent complex information — from simple counters to high-definition video — using the same simple building block: the bit.

A byte is a group of 8 bits. It is the fundamental unit of data storage and addressing in virtually all modern computers.

Why 8 Bits?

The 8-bit byte wasn't always standard. Early computers used various word sizes: 6-bit, 7-bit, 12-bit, and others. The 8-bit byte became dominant for several reasons:

1. Character Encoding: 7 bits (128 values) were enough for ASCII characters, and 8 bits (256 values) allowed for extended character sets.

2. Power of Two: 8 is a power of 2, making byte arithmetic simple and efficient.

3. Hardware Convenience: 8 bits fit neatly on circuit boards and memory chips.

4. IBM's Influence: The IBM System/360 (1964) standardized the 8-bit byte, and its immense commercial success made this the de facto standard.

What a Byte Can Represent:

With 8 bits, a byte can represent 256 (2⁸) distinct values, typically used as:

As data needs grew, we needed terms for larger quantities of bytes. This led to the familiar kilobyte, megabyte, gigabyte, and so on. However, there's a confusing historical inconsistency here that every engineer should understand.

The Binary vs. Decimal Confusion:

In everyday usage, "kilo" means 1,000, "mega" means 1,000,000, and so forth (powers of 10). But in computing, memory and storage have traditionally been sized in powers of 2.

This created the awkward situation where:

• 1 kiloByte was sometimes 1,000 bytes (10³)
• 1 kiloByte was sometimes 1,024 bytes (2¹⁰)

The IEC Standard:

To resolve this ambiguity, the International Electrotechnical Commission (IEC) introduced new prefixes:

• Ki (kibi) = 2¹⁰ = 1,024
• Mi (mebi) = 2²⁰ = 1,048,576
• Gi (gibi) = 2³⁰ = 1,073,741,824

So 1 MiB (mebibyte) is exactly 2²⁰ bytes, while 1 MB (megabyte) is exactly 10⁶ bytes.

Practical Reality:

In practice, the situation is messy:

• RAM is always measured in binary units (your "8 GB" RAM is really 8 GiB)
• Hard drives and SSDs use decimal units (a "1 TB" drive is exactly 10¹² bytes)
• File sizes are typically shown in binary units by operating systems

This is why a "1 TB" hard drive shows up as "931 GB" in your operating system — the drive uses decimal (1,000,000,000,000 bytes), but the OS displays binary (÷ 1,073,741,824).

While bytes are the fundamental addressable unit, CPUs typically work with larger chunks called words.

What Is a Word?

A word is the natural data size for a particular processor architecture. It's the amount of data a CPU can process in a single operation and typically matches the width of its registers.

• 32-bit architecture: Word = 32 bits = 4 bytes
• 64-bit architecture: Word = 64 bits = 8 bytes

The word size affects many aspects of computing:

Memory Addressing:

Every byte in memory has a unique address — a number that identifies its location. When you access memory, you specify the address, and the hardware retrieves the byte(s) at that location.

Conceptual Model of Memory:

Address       Data (Byte)
0x00000000    [01001101]
0x00000001    [11100010]
0x00000002    [00000000]
0x00000003    [11111111]
0x00000004    [10101010]
...           ...

In a 64-bit system, addresses are 64 bits long, allowing for an astronomical number of possible addresses. However, practical systems use only a fraction of this address space due to physical memory limits and operating system constraints.

When a multi-byte value (like a 32-bit integer) is stored in memory, the individual bytes must be placed in some order. Endianness describes this ordering.

Little-Endian:

The least significant byte (the "small end") is stored at the lowest memory address.

Example: The 32-bit integer 0x12345678 stored at address 0x100:

0x100: 78 (least significant)
0x101: 56
0x102: 34
0x103: 12 (most significant)

Big-Endian:

The most significant byte (the "big end") is stored at the lowest memory address.

Example: The same integer stored big-endian:

0x100: 12 (most significant)
0x101: 34
0x102: 56
0x103: 78 (least significant)

Why Does This Matter?

Endianness rarely matters when working within a single system — the same CPU that writes data will read it back correctly. It becomes critical when:

1. Network Communication: Data sent between different machines must agree on byte order. That's why network protocols standardize on big-endian ("network byte order").

2. File Formats: Binary file formats must specify endianness, or files become unreadable on different architectures.

3. Cross-Platform Development: Code that manipulates bytes directly (like parsers or serializers) must handle endianness explicitly.

4. Debugging: When examining raw memory, you need to know the endianness to interpret multi-byte values correctly.

While storage is measured in bytes, data transfer rates are typically measured in bits per second. This is an important distinction that often confuses beginners.

Why Bits for Transfer?

Historically, communication lines transmitted data serially — one bit at a time. Thus, "bits per second" (bps) became the natural unit for measuring transfer speed. This convention persists today.

Common Speed Units:

• bps = bits per second
• Kbps = kilobits per second = 1,000 bps
• Mbps = megabits per second = 1,000,000 bps
• Gbps = gigabits per second = 1,000,000,000 bps

Note: These use decimal prefixes (powers of 10), unlike storage which uses binary.

The Bits-to-Bytes Trap:

When an ISP advertises "100 Mbps internet," they mean 100 megabits per second. To convert to megabytes per second (more useful for thinking about file downloads), divide by 8:

100 Mbps ÷ 8 = 12.5 MBps

This is why downloads feel slower than the advertised speed suggests — looking at bits instead of bytes makes the number appear 8 times larger.

Let's apply our understanding of bits and bytes to real-world scenarios. This grounds the abstract concepts in tangible examples.

Estimating Data Sizes:

Being able to quickly estimate data sizes is a valuable engineering skill. Here are useful rules of thumb:

• 1 KB ≈ Half a typed page of text
• 1 MB ≈ A small book, a low-quality photo, or 1 minute of compressed audio
• 1 GB ≈ 1 hour of standard-definition video, or 250 high-quality photos
• 1 TB ≈ 1,000 hours of SD video, or 250,000 photos

These approximations help when designing systems, estimating storage costs, or evaluating bandwidth requirements.

We've explored the fundamental units of digital information. Let's consolidate what we've learned:

What's Next:

With a solid understanding of bits and bytes, we're ready to explore number systems: how binary relates to decimal and hexadecimal, how to convert between them, and why hexadecimal is universally preferred when humans need to read binary data. This knowledge unlocks the ability to read memory dumps, understand color codes, and decode many other computational representations.