Binary, Bits and Bytes

A bit is one binary digit: 0 or 1. Binary means representing information using these two symbols. A bit is a unit of data. The hardware that holds it is a physical part of the computer.

A zero carries information

Imagine a light with two states. An agreed rule could use 0 for off and 1 for on. Both answers tell you something. A stored 0 is just as real as a stored 1.

A bit can also stand for no or yes, or false or true. The meaning depends on the rule used. Two bits give four patterns: 00, 01, 10, and 11. Groups of bits can therefore describe much more than a single switch.

How hardware holds bits

Inside processors and memory, tiny electronic switches called transistors control electric signals. Hardware usually reads a low voltage as 0 and a high voltage as 1. Modern processors contain billions of transistors.

Storage devices keep data in several physical forms:

These features let hardware record and read bit patterns. The digits are labels people use for the states. There are no tiny written zeros or ones inside the device.

Why two states work well

Suppose a circuit treats a voltage near 0 volts as 0. It treats a voltage near 3 volts as 1. A small disturbance reduces a high signal to 2.7 volts. The circuit can still recognize it as high.

Now imagine fitting ten signal levels into the same range. Neighboring levels would be only about 0.3 volts apart. The same disturbance could make one level look like another. Two clearly separated states leave more room for small changes without changing the bit read.

That reliability helps digital copying. If every bit is copied correctly, the new file has exactly the same data. Repeating that copying process need not make the picture blurrier or the sound noisier. A damaged bit can still cause an error; binary does not prevent every possible failure.

One kind of data, many uses

Text, images, sounds, numbers, and program instructions all use bit patterns. The program reading the bits needs rules for interpreting them. For example, 01 could mean a direction in a robot code or a number in a calculation.

Two states are the standard because they make practical, reliable hardware. Other designs are possible. The reason for binary is how well it works in common hardware, not a rule that every possible computer must use exactly two states.

The air pressure in a sound wave changes continuously. Between two pressure values, there are more possible values. This kind of data is analog. Room temperature and tide height are other examples.

Digital data uses separate values, also called discrete values. A thermometer showing one decimal place might display 21.4 and then 21.5. It cannot display a value between them at that precision. The actual temperature can still lie between those readings.

From a signal to bits

A fixed group of bits has a limited number of patterns. It cannot store every possible value of a continuous signal. Digitizing turns the signal into numbers that the computer can record.

1. A sensor turns a physical quantity into an electric signal. A microphone does this for sound.
2. An analog-to-digital converter measures the signal at regular intervals. Each measurement is a sample.
3. Each sample is rounded to a value the system can record. That value is stored in binary.

For example, an outdoor sensor takes one reading each hour. It records whole degrees:

The stored values give a useful record, but not every detail. Rounding removes the decimal part's extra detail. The sensor also misses changes that happen between readings. A short temperature rise and fall could happen without appearing in the record.

More detail needs more data

Taking samples more often records more points along the changing signal. Using more bits for each sample allows more possible recorded values. This can reduce how much rounding is needed. Both changes increase the amount of data to store.

These choices answer different problems. More frequent samples help capture changes over time. More bits per sample help describe the value of each reading more closely.

Once the measurements are digital, a computer can edit and send them. Correct copies preserve the stored numbers exactly. That does not make the original recording perfect: the missing details were lost when the signal was first digitized.

Return to sound

To play a sound file, a digital-to-analog converter produces a changing electric signal from the stored numbers. A speaker turns that signal into sound waves.

“Digital” describes how information is represented. It does not mean “online.” A sound file stored on an offline computer is still digital. An electronic clock with moving hands can show time in analog form. What matters is continuous change compared with separate recorded values.

In a place value system, a digit's position helps determine its value. In decimal, the 4 in 407 means four hundreds. The 0 keeps the tens position, and the 7 means seven ones.

Compare the bases

A number system's base tells you how many digits it uses. It also tells you how the column values grow.

Decimal is also called denary. Here, “decimal” means base 10. A number such as 407 is decimal even though it has no decimal point.

Build the binary columns

The rightmost whole-number column is worth 1. Moving left doubles the value each time:

A 1 includes that column's value. A 0 leaves it out. This row therefore means one 8, one 4, no 2, and one 1:

The columns are powers of 2. Starting on the right, their labels are $2^0,2^1,2^2,2^3$ and so on. A power such as $2^3$ means three 2s multiplied together, giving 8. The value of $2^0$ is defined as 1.

