How Computers Think: Binary, Logic, and Circuits

Everything You've Ever Done on a Computer Comes Down to Two Digits

When you type the letter A on your keyboard, your computer doesn't see a letter. It sees 01000001. When you take a photo, your phone doesn't store a picture - it stores millions of numbers between 0 and 255, three per pixel. Every text you've ever sent, every video you've streamed, every Google search you've ever typed - all of it reduced to two digits: 0 and 1. That sounds like a brutal limitation. It is actually the most powerful idea in the history of engineering.

Binary is not some arbitrary convention that computer scientists chose because they liked the aesthetics. It is the inevitable consequence of building machines out of switches. And understanding how those switches combine to represent letters, colors, music, and eventually thought-like computation will change the way you see every device you touch. This is the foundation beneath every other topic in computer science. Nothing else makes sense without it.

Why Binary? Because Switches Have Two States

You might wonder why computers don't use the decimal system we grew up with - ten digits, zero through nine. Some early machines tried exactly that. ENIAC, built in 1945, used decimal internally. The problem was reliability. Engineering a component that can reliably distinguish between ten different voltage levels is hard. Engineering one that distinguishes between two - on or off, high or low, current flowing or not - is simple. And when you're connecting billions of components together, simple wins.

The component in question is the transistor. A transistor is a tiny electronic switch. Apply a voltage to its gate and current flows through it (that's a 1). Remove the voltage and current stops (that's a 0). That's it. No moving parts. No mechanical contacts. Just a sliver of silicon that either conducts or doesn't.

For perspective on how far transistor technology has come, look at the exponential growth in transistor counts over the decades.

That's a 12-million-fold increase in roughly 50 years. No other technology in human history has scaled at that rate. And every single one of those 28 billion transistors does the same fundamental thing - it switches between 0 and 1. The breakthrough was never about making the switch more complex. It was about making it unimaginably small and packing more of them onto a single chip.

Counting in Binary: The Powers-of-Two System

In the decimal system you learned as a kid, each digit position represents a power of 10. The number 347 means 3x100 + 4x10 + 7x1. Binary works identically, except each position represents a power of 2.

Think of it this way. Imagine you have 8 light switches on a wall. Each switch is either off (0) or on (1). With those 8 switches, you can represent any number from 0 (all off) to 255 (all on). That range - 0 to 255 - shows up everywhere in computing because 8 switches (8 bits) is one byte, the fundamental unit of digital storage.

Here's how the first 16 numbers look in 4-bit binary. Each column represents a power of 2, just like each column in decimal represents a power of 10.

To convert any decimal number to binary, you ask a simple series of questions: does the largest power of 2 fit into my number? If yes, write a 1 and subtract it. If no, write a 0. Move to the next smaller power and repeat. Take the number 42. Does 32 fit? Yes (42-32=10), write 1. Does 16 fit into 10? No, write 0. Does 8 fit? Yes (10-8=2), write 1. Does 4 fit into 2? No, write 0. Does 2 fit? Yes (2-2=0), write 1. Does 1 fit into 0? No, write 0. Result: 101010. That's 42 in binary.

Going the other way is even simpler. See 101010? Just add up the positions where there's a 1: 32 + 8 + 2 = 42. Once you do this a few times, it becomes second nature.

Logic Gates: The Building Blocks of Computation

Knowing how to represent numbers in binary is only half the story. The real magic is what happens when you start combining binary signals to make decisions. That's where logic gates come in. A logic gate takes one or two binary inputs and produces one binary output according to a fixed rule. There are four gates you need to know, and everything a computer does - from adding numbers to running neural networks - is built from combinations of them.

Here's the critical insight about gates: individually, they're almost trivially simple. An AND gate just checks if two things are both true. But when you start chaining gates together - the output of one feeding into the input of another - you can build circuits that do genuinely complex things. Addition, subtraction, comparison, memory, and eventually the full instruction set of a modern processor. It's the same principle behind LEGO: the individual brick is simple, but what you build with billions of them is limited only by the design.

From Gates to Circuits: Building an Adder

The simplest useful circuit you can build from logic gates is a half-adder - a circuit that adds two single-bit numbers together. It's the atom of arithmetic, and every calculator, spreadsheet, and physics simulation ultimately relies on this operation scaled up.

