Number Base Systems: Binary, Octal, Decimal, Hex

March 31, 2026 · 12 min read

Base Systems Explained

Number base systems are fundamental to computing, defining how information is stored, processed, and presented across digital systems. While you're likely comfortable with the decimal system (base-10) used in everyday life, computers operate on entirely different principles.

At its core, a number base system determines how many unique digits are available to represent values. In decimal, we use ten digits (0-9). When we reach 9 and need to count higher, we add another position to the left and start over. This positional notation is what makes base systems so powerful.

Computers use binary (base-2) because it aligns perfectly with digital electronics—transistors can be either on or off, representing 1 or 0. This two-state system is reliable, fast, and forms the foundation of all digital computation. However, binary numbers can become unwieldy for humans to read and write, especially when dealing with large values.

That's where octal (base-8) and hexadecimal (base-16) come into play. These systems provide a more compact representation of binary data while maintaining easy conversion paths. You'll encounter them in Unix file permissions, memory addresses, color codes in web development, and countless other computing contexts.

Why Multiple Base Systems Matter

Different base systems serve different purposes in computing:

• Binary (base-2): Direct representation of hardware states, essential for low-level programming and digital logic
• Octal (base-8): Compact representation for Unix permissions, legacy systems, and some embedded applications
• Decimal (base-10): Human-readable format for user interfaces and general-purpose calculations
• Hexadecimal (base-16): Efficient representation of binary data, memory addresses, and color values

Each system has its place in the computing ecosystem. Mastering conversions between them gives you deeper insight into how data flows through systems and helps you write more efficient, hardware-aware code.

Binary System (Base-2)

Understanding Binary Fundamentals

Binary is the simplest positional number system, using only two digits: 0 and 1. Each position in a binary number represents a power of 2, starting from the rightmost digit (2⁰ = 1) and increasing as you move left.

Let's break down the binary number 1101:

The sum of these values (8 + 4 + 0 + 1) equals 13 in decimal. This positional notation is consistent across all base systems—only the base value changes.

Binary in Programming

Modern programming languages provide direct support for binary literals, making it easy to work with binary values in your code:

// C, C++, Java, JavaScript
int a = 0b1100;  // Binary for 12
int b = 0b1010;  // Binary for 10

// Python
x = 0b1100  # Binary for 12
y = 0b1010  # Binary for 10

// Bitwise operations
int result = a & b;   // AND: 0b1000 (8)
int result2 = a | b;  // OR: 0b1110 (14)
int result3 = a ^ b;  // XOR: 0b0110 (6)

Real-World Binary Applications

Binary isn't just theoretical—it's used extensively in practical programming scenarios:

• Bit flags and permissions: Store multiple boolean values in a single integer
• Network protocols: TCP/IP headers, packet structures, and data transmission
• Graphics programming: Pixel manipulation, alpha channels, and color masking
• Embedded systems: Direct hardware control through register manipulation
• Cryptography: Bitwise operations for encryption algorithms
• Data compression: Huffman coding and other compression techniques

Binary Arithmetic

Binary addition and subtraction follow the same principles as decimal arithmetic, but with simpler rules:

Binary Addition Rules:

• 0 + 0 = 0
• 0 + 1 = 1
• 1 + 0 = 1
• 1 + 1 = 10 (0 with carry of 1)

Example: Adding 1011 (11) and 0110 (6):

  1011
+ 0110
------
 10001  (17 in decimal)

Understanding binary arithmetic is crucial for low-level optimization, implementing custom data structures, and working with hardware interfaces.

Octal System (Base-8)

Octal Fundamentals

The octal system uses eight digits (0-7) and represents each position as a power of 8. While less common than binary or hexadecimal in modern computing, octal has historical significance and specific use cases where it remains relevant.

Converting octal 157 to decimal:

• 1 × 8² = 1 × 64 = 64
• 5 × 8¹ = 5 × 8 = 40
• 7 × 8⁰ = 7 × 1 = 7
• Total: 64 + 40 + 7 = 111 (decimal)

Octal in Unix File Permissions

The most common use of octal today is in Unix/Linux file permissions. Each octal digit represents three binary bits, corresponding to read (4), write (2), and execute (1) permissions:

When you see chmod 755 file.txt, you're setting:

• 7 (owner): read, write, execute
• 5 (group): read, execute
• 5 (others): read, execute

Octal in Programming

Most programming languages support octal literals with a leading zero:

// C, C++, Java
int octal = 0157;  // 111 in decimal

// Python (legacy)
x = 0157  # Python 2 style

