Silicon to Scripting 4

Up until now, we have been building simple logic gates with abstract meaning. Our next goal is to make a gate that can add numbers. That sounds like a large jump, but as you will soon see, it is nothing new. It all comes down to interpretation.

Meaning and Interpretation

On and off, true and false, 1 and 0. They are basically the same thing, but they mean different things. We don’t say “can you turn the light true?”

We can interpret a light being on as true and off as false, but we have to do that mapping in our head.

However, we can make more complex mappings from binary 0s and 1s to anything. The meaning isn’t held in the 1s and 0s, it’s held in the mapping itself. By creating and agreeing on a mapping, we can extract meaning from binary.

Look at this sequence

11
11
10
11
01
11
00

It doesn’t mean anything to you… yet.

I could come up with an arbitrary binary mapping, or encoding, for directions, and as long as we both know the meaning, we can communicate in binary.

11 => Go Forward
10 => Turn Left
01 => Turn Right
00 => Stop

Given that, I could direct you to go somewhere with the same sequence.

11
11
10
11
01
11
00

What you just did was interpret 1s and 0s as directions, extracting meaning that wasn’t there initially.

Representing Numbers in Binary

Before we make something that can add numbers, we need to be able to represent numbers with 1s and 0s. We need to be able to interpret them as numbers. For now, we will only be dealing with the Natural Numbers (0, 1, 2, 3, …).

Try and come up with a scheme yourself, it’s a good exercise.

No, really, try it.

If you just saw this problem, you might come up with something along the lines of: count the number of 1s.

0000 => 0
1000 => 1
1100 => 2
1110 => 3
1111 => 4

This works, but it is inefficient. The maximum number we can represent with 4 binary numbers, also called bits, is 4. If we choose a smarter encoding, we can represent much higher numbers. We could also have the mapping assist us with arethemetic operations, but we’ll see that later.

To get understand how computers actually represent numbers, let’s look at our base 10 system. The number 1337 really means:

(1⋅1000)+(3⋅100)+(3⋅10)+(7⋅1)(1 \cdot 1000) + (3 \cdot 100) + (3 \cdot 10) + (7 \cdot 1) =(1⋅103)+(3⋅102)+(3⋅101)+(7⋅100)= (1 \cdot 10^3) + (3 \cdot 10^2) + (3 \cdot 10^1) + (7 \cdot 10^0)

This is because it is the base 10 system. Starting at 0, the rightmost digit is multiplied by 10010^0 and so on. We have the 1s place, 10s place, 100s place, …, because 1=1001 = 10^0, 10=10110 = 10^1, …

Instead of 10010^0, 10110^1, 10210^2, we will use 202^0, 212^1, 222^2, because we only have 2 possible options for each place (1 or 0). Now if we take a number like 13, in base 10 it would be

(1⋅101)+(3⋅100)(1 \cdot 10^1) + (3 \cdot 10^0)

but in base 2 it would be

(1⋅23)+(1⋅22)+(0⋅21)+(1⋅20)(1 \cdot 2^3) + (1 \cdot 2^2) + (0 \cdot 2^1) + (1 \cdot 2^0) =(1⋅8)+(1⋅4)+(0⋅2)+(1⋅1)= (1 \cdot 8) + (1 \cdot 4) + (0 \cdot 2) + (1 \cdot 1)

We can just take the coefficients, and form the base 2 number 1101.

Note: To not get confused between different bases, there is some popular notation. Mathimiticians subscript the number with the base: 110121101_2, and programmers prefix the number with a 0b: 0b1101.

Comparing this to our previous encoding, our new maximum number is 8+4+2+1=158 + 4 + 2 + 1 = 15 which is also 24−12^4 - 1. The maximum number increases exponentially. With 8 bits, our previous system could only represent a maximum of 8, while this one can represent 28−1=2552^8 - 1 = 255.

part 5