Binary and Hexadecimal

Two states

Inside a computer, everything is stored and moved as electrical signals, and to keep the circuits simple each signal has just two states: no voltage, read as 0, or voltage, read as 1 ¹. One such 0-or-1 is a bit, short for binary digit ¹. Numbers, text, pictures, programs: all of it is long sequences of bits, given meaning by how they’re read. This module is about the first and most basic readings, numbers and text.

Place value in decimal

You already know a positional number system. In decimal, base 10, each digit is worth ten times the one to its right ¹:

8425 = 8×1000 + 4×100 + 2×10 + 5×1
     = 8×10³  + 4×10² + 2×10¹ + 5×10⁰

Each digit holds one of ten values, 0 to 9; past 9, you carry to the next place.

Place value in binary

Binary, base 2, works the same way with powers of two, and each digit holds 0 or 1 ¹. Reading right to left, the places are worth 1, 2, 4, 8, 16, 32, 64, 128:

So 11001000 is 128 + 64 + 8 = 200. Programmers write 0b in front of a binary number, as in 0b11001000, so it isn’t mistaken for decimal ¹.

Counting in binary is the same carrying game with only two digits: 0, 1, 10, 11, 100, 101, 110, 111, 1000. Each time a column fills, it rolls over and carries left.

bash does conversions to decimal for you, with base#digits inside $(( )) ²:

me@linuxbox:~$ echo $((2#1011))
11
me@linuxbox:~$ echo $((2#11111111))
255

Bits, bytes, and words

A single bit doesn’t say much, so bits are grouped ¹:

• A byte is 8 bits, and holds 2⁸ = 256 different values, 0 to 255. It’s the smallest piece of memory a program can address.
• A word is the size the processor works with naturally, 32 or 64 bits on current computers.

Each extra bit doubles the number of values: n bits give 2ⁿ ¹. Sixteen bits give 65,536; 32 bits about 4.3 billion; 64 bits about 18 quintillion.

Hexadecimal

Long strings of 0s and 1s are hard to read, and decimal doesn’t line up with bits. Hexadecimal, base 16, does both jobs: it’s compact, and since 16 = 2⁴, each hex digit is exactly four bits ¹. The digits past 9 are letters: A is 10, B 11, up to F for 15 ¹.

A byte is two hex digits. 11001000 splits into 1100 (12, C) and 1000 (8), so it’s 0xC8; 0x marks hex the way 0b marks binary ¹. You’ll see hex everywhere bytes show through: memory addresses, colors like #FF8800, MAC addresses, git’s commit IDs, and the xxd dumps in the next lesson.

me@linuxbox:~$ printf '%x\n' 255
ff
me@linuxbox:~$ printf '%X\n' 48879
BEEF
me@linuxbox:~$ echo $((16#ff))
255

printf with %x (or %X for capitals) writes a number in hex; 16# reads it back ².

Octal, and chmod

Octal, base 8, groups bits in threes, and survives mainly in one place you know: file permissions (Shell course, module 3). Each permission triple, rwx, is three bits, so one octal digit:

me@linuxbox:~$ printf '%o\n' 493
755
me@linuxbox:~$ echo $((8#755))
493

755 is 111 101 101: rwx for the owner, r-x for group and others.

Python for conversions

bash’s printf has no binary format, so for decimal to binary, Python, which is on every Ubuntu system, is handy ³:

me@linuxbox:~$ python3 -c 'print(bin(200))'
0b11001000
me@linuxbox:~$ python3 -c 'print(hex(255), oct(493))'
0xff 0o755
me@linuxbox:~$ python3 -c 'print(int("11001000", 2), int("ff", 16))'
200 255

bin, hex, and oct write a number in base 2, 16, or 8; int(text, base) reads one back ³.

Kilobytes and kibibytes

Sizes use two different scales, which is why a “1 TB” drive shows up as about 931 “GB”:

• Decimal (SI) prefixes: kilobyte, kB = 1,000 bytes; megabyte = 1,000,000; and so on. Drive makers use these.
• Binary (IEC) prefixes: kibibyte, KiB = 1,024 bytes (2¹⁰); mebibyte, MiB = 2²⁰; gibibyte, GiB = 2³⁰ ⁴. Memory and much software count this way.

1 TB is 10¹² bytes; divided by 2³⁰ that’s about 931 GiB. Same bytes, different units. df -h (Linux course, module 4) uses powers of 1,024, and df -H powers of 1,000 ⁵.

Your turn

So

Bits have two states, and binary is place value with powers of two: 11001000 is 128 + 64 + 8 = 200. A byte is 8 bits, 256 values; n bits give 2ⁿ values. Hexadecimal packs four bits per digit, so a byte is two hex digits (0xC8), and octal packs three (chmod’s 755). bash converts with $((2#...)), $((16#...)), and printf '%x'; Python with bin, hex, and int(text, base). And a kibibyte is 1,024 bytes, a kilobyte 1,000.