Hexadecimal: Binary for Humans
Binary strings get long and unreadable fast. A 32-bit IPv4 address in binary is 32 characters. A 64-bit memory address is 64 characters. Hexadecimal compresses this by grouping every 4 bits into a single hex digit — because 2⁴ = 16, the base of hexadecimal.
Hex uses digits 0–9 and letters A–F, where A = 10, B = 11, C = 12, D = 13, E = 14, F = 15. One hex digit represents exactly 4 bits. Two hex digits represent one byte (0–255). This is why byte values appear everywhere as two-digit hex pairs.
Converting binary to hex is mechanical — split into groups of 4 bits and convert each group:
Binary: 1011 0101
↓ ↓
Hex: B 5
Result: 0xB5 = 181 decimal
The 0x prefix signals hexadecimal in most programming languages. You will see it in memory addresses (0x7FFE4A2B), CSS colors (#FF5733 — same format without the prefix), and byte-level data manipulation.
Hex in Real Code
CSS colors are three hex pairs: red, green, blue, each 0–255 as two hex digits.
/* CSS color: #FF5733 */
Red: 0xFF = 255
Green: 0x57 = 87
Blue: 0x33 = 51
/* Or use rgb() for the same values */
color: rgb(255, 87, 51);
Memory addresses in a debugger or crash dump look like 0x00007FFE4A2B3C10 — a 64-bit address in 16 hex digits. When you are reading a stack trace or a memory dump during debugging, hex is the native representation. Developers who cannot convert hex to decimal mentally take significantly longer to interpret debugger output.
Hash values from cryptographic functions like SHA-256 are displayed as hex strings — 64 hex characters representing 256 bits. The hash generator tool on WOWHOW lets you generate and inspect these values directly.
Octal: The File Permissions System
Octal (base 8) uses digits 0–7 and groups 3 bits per digit. Its primary practical application for developers is Unix/Linux file permissions — a system that has been standard since the 1970s and is still how every Linux server, macOS machine, and container runtime manages file access.
The chmod command takes an octal number representing three permission triplets:
chmod 755 myfile
7 = 111 in binary = read (4) + write (2) + execute (1) = owner has all permissions
5 = 101 in binary = read (4) + execute (1) = group can read and execute
5 = 101 in binary = read (4) + execute (1) = others can read and execute
Breaking down the octal number 755: each digit maps to one of the three permission groups (owner, group, others). Each digit is 3 bits. Bit 2 is read (r), bit 1 is write (w), bit 0 is execute (x). Adding up the set bits gives the octal value.
Common chmod values:
755 → rwxr-xr-x (executable scripts, directories)
644 → rw-r--r-- (regular files, configs)
600 → rw------- (private keys, secrets)
777 → rwxrwxrwx (⚠️ never use on production — world-writable)
400 → r-------- (read-only, SSH private keys)
When a deployment fails with “Permission denied” or a cron job silently does nothing, the first diagnostic is always ls -la to check octal permissions. Developers who understand the octal-to-binary mapping can read the symbolic output (rwxr-xr-x) and the numeric (755) interchangeably — and they fix permission bugs in seconds instead of minutes of trial-and-error.
Two’s Complement: How Negative Numbers Work in Binary
Unsigned binary handles only non-negative integers. Real programs need negative numbers. The standard representation for signed integers is two’s complement, and understanding it explains several classes of bugs — integer overflow, sign extension errors, and unexpected behavior when mixing signed and unsigned types.
In an 8-bit two’s complement system, the most significant bit (MSB) is the sign bit: 0 means positive, 1 means negative. The positive range is 0–127 (0x00–0x7F). The negative range is −128 to −1 (0x80–0xFF).
To negate a number in two’s complement: flip all bits, then add 1.
Represent -42 in 8-bit two's complement:
Step 1: Start with 42 in binary
42 = 00101010
Step 2: Flip all bits (one's complement)
11010101
Step 3: Add 1
11010101
+ 1
---------
11010110
Result: 11010110 = -42 in two's complement
Verify: 11010110 → flip → 00101001 → add 1 → 00101010 = 42 ✓
This matters for real bugs. In C, the expression (int8_t)127 + 1 produces -128 — signed integer overflow wraps around. In JavaScript, bitwise operators convert their operands to 32-bit signed integers, which means ~0 is -1 (flip all bits of 0x00000000 → 0xFFFFFFFF → two’s complement of -1). If you have ever seen a bitwise NOT produce a negative number and been confused, this is why.
Bitwise Operations: Where Theory Becomes Code
Bitwise operations work directly on the binary representation of integers. They are available in every systems language and in JavaScript/TypeScript via the operators &, |, ^, ~, <<, and >>. The practical applications include feature flags, permission masks, hardware register manipulation, and performance-sensitive data packing.
AND for Masking
The AND operator (&) keeps only the bits that are set in both operands. It is used to extract specific bits from a value — called masking.
// Extract the lower nibble (4 bits) of a byte
const byte = 0xB5 // 10110101
const mask = 0x0F // 00001111
const lower = byte & mask // 00000101 = 5
// Check if a permission bit is set
const READ_PERMISSION = 0b100 // 4
const WRITE_PERMISSION = 0b010 // 2
const EXEC_PERMISSION = 0b001 // 1
const userPermissions = 0b110 // read + write, no execute
if (userPermissions & READ_PERMISSION) {
console.log('User can read')
}
if (userPermissions & EXEC_PERMISSION) {
console.log('User can execute') // ← this will NOT print
}
OR for Setting Flags
The OR operator (|) sets bits. Use it to add a permission or enable a feature flag.
// Grant execute permission to a user
const newPermissions = userPermissions | EXEC_PERMISSION
// 0b110 | 0b001 = 0b111 = read + write + execute
XOR for Toggling
XOR (^) flips bits that differ. Toggle a flag without knowing its current state:
// Toggle the write permission bit
const toggled = userPermissions ^ WRITE_PERMISSION
// If write was set: removes it. If not set: adds it.
Bit Shifting for Fast Arithmetic
Left shift (<<) multiplies by powers of 2. Right shift (>>) divides by powers of 2. These operations are a single CPU instruction and execute faster than multiplication and division on most architectures.
// Multiply by 8 using left shift
const x = 5
const result = x << 3 // 5 × 2³ = 5 × 8 = 40
// Divide by 4 using right shift (integer division)
const y = 100
const half = y >> 2 // 100 / 4 = 25
// Pack two 8-bit values into a 16-bit integer
const high = 0xAB
const low = 0xCD
const packed = (high << 8) | low // 0xABCD
// Unpack them
const extractedHigh = (packed >> 8) & 0xFF // 0xAB
const extractedLow = packed & 0xFF // 0xCD
The packing pattern is common in network protocols, graphics (packing RGBA channels), and data serialization where you need to combine multiple small values into one integer without a struct.
IP Addresses and Subnet Masks
IPv4 addresses are 32-bit integers displayed as four decimal octets. Understanding this makes subnet calculations trivial instead of mysterious.
IP address: 192.168.1.100
In binary: 11000000.10101000.00000001.01100100
Subnet mask: 255.255.255.0 (a /24 network)
In binary: 11111111.11111111.11111111.00000000
Network addr = IP AND mask:
11000000.10101000.00000001.00000000
= 192.168.1.0
Host bits: The last 8 bits (00000000 to 11111111)
= 256 addresses (0-255), 254 usable hosts
The CIDR notation /24 means 24 bits are the network prefix — exactly the mask above. /16 means 16 bits (255.255.0.0), /8 means 8 bits (255.0.0.0). Cloud engineers who can mentally calculate subnets in hex save significant time during infrastructure debugging. The binary converter handles IP address to binary conversion as a starting point for these calculations.
Base64: Encoding Binary as Text
Base64 is not a number base in the arithmetic sense, but it follows the same principle — encoding binary data into a character set that is safe for text transport. Base64 groups 6 bits at a time (2⁶ = 64 characters in the alphabet) and is used for encoding binary files in emails, JWT tokens, and data URIs.
A 3-byte (24-bit) sequence becomes four 6-bit groups, each mapped to a printable character. The output is always 4/3 the size of the input (plus padding). Use the base64 encoder/decoder on WOWHOW to inspect JWT payloads, decode image data URIs, or understand what a base64 blob contains.
// Decode a JWT payload (the middle section between the dots)
const payload = 'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0'
const decoded = atob(payload)
// {"sub":"1234567890","name":"John Doe"}
Practical Reference: Base Conversion Cheat Sheet
Applying This in Daily Development
Number system knowledge compounds. Once you can read hex memory addresses in a debugger, crash dumps become less intimidating. Once you understand permission bits, chmod and umask become tools you configure deliberately rather than commands you copy from Stack Overflow. Once bitwise operations are comfortable, you write leaner feature flag systems, tighter data serialization, and faster numeric algorithms.
The fastest way to build this fluency is deliberate practice with a tool that gives instant feedback. Open the binary converter, pick a number you know — today’s date, a port number, an HTTP status code — and convert it manually, then verify. Do this for five minutes a day for a week. The conversions will become automatic.
For encoding and decoding workflows — JWT payloads, data URIs, image blobs — the base64 encoder/decoder handles the binary-to-text layer. For generating and inspecting hashes, the hash generator shows you the hex output of MD5, SHA-1, SHA-256, and SHA-512 side by side.
Number systems are not something you study once. They are a vocabulary you use every time you configure a server, debug a network issue, optimize a hot loop, or read a memory dump. The developers who internalize them are not just faster — they catch a class of bugs that the rest of the team cannot even see.
Every tool mentioned in this guide is available free at wowhow.cloud/tools — no signup, no install, instant in-browser conversion.
Comments · 0
Beta: comments are stored locally on your device and not visible to other readers.
No comments yet. Be the first to share your thoughts.