// Python (modern)
x = 0o157  # Explicit octal prefix

// JavaScript (strict mode requires explicit prefix)
let octal = 0o157;

Binary-Octal Conversion

Converting between binary and octal is straightforward because each octal digit represents exactly three binary digits. Group binary digits in sets of three (from right to left) and convert each group:

Binary 101110111 to octal:

• Group: 101 110 111
• Convert: 5 6 7
• Result: 567 (octal)

Decimal System (Base-10)

The Human-Friendly Base

Decimal is the number system we use in everyday life, featuring ten digits (0-9). Each position represents a power of 10, making it intuitive for human calculation and communication.

While computers don't natively work in decimal, it remains the primary interface between humans and machines. Every number you see on a screen, every calculation result, and every user input is typically presented in decimal format.

Decimal in Computing

Computers store decimal numbers in binary format, which can lead to interesting precision issues, especially with floating-point arithmetic:

// JavaScript example
console.log(0.1 + 0.2);  // 0.30000000000000004 (not exactly 0.3!)

// This happens because 0.1 and 0.2 cannot be represented
// exactly in binary floating-point format

For financial calculations or situations requiring exact decimal precision, specialized libraries or data types are necessary:

• Java: BigDecimal class
• Python: decimal module
• JavaScript: Libraries like decimal.js or big.js
• SQL: DECIMAL or NUMERIC types

Decimal Representation Challenges

Understanding how computers handle decimal numbers is crucial for avoiding bugs:

• Floating-point imprecision: Not all decimal fractions can be represented exactly in binary
• Rounding errors: Accumulate over multiple operations
• Comparison issues: Never use == for floating-point comparisons; use epsilon-based comparison instead
• Range limitations: Standard floating-point types have maximum and minimum values

Hexadecimal System (Base-16)

Understanding Hexadecimal

Hexadecimal (hex) uses sixteen digits: 0-9 and A-F (where A=10, B=11, C=12, D=13, E=14, F=15). It's the most popular alternative to binary in computing because it provides a compact, human-readable representation of binary data.

Each hex digit represents exactly four binary digits (bits), making conversion between hex and binary trivial. This 4-to-1 relationship is why hex is so prevalent in computing.

Hex in Web Development

Web developers encounter hex constantly in color codes. The format #RRGGBB represents red, green, and blue color channels:

/* CSS color examples */
color: #FF0000;  /* Pure red: R=255, G=0, B=0 */
color: #00FF00;  /* Pure green: R=0, G=255, B=0 */
color: #0000FF;  /* Pure blue: R=0, G=0, B=255 */
color: #10b981;  /* Custom green: R=16, G=185, B=129 */

/* Short form (when digits repeat) */
color: #FFF;     /* Same as #FFFFFF (white) */
color: #000;     /* Same as #000000 (black) */

Breaking down #10b981:

• 10 (hex) = 16 (decimal): Red channel
• b9 (hex) = 185 (decimal): Green channel
• 81 (hex) = 129 (decimal): Blue channel

Use the Hex Converter to quickly translate between hex color codes and RGB values.

Hex in Memory Addresses

Memory addresses are universally displayed in hexadecimal because it's compact and aligns perfectly with byte boundaries:

// C pointer example
int* ptr = 0x7fff5fbff8ac;  // Memory address in hex

// Assembly language
MOV AX, 0x1234    ; Load hex value into register
JMP 0x00400000    ; Jump to memory address

A 64-bit memory address would be 16 digits in hex but 64 digits in binary—hex is clearly more manageable for humans to read and communicate.

Hex in Programming

All major programming languages support hex literals with the 0x prefix:

// C, C++, Java, JavaScript, Python
int value = 0xFF;        // 255 in decimal
int mask = 0x00FF00;     // 65280 in decimal
int flags = 0xDEADBEEF;  // Common debug value

// Bitwise operations with hex
int result = 0xF0 & 0x0F;  // 0x00 (bitwise AND)
int result2 = 0xF0 | 0x0F; // 0xFF (bitwise OR)

Binary-Hex Conversion

Converting between binary and hex is simple—group binary digits in sets of four:

Binary 11010110 to hex:

• Group: 1101 0110
• Convert: D 6
• Result: D6 (hex) = 214 (decimal)

Hex 3F to binary:

• 3 = 0011
• F = 1111
• Result: 00111111 (binary)

Conversion Techniques Between Bases

Manual Conversion Methods

Understanding manual conversion helps you grasp the underlying mathematics and debug issues when tools aren't available.

Any Base to Decimal (Expansion Method):