Say which base you mean

The digits 101 have different values in different bases. Decimal 101 means one hundred and one. Binary 101 means one 4 and one 1, which is five.

A small lower number, called a subscript, can show the base:

Read binary digits one at a time: “one zero one.” This avoids accidentally reading them as a decimal number. Changing the written base changes the representation, not the amount being counted.

Keep the zeros in the right places

Zeros on the left do not change a whole number's value. Binary 101, 0101, and 00000101 all mean five. Computers often use groups of eight bits, so the full byte is 00000101.

A zero on the right changes the places of the other digits. Binary 1010 means one 8 and one 2, giving ten. It is double the value of 101.

The leftmost bit has the largest place value in the written group. It is the most significant bit. The rightmost bit is the least significant bit, worth 1. Always start your place value labels at the right, even when the written number has fewer than eight digits.

Decimal counting moves to a new column after 9. Binary has only 0 and 1, so it moves to a new column after 1. The next binary number after 1 is 10, which means two.

Watch the count grow

The next number is 10000, which means sixteen. Continue with 10001, 10010, 10011, 10100, 10101, 10110, and 10111 for seventeen through twenty-three. Then 11000 through 11111 give twenty-four through thirty-one.

Find the next pattern

To increase a binary number by one, work from the right:

1. Change each ending 1 to 0.
2. Change the first 0 you reach to 1.
3. Leave the bits farther left unchanged.

For 1011, the two ending 1s become 0s. The next bit is 0, so change it to 1. The result is 1100. The decimal count has moved from eleven to twelve.

If all the bits are 1s, write a new 1 on the left. That takes 111 to 1000, or seven to eight. A binary count never uses a digit 2.

Use the column rhythms

The ones bit alternates 0, 1, 0, 1. The twos bit stays 0 for two counts, then 1 for two counts. The fours bit stays the same for four counts at a time. Each column changes half as often as the one on its right.

Every column except the ones column has an even value. That makes the last bit a quick odd-or-even check. A last bit of 1 means odd; a last bit of 0 means even. For example, 10110 means twenty-two and 10111 means twenty-three.

Recognize useful shapes

A single 1 followed by zeros marks a power of 2. Binary 1000 is eight; 100000 is thirty-two. A row of 1s is one below the next power of 2. Five 1s, 11111, mean thirty-one.

You can model five bits with five fingers. Give them values 16, 8, 4, 2, and 1. A raised finger means 1. Raise the 4 and 2 fingers to show 00110, or six. All five fingers raised show thirty-one. The all-lowered pattern also counts: it shows zero.

One bit has two possible patterns: 0 and 1. Add another bit, and each old pattern can end in either 0 or 1. You now have 00, 01, 10, and 11. Each extra bit doubles the number of patterns.

Patterns and largest values

For a group of $n$ bits:

If the patterns represent whole numbers starting at zero:

The pattern for zero is part of the count. That is why 256 patterns do not give a largest value of 256.

A group of four bits is a nibble. A group of eight bits is a byte. The largest eight-bit value has every bit set to 1:

Choose enough bits for a code

Suppose 30 students need different ID codes. Four bits offer only 16 patterns. Five bits offer 32, enough for the class with two patterns unused. Five is the smallest suitable bit count.

For 300 students, one byte is too small. Eight bits give 256 patterns. Nine bits give 512, so nine bits can give everyone a different code.

You do not need one bit for every person. A bit is one position in a pattern. Different combinations of those positions create the different IDs.

Store a number starting at zero

A number and a count of items ask slightly different questions. Thirty-two different items need 32 patterns, so five bits work. The whole number 32 needs a pattern beyond 0 through 31, so it needs six bits.

To store 200, eight bits are enough because the range ends at 255. The number 256 needs a ninth column, worth 256, so its binary form is 100000000.

A score stored as a whole number starting at zero in one byte can reach 255. A score of 300 needs more than a byte. This is a question about whether enough patterns are available for the values being stored.

Check the doubling

Eight bits give $2^8$ patterns. That means multiplying eight 2s together, giving 256. Multiplying 2 by 8 gives 16 and answers a different calculation. When deciding on a code size, list the doubling sequence until it reaches the number of choices needed, then check that one fewer bit would be too small.

To read a binary number as decimal, label its columns. Start with 1 under the last bit, then double as you move left. Add only the values above 1s. A 0 means that place contributes nothing.

Start with four bits

