Understanding Binary Arithmetic: The Light Switch

The Light Switch Analogy

Let's explore binary numbers through a wall of switches:

• Each switch: Represents one binary digit (called a "bit")
• OFF (down): Represents 0
• ON (up): Represents 1
• The row: A binary number made of multiple switches (bits)

Why Binary? Why Not Decimal?

Computers use binary because electronic components are most reliable in two states:

• Voltage high or low: Easy to distinguish 0V vs 5V (or similar)
• Magnetic polarity: North or south on hard drive platters
• Light on or off: Fiber optic cables, optical drives
• Charge present or absent: SSD memory cells

Ten distinct states (decimal) would be much harder to implement reliably. The electrical noise would cause constant errors!

Binary Addition: Adding Two Switch Rows

When we add two binary numbers, we work right to left (just like decimal). The rules are simple:

• 0 + 0 = 0 (both switches off → result off)
• 0 + 1 = 1 (one switch on → result on)
• 1 + 0 = 1 (one switch on → result on)
• 1 + 1 = 10 (both on → result off, carry to next position)

That last rule is key: when we add 1 + 1 in binary, we get 0 and carry 1 to the left. This is like adding 5 + 5 in decimal: we get 0 and carry 1.

A Visual Example: 11 + 1 = 100

Let's add the binary numbers 11 (which is 3 in decimal) and 1 (which is 1):

   1 1   (binary for 3)
 +   1   (binary for 1)
 ------
 1 0 0   (binary for 4)
 ↑ ↑ ↑
 │ │ └── 1 + 1 = 0, carry 1
 │ └──── 1 + 0 + carry(1) = 0, carry 1
 └────── 0 + 0 + carry(1) = 1
              

Notice how the carry ripples from right to left. This "carry propagation" is the heart of binary addition!

The "All Ones" Case

What happens when all switches are ON? Like 1111 (which is 15)?

Adding 1 creates a cascade of carries:

• Rightmost: 1 + 1 = 0, carry 1
• Second: 1 + carry(1) = 0, carry 1
• Third: 1 + carry(1) = 0, carry 1
• Fourth: 1 + carry(1) = 0, carry 1
• New position: carry(1) = 1

Result: 10000 (16 in decimal). We needed an extra switch!

Place Values: Powers of 2

In decimal, each position is worth 10× more (ones, tens, hundreds...). In binary, each position is worth 2× more:

So 10110 = 16 + 0 + 4 + 2 + 0 = 22