How Computers Work : The 1s And 0s

Computers are amazing. From the simplest notes app on your phone to the incredible systems that put robot helicopters on Mars, they power our world. And, most amazingly, they do it all with nothing more than a bunch of 1s and 0s.

This is the story of how that works.

Before we talk about the 1s and 0s, let's look at a light switch. It has two positions : OFF and ON . Clicking or tapping the switch flips it back and forth between the two positions.

Try it and see.

A switch that isn't connected to anything isn't a lot of use. Let's connect ours to a light. Now clicking the switch toggles the light on and off too.

Of course, our switch doesn't have to control a light. It could control a fan, a garbage disposal, or an air conditioner. Anything that needs to be turned off and on.

Instead of turning something off and on, we could also use the switch to toggle back and forth between two things. For example, we could have the switch control an "Open/Closed" sign for a shop.

Toggling this switch ON shows the "Open" sign. Toggling it OFF changes the sign to "Closed".

Instead of a sign that says "Open" or "Closed", let's attach a sign with a number on it. When the switch is OFF, the number will be "0". When the switch is On, the number will be "1".

We'll be making a bunch of imaginary computers as illustrations. Each one will have two parts :

Now, let's make a computer that does something. This one has a single bit in its Memory. Since this is an Imaginary Computer, we could click the switch to toggle the bit directly in the Memory even though it's "inside" the computer. But, let's set it up more like a real world computer and add a "Toggle Bit" button on the Screen that we'll use to do the toggling.

Give it a shot to test it out.

We can see our bit in the Memory of our Imaginary Computer, but, since it's "inside" the computer, we wouldn't be able to see it in the real world. So, let's show the current number for the bit beside the button on the Screen as well.

Now, when we click the "Toggle Bit" button we see the displayed value on the Screen change as well as the actual bit in Memory :

We can store more than one bit in our computer's Memory.

Let's add another one connected to another button and label the bit/button pairs "A" and "B" so we can keep track of what's connected to what.

Clicking one of the buttons toggles the corresponding bit without affecting its neighbor.

Apps can combine the values from multiple bits in Memory together to do useful things on the Screen. For example, we can make a "Total" display on the Screen that shows the values of the bits in Memory added together.

Click the buttons and you'll see that :

If we wanted to count to three, we could add another bit/button pair like this :

The technique to eliminate both issues is to multiply the value of each bit by a specific amount before counting it.

Specifically :

Let's add two more bit/button pairs.

We'll make a "D" bit with a multiplier of "8" and an "E" bit with a multiplier of "16".

While we're at it, I'm going to reverse the order of the switches in Memory from : "A, B, C, D, E", to : "E, D, C, B, A". That doesn't have any affect on the way things work. It's just to make things easier to read in later examples by putting the bit with the switch with the highest multiplier first.

Play around and you'll see that with five bits we can now count from 0 (with all the bits toggled to 0) to 31 (when all the bits are toggled to "1"). And, we can get any number in between by toggling some bits to "1" and others to "0.

Putting the bits into an order with the highest multiplier first has an interesting effect. We can now read all the bits together and treat them like their own number. And, those numbers always correspond exactly to specific Total values.

For example :

So far, each button on the Screen has been paired directly with a single bit in Memory. Apps can also use buttons that control multiple bits at the same time.

For example, here's a counter with five bits in Memory but only two buttons. One that adds to the Screen's Total and one that subtracts from it.

Everything we've done to this point has displayed numbers on the Screen based directly on the value of the bits in Memory We've either displayed them directly or added them together with their multipliers to get a Total number value.

Since the bits in a computer's Memory can only be 1s or 0s we'll have to come up with a new technique to handle letters. We'll do this by creating a "Memory Map Dictionary" which works like this :

Of course, there are more than just U.S. English alphabet letters involved in writing. Punctuation, accent marks, and languages like Chinese, Japanese, and Korean that use entirely different characters, for example.

For a real - world computer app we'd want to be able to handle them all. Thankfully, a bunch of folks already got together and created a Memory Map Dictionary that includes everything for us. It's called Unicode ¹ . Here's a basic example that uses it.

So far we've been using buttons to update the values of the bits in Memory, but you wouldn't want to have to click a bunch of buttons every time you want to type something. Instead, you'd want to use a text box like this one where you can type a letter.

Let's take the step from letters to words. We'll still use bits in Memory, but things are going to look a little different. Our Unicode example above used eight bits for the letter. We'll continue with that, but set up our Memory so it can hold multiple letters. To make things easier to read, I'm removing the switches and grouping each collection of eight bits together.

Type a single letter and you'll see the first eight bits that represent that letter. Type another letter and you'll see the next eight, etc... I recommend starting with a uppercase "A" and an lowercase "z" for the first two letters to make it easy to see the differences in the bits for each letter in Memory.

Grouping bits into sets of eight is so common in the computer world that a group of that size has its own name : byte

Pronounced "bite", it's what's being referred to in words like "Megabyte", "Gigabyte", and "Terabyte".

A Megabyte is 1,048,576 bytes ² . That number may seem weird, but there's a reason it's so specific. It's 2 to the 20th power. That's because computers use sets of bits (which we've seen are based of multiples of 2) to keep track of the memory itself. (We won't be getting into that in this post. For now, it's enough to know that it's just another example of computers using bits for everything.)

We've used bits to calculate numbers and to make letters. Now, let's use them to make colors.

We'll start with two colors (Black and Bright Green) and we'll use a single bit to toggle between them. We'll make the color Black when the bit is "0" and Bright Green when the bit is "1".

To add more colors, we'll add more bits and create a new Memory Map Dictionary that assigns colors to each number :

Let's replace the two toggle buttons with a slider which makes for a nicer interface for changing between our four colors.

Now, let's use eight bits (aka one byte ) for the color. That'll give us Black when all the bits are "0", and 255 varying shades of Green (some of which are so close to black that it's hard to tell they have any color at all, but they do). With that many shades we can make a very smooth color slider.

Our next step is to be able to pick any color we want (not just a shade of green). Before we do that, we need to cover a little bit about how Screens work. We'd need an entire post to really get into the details but for now we can work with this :

Providing one slider for Red, one for Green, and one for Blue gives us this :

This has been a long post and this feels like a good place to wrap it up. We used our bits to make numbers, letters, and colors. Sounds and music would be a good next topic, but it's really the same thing. You come up with a way to represent whatever your interested in (e.g. the volume for a sound) as a number and then store that number in bits .

I've been programming computers for a few decades. I spent a lot of that time not knowing how bits worked. When I learned about them they seemed unreal. Still kinda feels like that sometimes, if I'm being honest. To be able to do so much with so little feels like sorcery. But, there's no magic. It's just a bunch 1s and 0s .