For binary 1011, the column values are 8, 4, 2, and 1. The 1s select 8, 2, and 1:

Adding the digits themselves would give three. That counts how many 1s appear, but it does not measure their values. The leftmost 1 contributes eight, not one.

Read a full byte

Use the same steps for 01101101:

The 128, 16, and 2 columns have zeros, so leave them out.

For 10010110, the first bit is 1. This time the 128 column must count:

Work through the columns in order so that you do not overlook a 1 or include a 0's value.

Line up short numbers on the right

A short number still ends in the ones column. In an eight-column table, 101 belongs under 4, 2, and 1. Its full-byte form is 00000101.

Putting 101 under 128, 64, and 32 would give 160. That would describe 10100000, a different number. The table's unused leading places may get zeros; the digits must not move away from the ones column.

Catch errors with two quick checks

Check the last bit. A last bit of 1 requires an odd decimal answer. A last bit of 0 requires an even answer. The answer 150 for 10010110 passes this check because both are even.

Then check the highest place marked 1. A byte starting with 1 must be at least 128. A result of 22 for 10010110 would be too small, even though 22 is also even. These checks catch some errors, but adding the selected values still provides the full check.

Useful boundary patterns include 00000000 for zero, 01111111 for 127, 10000000 for 128, and 11111111 for 255.

Read a measurement

A sensor sends 00011001 as a temperature in whole degrees Celsius. Its 1s sit under 16, 8, and 1, giving 25 °C. The bit pattern supplies the number. The sensor's agreed format supplies its meaning and unit.

A decimal number can be split into binary place values. Begin with the largest column and decide whether it fits. Each decision produces one bit, including a 0 when the value does not fit.

Work through every column

To convert 45 into a full byte, use 128, 64, 32, 16, 8, 4, 2, and 1:

Reading the bits across gives 00101101. Adding its selected values checks the answer:

The zero in the 16 column is essential. Removing it would move the other bits into different columns. A place that does not fit still needs its digit.

Keep going after the remainder reaches zero

Now convert 200. Take 128, leaving 72. Take 64, leaving 8. Skip 32 and 16 by writing zeros. Take 8, leaving zero. The final three columns, 4, 2, and 1, all get zeros.

The full result is 11001000. Stopping immediately after taking 8 would leave 11001, which means 25. The last three zeros keep the chosen 128, 64, and 8 in the correct places.

Why a column is used once

Every binary column holds only 0 or 1. After you subtract the largest place value that fits, the remainder is smaller than that value. You can continue with smaller columns without using that place again.

For example, six is four plus two. It is written 110, or 00000110 as a byte. Describing six as three twos does not give a valid binary row, because a column cannot hold a digit 3.

Zero needs no selected place values. As a byte it is 00000000. Every number from zero through 255 fits in eight columns. The next column to the left would be worth 256.

Try a game score

A game stores a score of 89 in one byte. The 128 column is too large. Take 64, leaving 25; take 16, leaving 9; take 8, leaving 1; then take 1. Fill the other columns with zeros to get 01011001.

Check the result by reading it back:

The final bit is 1, as expected for an odd score. Reading back tests both the chosen values and the zeros that hold their places.

Repeated division gives another way to turn decimal into binary. Each division finds one bit. The important detail is that it finds the bits from right to left.

Keep the whole-number answer and remainder

Divide the number by 2. Record the whole-number answer, called the quotient, and the remainder. Divide that quotient by 2 again. Continue until the quotient becomes zero.

For 13:

Read the remainder column from the bottom upward: 1101. In a full byte, this is 00001101.

Do not stop at a quotient of 1. The last division gives a remainder of 1, which is the leftmost bit. Also, record 6 remainder 1 for the first line, not 6.5.

Why the order is reversed

When an even whole number is divided by 2, its remainder is zero. An odd number leaves one. This tells you the number's ones bit.

The quotient is what remains after that rightmost bit is removed. Dividing the quotient finds the next bit to the left. So the first remainder belongs on the right, and the final remainder belongs on the left.

For 13, reading the remainders downward would give 1011. That is eleven, so direction changes the answer.

A longer example

For 156, record these quotients and remainders:

• 156 divided by 2 gives 78, remainder 0.
• 78 gives 39, remainder 0.
• 39 gives 19, remainder 1.
• 19 gives 9, remainder 1.
• 9 gives 4, remainder 1.
• 4 gives 2, remainder 0.
• 2 gives 1, remainder 0.
• 1 gives 0, remainder 1.

