Number Bases for Developers: Binary, Hex & Octal

Q: What mistakes happen with number bases?

(1) Forgetting the leading-zero octal trap in legacy languages (010 = 8 in old JS/C literals — use 0o10 explicitly); (2) parsing "08"/"09" as octal (invalid digits — classic parseInt bug, always pass the radix: parseInt(x, 10)); (3) signed vs unsigned hex reads: 0xFF as signed byte = −1 (two's complement); (4) case sensitivity assumptions (0xff = 0xFF, both fine); (5) confusion between the VALUE and its representation (255, 0xFF, 0b11111111 are the same number); (6) floating-point bases — 0.1 has no exact binary form, the root of 0.1+0.2 ≠ 0.3.

Key Takeaways

Why hex: 1 hex digit = exactly 4 bits — 0xF0 = 0b11110000; no other base maps this cleanly

Landmarks: 0xFF = 255 (1 byte), 0xFFFF = 65,535, 0x7FFFFFFF = 2³¹−1 (max int32)

Colors: #FF8000 = R255 G128 B0 — each channel is one hex byte 00-FF

Prefixes: 0b binary, 0o octal, 0x hex; octal survives in Unix permissions (chmod 755)

Core answer: Programmers convert between binary/decimal/hex daily: hex is binary in 4-bit groups (0xF = 1111 = 15), one byte = 2 hex digits = 8 bits = 0–255. Signed integers use two's complement: int8 spans −128 to 127, uint8 spans 0–255. Memorize the powers of 2 up to 2¹⁶ = 65,536 — they are the vocabulary of computing.

The essential tables

Hex digit = 4 bits (nibble)
Hex	Binary	Dec	Hex	Binary	Dec
0	0000	0	8	1000	8
1	0001	1	9	1001	9
2	0010	2	A	1010	10
3	0011	3	B	1011	11
4	0100	4	C	1100	12
5	0101	5	D	1101	13
6	0110	6	E	1110	14
7	0111	7	F	1111	15

Powers of 2 worth memorizing

2⁸=256 · 2¹⁰=1,024 (K) · 2¹⁶=65,536 · 2²⁰=1,048,576 (M) · 2³⁰≈10.7亿 (G) · 2³²≈42.9亿 · 2⁶⁴≈1.8×10¹⁹

Two's complement in one minute

Negative numbers store as "invert all bits, add 1": −1 in int8 = 1111 1111; −128 = 1000 0000. Benefits: one zero, addition just works, and overflow wraps silently — (int8)127 + 1 = −128. That wraparound is the root of countless bugs (and the Gandhi-nuclear bug in Civilization lore).

Worked examples

Example 1 — Reading a memory dump. Bytes "48 65 6C 6C 6F" in hex = ASCII "Hello". Two hex digits per byte makes hex the universal byte notation.

Example 2 — Bitmasking permissions. Flags READ=0b001, WRITE=0b010, EXEC=0b100: rw = 0b110 = 6. Test a bit: (flags & WRITE) != 0; set it: flags |= WRITE; clear: flags &= ~WRITE.

Example 3 — Color math. #FF8000: red=0xFF=255, green=0x80=128, blue=0. Halving brightness: >>1 per channel conceptually (with rounding care).

Example 4 — Why 0.1 + 0.2 ≠ 0.3. Binary floating point can't represent 0.1 finitely (like 1/3 in decimal): the sum is 0.30000000000000004. Money must use integer cents or decimal types — never float.

Common mistakes and myths

Off-by-one in ranges — uint8 holds 0–255 = 256 values, not 0–256; array of 10 has indices 0–9.
Signed overflow assumptions — in C it's undefined behavior (not guaranteed wraparound); in Java it wraps; check your language.
Confusing KB with KiB — see the data storage guide; 2⁴⁰ ≠ 10¹².
Char = byte — in UTF-8 a Chinese char is 3 bytes, an emoji 4; byte counts ≠ character counts.
Assuming floats are exact — use integer minor units for currency and epsilon comparisons for floats.

Frequently Asked Questions

Why do programmers use hexadecimal?

Because 16 = 2⁴: every hex digit encodes exactly 4 binary bits, so hex is a compact, lossless view of binary. 0b10101100 = 0xAC at a glance (1010 = A, 1100 = C). Memory addresses, byte values, colors, masks — anything byte-structured reads 4× shorter in hex with zero conversion cost. Decimal requires actual division; hex requires none.

How do I convert binary to hex instantly?

Group bits in fours from the right, translate each nibble: 0000-1001 = 0-9, 1010 = A, 1011 = B, 1100 = C, 1101 = D, 1110 = E, 1111 = F. 0b11010110 → 1101 0110 → D6. Hex → binary: expand each digit to 4 bits. This two-step (via grouping) beats decimal detours entirely. Practice on a byte a day and it becomes reflex in a week.

What hex landmarks should I memorize?

0xFF = 255 (byte max); 0x100 = 256; 0x3FF = 1,023 (10 bits); 0xFFF = 4,095 (12 bits); 0xFFFF = 65,535 (16-bit max); 0x7FFFFFFF = 2,147,483,647 (signed int32 max); 0x80000000 = int32 min magnitude; 0xFFFFFFFF = 4,294,967,295 (uint32). Powers of two in hex are round: 1K = 0x400, 64K = 0x10000, 1M = 0x100000.

How do hex color codes work?

#RRGGBB: three bytes in hex, one per channel, 00 (0) to FF (255). #FF0000 pure red; #FFFFFF white; #000000 black; #808080 mid-gray. #RRGGBBAA adds alpha. Shorthand #F80 = #FF8800. Quick reads: first digit pair dominates → #C04030 is reddish. Grayscale has equal pairs (#A3A3A3). 24-bit color = 16.7M combinations — all addressable in 6 hex digits.

What bit operations matter most?

AND (&): mask bits — x & 0xFF keeps the low byte. OR (|): set bits — flags |= 0b0100 turns bit 2 on. XOR (^): toggle/swap tricks. Shifts: << n multiplies by 2ⁿ (x << 3 = x×8), >> divides (floor). Test bit: x & (1 << n). These run in one CPU cycle and drive flags, permissions, graphics and every performance-critical inner loop.

What mistakes happen with number bases?

(1) Forgetting the leading-zero octal trap in legacy languages (010 = 8 in old JS/C literals — use 0o10 explicitly); (2) parsing "08"/"09" as octal (invalid digits — classic parseInt bug, always pass the radix: parseInt(x, 10)); (3) signed vs unsigned hex reads: 0xFF as signed byte = −1 (two's complement); (4) case sensitivity assumptions (0xff = 0xFF, both fine); (5) confusion between the VALUE and its representation (255, 0xFF, 0b11111111 are the same number); (6) floating-point bases — 0.1 has no exact binary form, the root of 0.1+0.2 ≠ 0.3.