📘 Number Systems and Data Representation

Everything in a computer is bits. This page explains how bits become integers, fractions, text, and multi-byte values, and where those representations surprise programmers. Every example value on this page was checked with Python.

Table of Contents

1. Bits, Bytes, and Words
2. Number Bases and Conversion
3. Unsigned Integers
4. Signed Integers and Two's Complement
5. Overflow
6. Bitwise Operations
7. Floating Point (IEEE 754)
8. Money and Exact Decimals
9. Characters and Text Encoding
10. Endianness
11. Data Size Units
12. Questions

1. Bits, Bytes, and Words

With n bits you can represent 2^n distinct values. Powers of two worth memorizing: 2^8 = 256, 2^10 = 1,024, 2^16 = 65,536, 2^20 ≈ 1 million, 2^30 ≈ 1 billion, 2^31 ≈ 2.1 billion, 2^32 ≈ 4.3 billion, 2^63 ≈ 9.2 x 10^18, 2^64 ≈ 1.8 x 10^19.

2. Number Bases and Conversion

Decimal to binary: divide by 2 repeatedly, read remainders bottom up.

45 / 2 = 22 r 1
22 / 2 = 11 r 0
11 / 2 =  5 r 1
 5 / 2 =  2 r 1
 2 / 2 =  1 r 0
 1 / 2 =  0 r 1      -> read upward: 101101

Binary to decimal: sum the powers of two where bits are 1: 101101 = 32 + 8 + 4 + 1 = 45.

Binary to hex: group 4 bits from the right; each group is one hex digit. 1101 1110 1010 1101 = D E A D = 0xDEAD. Octal groups 3 bits the same way (which is why Unix permissions like 755 are octal: rwx is 3 bits).

Hex is popular because two hex digits are exactly one byte: colors (#FF8800), memory addresses, hashes, MAC addresses.

3. Unsigned Integers

An n-bit unsigned integer holds 0 to 2^n - 1.

Java has no unsigned primitive types (except char), which is why it offers Integer.toUnsignedString and friends.

4. Signed Integers and Two's Complement

Three historical schemes for negative numbers:

To negate in two's complement: invert all bits and add 1.

 13 = 00001101
~13 = 11110010
+1  = 11110011   -> this is -13

Check: 11110011 + 00001101 = 1 00000000; the carry out drops, leaving 0.

The range is asymmetric: there is one more negative value than positive, so abs(INT_MIN) overflows (it stays INT_MIN in Java and is undefined behavior in C).

The top bit tells the sign, and its weight is negative: 11110011 = -128 + 64 + 32 + 16 + 2 + 1 = -13.

Sign extension: widening a signed value copies the sign bit into the new high bits (11110011 becomes 11111111 11110011), keeping the value -13.

5. Overflow

Fixed-width integers wrap around.

int8:  127 + 1  = -128      (01111111 + 1 = 10000000)
uint8: 0 - 1    = 255
int32: 2,147,483,647 + 1 = -2,147,483,648

Famous overflow bugs:

• Binary search midpoint: mid = (lo + hi) / 2 overflows for large arrays; use lo + (hi - lo) / 2. This bug sat in the JDK for about nine years.
• Year 2038: 32-bit signed time_t overflows on 19 January 2038; 64-bit time fixes it.
• Ariane 5 (1996): a 64-bit float converted to a 16-bit integer overflowed and destroyed the rocket.
• Gangnam Style exceeded YouTube's 32-bit view counter in 2014.

JavaScript example: 2 ** 53 + 1 === 2 ** 53 is true, which is why large IDs (Twitter/X snowflake IDs) are sent as strings in JSON.

6. Bitwise Operations

Common tricks

Real uses: permission flags (O_RDONLY | O_CREAT), bitmaps and Bloom filters, hash functions, network masks (ip & mask), compact sets (bitmask DP), and feature flags packed into one integer.

7. Floating Point (IEEE 754)

Floating point stores numbers in scientific notation in base 2: (-1)^sign x 1.mantissa x 2^(exponent - bias).

Encoding -5.75 as a float

1. Sign: negative, so 1.
2. 5.75 in binary: 5 = 101, 0.75 = .11, so 101.11.
3. Normalize: 1.0111 x 2^2.
4. Exponent: 2 + 127 = 129 = 10000001.
5. Mantissa: bits after the leading 1: 0111 followed by zeros.
6. Result: 1 10000001 01110000000000000000000 = 0xC0B80000.

Why 0.1 + 0.2 != 0.3

0.1 in binary is 0.000110011001100... repeating forever, like 1/3 in decimal. It must be rounded to the nearest representable value (as a float, 0x3DCCCCCD), and so must 0.2. The rounding errors add up: in double precision, 0.1 + 0.2 is 0.30000000000000004.

Rules that follow:

• Never compare floats with ==; compare with a tolerance: abs(a - b) <= eps * max(abs(a), abs(b)).
• Adding a tiny number to a huge one may do nothing: 1e16 + 1 == 1e16 is true in doubles.
• Summation order changes results; use Kahan summation or higher precision for long sums.
• Integers are exact in a double only up to 2^53.

Special values

Largest float is about 3.4 x 10^38, smallest positive subnormal float about 1.4 x 10^-45.

Machine learning increasingly uses low precision (bfloat16, fp8, even 4-bit formats) because models tolerate rounding and smaller numbers mean more throughput per memory byte.

8. Money and Exact Decimals

Never store money in binary floating point.

Rounding mode matters too: financial systems often use banker's rounding (round half to even) to avoid systematic bias. Python's round(2.675, 2) returns 2.67, not because of banker's rounding but because 2.675 is actually stored as 2.67499999...

Fixed point (an integer with an implied decimal point) is also used in embedded systems without floating-point hardware and in some audio and DSP code.

9. Characters and Text Encoding

Unicode is the character set (which number each character gets); UTF-8 and UTF-16 are encodings (how that number becomes bytes).

UTF-8 layout

Examples: A is 41, € (U+20AC) is E2 82 AC, 😀 (U+1F600) is F0 9F 98 80.

Properties that make UTF-8 the default: ASCII text is unchanged, no byte-order issues, self-synchronizing (you can find character boundaries from any byte), and no zero bytes except for NUL.

String length is ambiguous

Emoji like 👨‍👩‍👧 are several code points joined with zero-width joiners but display as one grapheme. Consequences: truncating strings by bytes or UTF-16 units can cut characters in half; database column limits (VARCHAR(255)) may count bytes or characters depending on the engine; MySQL's old utf8 charset holds only 3 bytes, so use utf8mb4 for emoji.

Normalization: é can be one code point (U+00E9) or e plus a combining accent (U+0065 U+0301); compare strings after normalizing (NFC).

10. Endianness

How a multi-byte value is laid out in memory. The value 0x12345678 stored at address 100:

Convert at the boundary with htonl / ntohl (host to network long, and back) or ByteBuffer.order(...) in Java. Endianness applies to bytes within a value, not to bits within a byte or to the order of characters in a UTF-8 string. A byte order mark (BOM, U+FEFF) at the start of UTF-16 text tells readers which order was used.

11. Data Size Units

This is why a "1 TB" drive shows about 931 GiB in an operating system that reports binary units. Network speeds use bits (Mbps), storage uses bytes (MB/s): 1 Gbps is at most 125 MB/s.

12. Questions

Next: Digital Logic and Computer Architecture.