Reading upward gives 10011100. Check the selected place values:

Choose and check a method

Subtraction makes place values visible in a table. Division builds the bits without needing that table. Both methods describe the same number and must agree.

For any conversion, first read the result back to recover the starting number. Then use quick checks: an odd starting number must end in 1, an even number must end in 0, and a whole-number byte must lie from zero through 255. For example, 01100100 reads back as 100 and ends in 0. A quick check can flag an error; it cannot replace checking the full value.

Column addition groups equal place values. Start on the right, where the ones are. In decimal, ten ones become one ten. In binary, two ones become one two, so a column reaches its carrying point at two.

Four rules for two bits

The last row means one plus one makes two. Binary writes two as 10: one two and no ones. A digit 2 cannot appear in a binary answer.

Include an incoming carry

A column can contain the two digits being added and a carried 1. If all three are 1, their total is three. Binary three is 11:

Write 1 in the current column and carry 1 left. With two 1s, you write 0 and carry 1. With three, you write 1 and carry 1. Keeping these cases separate prevents a common carrying error.

Add without carrying

Consider 101 plus 010. All numbers in this sum are binary.

1. Ones: one plus zero gives one.
2. Twos: zero plus one gives one.
3. Fours: one plus zero gives one.

The result is 111. In decimal, five plus two gives seven, so it checks.

Follow a carry through the columns

Now add binary 011 and 001:

1. Ones: one plus one gives binary 10. Write 0 and carry 1.
2. Twos: one plus zero plus the carry gives binary 10. Write 0 and carry 1.
3. Fours: zero plus zero plus the carry gives 1. Write 1.

The result is 100. This is three plus one making four.

The first carry does not disappear after it is written. It becomes an extra amount in the next column. That column can produce another carry, which must move left again.

Keep a clear record

On paper, write a small carry above the next column before adding it. Use a separate row so that carries do not look like answer digits. For each column, ask how many 1s are present, including the carry. Then choose the rule for zero, one, two, or three.

Writing 0 for one plus one without recording the carry loses the whole value of two. The carry preserves that value in the next place.

Longer binary sums follow the same rules as short ones. The challenge is keeping track of place values and each incoming carry. Line up the final digits before beginning.

Align different lengths

To add 1101 and 11, put both ones bits together. The shorter number can be written 0011. All the numbers here are binary:

The total is sixteen. A carry from the leftmost written column becomes a new digit on the left. Written as full bytes, the same sum is 00001101 plus 00000011, giving 00010000.

Work through a full byte

Add 00101101 and 00011011. Work from the ones column toward the 128 column:

The result bits were found from right to left. Put each one under its own column, then read the answer normally: 01001000.

The 8 column has three 1s. It leaves a result bit of 1 and still sends a carry onward. Treating it as two 1s would incorrectly write 0 there.

Check in decimal

Convert each starting number and the proposed result:

The ordinary sum is $45+27=72$, so the binary answer checks. Checking only the inputs would not check your written result.

For a larger example, 10110100 plus 00101101 gives 11100001. Their decimal values are 180, 45, and 225. The carries begin in the 4 column and continue through the 32 column; that column has three 1s and writes 1.

Repair a failed check

If the total does not match, compare the numbers' alignment first. Then trace each carry from right to left. A missed carry changes all the work that depends on it. Keep the final answer in binary when binary is requested; decimal is the checking tool.

A processor's circuits follow these same addition and carry rules. The rules describe the arithmetic, while the circuit design determines how the hardware performs it.

An encoding scheme matches bit patterns to meanings. Encoding turns information into bits. Decoding uses the scheme to turn the bits back into information.

Agree on the patterns and groups

A robot uses this two-bit direction code:

The message 10 11 00 tells it to go south, west, north. The route east, east, south becomes 01 01 10. The spaces show where the two-bit groups end.

Group length matters. The stream 101100 splits into 10 11 00 as two-bit groups. Split into three-bit groups, it becomes 101 100. Those groups belong to a different code. Sender and receiver need the same meanings and the same grouping rules.

Give every choice its own pattern

The seven days of the week need seven different patterns. Two bits give only four, so they are too few. Three bits give eight, leaving one pattern spare. The 26 English letters need five bits for a simple fixed-length code, because five bits give 32 patterns.