1. Write down the number with position indices (starting from 0 on the right)
2. Multiply each digit by the base raised to its position
3. Sum all the results

Example: Hex 2A3 to decimal:

• 2 × 16² = 2 × 256 = 512
• A × 16¹ = 10 × 16 = 160
• 3 × 16⁰ = 3 × 1 = 3
• Total: 512 + 160 + 3 = 675

Decimal to Any Base (Division Method):

1. Divide the decimal number by the target base
2. Record the remainder
3. Divide the quotient by the base again
4. Repeat until quotient is 0
5. Read remainders from bottom to top

Example: Decimal 156 to hex:

156 ÷ 16 = 9 remainder 12 (C)
9 ÷ 16 = 0 remainder 9
Result: 9C (hex)

Programming Conversion Functions

Most languages provide built-in functions for base conversion:

// JavaScript
let decimal = 255;
let binary = decimal.toString(2);    // "11111111"
let octal = decimal.toString(8);     // "377"
let hex = decimal.toString(16);      // "ff"

// Parse from string
let fromBinary = parseInt("11111111", 2);  // 255
let fromHex = parseInt("ff", 16);          // 255

// Python
decimal = 255
binary = bin(decimal)    # "0b11111111"
octal = oct(decimal)     # "0o377"
hex_val = hex(decimal)   # "0xff"

# Parse from string
from_binary = int("11111111", 2)  # 255
from_hex = int("ff", 16)          # 255

// Java
int decimal = 255;
String binary = Integer.toBinaryString(decimal);  // "11111111"
String hex = Integer.toHexString(decimal);        // "ff"

// Parse from string
int fromBinary = Integer.parseInt("11111111", 2);  // 255
int fromHex = Integer.parseInt("ff", 16);          // 255

Practical Conversion Examples

Example 1: RGB Color to Hex

Converting RGB(16, 185, 129) to hex color code:

1. Red channel (16): 16 ÷ 16 = 1 remainder 0 → 10
2. Green channel (185): 185 ÷ 16 = 11 remainder 9 → B9
3. Blue channel (129): 129 ÷ 16 = 8 remainder 1 → 81
4. Result: #10B981

Example 2: File Permissions

Understanding chmod 644:

• 6 (owner): 110 binary = read(4) + write(2) = rw-
• 4 (group): 100 binary = read(4) = r--
• 4 (others): 100 binary = read(4) = r--

This gives the owner read/write access, while group and others can only read.

Example 3: Network Subnet Mask

Converting subnet mask 255.255.255.0 to binary:

• 255 = 11111111
• 255 = 11111111
• 255 = 11111111
• 0 = 00000000
• Result: 11111111.11111111.11111111.00000000 (or /24 in CIDR notation)

This shows that the first 24 bits identify the network, and the last 8 bits identify hosts.

Example 4: Bitwise Flag Operations

Using hex for readable flag manipulation:

// Define flags
const READ = 0x01;    // 0001
const WRITE = 0x02;   // 0010
const EXECUTE = 0x04; // 0100
const DELETE = 0x08;  // 1000

// Combine flags
let permissions = READ | WRITE | EXECUTE;  // 0x07 (0111)

// Check if flag is set
if (permissions & WRITE) {
    console.log("Write permission granted");
}

// Remove a flag
permissions = permissions & ~WRITE;  // Remove write (0x05 = 0101)

// Toggle a flag
permissions = permissions ^ EXECUTE;  // Toggle execute

Example 5: Memory Dump Analysis

Reading hex dump output:

0x00000000: 48 65 6C 6C 6F 20 57 6F 72 6C 64 21 00 00 00 00
0x00000010: 54 68 69 73 20 69 73 20 61 20 74 65 73 74 2E 00

Converting hex to ASCII:

• 48 65 6C 6C 6F = "Hello"
• 57 6F 72 6C 64 = "World"
• 54 68 69 73 = "This"

Use the ASCII Converter to quickly translate between hex values and text.

Advanced Applications in Computing

Bitwise Operations and Optimization

Understanding number bases enables powerful optimization techniques through bitwise operations:

// Fast multiplication/division by powers of 2
int multiplyBy8 = value << 3;   // Left shift by 3 (2^3 = 8)
int divideBy4 = value >> 2;     // Right shift by 2 (2^2 = 4)

// Check if number is even/odd
bool isEven = (value & 1) == 0;  // Check least significant bit

// Swap values without temporary variable
a = a ^ b;
b = a ^ b;
a = a ^ b;

// Set specific bit
value |= (1 << n);   // Set nth bit to 1

// Clear specific bit
value &