When you add two single-bit numbers, there are only four possible cases: 0+0=0, 0+1=1, 1+0=1, and 1+1=10 (that's "10" in binary, which equals 2 in decimal). Notice that the last case produces two digits - a sum digit and a carry digit. A half-adder needs two outputs: Sum and Carry.

Look at those results carefully. The Sum column (the rightmost digit of each result) follows the XOR pattern exactly: it's 1 only when the inputs differ. The Carry column follows the AND pattern: it's 1 only when both inputs are 1. So a half-adder is literally just one XOR gate and one AND gate wired to the same two inputs.

This is where the abstract becomes concrete. A modern 64-bit processor can add two 64-digit binary numbers in a single clock cycle - about 0.3 nanoseconds on a 3 GHz chip. It does this using a chain of full-adders (slightly more complex versions of the half-adder, with an extra input for the carry from the previous column). The entire addition circuit is just XOR and AND gates, repeated 64 times, with the carry output of each stage feeding into the next. No magic. No mystery. Just logic gates doing exactly what their truth tables say.

How Text, Images, and Sound Become Numbers

Binary arithmetic is what makes computation possible. But before a computer can compute anything useful about the real world, it needs to translate human things - letters, colors, sounds - into numbers. This encoding is one of the most elegant parts of the entire system.

Text: ASCII and Unicode

The original text encoding, ASCII (1963), mapped 128 characters to the numbers 0-127. That covered uppercase and lowercase English letters, digits, punctuation, and some control characters. The letter A is 65 (01000001 in binary). A lowercase a is 97. The digit character "0" is 48 - not zero itself, but the symbol for zero. The space character is 32. These assignments weren't random: uppercase letters occupy a continuous block (65-90), lowercase letters another (97-122), and digits another (48-57), making alphabetical sorting as simple as numerical sorting. Simple, compact, and completely inadequate for a world with more than one language.

Early computers could only display ASCII art - pictures made from text characters. That era produced some remarkably creative work, but the real limitation was language. ASCII had room for English and basic Western European punctuation. Chinese, Arabic, Hindi, Korean, Japanese? Not a single character. For decades, different countries created incompatible encoding schemes, and sending text across borders was a nightmare of garbled characters.

Unicode solved this by expanding the number space to 1,114,112 possible characters. It covers every writing system in active use - Latin, Cyrillic, Chinese, Arabic, Devanagari, Korean, Japanese, Ethiopian, Cherokee, and hundreds more - plus mathematical symbols, musical notation, and yes, emoji. The key insight was that characters are just numbers with an agreed-upon meaning. The thumbs-up emoji is number 128,077. Your computer and your friend's phone both know that 128,077 means a thumbs-up because they both follow the Unicode standard.

Images: Pixels and RGB

A digital image is a grid of tiny colored dots called pixels. Each pixel's color is defined by three numbers: how much red, green, and blue light to mix. Each value ranges from 0 (none) to 255 (full intensity). That gives you 256 x 256 x 256 = 16.7 million possible colors per pixel - more than the human eye can distinguish.

This is where binary math meets daily life. Every color code you've seen in web design - #FF5733, for example - is just three hexadecimal numbers (FF=255 red, 57=87 green, 33=51 blue) representing an RGB value. Hex is a shorthand for binary: each hex digit maps to exactly 4 binary digits. The web designer typing #FF5733 is, without thinking about it, specifying 24 binary digits of color information.

Sound: Sampling the Air

Sound is a continuous wave of air pressure. To digitize it, a computer takes samples - measurements of the wave's amplitude at regular intervals. CD-quality audio samples 44,100 times per second, with each sample stored as a 16-bit number (65,536 possible levels of amplitude). Two channels for stereo means 44,100 x 16 x 2 = 1,411,200 bits per second of audio. That's where the "10.58 million numbers per minute" figure comes from. MP3 and AAC compression reduce this by a factor of roughly 10 using psychoacoustic tricks - removing frequencies the human ear is less sensitive to.

The Fetch-Execute Cycle: How a CPU Actually Processes Instructions

You now know how data is represented (binary), how decisions are made (logic gates), and how arithmetic works (adders built from gates). The final piece is understanding how a CPU ties all of this together to run a program. The answer is a relentless four-step loop called the fetch-execute cycle, and your processor repeats it billions of times per second.

Every program you've ever used - your browser, a video game, a spreadsheet - is a long list of these simple instructions stored in memory. The CPU fetches them one at a time (or, in modern processors, several at once using pipelining), figures out what each one says, does it, and saves the result. An instruction might be "add these two numbers," "compare this value to zero," or "jump to instruction 4,000 if the comparison was true." That last one - the conditional jump - is what makes programs able to make decisions, loop, and do different things under different conditions. It's the computational equivalent of an "if-then" statement, and it's built from the same comparison and logic gate circuitry we covered above.

A 3 GHz processor completes roughly 3 billion of these cycles per second. Modern chips have multiple cores, each running its own fetch-execute cycle, and techniques like pipelining mean each core can overlap several instructions at different stages. But strip away the optimizations and it's still the same loop: fetch, decode, execute, store. Over and over, billions of times per second, forever.

Why This Matters for You

Understanding binary, logic gates, and how data is encoded isn't trivia for computer science majors. It's a lens that makes everyday technology transparent instead of mysterious.

File sizes stop being mysterious. A 5-minute uncompressed audio track at CD quality: 44,100 samples/sec x 16 bits x 2 channels x 300 seconds = 423 million bits = about 50MB. MP3 compression brings that to 5MB. A 4K video frame is 3840 x 2160 pixels x 3 bytes = 24.9MB per frame, at 30 frames per second that's 747MB per second of raw video - which is why video compression (H.264, H.265) is one of the most important algorithms ever invented.

Color codes in design become readable. #000000 is black (zero red, zero green, zero blue). #FFFFFF is white (maximum everything). #FF0000 is pure red. Once you know each pair of hex digits is one byte (0-255) for one color channel, you can read any hex color at a glance.

Networking clicks into place. Every device on the internet has an IP address, and an IPv4 address is just a 32-bit binary number split into four 8-bit chunks and written in decimal. 192.168.1.1 in binary is 11000000.10101000.00000001.00000001. With 32 bits, there are 2^32 = 4,294,967,296 possible addresses - which is why we're running out and transitioning to IPv6 (128 bits, or 340 undecillion addresses).

QR codes are literally visible binary. Those black and white squares? Each one is a bit. Black = 1, white = 0. Scan one with your phone and you're watching an optical sensor read binary data in real time, then your phone decodes it into a URL or text string using the same encoding principles we covered above. Every restaurant menu QR code, concert ticket, boarding pass, and payment code works on this exact principle - binary data encoded as a visual pattern of two contrasting states.

Debugging and troubleshooting become less mystifying. When a web developer sees a "404" error, they're looking at a binary-encoded status code. When a network admin inspects packet headers, they're reading binary flags. When a graphic designer wonders why their gradient looks "banded" in an 8-bit image but smooth in 16-bit, the answer is in the math: 8 bits gives 256 levels of brightness per channel, while 16 bits gives 65,536. More bits, smoother gradients - because the underlying reality is analog, and more binary digits mean a finer approximation.

Answers to Questions Students Actually Ask

Why not use base-10 computers? Some were built. ENIAC (1945) used decimal circuits internally. The problem was engineering: a component that reliably distinguishes 10 voltage levels is far more expensive and error-prone than one that distinguishes 2. When you're scaling to billions of components on a single chip, the reliability advantage of binary overwhelms any convenience of decimal. Every experimental non-binary computer was eventually replaced by binary ones for this reason.

What's the difference between a bit and a byte? A bit is a single binary digit - 0 or 1. A byte is 8 bits, giving you 256 possible values (2^8). Your internet speed is measured in bits (megabits per second), but your file sizes are measured in bytes (megabytes). This mismatch confuses almost everyone, and ISPs exploit it shamelessly. To convert: divide bits by 8 to get bytes. So a 100 Mbps connection delivers a theoretical maximum of 12.5 MB/s. In practice, protocol overhead and network congestion reduce it further, typically to around 10-11 MB/s real-world download speed.

Can computers do anything without binary? Classical computers are pure binary - every computation ultimately reduces to sequences of 0s and 1s manipulated by logic gates. Quantum computers are a fundamentally different approach: they use qubits, which can exist in a superposition of 0 and 1 simultaneously. This doesn't mean quantum computers are "better" at everything - they're dramatically faster for certain specific problems (like factoring large numbers or simulating molecules) but they won't replace your laptop for browsing the web or editing documents. The two architectures solve different categories of problems.

If binary is so simple, why are computers so complex? Because complexity emerges from scale and combination, not from individual component complexity. A transistor that switches between 0 and 1 is simple. Connect 28 billion of them in carefully designed logic circuits and you have a chip that can run a large language model, render photorealistic 3D graphics, and decompress 4K video in real time. It's the same principle as biology: a neuron either fires or doesn't (roughly binary), but 86 billion of them connected in a brain produce consciousness, language, and creativity. Simplicity at the component level combined with astronomical scale produces emergent complexity. That's the deepest lesson of how computers think.