A code may leave patterns unused. The aim is enough distinct patterns, not one bit per item. Sharing one pattern between two meanings would make decoding unclear unless another rule supplied the missing information.

Draw with bits

A pixel is one small picture element in a digital image. A black-and-white grid can use one bit per pixel. Choose 1 for black and 0 for white. A five-pixel row, 00100, then has one black pixel in the center.

Five rows—11111, 00100, 00100, 00100, 00100—draw a capital T. The grid holds five times five pixels, so its pixel data needs 25 bits. Reversing the color rule would reverse the black and white areas.

An eight-by-eight grid has 64 pixels. At one bit per pixel, that needs 64 bits, or 8 bytes. The width and height must be known so the receiver can rebuild the rows.

Bits do not label their own meaning

The byte 01000011 is the number 67 when read as a binary whole number. In ASCII text it represents “C.” Under the black-and-white rule above, it is a row of white, black, four whites, and two blacks.

The bits have not changed. The interpretation has. A file format tells a program how to read the data and which rules apply to its parts. For example, a pet record can keep an age as a number, a name as text, and a picture as pixels. A program needs to know which part it is reading.

A character can be a letter, digit, space, punctuation mark, or symbol. A character set gives characters numbers. An encoding stores those numbers as bit patterns.

Use ASCII for simple English text

ASCII assigns numbers from zero through 127. These 128 codes fit in seven bits. They include letters, digits, punctuation, spaces, and control codes such as a new line.

When stored one character per byte, an ASCII code has a leading 0. Some useful character numbers are:

The letters run in order. Since “A” is 65, “C” is 67. Uppercase and lowercase are different characters: “A” is 65 while “a” is 97.

Encode and decode text

For “Hi,” look up the character numbers, then convert them:

• “H” has number 72 and byte 01001000.
• “i” has number 105 and byte 01101001.

The stored sequence is 01001000 01101001. Keep the bytes in the same order as the characters.

To decode 01000011 01000001 01010100, convert each byte into decimal. The values are 67, 65, and 84. ASCII gives “C,” “A,” and “T,” spelling “CAT.”

A digit used in text has its own character code. The character “7” is 55, stored as 00110111. The number seven is 00000111. A program must interpret typed digits as a number before doing arithmetic with that value.

Count all the characters

For text stored one ASCII character per byte, count spaces and punctuation too. “Hi there!” contains nine characters: two letters, a space, five more letters, and an exclamation point. It needs 9 bytes, or 72 bits, for the text itself.

Store writing from many languages

ASCII cannot represent most writing systems. Unicode assigns character numbers across many languages, symbols, and emoji. Its first 128 numbers match ASCII, so “A” still has number 65.

UTF-8 stores a Unicode character number using one to four bytes. “A” takes one byte, “é” takes two, “€” takes three, and “😀” takes four. A visible symbol can sometimes be built from several Unicode character numbers, so it is unsafe to assume every symbol on a screen occupies one byte.

For a UTF-8 size calculation, use the byte length of each character being stored. For plain ASCII text in UTF-8, each character still uses one byte. For other text, counting the characters alone may not tell you its byte size.

A bit and a byte measure different amounts of data. A bit, written b, is one binary digit. A byte, written B, is eight bits. A nibble is four bits, so two nibbles make one byte.

Name the larger units

Standard decimal prefixes grow in steps of 1,000:

Kilo means thousand, mega means million, giga means billion, and tera means trillion. These prefixes follow the same pattern as other decimal measurements.

A short text note may need kilobytes. A phone photo or a song often needs megabytes. A movie or large game may need gigabytes. A large drive can hold terabytes. File sizes vary, but these examples help judge whether an answer is sensible.

Capitalization matters. Eight megabits, written 8 Mb, contain the same amount as one megabyte, written 1 MB. Dropping the capital letter can change a measurement by a factor of eight.

Recognize steps of 1,024

Computers also use quantities based on powers of 2. The value $2^{10}=\mathrm{1,024}$ is close to 1,000. Some older labels and course questions therefore use 1,024 at each step between byte units.

Standard binary prefixes make the difference clear:

Use 1,000 for kB, MB, GB, and TB unless a question explicitly gives a 1,024 convention. A question using that convention needs the same step throughout. A drive's bytes can be reported with different numerical values when different unit sizes are used.

Memory and storage have different jobs

Memory, usually RAM, holds programs and data currently in use. It usually loses that data when power is removed. Storage, such as an SSD, keeps files when the device is off.

