We have 10 fingers, so why not use Decimal? The inevitable reasons engineers chose Binary to fight voltage noise, covering Base64, Floating Point, and Y2K38.
Why does my server crash? OS's desperate struggle to manage limited memory. War against Fragmentation.
Two ways to escape a maze. Spread out wide (BFS) or dig deep (DFS)? Who finds the shortest path?
Fast by name. Partitioning around a Pivot. Why is it the standard library choice despite O(N²) worst case?
Establishing TCP connection is expensive. Reuse it for multiple requests.
To a computer, the world has only two colors: 0 (OFF) or 1 (ON). Why not Decimal? Humans have 10 fingers. Actually, early computer pioneers like Babbage did try to make Decimal computers using gears. But electronic computers chose Binary.
Suppose we build a Decimal Computer with 5 Volts.
Since electricity in the real world is not clean, noise makes voltage dance. If I sent 5V (9) but 4.6V arrived due to resistance, is it 8 or 9? This ambiguity causes fatal errors in calculation.
This wide Threshold makes digital systems incredibly reliable. Even if noise corrupts 5V to 3.8V, it is still safely in the "High" zone.
We group 8 bits into a Byte. ($2^8 = 256$ possibilities).
To store -5:
We use Two's Complement.
0000 0101 -> 1111 1010)1111 1011)
This allows 5 + (-5) = 0 using standard binary addition logic. No special subtraction hardware needed.0.1 in binary is an infinite repeating fraction 0.000110011....
Computers truncate it, causing precision errors like 0.1 + 0.2 != 0.3.
IEEE 754 defines how to store these numbers using Sign, Exponent, and Mantissa bits. This is why you should never use float types for financial calculations.
Because we only have 23 bits for Mantissa, we lose precision after certain decimal points. This is an inherent limitation of binary floating point systems not a bug.
You might think "I'm a high-level developer, I don't need bits." But understanding bitwise logic is crucial for performance and understanding low-level systems.
Look at Unix permissions chmod 755 (rwxr-xr-x).
Instead of creating 3 boolean columns (CanRead, CanWrite, CanExec), we use a single integer.
100010001If I want Read + Execute: 4 | 1 = 5 (101).
// Adding permission (OR)
let permission = 0;
permission = permission | READ | WRITE; // 110 (6)
// Checking permission (AND)
if (permission & WRITE) {
console.log("Written!");
}
// Removing permission (NOT + AND)
permission = permission & ~WRITE; // 100 (4)
<<, >>)Shifting bits to the left is multiplying by 2.
Shifting bits to the right is dividing by 2.
5 << 1 becomes 10. 10 >> 1 becomes 5.
This is much faster for the CPU than actual multiplication instructions.
Why do we use Hexadecimal (Base-16)?
Because Binary is too long for humans to read.
1011 0101 1100 1111 is hard to read.
Group them by 4 bits: B (11) 5 (5) C (12) F (15).
0xB5CF. Much cleaner.
This maps perfectly to bytes. 1 Byte (8 bits) is exactly 2 Hex digits.
That's why colors are #FFFFFF (Red FF, Green FF, Blue FF).
Why do we convert images or files to Base64 strings? Because some systems (like email or JSON) are designed to handle text, not binary data.
Base64 increases the size by 33%. Why? It takes 3 bytes (24 bits) of binary data and splits it into 4 chunks of 6 bits. ($2^6 = 64$). Each 6-bit chunk maps to a printable character (A-Z, a-z, 0-9, +, /).
Man (ASCII) -> 01001101 01100001 01101110 (Total 24 bits)010011 (19) 010110 (22) 000101 (5) 101110 (46)T W F uTWFuSo when you see data:image/png;base64,..., you are looking at raw binary data chopped into 6-bit pieces to survive in a text-only world. It's a bridge between the binary underworld and the text-based internet.
Why does my 512GB SSD only show 476GB in Windows? It's because hard drive manufacturers and Windows speak different languages.
Manufacturers say: "Here is $512 \times 10^9$ bytes!" Windows says: "Okay, dividing by $2^$... That's 476 GiB." So you are not being cheated. It's just a unit mismatch born from the binary nature of computers.
What happens if you add 1 to the maximum integer?
In an 8-bit system, the max is 1111 1111 (255).
Adding 1 result in 1 0000 0000 (256).
But the system only has 8 bits, so the leading 1 is dropped (Overflow).
The result becomes 0000 0000 (0).
This is why:
We live in a world of Bits (0 OR 1). The future belongs to Qubits (0 AND 1). Thanks to Superposition, a Qubit can exist in both states simultaneously. While a classic computer tries every path in a maze one by one, a quantum computer tries all paths at once. However, for now, mastering 0 and 1 is enough to build great software.
Understanding binary helps you understand data types, memory limits, and character encodings. It is the alphabet of our digital world.