Bits & Binary

A bit (short for binary digit) is the smallest unit of information a computer can store. It has exactly two possible values: 0 or 1. Every file, every number, every pixel on your screen is ultimately a sequence of bits.

Bits are grouped together to represent larger values and more complex data:

Computers are built from billions of transistors, tiny electronic switches that are either conducting electricity or not. This physical reality maps perfectly to binary: a high voltage represents 1, a low voltage represents 0. Designing circuits that distinguish between just two states is dramatically simpler and more reliable than distinguishing between ten.

This is why all digital information, no matter how complex, is encoded as sequences of 0s and 1s at the hardware level.

In everyday life we use base-10 (decimal): each digit position represents a power of 10. Binary works the same way but in base-2: each position represents a power of 2.

Reading a binary number is straightforward: assign place values from right to left starting at 2⁰ = 1, then add up the positions where a 1 appears.

Worked example: 00101010 in binary

Positions with a 1: 32 + 8 + 2 = 42

So 00101010 in binary equals 42 in decimal. The diagram below shows this visually.

Bitwise operators work directly on the individual bits of integer values. They are extremely fast — a single CPU instruction — and appear in everything from graphics engines to network protocols.

AND (&)

Sets a result bit to 1 only if both input bits are 1.

  0101   (5)
& 0011   (3)
------
  0001   (1)

Practical use: permission checks. If READ = 0001 and a user's permission byte is 0101, then perms & READ != 0 tells you the READ bit is set without touching other bits.

OR (|)

Sets a result bit to 1 if either input bit is 1.

  0101   (5)
| 0010   (2)
------
  0111   (7)

Practical use: granting permissions. perms | WRITE turns on the WRITE bit while leaving all other bits unchanged.

XOR (^)

Sets a result bit to 1 if the input bits are different.

  0101   (5)
^ 0011   (3)
------
  0110   (6)

Practical use: toggling flags. flags ^ FLAG flips a bit: if it was 1 it becomes 0, and vice versa. XOR is also used in simple checksums and encryption — XORing a value with itself always produces 0.

NOT (~)

Flips every bit.

~ 0101   (5)
------
  1010   (-6 in two's complement)

Practical use: clearing bits. perms & ~EXEC clears the EXEC bit: ~EXEC produces a mask with every bit set except EXEC, so ANDing with it zeroes out that one bit.

Left shift (<<) and right shift (>>)

Shifts all bits left or right by a given number of positions. Zeros are shifted in.

0001 << 2  →  0100   (1 becomes 4)
1000 >> 1  →  0100   (8 becomes 4)

Practical use: fast multiplication and division. Left-shifting by n is equivalent to multiplying by 2ⁿ. Right-shifting by n is equivalent to dividing by 2ⁿ. Compilers often emit shift instructions instead of multiply/divide because they execute in a single cycle.

A bitmask is an integer value used together with a bitwise operator to isolate, set, or clear specific bits in another integer. Think of it like a stencil: the mask covers the bits you want to leave alone, and exposes only the bits you want to work with.

Checking a bit

perms  = 0b00000101   # READ and EXEC set
READ   = 0b00000001

is_readable = (perms & READ) != 0   # True

Setting a bit

perms |= WRITE    # turns on bit 1 regardless of its current value

Clearing a bit

perms &= ~EXEC    # turns off bit 2 regardless of its current value

This three-operation pattern (check, set, clear) appears in Linux file permissions (chmod), TCP flag bytes (SYN, ACK, FIN), network subnet masks, and hardware device registers.

The code example below demonstrates all three operations in a Bash script using Unix-style permission flags:

# Permission flags (bitmask)
READ=1    # 001
WRITE=2   # 010
EXEC=4    # 100

user_perms=5  # 101 — READ + EXEC granted

# Check if WRITE permission is set
if (( (user_perms & WRITE) != 0 )); then
  echo "Write permission granted"
else
  echo "Write permission denied"   # prints this
fi

# Grant WRITE permission
user_perms=$((user_perms | WRITE))  # 101 | 010 = 111

# Revoke EXEC permission
user_perms=$((user_perms & ~EXEC))  # 111 & ~100 = 011

The same pattern appears in PostgreSQL row-level security, JWT scope bytes, and virtually every embedded systems driver you will encounter.

• Bitwise Operators in Practice — MDN Web Docs
• Bit Twiddling Hacks — Stanford CS
• Number Systems: Binary, Octal and Hexadecimal — Khan Academy
• How Computers Work: Binary & Data — Crash Course Computer Science