Both are measured in bytes. A laptop could have 16 GB of memory and 512 GB of storage. The first supports active work; the second holds saved files. More storage does not mean the laptop has the same amount of working memory.

Compare units before numbers

From smallest to largest, 900 kB, 500 MB, 3 GB, and 2 TB are in order. The largest written number, 900, labels the smallest amount. For close sizes, convert to a shared unit: 1,500 MB exceeds 1 GB because 1 GB is 1,000 MB.

Converting a data size changes its unit, not its amount. A smaller unit needs a larger number. A larger unit needs a smaller number. This gives you a useful check before calculating.

Count each unit step

Between byte units, move along this order: bytes, kB, MB, GB, TB. Going toward smaller units multiplies by 1,000 at each step. Going toward larger units divides by 1,000.

For one step, 3 GB becomes 3,000 MB. For two steps, convert 2.5 GB to kB:

There are two steps from GB to kB. Multiplying by 1,000 only once would leave an answer in MB.

In the other direction:

So 4,500 MB is 4.5 GB. Likewise, 750 kB is 0.75 MB. A result below one is valid when the starting amount is less than one whole larger unit.

Treat the bit–byte step separately

One byte has eight bits. Multiply bytes by 8 to find bits; divide bits by 8 to find bytes.

For 4,000 bits:

For 2 MB, first find 2,000,000 bytes. Then multiply by 8 to get 16,000,000 bits. The factor 8 belongs to the bit–byte step, not every step between larger units. Three bytes contain 24 bits, which is six nibbles.

Use the stated convention throughout

With binary units, the step is 1,024. Two GiB become 2,048 MiB. A course question may instead state a 1,024 convention while writing GB and MB. Under that stated convention, 2 GB becomes 2,048 MB and 5,120 MB becomes 5 GB.

Do not switch between 1,000 and 1,024 halfway through a calculation. Write down the step size at the start when a question supplies one.

Compare a file with free space

A file needs 1,800 MB. A drive has 2 GB free. Convert the free space to 2,000 MB, then subtract the file size. It fits, with 200 MB left.

Read a speed label

Transfer speeds are often measured in bits per second. A speed of 100 Mbps means 100 megabits per second. Dividing by 8 gives 12.5 MB per second.

At that steady data rate, a 500 MB file takes:

The rate and file size must use matching units. Real transfers can take longer when the rate varies or extra data is sent.

A file's size depends on its contents, length, quality, and compression. Similar photos can have different sizes. An estimate helps plan storage when exact sizes are not available.

Choose useful rough sizes

Simple English plain text often takes about one byte per character. A page of 3,000 such characters is about 3 kB. A phone photo might be about 4 MB. Music at a common MP3 quality uses about 1 MB per minute. HD video streaming can use up to about 3 GB per hour.

These are planning figures, not fixed sizes for every file. Plain text is generally small; video usually needs much more data. Compression reduces a file's size by representing its data with fewer bits. JPEG photos and MP3 audio use compression.

Estimate a collection

To plan storage, multiply the number of each file type by its estimated size. Convert all totals into one unit before adding.

Suppose a collection contains 200 photos, 30 four-minute songs, and two hours of HD video. Estimate photos at 4 MB each, songs at 4 MB each, and video at 3 GB per hour:

• Photos: $200\times 4=800\text{ MB}$.
• Songs: $30\times 4=120\text{ MB}$.
• Video: $2\times 3=6\text{ GB}=\mathrm{6,000}\text{ MB}$.

The estimated total is 6,920 MB, or about 6.9 GB. It fits in 8 GB of free space, leaving roughly 1.1 GB. Adding 800, 120, and 6 directly would mix units and give a meaningless total.

Find an approximate file count

A phone has 16 GB free. At 4 MB per photo, first convert that space to 16,000 MB:

That is about 4,000 photos. Real photo sizes vary, so leave some spare space when planning. Use the device's free space; its full advertised capacity also holds the operating system, apps, and existing files.

A plain-text book with 500,000 characters at one byte each needs about 500,000 bytes. That is 500 kB, or 0.5 MB, for its text.

Separate pixel data from the whole file

Some data sizes follow directly from the coding rule. A 100-by-100 black-and-white image at one bit per pixel contains 10,000 pixel bits:

That is the pixel data size. A complete image file may also store its dimensions and format details. Compression can change its size too. Keep the quantity being calculated clear: raw picture data and a saved file are not always the same size.