How Computers Work: From Binary Numbers to CPU Design Explained

So, in this video, I'd like to try and explain just exactly how a computer works. And I know that sounds like an

incredibly open-ended and difficult question to answer. And I'm going to go ahead and guess that the length of this

video will make that self-evident that it's not any trivial question in itself. But, uh, this is something that I

wondered a lot growing up. And, uh, even when I got to college, I knew I was going to study computer science. But it

wasn't until halfway through my degree where I took the course which answered this question and I found everything I

learned really interesting. Ended up TAing that course for a few semesters afterwards and uh find the really

low-level stuff of computing to be fascinating. And I've been surprised at uh a the lack of direct resources online

that can answer this question for just an average person who's curious and b how many uh friends I have working

technical jobs or who studied computer science or related degree in college and are not too sure how a computer actually

works. And I think um there's a lot of benefits to be held from this knowledge. Uh if you are just curious like I am, I

want to cater this video to be completely digestible even if you have no mathematical or technical background.

And I also want this video to be useful for someone who might already be uh doing an engineering relating job

because uh a lot of these lower level principles might actually affect how you structure code or just uh lay out your

programs at a higher level. Um so in this video I'd like to start with no assumption of what a computer work how a

computer works. uh just basic mathematics will be assumed which I'm assuming if you clicked on this video

you have a somewhat of an understanding of um we're just going to be starting simple with like addition, subtraction,

multiplication, division uh and like exponents. I think that's probably all the background you need to be able to

follow along for this entire video. So I'm going to answer this question by making a CPU from scratch. Um

and then we're going to go ahead take that processor uh which can run one program and build an operating system or

just explain kind of at a higher level how an operating system can be built for our processor uh and what an operating

system actually is because that's also a great question in itself. Um but without getting into too much detail now the

computer you're watching this on even if it's a phone uh is is doing multiple things at once. And if you're like me,

uh you probably have this YouTube video open, iMessage in your background, um and maybe a few other tabs behind those

two. And uh it's a really interesting question cuz we're going to get to a point in this video where you design a

CPU and it can execute one program. And a really common and good follow-up question is how can my computer run

multiple programs at the same time? Um, and so we're going to go ahead and dive into what that looks like as well

because it's a it's interesting to know how a computer works. Um, but I also want to make it pragmatic and get to

something more modern uh, which is an operating system. So, uh, I also would like this video to be useful um, even if

you don't watch it all the way through. I have no idea how long this is going to be. I am guessing it will not be short

though. And what I would hope is um for those of you who don't watch it all the way through, which is the vast majority,

I'm assuming, uh the individual segments uh will be of value themselves. And maybe hopefully you learn something

interesting along the way. Even if you didn't take it all the way, you learned something. Um and what we're actually

going to start at is one of the most interesting topics I think personally uh that anyone can know. And if you only

watch this first segment of the video and nothing else, you've at least learned something really interesting.

Um, so I'm going to start by uh explaining how computers represent numbers and letters. Uh, how do we how

can computers count? How can they add numbers? Um, and you've probably heard of something

along the lines of computers speak in zeros and ones. And uh, this isn't nonsense. It's actually very true.

Computers don't really recognize or process numbers the way we do. They only operate on zeros and ones. And once we

uh understand how computers represent numbers, it's going to make sense why they do it like this. Um without getting

into too much specifics now, but also without being incredibly vague, uh I'll say when we design computers, um they're

built with electricity. And so we can represent the absence of electricity with a zero and the presence of

electricity with a one. Um and with this it it kind of gives us a lot of flexibility to well if we can represent

anything in zeros and ones and we know how to represent zeros and ones with electricity or the absence of it. Then

we can kind of build on top of that and design an entire computer. Um, and you may be wondering, well, why don't we

just use a little a little bit of electricity represents uh a one, a little bit more than that represents a

two, and so on and so on until the the maximum of electricity we could have represents a 10, and then computers

could just work with the the numbers we know. Um, but from an engineering perspective, it's not that easy to

implement. Um, I don't want to get into the specifics of electricity because that's also uh probably a little too low

level for what I want to accomplish in this video, but um, it turns out electricity is is very inconsistent in

in in I guess flickers might be a better word for what I'm trying to say. Um, so we find it easier just to say have a

certain threshold of of electricity, quote unquote, and anything below that we interpret as a zero, and anything

above that threshold we interpret as a one. Um, and again, it's not going to make perfect sense what I'm saying. If

you're already a little bit confused, it should be confusing cuz I'm kind of jumping jumping ahead of myself here.

So, I just wanted to give some context for why we uh represent numbers with just zeros and ones in computers. So,

let's go ahead and understand how computers represent numbers. Um, so I'm going to clear this screen here that

you've been staring at for 5 minutes now. And let's start with uh a quick recap of how we represent numbers. So if

I put the number 724 on the screen, intuitively you know exactly what this is. I mean it's a number you can

rationalize. You can imagine say 724 uh pencils in your hand or something like that. But how do we actually uh how

did we learn this? When you were in elementary school and learning how to count, this number wasn't always easy to

you. In fact, the first time you saw this, it probably made no sense to you, but you're older now, you're smarter,

and you know how to interpret this. Um, so I'm going to redumb this back down to our elementary school level and uh see

how we can build this number by looking at each of the digit positions. So, we know this right here is the ones place.

That's probably not surprising. Um, we know this is called the 10's place. And then we know this is called the

hundred's place. And uh this is something you know and you don't remember when you learned it,

but you know that you learned it at some point. And we know that if we keep going, we have the thousand's place and

then the 10,000's place, then the hundred thousand's place and the million's place, the 10 million's place,

the 100 million's place, and so on and so on. Um and so

what exactly do each of these places mean? And how can we take the values from each of these places and and

generate a composite number? Um, so it turns out that to to get the value of a number, uh, we have to, and this is

going to sound painfully obvious and almost a little bit confusing because of how obvious and true it is to you, but

I'm saying it cuz it's going to make sense when we look at the computer version. um to get the value of a

number, we could look at the value of each of the digits places and kind of sum them all up together. So, we know in

the ones place, this four uh is just going to be whatever value is in that digit spot times the weight of that

spot. So, right here we have 4 * 1, which equals 4. And then over here, we have a two and it's in the 10's place.

So that's going to be time 10 and that's going to be 20. And then over here we have a [snorts] seven in the hundred's

place. So we multiply it by the weight of that place which is a 100 and we have 700. And then we can as I said we could

add all these values together. So once we compute the weight of each digit position we can go ahead and add those

uh those scaled weights together. So then we have 700 + 20 + 4. And I'm going to stack those numbers on top of each

other because that's kind of how we learn how to add numbers. Um, oops, not 24. Uh, and we know exactly that there's

only one non-zero digit in each position. So it's just going to carry right down. Um, and so we kind of

started with 724 and ended with 724. Um, and that's that's nothing too crazy. Um, but let's go ahead and and structure

that out a little more. So, what we saw here is that 724 is equal to 7 * 100 +

2 * 10 + 4 * 1. And where did that come from? Just to recap, it is for each digit

position, we take the value that is in that that spot and then multiply it by the weight of the position. So we know

the very first digit position is the one's place, so its weight is one. Then the next one is the 10's place, so its

weight is 10. And then the next one's the hundred's place, so its weight is 100. Um, and then if we were to expand,

so we've kind of taken our number 724 and written written it out in this expanded way. Um, and hopefully I've

convinced you that this is true and correct, and it it is. Um, unless I've made some error, but let's look at an

even uh more alternative way uh to to to write out this expanded form. And all I'm really going to do is uh replace the

weights um of the position. So, let me write this out and then we'll kind of uh revisit what I'm trying to say.

Okay, so I told you um that this is going to run on basic math. Uh and the exponent is probably as complicated as

we need to get for you to understand everything about how a computer works. Um everything loosely put everything uh

that I'm going to teach you in this video. Um so just to recall that uh 10 uh to the 1 is is 10 10^ squared uh when

we have a a number raised to an exponent it just means we multiply the number by itself that many times. Um so 10 by 10

is equal to 100. And then if we had 10 cubed we multiply 10 by itself three times. um and that's going to be a

th00and. And then uh one caveat to that is um there's this rule that says anything

raised to the zero power is equal one. Um and uh so that means that when we have 10^ the 0, it's going to equal one.

Um, that's just something you probably learned in algebra 2, uh, from high school, which is probably so far out of

your memory at this point, but just just take it to be the truth that, uh, anything raised to the power of zero,

we're just going to say equals 1. Um so what I've done here is I've rewritten our expression uh in this kind of

exponentiated form where each component in our sum is some number multiplied by 10 raised to some power. Um and we also

have it that uh the powers are increasing. So we start with the zero power then we go to power one and then

we go to power two. Uh, and that that's funny enough and that that's actually uh not surprising or the more you think

about it, the more unsurprising it should be because uh 10^ the 0 is 1 and so that's the one's place and then uh 10

to the^ of 1 is 10 and that's the 10's place and then 10 to the^ of two is 100 and that's what we call the hundred's

place. Um so all we've really done here is is taken our number 724 and in write it out in this expanded form. Um and

that is all we will recap about the numbers that you and I know. So now that we know uh or now that I've shown you

just an alternate way to consider the numbers we know um we have the context uh to go ahead and move on and learn how

computers count numbers. So this is how we count numbers. And it turns out computers do it very similarly. So all

of this right here is called decimal. That is our human way of counting numbers. And it's also something that's

called base 10. And what does that mean? Base 10 is worth uh worth probably discussing a

little bit before I move on and and jump to the computer equivalent. But um one way to interpret base 10 is that it

means that for any digit position in a number, there are 10 different values that could go into that digit spot. So

uh in our 724, um let's say I pick this digit position right here. We could either have uh a

zero, a one, a two, or all the way up to a nine. Um so we could have 10 different numbers

could go in this spot. And if you're wondering why it's not nine, it's because uh one through nine is nine

numbers and then the digit zero lets us add one and so we have 10. So we actually have it that in uh any digit

position um there can be 10 different values in base 10. And uh let's also see what happens when we're counting. So for

counting in base 10 i.e. The only way that you and I know how to count for now, um, we start with the number zero,

it becomes one, and then two, three, and then we're going to go all the way up and we get to nine. And each time here,

we're just adding one. So, we're just plus one, plus one, um, all the way down. We get to eight, we add + one, we

get to nine. Um, and we've used all 10 available values that can fit in this digit position. So when we want to add

one to nine um we're stuck. We can't do that in one digit position. So we have this idea of rolling over um where we we

reset this digit back to zero and then carry carry uh a one over to the next digit place. Um and so if we take these

numbers and and write it out in our expanded form, then we know 9 is just equal to or let's start with 10. 10 is

equal to 1 * 10 uh + 0 * 1. Um oops. And then if we have 9 um then we have zero in the 10's position

and a nine in the ones position. Um, and so it's kind of curious that when we we get to the maximum value in a current

digit position and we want to add one to that, then we roll over the current digit position back to a zero and then

add one to the next digit position. This kind of makes sense because what we're doing here is we are when we have this

nine here, um, we know that we want to add one more to our collective value. So what we could do is subtract nine from

this spot and then add one from this spot and that gets us the exact difference. Um that that is the same as

accomplishing uh a net just addition of one. We took all the value from the uh the digit position to the right and then

reset it to a zero and then added one to the next digit position to the left and this is the same number. Um,

so that's how we kind of carry over and and we kind of see this happen when we add numbers. So if I go to a quick

example where we add numbers, let's say we have um 18, we want to add three. Then uh we have 18 + 18 + 3. We start in

the rightmost digit position and we add the two numbers together. So an 8 + 3 is an 11. And you remember from elementary

school that you put the one down here, the remainder, and then you add the carryover up here. And um then you do 1

plus one is two. And that's that is the uh kind of exact same logic that we're showing in this in this uh extended

form. But obviously when you were younger, there was no no reasonable way for you to understand this version of

things. You kind of just learn this rule that you uh you kind of take what you have. if if you if a digit position

exceeds 10, you put the remainder down below and then add one to the carryover. Um, and so that is uh just some more

context that we're going to see this come back very shortly. So we saw that base 10 is this idea that we can have 10

different values in any digit position. And now we're going to come and uh learn what base 2 is. So we said humans speak

in base 10. Um so this decimal is synonymous with base 10. And now I'm going to make this claim

that computers uh operate in base 2. And this is called binary. And so what does this actually mean? Um

well we said in base 10 what that means is that in any digit position you can have 10 different values. And so what we

can translate that to in base 2 is then in any digit position we can have two different values. And those two

different values are zero and one. Um and that is just exactly where the idea that computers only speak in zero and

one come from. Um but let's go ahead and see what that means. So, um, I'm going to give us a binary number. So, we're

going to start with the binary number 1011. Um, and this is a binary number. This is

this is not to be confused with the number 1,11. This is uh which is in base 10. Um, so I

will distinguish it by subsetting it with this two. Um, so I will try to make the distinction as clear as possible. If

we are speaking about a decimal number, i.e. a number that you and I are familiar with, um, I'll write a 10 next

to it. So, if instead I wanted to say, I guess our example above, we had the number 724.

So, from now on, I would say 724 base 10 just so you uh don't get confused. But in general, it's for I'm not going to

try to give you a a complicated example. Um, so if there's just zeros and ones, it's probably safe for you to assume

that I'm talking about base 2. And if there's other digits, then it's the base 10 that we're so familiar with. Um,

and let's go ahead and I'm also going to rewrite our expanded form of 724. So, let me move this down. Um, and for 724,

we said it was 7 * 10^ 2 + 2 * 10 1st power + 4 * 10 0 power. because we start uh with the lowest

power of 10 and then we just keep adding one each time. Um and so now we're I'm I'm kind of we're kind of curious here.

Uh how can we take this binary value and translate it back to a decimal value? What does 1011 mean in binary? Like what

number is that to us? Um and it turns out we're just going to follow the same exact expansion rules. So, uh, we're

going to sum up for each digit position, um, the value in that position, which is either a one or a zero. And then instead

of 10 raised to some power, we're going to use two raised to some power because this was for base 10, but now we're

going to be using base 2. So it'll be we're going to start with um the one spot is going to be two to the zero and

then instead of the 10 spot being afterwards uh we're going to have the two spot which is a little interesting

cuz you know in our in our current uh number we would have um in our in our binary system that we're so comfortable

with we start with the ones position and then go to the 10's position and then the hundred's position. Um, and now

we're going to start with the one's position and then go to the two's position cuz that's 2 to the first

power. And then after that position, we have two to the second power, which is four. Um, and after that would be 8. And

so if I come to our original decimal example, we notice that between each of these, we're multiplying by 10. And now

we're in each of these, we're multiplying by two. Um, we're looking at increasing powers of two, which is is is

pretty interesting. Um, so let me go ahead and erase that. And if this is feeling a little bit confusing, I really

hope it it it should it shouldn't feel intuitive yet. Um, I've said a lot of random things so far in this video. Um,

and now is where we're actually start tying them together. So, let me spill the answer for you on this one, and then

we'll we'll walk through and see what it means. So, um, let's start with the rightmost digit

position. Uh, cuz we start with, uh, 2 to the^ of 0. Um, so I'm going to do 2 to the^ 0. And what do we multiply it

by? We multiply it by the one that's there. And then we have that digit position done. Now we come on to this

digit position. Uh, we have uh, we're not on the 2 to the^ of zero. Now we're on 2 to the^ of one. And then we

multiply that by whatever is in that digit position, which also just happens to be a one. Um, let me move this over

here. Um, and then we then move on to this digit position, which is the 2 to the^ of two position. And what's there

is multiplied by a zero. And then we come on to the very last digit position. And that one is uh the next power to

use. We use powers 0, one, and two. So now we use the power of three um and we multiply it by whatever is there. So now

we have this expression um and you might need to pause here and just read this out loud to yourself to

make sure that you understand exactly how I derived this long form expression. Uh it may not be clear what exactly I'm

doing but how I got this expression should be clear. Um and you should also be able to

understand that uh in base 10 i.e. top row binary that or decimal sorry that we're used to. Uh each digit position is

some increasing power of 10. That's the weight for each digit position. Now that we're in base 2, each digit position,

the weight of that position is some power of two. Um and let's go ahead now. Uh if you need to pause and and just run

through what I explained, do that now. But let's go ahead and uh expand this out. Um so we know that uh we have 1 and

then 2 to the^ of 3. So 2 cubed is 2 * 2 * 2 and 2 * 2 is 4. So * 2 is 8. So we have 1 * 8. And then we have 2 ^ 2 um

which is 2 * 2 which is just equal to 4. And we multiply that by 0. Um and then we have 2 to the 1st power

which is the easy one. And we all know that's just two. Any number to the first power is just saying multiply that

number by by itself uh once not two not two times that's squared. So we just have it once then it's just that number

itself. Um and then we also said earlier that anything to the power of zero is just one. So now we have this expression

and now we're this should look pretty comfortable. Uh no exponents here. So 8 * 1 is 8. Uh 0 * 4 is 0. 2 * 1 is 2. And

1 * 1 is 1. And that's just 8 + 2 which is 10 + 1 which is 11. So and that's base that's uh base 10 11. So the the

number the 11 we're comfortable with. So now I can tell you that this number 1011 in binary is just 11. Um

and that is a totally different way of representing a number uh that we are already familiar with. Um and this is

really interesting because we only had zeros and ones to work with, but we were able to map that back to a number that

we know perfectly. Uh that doesn't need to just use zeros and ones. Um so let's go ahead and look at uh one more

conversion example. Um and uh let's do the number um 1 0 uh 01. Um and kind of go through the

same process again. So uh we know that the weighted positions let's start with that actually. Um let me make this a

little bit wider so we can write on top of them. 1 0 0 1 that's base 2. And we want to know what this equals in base

10. Um and so if we start from the right we know that this is the 2 to the 0ero position then this is 2 to the 1 then

this is 2^ 2ar and this is 2 ^ 3. Um and that's just for our reference. Um so we can go ahead and generate this uh this

long form expression where we know if we start from the very right we know that that is

1 * 2 0 and then we have a 0 * 2 the 1. Um and the the 0ero comes from the fact that that's what's in this digit

position and that's also where the one comes from here. And then for the next digit position we have a 0 * 2 ^ of two.

And then for the very last digit position we have 1 * 2 ^ of 3. Um so then we can go ahead and combine those.

We add those all up. Um so this 1 0 0 1 in base 2 is equal to 1 * 2 cubed + 0 * 2^ 2 + 0 * 2 the 1st power + 1 * 2 0

power. Um, and this time, uh, I could expand this all out, but there's something interesting to note here, and

that's that we have two examples of us multiplying a number by zero. And from basic numbers, uh, as you also learn in

school, anything times 0 is just zero. Um, so there's no point in us doing these expansions of converting 2 ^2 to 4

uh, just to multiply by zero. If we see that it's being multiplied by a zero, let's just ignore it because we know

it's not going to add any any values to our final sum. And that's that that that's going to save us some time later.

Uh if I gave you a super long binary number that was like say a 100 digits wide and told you to convert it um

then you know this would this would be kind of uh a big time saving um for all those zeros that you could drop out. Uh

so then we can simplify this expression. Uh we dropped out those zeros. We just have these two terms left. And then we

know that 2 cubed is 8. So that's 1 * 8. And then uh remember that anything to the power of 0 is just 1. So then we

have 8 + 1 which is 9. So and that's 9 in the decimal we know. So this 1 0 0 1 in base 2 is equal to 9 in the number

system that we know. And this is uh really cool. Um, I remember when I first learned this, I was kind of mind blown

uh at the fact that we could take these random se this seemingly random sequence of zeros and ones and then map it back

to a number that we are so familiar with. Um, and that uh should make it clear how we go

from binary the zeros and ones to decimal which is a number system we speak. Let's look at one other example.

What if I gave you this this big number right here in binary? That's not the number 10,000. That is 1 0 0 0 in

binary. But I would like to know what is this in base 10. Um and uh well, we know let's just go ahead and

count our positions and then generate this expression. Um so we know our digit positions start at 0 1 2 3 and four. So

we have uh that it equals 1 * 2 4 and then + 0 * 2 3 + 0 * 2 ^ 2 + 0 * 2 ^ of 1 + 0 * 2 ^ of 0. And from the rule we

learned in the example before, whenever we're multiplying something by zero, we can just get rid of that term cuz it's

going to equal zero. That's exactly what's happening in all of this expression except for this one digit

position. And then we just know that uh 2 to the 4 is equal to 2 * 2 * 2 * 2. And that's going to be uh 2 * 2 is 4.

Multiply by 2 again you get 8. And then one more time you get 16. So this number right here uh 1 0 0 0 in decimal is

actually going to be equal to 16 or sorry 1 0 0 0 in binary is going to be equal to 16 in decimal um and uh luckily

this is a very popular concept. So if you're feeling a little confused here um on anything I've shown that's totally

fine. Just go ahead and Google it. watch another YouTube video if you need to. Um, I do not want to do more examples

just because this video could drag on forever. Okay, so now we have learned up to this point how to take a binary

number and translate it back into the base 10, i.e. decimal number that we're more familiar with. So, what I'd like to

do now is the exact opposite process. If I have a number like 14, how can I get it to binary? And we're going to almost

take the inverse of the exact process we we had before. And why are we going to learn this? It's going to be because um

we're going to want to program our computer eventually. And we're going to want to be able to store numbers in our

computer. And it's going to be useful then, in fact imperative that we know how to take the number we want to put

into our computer and convert it to binary so we can load it into the language that the computer speaks. So uh

we've been working with this number 724. So let me go ahead and give us the expanded version one more time. So we

said this was 7 * 10 ^ of 2 + 2 * 10 1st power + 4 * 10th power. [snorts] And

I'm also going to go ahead and bring up this binary example from above. Uh where we had let's just say 1 0 1 1.

And I'm going to sub subscript this with two because it's binary. And we said this is equal to 1 * 2 to the 3 + 0 * 2

^ 2 + 1 * 2 1st power plus uh sorry 1 * 2 to the zeroth power. [snorts] And if we notice something here um everything

on our right hand side is decimal numbers the ones we're very familiar with. And we know that we take this this

left-hand side which is unfamiliar to us and we're able to expand it out in a form that is actually only containing

decimal numbers. [snorts] And this is the exact kind of logic we're going to take to get a number from

binary to decimal. So if I have the number 724 and want to convert it to to binary then if there's a way where I

could write it out in this expanded form as uh numbers zeros and 1* 2 to some power then we know we can just read the

the multiplicate the multiplicative coefficients left to right to know our number. Um in this case it's easy. we

have we have a one and then a zero and a one and a one and this is exactly how we end up with this number over here. So

this is a little abstract um and this is probably a little more complicated than what we just learned. Uh it's my

personal opinion that taking a a binary number and converting it to decimal is easier than me asking you to take a

decimal number and convert it to binary. But let's go ahead and do this by working through an example. Um so let's

take the number 15. 15 in base 10 i.e. just the regular 15 we're familiar with. What exactly is that in decimal or in

binary? Um so question mark base 2. What we want to end up with is some expression where we start with 2 ^ 0 and

work up to some power of two and multiply each of those terms by either a zero or a one. uh until we have some

equivalent value that sums up to 15. And as we kind of saw earlier with this binary conversion, we only really need

to care about the powers of two that are multiplied by one. I in our example here, this one uh since it's multiplied

by zero, it drops out. So we kind of know that uh I'm going to move this out the way. Uh this is really just equal to

uh 2 ^ 3 + 2 ^ of 1 + 2 ^ of 0. Um and I'm gonna make this interesting claim uh that any number in decimal any number

that you can think of can be expressed as a sum like this. And what do I mean this? I mean a sum of powers of two. And

there is a exactly one way to represent each number accordingly. Um and I can show you some examples. So if

we have the number one in decimal, then we know that two to the 0ero is just one. And then let's say we have the

number two in decimal. Well, this is easy as well. We know 2 to the^ of 1 is just two. Uh but let's look at let's

look at h what happens when we have three. Um well, we know how to represent one and two in binary. Uh and we can

just add those together because they sum to three. So we would just add their binary representations together and we'd

be left with 2 1 + 2 0 and then four is easy uh because we would know that 2 ^ of 2 is 4. Um and then we'll do one more

which is five uh and we know that uh 5 is equal to 4 + 1. So that's 2 ^ of 2 + 2 ^ of 0. And now uh for each of these

let's uh go ahead and convert it back to binary. Um so let's start with this this five because I think it's the most

interesting case. And we know that the uh we can't skip any digit positions. I.e. the rightmost digit position in our

binary number has to start at 2 to the 0. The power has to be zero. And then we have to keep working up from there until

we we have all the powers that we need in our sum. And that's the same way when you're when you're building out a number

in decimal. You can't skip the 10's place or the hundreds place just because the value in that digit position is

zero. You have to explicitly write a zero to make it apparent that there is no value in the 10's place and then the

next value is the hundred's place. So in our example here what we would need to do is um I'm going to bring out in this

long form. So we we know we have this 2 to the two. We don't have any uh thing multiplied by 2 to the first power. So

we do is we just leave it as a zero. We make the coefficient zero because that means it multiplies out to nothing. And

then we have 1 * 2 to the 0 power. And this is the exact form from earlier where it was pretty easy from there just

to read the coefficients left to right. 1 0 1. And now we have our decimal or our binary number. Sorry. So we took our

five and uh got it to a binary representation. And if you don't believe me, well, the evidence is on the screen.

But if you want to verify for yourself, pose the counter question. What is the decimal representation of the value of

the binary value 101? And if you expand it out like I've already done, you're just going to get five. And uh let's do

this for the example of 42. So we have all we have is 2 ^2. But we know we have to get all the way back down to the

power of zero. 2 to the^ of 0. we just add in 0 * each of those terms. So we have 1 * 2 ^ of 2 and then we don't want

to add anything else. So we just do 0 for the first power of two and zero for the zeroth power of two. And then we

know we just read these coefficients left to right which is 1 0 0. So that's how we represent four in binary. And in

our example here, we have it easy cuz we have every power of two uh in the entire range included. So we know that's 1 * 2

^ of 1 + 1 * 2 ^ of 0. And that's just going to be equal to 1 1 in binary. And we'll just go ahead and finish out what

we have here. Uh we know that 2 ^ of 1 is equal to 1 * 2 ^ of 1. Then we don't want to add anything else. We just

multiply the remaining terms by zero. And there's only one remaining term for us to get back to the power of zero. So,

we're just left with one zero. Uh, and that's supposed to be subscripted with the two.

And last but not least, uh, this one's trivial. Um, we've already worked our way back down to 2 to the^ of 0. So, we

just have that one term and that's just equal to one. Um, so hopefully you notice a little bit of a pattern here.

uh where I have been able to convince you at least that the first five numbers in decimal are are uh able to be

expressed as a sum of twos raised to various powers. And if we can figure out for any number what that sum is, then

I've shown you it's pretty easy once you have that to expand it out and then get the binary representation.

[snorts] So let's try a uh a little bit more difficult example. Um uh let's try 13.

And >> what we're going to do is we want to find the sums of twos to various powers

that sum up to 13. And we're going to do this by starting uh with the biggest power of two that is that can uh

contribute to our sum. So uh I'll go ahead and and write this table out over here. We know 2 to the^ of 0 is one. 2

to the^ of one is two. Then 2^2 is 4. 2 cubed is 8. 2 to the 4 is 16. 2 5th is 32. And I'll do one more. 2 6 is equal

to 64. And what we want to do is just start with the biggest uh x such that 2 to the

x is less than our target value of 13. And that's going to happen uh right here. 2 ^ of 3 is 8 which is the largest

value uh that is less than or equal to our target value. So we know that uh 2 cubed is going to be in this expression

and then when we have uh we kind of have um 13 on this side and we have eight on this side and so that means we need to

get five with some remaining combinations of entries on this list. So we'll do the same process for five. And

if we look at this list, uh we know that one is less than five, 2 is less than five, four is less than five, 8 is not

less than five. So this two 2^2 is the biggest power of two, which is less than or equal to our remainder, which is

five. Our remaining sum, should I say. So then I'll add our two squared in. And now we have a four. And so we know that

13, we have 13 on this left side and we need to get 13 on the right hand side or else they're not equal. And we have 12

on the right hand side. So we just need to get one more. And that's easy enough because we know that 2 to the^ of 0 is

one. So I'll just add that in. And now we've uh done the exact task that we we we said was the difficult part, which is

expressing our target number of 13 as a sum of various powers of two. So now let's go ahead and uh I should have

demarcated this with a base 10. So you know I'm working with the decimal number. Let's go ahead and and bring

this out to the expanded form where we add in the ones and zeros and the missing powers of two. So we would know

we have 1 * 2 ^ 3 + 1 * 2 ^ of 2. We don't have any term with 2 ^ of 1. So we multiply it by zero. So it doesn't

actually add anything. And then lastly we do have 2 to the^ of zero. So we will put a one there. And from there, it's

pretty easy. We just read left to right what the coefficients are. And we have uh our binary equivalent. So 13, the

decimal version of 13, the number that you and I know is 13 is equal to 1101 in binary. And you can expand this out,

which is kind of what we have right here to prove that in fact uh I am not lying to you. It is 13. So let's try one more

example of that just because I think it's a little complicated. Um, let's go ahead and do uh let's say 22. I

just picked it off the top of my head. Hopefully it works out to be somewhat pretty. Um, so we have to find the uh

the sums of powers of two again. And I'm going to go a little bit faster this time. So I'm just going to look at our

list and I can see that 16 is the biggest value here that is is less than or equal to 22. So I know we have a two

to the four here and let's keep things easy. So, I have 22 = 16 + uh we know we're going to need something else cuz

the left hand side does not equal the right hand side. And 22 - 16 is 6. So, we're trying to get a six now. Um, and

four is the next candidate here in terms of largest power of two that doesn't exceed our target of six. So, I'll add a

two squared into our sum and that's going to be equal to four. And now we have 22 on the left hand side and 20 on

the right hand side. So all we need is to get two uh to our expression. And that's easy. We know 2 to the^ of 1 is

just two. And now we know that the 22 is equal to 22. So we've we've con we can convince ourselves that this uh

left-hand expression here is equal to the right hand side of the expression. And so then what we can do is we can go

ahead and write this out in the expanded form which you should be comfortable with now hopefully or it should at least

be becoming apparent to you. And that's equal to 1 * 2 ^ 4. There's no 2 3. So we just write a zero as the coefficient

because it multiplies away. Uh and that's because anything multiplied by 0ero is just zero. So this this term we

just added contributes nothing to our sum. And then we have a 2 ^2. So we'll add the 2^2 in. And we have a 2 to the^

of 1. And we do not have a 2 to the^ of 0. But we need to go all the way down from the largest power of two, which is

four, all the way down to zero. So we stop like this. And then we can we can take these coefficients and just read

them left to right. So that's 1 0 1 1 0. And that means that 22 in decimal is equal to the binary number 1 0 1 1 0.

Cool. So, you've now uh gotten a pretty high level but also complete understanding of

what binary is. I've shown you how to take a binary number, convert it to decimal so you can make sense of it and

also how to take a decimal number and convert it to binary. And there is one final thing that we will want to do and

be able to understand about binary numbers and that is how do we add them? And I talked a little bit about this

earlier when we we talked about decimal, but let's go ahead and and recall our decimal example. Let's say I have 74 +

39. Well, we keep we start at the rightmost digit position and we keep adding the

values in the corresponding digit position. So, we'd add this 49 together and we'd write the sum of them below.

So, let me actually pick a better example. Uh let's do uh 782 plus um 531.

So in our example, we'd start with this rightmost digit position. And we just know 2+ 1 is 3. So we write it down

here. And we move on to the next digit position, which is 8 + 3. And 8 + 3 is 11. Which you should remember this means

we have carryover. So we put the remainder, which is 1, down here. And then we carry over a one up here. And

then now when we get to the next digit position, we add 7 + 5 which is 12. But we also have to factor in this carryover

which makes it 13. And that's exactly what we do. So for decimal, what we did is we started at the rightmost digit

position and for each digit position, we added the corresponding numbers for a and b. If I'm letting this be A and this

be B, our two operands, and I'm going from right to left until we've added all of the digit positions together, and you

have your sum. And it turns out binary is going to be exactly identical to this. So, um let's

see, we have our 22 and we also learned that uh let's take 22 and add uh another random number to it and see what the

result is. So, I'm going to take 22, which we know is 1 0 1 1 0. And let me pick another number. Uh, so we don't

have to reconvince ourselves that this is true. Um, and I'm going to come all the way back up here. And we said that,

uh, 1 0 0 1 is equal to 9. So, let's do this. 1 0 0 1 is equal to 9. So, intuitively, we're adding 22 + 9. And

these are both the decimal numbers we're so comfortable with. We know that's equal to 31. Uh and you know, maybe you

have to to verify that yourself, but you can use your calculator here. Um so we're going to start right to left. And

before I start this, you might have a quick question. And that's uh the two operands we have, this a and b, this 22

and 9, do not have the same number of digit positions. So what do we do here? And there's something beautiful you

learn that carries over and is just as true now. So let's go back to our decimal word for our decimal world for a

second. And if I gave you the number 762 arbitrarily chosen, then you know that this is equal to the same number as

0762, which is equal to the same number as 00762.

And more generally, uh any amount of zeros before our number are equal to the original number. And that's because we

just ignore ignore any leading zeros. And why is this uh why can we do this if that's not clear? Um and that's because

if we expand this 762 in our exponent way, we know we have 7 * 10 2 power + 6 * 10 1st power + 2 * 10 to the 0 power.

And if we add any number of twos, all we're doing is adding 0 * 10 to some increasing power. And we already

discussed why 0 * any number is equal to zero. So this 0 * 10 the cubed is just going to drop out. And if we had the

same thing again where we had a 0 * 10 4, that's just going to drop out. So any amount of leading zeros actually has no

impact on the total value of our number. And so what I'm trying to get at and took a long way of explaining is that

you're able to add number you're able to add zeros to the start of a number without changing its value. So what I'm

going to say in binary is that if we have this number in binary, it's going to be the equivalent of this number in

binary where we add one one or one zero. Or we could add any number of zeros and it's going to be the equivalent

value in binary. So, I'm just going to go ahead and take that logic and make our two operants in this addition

problem uh have the same number of digit positions. Just like that, I added a zero to the front of our number, but did

that does not change the uh numerical interpretation of that value. So,

going to take a sip of water here. Let's go ahead and add these two numbers together then. So we have a 0 and a 1,

which 0 + 1 is 1. And then we have 1 plus 0, which is 1. 1 + 0, which is 1. 1 + 0, which is 1. And 1 plus 0, which is

1. Um, and this is not that interesting. Uh, we didn't actually see carryover, so I kind of picked a bad example in

hindsight, but we'll do another. Don't worry. Um I am going to claim that this number in binary plus this number in

binary equals this number in binary. Um and our if we did everything right, we should hope that this number is actually

equal to 31. So let's go ahead and uh convince ourselves that that's the case. So uh we start with 2 ^ of 0 1 2 3 4. So

we have 1 * 2 ^ 4 + 1 * 2 ^ of 3 + 1 * 2 ^ of 2 + 1 * 2 1st power + 1 * 2 to the zero power. And that's cuz we have one

in all these digit positions which is just equal to 2 4 which is 16 + 8 + 4 + 2 + 1. And 16 + 8 is 24 + 4 is 28 + 2 is

30 + 1 is 31. And uh sure enough this is the exact result we were expecting. Um but what if I wanted to give a more

nuanced example uh one where we had carryover. Well um let's do exactly that. Let's go ahead and do 101

plus one one. Um, and I will go ahead and spill this out for you that this is uh five

plus 7. Um, and we would hope that the result is then 12. And it'd be a good exercise

for you probably to pause this video and convince yourself that those two numbers are uh five and seven. But uh we we need

not do that for the sake of time. So, uh, we add this 1 + 1 and we may be convinced to write a two down here cuz,

you know, there's no, it doesn't sum the more than 10. We don't carry over. But remember, in in binary, we only have

zeros and ones to work with. So, versus decimal where we carry over when we're going from 9 back to to zero to 10. Uh,

in binary, we carry over uh when we're going from one to two, i.e. we roll it back to a zero. So, we put this

remainder down here. um we put a zero down below and then and then carry a one over and now we have 1 plus zero which

is one but we have another one that we have to add the carryover and we're at two and we have the same issue as

before. So we put the the carryover we put a zero below and then carry over once again. Um

>> and now we have 1 plus 1 + 1 which is three. And we're going to go ahead and it's it's interesting. We we put the

remainder uh when we modulo by two. So 3 / 2, the remainder is just then a one and then we carry over a one here. And

uh this is our final result. And uh this is actually equal to the bi to the uh number 12. You can verify this yourself

for it to be true. So basically when we're adding binary numbers, if we have a zero and a one in a position, it

becomes zero. If we have a one and a zero in a position, sorry, I misspoke. If we have a zero and a one, it's a one.

A one and a zero, it's a one. A zero and a zero sums to a zero. And then if you have a one and a one, we know this is

binary two. And so that means we put a zero over here because the two divided by two, there's no remainder. And so we

just carry over a one. And then the uh interesting case that we can't generalize from the remainder of these

is if we have a one and a one and a one and that means we have three and we know that the binary representation of three

is one one but what we do uh to get that if you don't understand is uh we have the three we take the remainder when you

divide it by two 3id two has a remainder of one so we put the one below and then we uh carry over the extra one and uh

these are kind of the four patterns you need to understand um when you're adding binary numbers.

Awesome. Um and this is now uh has become clear how you can take binary numbers and convert between decimal

either binary to decimal or decimal to binary and how you can add binary numbers together. Okay. So now you have

uh learned all but one of the fundamental tricks of binary. So, we learn how to go from decimal to binary.

Then we learn how to go from binary to decimal. And then we learn how to add binary.

But we have yet to learn how to subtract binary. And that is the last thing we need to do

before we have mastered binary. So what we would like to understand is how can we subtract two numbers in

binary and it does follow a very similar process to the subtraction that we know. But it turns out there's a better way to

do it. But before we can even look at subtraction, you may have another question that you wondered at some

point. And that's how do we represent negative numbers? And there is a multitude of ways for us

to represent negative numbers, but the one we're going to go with is a very popular one called TW's complement.

[snorts] And what this is is a very simple rule where all you do is interpret the leftmost digit in your

binary number to have a negative waiting. Now, this is confusing and it's going to require some

digestion, but what we need to agree on now uh is how many digits each of our binary

numbers are going to have. So, in decimal we have uh say the number 7 or it could be 656

or 10,432 and this has one digit, this has three digits and this has five digits. And we

also saw some binary examples. uh we had 1 one which we saw was three and that's two digits and we had something more

complicated uh where we could have like a 1 0 1 0 1 and that's going to be five digits. Um so binary and decimal have

this property in common where you could represent a number and it could take any number of digits to represent that

number. Um for two's complement it gets a little tricky with this variable notation. So, we actually want to agree

on a fixed width for every number. And this may seem like a restriction, and it is. Um, computers uh aren't able just to

arbitrarily represent any digit of any length. Um, and this is one of the design choices that will become more

apparent why that's the case as we design our computer. But for now uh what I would like to do is let's just make

this assumption or write this on the screen that every number in binary. So every binary number

uh shall use four digits. So if our number that we're trying to

represent in binary is less than four digits then we just pad it with zeros. Okay, that's easy. Uh, but what if we

have a number that we want to represent that's more than five digits? We saw some examples earlier. Sorry, more than

four digits. Um, we saw some examples of these numbers earlier and we're actually just going to say our computer is unable

to represent them. We have a upper bound uh on the range of values we can represent. Um, and that's true. If if in

decimal I said you can only use three digits. um then the largest number you could represent is 999 and the smallest

you could represent is zero and that means there's actually 1,000 distinct values you can represent in this range.

Um, and we're going to make the same restriction on binary. And I'm going to

start this off with four. Uh, just so we can learn how to do this choose complement. And it turns out in our

computer, uh, we're going to use eight. In our computer, we're going to restrict every number in binary that we represent

to be exactly eight digits. And this is just one of many design choices that a uh, implementer of a computer has at

their liberty. So, more modern computers, you may have heard of 32bit or 64-bit computers. Um, those are two

very popular representations. Uh, and that is kind of the same rule. If you've heard those numbers before, what that

means is internally that computer is you can say representing every number is exactly either 32 or 64 bits. Um, you

may be wondering, hey, this is kind of a a pretty tight restriction. Like with four binary digits, we can't represent

that many numbers. Um, and it's true. With 32 or 64, however, you are able to represent very large numbers and numbers

larger than most people need to represent for computational purposes. And there are actually uh techniques

that we can use to get around this to represent even larger numbers. Um, but those are uh implemented at a higher

level. So I'm not going to say that each binary number shall use four digits. Um so uh we can't represent the number in

our scheme 1 011 cuz that's five digits. Um cool. So I uh said uh we have this number one 011 and we know this is equal

to let's just I picked this number out of nowhere. It's a four-digit binary number. We can expand this out as 1 * 2

^ of 3 + 0 * 2 ^ of 2 + 1 * 2 ^ of 1 + 1 plus sorry 1 * 2 ^ of 0 and what 2's complement says is we take the most

significant digit position i.e. the left one and its weight is multiplied by negative one. So now instead of this

being a positive 2 cubed, instead of this digit having weight 8, it's actually going to have weightg.

So what this means is we have uh this -1 * whatever is inside our representation of that digit position. Um + 0 * 2^ 2 +

1 * 2 ^ of 1 + 1 * 2 ^ of 0. And so that means that we have8 + 0 + 2 + 1. And that means we have -8 +

2 + 1. Sorry, I don't know why I wrote a six. And that's going to be equal to -5. Um, and this is should be a little bit

confusing because you're you should be wondering, hey, why isn't this equal to 11? And why did we choose it to be like

this? Um so those are two loaded questions. So I want to make sure understand first is how we can interpret

numbers in two's complement. Um and that is that this uh most significant digit position is going to have weight

negative uh negative value. And this actually means that uh for our four-digit values, whenever we have a

one in this most significant digit position, the leftmost one, our number is going to be negative. Um cuz this has

the most weight and uh these all have less weight than it. So as long as this one's this leftmost digits a one, that

means our number is negative. Um and then similarly if that's a zero then we have the original logic before uh where

we're adding sums of weights of twos that are multiplied by either one or zero and so that means the number must

be positive. Um so let's do one more example. Uh let's say I had one one one. So we have

- 1 for this leftmost digit position time 2 ^ of 3 and then we have + 2^2 + 2 the 1 + 2 0 and so that is -8 + 4 + 2 +

1 and that's going to be equal to uh -1 if we sum these all up. And so this is interesting because you know in in what

we learned about less than an hour ago we had uh this would be equal to uh 8 + 4 which is 12 + 2 which is 14 + 1 which

is 15. Uh this should be 15 but now it's negative 1. And that's a little bit confusing. Um but this is actually how

we're going to build our computer. So you should make sure this is clear to you. This isn't something I would

recommend skipping over. uh our computer is going to use two's complement which is the exact binary we just learned with

this one caveat that uh any weighted value i.e. The leftmost digit position has weight negative and

this lets us represent negative numbers. Uh we just saw how to represent negative one. Now so what I'd like to show next

uh well I will tell you that addition works out the exact same. So let's say I had -1 and I want to add -2. So uh if I

wanted to or let's say we have uh -5 and negative 1 and we want to add those together then we have -5 + -1 which is

equal to -6 and we know these binary representations are 1 0 1 1 and then 1 one1. So we can do the same arithmetic

as before. So 1 + 1 we put a zero below and carry a one over here. Then 11 one one we have a one below and a one

carries over. And then one 0 one we have a zero below and a one carries over. And uh then we have 111 which is you know

just three 1. Um and we've kind of made a interesting remark. Uh let's go ahead and ignore

this leftmost digit position because we said we're only working with four bit values now. Fourdigit values. And let's

figure out what 1 0 1 0 in two's complement binary equals. And that's going to be equal -2 ^ 3 plus we skip 2

^ of two. We do have 2 the^ of 1 and we skip 2 to the^ of 0. And that's going to be equal to8 + 2 which is just equal to

-6. And so that's that's that's beautiful. We had a -5 here ag -1. We added them together and we still got the

-6. This does mean however that there are uh some binary values that fit in four

digits but this if we add them together it can't actually fit in four digits. So let's let's let's look at an example of

that. Let's say I have the binary number 011 1 and I will tell you that this is 1 + 2 + 4 which is 7. So we're doing 7 + 7

and we would expect 14 to come out. So let's do the arithmetic. 11 1 is zero. 11 one is one with a carryover. 11 one

is one with a carryover. And then 1 0 0 is just one. Um and this should equal 14. But if we

actually expand this out, uh we well we already know there's some danger because this leftmost bit is this leftmost digit

is a one. Which means as I said earlier that the number is actually negative. We know this can't be the case because 14's

positive. But let's go ahead and and expand it out. Uh we have -2 cubed + 2^ 2 + 2 1 and that's -8 + 4 + 2

and that's going to be equal to -2 which is not equal to 14. So I'm going to take a sip of water

here. This is interesting. Because we have this two's complement

rule, there are actually ranges of the values we can represent in terms of four binary digits

and it's just a limitation and it's something we're have to be careful of when we're designing our computer. Our

computer which I said will operate on 8bit values, eightdigit binary values. If we add two numbers that individually

may be able to be represented in eight digits, uh it's possible their sums not able to be represented in eight digits.

And we have this issue and this is called overflowing computers. You may have heard of it before. Um but it it

means that we can't represent a number in the number of digit positions that we have. And that's just something to be

aware of. um I will try ignore all of those cases and and hide things away so that we we don't have to worry about it

because I don't want to get too technical here. But uh I just wanted to make it something that we aware of. And

then there's one other really interesting uh property of two's complement and that is to negate a

number. So uh in in in decimal it's easy. If we have 10 and we want to negate it, we

just write -10. And if we have -6 and and we want to negate it, we just write six. And it's easy because we just have

this negative sign that we can just throw in front of our number. And we are learning that you can't do the same in

binary. There is no just negative sign we can throw on cuz we don't have a negative sign. All we have is zeros and

ones to work with. And I mean that literally. So there is a really cool property. You

do not need to understand why this works, but it turns out to negate a number, you invert you invert

all the digit positions and then you add one to the result. So, uh let's come up here. Um we had

seven which we know is is actually let's pick let's pick this example 1 0 1 0 we know is -6. So -6 in in decimal is 1 0 1

0 uh in this two's complement. And uh we want to figure out what the negated value is we know it's six but how do we

get that now? And what I'm saying is step one is you invert all the digit positions. So your ones become zeros and

your zeros become ones. So we end up with one becomes 0, a 0 becomes a 1, a one becomes a zero, and a zero becomes a

one and then we add one to the result. So we have 0 1 0 1 and we just add one. And this is the binary addition we

already learned how to do. So we know a one and a one is a zero with a carryover. And then we have 1 0 0 which

is 1, 1 0 which is 1 and 0 0 which is 0. And this should be the negation of this. And we know this is equal to -6. So this

should equal six. And let's go ahead and see if that's true. We have 2 to the^ of two, 2 to the^ of 1, and then nothing

for 2 to the^ of 0, uh, which is 4 + 2, which is six. And so that's that's really cool. Um, so I showed you how to

negate a number in two's complement. But but why did I do that? And that's because if I scrolled back up, uh, I

said we learned how to do addition in binary, but we did not learn how to do subtraction. How can I do a? We know how

to do a plus b. And how do I do a minus b? Interesting question. And uh it turns out you already know how to do it based

on what I just showed you. Because a minus b is equal to a + b. And I know how to I showed you how to

negate a number. I showed you how to take some b and make it negative b. And then I already showed you how to add two

numbers together. So, it turns out you actually do know how to subtract. Um, and this is pretty powerful. So, let's

say I wanted to do 6 minus 2. Well, we know that six in decimal is equal to 0 1 1 0 in our two's complent binary and two

um in in in uh decimal I will go ahead and just tell you is this number right here. So, I

want to do 6 minus 2. And to do that, I'm going to do 6 + -2. So the first we need to do is is is what is -2 uh in in

binary. And so what we do is we take our representation of two. The first thing we do, I'm going to scroll up here. We

invert all the digit positions. And then we add one. So 0 0 1 0 becomes 1 1 0 1. And then we add one to it. And we are

left with 1 1 0. And you can convince yourself this is true, but I'm not going to for

the sake of time. And then what we want to do is 6 to get 6 - 2. Uh, I'll write this out. We want 6 - 2. Uh, we're going

to do 6 + -2. And we now have 6. And we now have -2. And we know how to add. So we'll just add them. So we'll do 0 1 1 0

+ 1 1 0. And let's go ahead and add. And so that's zero here, a zero here, a one with a carryover, and a zero with a

carryover. But we said we were working with fourdigit positions. We just look at the four that we have, and we would

hope that this number is equal to four. And it turns out this is this is it because it is uh we have 2 the^ of 0, 2

the^ of 1, and 2 the^ of 2. We just have a 2 to the^ of two, which is 2 * 2, which you should know is four by now. So

you uh and I know we just went a little quickly and I only gave one example. The website I will link uh I will link a

website below that I've written and it has more examples and is written with a little bit more detail. So if any of

this is confusing to you uh you can just go to that website and get a more complete understanding and some examples

may help work out the gaps. So now uh up to this point let's recap what we've learned. We have learned uh how to well

first off we recaped decimal but I'm not going to include that because intuitively you already knew that we

learned how to go from decimal to binary. We learned how to go from binary to

decimal and we actually did that first. We learned how to negate. We learned two's complement. So how do we represent

negative numbers? We then learned how to add binary numbers.

And lastly, we learned how a a little trick that lets us subtract binary numbers.

And this is all you need to know about how computers represent numbers. So even if you stop watching this video right

now, you have walked away with a a very interesting uh lesson. And that is how do computers represent numbers? And you

may not understand why it needs to be done like this yet because we haven't got any further. But at least you

understand what's happening under the hood. And when you type in uh when you're typing in 5 + 7 to your

calculator, it's not doing 5 + 7. It's doing uh 1 0 1 plus some other binary string. And it's pretty interesting. Um,

so if you've made it this far, you have learned what in my subjective opinion I would say is one of the two most

difficult components of this video. Uh, I think understanding this binary representation is very difficult and

we're going to come back eventually and there's going to be one other really difficult concept uh, which is how we

can store memory on computers. Um, and I think if you can power through both of those, then you will have a full

understanding. And I think everything else in this video will be easier than those two topics. So, even though we're

not halfway done with this video, metaphorically and in terms of difficulty, I would argue we are halfway

through the difficulty. So, what we're going to do next is learn about something called a logic gate.

And, uh, it's going to have nothing to do with what we just did. what I just did. I'm gonna ask that you mentally

push aside and then we're immediately going to bring it back together. Uh and and and so I'm I've taught you binary.

I'm now going to teach you something called logicates which are independent of binary. And then we're going to bring

it together and see how these two topics relate. Okay? So I'm going to ask that you

mentally put everything that we just did aside in your head. Ignore it all. and we're going to learn a new concept and

it's going to seem a little bit familiar as it probably should and you'll see why they are familiar and similar in nature.

But don't worry, uh, what we just learned is not going to be abandoned. Binary, I didn't put that in there just

to torture you. I put that in because it's going to be a very real concept that is almost fundamental to the

entirety of this video. and we're going to tie these things called logic gates back together with

binary afterwards. So, let's go ahead and uh see what a logic gate is. And I actually think that you may find uh the

content in this section pretty interesting. Not to say binary is uninteresting. I just think that the

majority of people will find it a little bit tedious or boring the more specific you go into it. Let us start with the

first logic gate which is called the AND gate and it looks like this.

Uh I will zoom in and draw this a little bit better. So we will say we have a and b and then we will say the outputs y. So

a logic gate takes in two inputs and puts out an output this and gate specifically. So what I will say is that

the output y is a function of a and b. And please do not let this scare you if it's giving

you uh PTSD to your high school algebra classes. It's not as difficult as it seems. And we're also going to add this

rule that a is either a zero or a is equal to one. And we're going to do the same thing for b. B is going to be

either a zero or it's going to be equal to one. And we're going to do the same thing for Y.

Y will either be a zero or it will be a one. So our function here Y is a function. Y will be the output of this

gate and its inputs to the gate are going to be A and B. So whatever A and B are will determine what Y is. and a and

b can only be either zero or one. So there's not that many combinations. So there's two values that we have that are

inputs to this function. And there's two different values that each of those inputs could have. So we're actually

going to we could build out a table to represent each of the inputs and look at what the output's going to be. So I'm

going to uh erase this and make this truth table. So we have a and b as our inputs and then I'll add

this column for y which is the output. So uh our our four different possible cases are a and b are both zero. Maybe a

is a one and b is a zero. Maybe a is a zero but b is a one. Or maybe they're both ones. And and this is uh this is

all the possible input combinations there are. If you don't believe me, please try invent another one and I

guarantee that you will not be able to do so. Now, I'm just going to tell you what the

ANDgate does. Uh, you may have guessed, but it outputs a one if both of the inputs are one and otherwise it outputs

a zero. So, it's an ANDgate because we say it outputs one if A and B are one. Otherwise, it's going to output a zero.

So in our example here, when a and b are both ones, y is going to be equal to one. And in any other case, y is going

to be equal to zero. And that's because the definition of an andgate is that it only outputs one if

both of the inputs are one. Okay, congratulations. You've learned your first logic gate. We've learned

that logic gates take in a a certain number of inputs, but they will always only output one number. I'll tell you

that now. We're going to look at other logicates. Some may take in two inputs, some may only take in one input, but

they're always only going to output one value. And that one value is going to always be determined strictly based the

inputs. So us having an A set to one and B set to one means Y will always be set to one for an ANDgate. And this property

is what we call determinism. And it's a scary sounding word, but to be deterministic, it means that the

output y is is strictly dependent and can be determined based on the value of the inputs a and b. Um, and that's just

a word that if you curiously read around online, you will probably come across. So, I thought it was worth mentioning.

Let's go ahead and look at some more other logic gates that we have. We have the ANDgate. Now, let's go ahead and

look at the ORgate. So the orgate looks like this. We have our two inputs still.

We have a b and y. Uh and it looks different because it has this little curvature on the inside. Uh but this is

a orgate. So let's do the same thing as before. Uh let's build this truth table out.

And we have the same uh same conditions that our inputs and outputs are all binary. I.e. either either zeros or

ones. So this table will be the exact same before up till now. And I will tell you

that the orgate uh you should hopefully be able to guess the andgate outputs one if a if and a and b are both one i.e

both of its inputs are one. The orgate is going to output a one as long as either of its inputs are one. So if a or

b is a one then we're going to output a one. So uh this is going to happen not in our first case. Neither of the inputs

are one. So we output nothing. We output a zero. In the remainder of the cases at least a or b one of them if not both is

a one. So that's alga output a one. And it doesn't require there's nothing wrong with both of them being one. It

just says as long as either of them is a one I will output a one. And that's what the orgate does.

Now we're going to look at the exclusive orgate. And this is called XOR. Exor exclusive or. And it looks like our

orgate, but it has this extra line. And this is going to be the exclusive ORgate. And what this one's going to do

is it's going to output one as long as either A or B is a one. but is with the added condition that both of them can't

be a one. So if A and B are both one, then it's going to output a zero. But if just one of them is a one, then it'll

output a one. So let's draw this truth table out. 0 0 1 0 0 1. And it doesn't really

matter for a truth table what order we put everything in as long as we have all the cases. So AB both zero there. It

means there's no neither of them are zero. So we up a zero. Then a is one and b is zero. So uh either of them is one

but not both of them. So it's a one. And the same can be said for the next case. But in this final case, a and b are both

one. So we say that the output's going to be a zero cuz it has to be exclusive. Either one one of them can be a one but

not both of them. And this is called the uh exclusive orgate. So in English this may translate to exactly one of a or b

is equal to one. And what you're going to kind of see here uh and I've kind of intuitively

hinted it but I'm going to now make it more explicit is that a lot of times we will interpret a zero to be false and a

one to be truthful. Um so we can kind of give some of these values use these truth truth values if you could say. So

if I looked at the output of some logic gate um then if it's a one the output of that gate is saying true. So the

condition based on the inputs is being met. And if it's a zero it means the condition is not being met. So the

output's false. Um and that's just just something worth putting out there. So we've seen the ANDgate, the OR gate, the

exclusive orgate. Let's do a different type of gate and this is going to be called the inverter gate.

And this is interesting because it only has one input. So I mentioned this earlier. I said logic gates have a

variable number of inputs but always only have one output. And that's exactly what we have here. So our truth table uh

this is the knockgate. And all the knockgate does is just invert its input. So if you throw in a zero, it's going to

output a one. And if you throw in a one, it's going to output a zero. So let's go ahead and build a truth table for this.

Well, this is easy. The A can either be zero or one. And then we just invert its value. So if we throw in a zero, we get

out a one. And if we throw in a one, we get out a zero. And this is how the inverter gate works.

So we've seen four gates and there's one other gate we should discuss and this gate is going to be a little bit

interesting because it has a a pretty unique feature about it. And this is going to be called the NAND

gate. So it is the output of the NAND of the and AND gate negated. So it means not

and so as long as not A and B are both one, this is going to output a one. So it's literally going to be the opposite

of our ANDgate. Our ANDgate only outputs one if A and B are both set to one. But our NANDgate is going to ensure it's

going to output one. It's going to tell you if not A and B are both set to one. So, our NANDgate looks like our ANDgate,

but it has this little circle afterwards, and it's going to take in our our same two familiar inputs. I'm

also just arbitrarily calling these A and B. They can be called whatever. And in fact, when you see these logic,

they're usually not labeled letters. I'm just trying to make it clear that we have our our inputs on the left and then

our output on the right. Um, and that's what you should really capture here. So, let's build our truth table. We have A,

B, and Y. And we are going to say this means not and so we will out output a one as long

as the condition met. And the condition is that not both A and B are one. So that happens in our first three cases

and not the last case. In the last case, A and B are both one. Um which means that A and B is true. But we want the

negated version of that. we we we say not A and B. Uh so we output at zero. So there's this really interesting

thing. I'm going to make two pretty shocking claims. So the first is we can build our entire computer out of these

logic gates right here. The computer we're going to design is with one very minor exception is going to be built

entirely out of logic gates. We are going to be able to build storage using logic gates. We're going to be able to

add numbers with logic gates, subtract them, and do everything that a CPU can. It turns out your computer that you're

watching this on is is generally speaking built out of just logic gates. The one exception uh for our computer is

going to be this thing called the clock, which will just synchronize everything. Our clock is just going to alternate

between 0 and one at a fixed pace. And every other component in our computer is going to look at that clock to know what

time it is. Generally speaking, the clock's not going to be built with logic gates. And we're actually not

going to study how the clock is built cuz it's going to be built out of electricity. But, uh, logic gates, uh,

back to the claim, can can be used to build our entire computer. So, we're going to take these very, very simple

logic gates and we can chain them together as in the output of one can become the input of another and we can

build these very complicated circuits. And and the the goal of this video is to build a circuit that's complicated

enough to to be an entire computer. And this sounds like a crazy ambitious goal, but it's it's really cool. And this was

one of the most fascinating things for me when I learned this is that we can build an entire computer out of some

logic gate, which seems pretty trivial. And I'm going to make another claim. I'm not going to back this one up, but it

turns out that this nan gate right here, it's called the universal gate. And any of these other logicates can be

built out of nan gates uh chained together. And we're going to see what chain together means shortly. But what

that means, if you can take that to be the truth, is that you can actually build an entire computer just out of

NAND gates, which is crazy. And that is uh to my understanding actually how most computers are implemented. You have just

have a lot of nan gates. And how are we going to build a computer out of chains together? Uh well, I kind

of mentioned this earlier when we were discussing binary. I said in computers, we either have electricity on a wire or

we don't. If we have no electricity on a wire, we'll treat that as a zero. And if we do have electricity on that wire,

we're going to treat that as a one. And these these these logicates can be built physically. We're not going to see how

they're built physically because that also deals with electricity which I'm not well equipped to teach you about

because I barely understand myself. But uh we can understand at at a level at a higher level that will just treat the

presence of electricity as a one in the absence of it as a zero and build these these these uh logic gates together and

chain them together in such a way that if we did have real electricity and a way of building these logic gates both

of which we do uh it could it could run an entire computer and that's actually something I've done. I've built the

computer that we're going to study uh with wires in the logic gates that you can buy online. And that's something I

hope to demonstrate later on in this video. But let's get back to our goal here cuz I've I've made this crazy claim

that we're going to build an entire computer out of Logicate. So I that's going to be what the next uh next big

segment of this video is about. How do we actually go about doing this? Um, and to do that, I want to start by

explaining how we can chain these logic gates together. So, let's explain how we could we could build a NANDgate by

chaining two of the other logic gates we have together. So, uh, as a reminder, the NANDgate just takes whatever the

output of the ANDgate is and inverts it. It negates it. So, if the ANDgate outputs a one, then we we output a zero.

And if it if the ANDgate outputs a a zero, we should output a one. And uh if if I asked you which two gates

we could combine um the answer would be we could combine an AND gate and a inverter gate together to build this

circuit out. So let's go ahead and see uh what this does. I will spill the answer for you and then we will we will

verify that things are true. So I'm going to take our A and B which are our inputs. I'm going to feed them into this

and ANDgate. And then I'm going to feed the output of that and AND gate into a notgate. This gate that we saw down

here. And then I'm going to let that be the output Y. And so I have this circuit. And this is this is pretty big.

What we just did is we we took the output of one gate and fed it in as the input of another gate. And it's it's a

small example, but we're we're going to see more complicated ones very quickly. So let's go ahead and convince ourselves

that this is actually equivalent to our NAND gate from over here. And the way we can do that is we can build a truth

table uh for what we have here. And what we have here is called a circuit. A circuit is what happens when you chain

logic gates together. And by chaining logic gates together, we can provide we can build circuits that accomplish more

interesting things. So these are these these these uh logic gates on their own don't do very much but by chaining them

together we could actually have them do really interesting things. Uh and I mean the end goal is chaining them together

in such a way that we build an entire computer. Uh and that is totally possible as I will try to convince you

over the next few hours. So let's go ahead and build out our truth table. We have two inputs and one output.

And let us see uh we know our our output cases are as follows. I'll change up the order here a little bit for the second

and third rows. So when a and b are both zero, well we have a is zero here, a zero here. 0 and 0 is zero cuz not both

of them are one. And then we invert it and uh produce a one. So we end up with a one as the output of our our circuit

when the inputs are both zero and zero. And and let me change color here just so it's easier to follow. Then let's

suppose we have zero and one. Then the endgate's still going to output a zero because not both the inputs are one. But

when we invert it, it becomes a one. So uh this is a one here. And if I flip this uh if I say that B is going to if A

is going to be sorry I did that backwards actually. Um, I showed you, let's see, I showed you 0 1. Oh, no, no,

I did that correctly. Now I'm going to show you one zero. And we know the output of the endgate is going to be

unaffected. It's still going to be a zero. But then when we invert it, it becomes a one. And lastly, uh, if we

have a one and a one, then what happens is our AND gate outputs a one, but when we invert it, it becomes a zero. And so

we we have this truth table right here. And I'm going to replace this with white now

that we're done drawing. What we would expect is that if this circuit is equal to the nan gate, then

the truth table should be identical. And if I scroll out, we can see that the truth tables are identical. Uh you can

compare each of the four rows against each other. Um I know I've swapped the order of the middle two, which I

shouldn't have in hindsight cuz it's a little confusing now. Uh, but I was trying to illustrate the point that the

truth table doesn't matter what order the inputs are in as long as you cover all the possible inputs. Um, but in

general, I've shown you how to build a circuit by chaining logic gates together and that you can verify that two

circuits are equal by showing that their truth tables are identical for every pair of input combinations.

So this function, this circuit is a function of A and B and it's going to equal Y. And so is our NANDgate. And it

turns out they're actually they're the same function um because they always equal the same value. And so this is

this is pretty interesting. And uh we could every time we we could avoid using the nan gate just by by drawing this.

But it turns out that we use a nan gate enough where we we want to give it its own gate. um because it it kind of when

we have these big circuits that chain a lot together, it it becomes a little bit more convenient to have uh simplified

ways to represent things we use frequently. And we will see this later on. We'll design some interesting

circuits and then we will just uh demark them as a new type of of of gate or maybe we'll say uh a triangle represents

this circuit underneath the hood. Um but but don't think about that now. That's something that uh is more of a future

concern. Let's try another circuit. So you've seen um a circuit now that has two inputs and

one output. And so for logic gates, I I made a claim. I said a logic gate has uh at least one input

and it always has exactly one output. A circuit has at least one input, but it may have multiple outputs. And

we'll see this later um when we actually try to build more meaningful circuits. Let's try build something uh and let me

draw a circuit and then we will build a truth table for it and and analyze that truth table and see if we can derive

some meaning for that circuit. Okay, this is our circuit. I'm going to take a sip of water while you look at

that. And I would like you to notice that there's three inputs. and one output. And uh we have a

inverter a notgate right here. Then we have two ANDgates over here. And then we have an OR gate over here.

That's just because uh you know it may actually be useful to screenshot this as you follow along or just you can Google

logic circuits and it'll be there. It's also in the website I have linked below. Um but we have a a circuit now and uh

this may seem like a random circuit but it actually does something a little bit interesting. Um so [snorts] I will spoil

the fun and say that this is a selector circuit. So if you put some value of A and B uh put some values in A and B then

C serves as a selector where if C is zero then the output so I'll write this out. If C is zero, then

Y is going to equal to A. And if C is one, then Y will equal B. So C effectively

controls what flows through as the output of this. So I'm going to move this over here. And let's verify this by

building a truth table for our circuit. So this truth table is going to be a little bit longer. There's actually

gonna be eight different values we can pass in. Um, so I'm going to come here. We have eight different values we can

pass in. Our output's still y. And uh, I will write out all the eight values. Uh, it may be interesting to you where I'm

getting these values from. Uh, but you you need not worry about it. Um, I'm just you'll get more comfortable

enumerating all these values out the more you do do it on your own. Um, it's getting a little messy because I

have not the best handwriting. Um, okay. So, uh, believe me, please when I say that these are all the possible

values of A, B, and C. If you do not believe me that I challenge you to pause this and try to generate a a

new uh combination of A, B, and C that's not in this table. And if you're curious where this this comes from, why how do I

know how many are in how many different values there are? Well, if we're looking at A, B, and C stacked next to each

other, um they're all either they're binary values. They're binary digits. So, there's two different values that

can go into each of these digit positions. And so I multiply the different possibilities together to

figure out the total number of combinations. So in that case there's eight. Uh and that's because um for each

of the position we can either choose a zero or one uh 01. And then we multiply that by the number of ways there are to

pick out the remaining digits. Um and we can apply this process over and over. Um,

but I'm not going to get into that cuz I think it's a little mathy and uh that's actually a study of combinotaurics,

which is probably a little too uh technical for what we're getting into today. But let's go ahead and trace

through this. So, I'm going to switch my pen back to red and I'm going to make it a little bit bigger here so it's more

readable. Our first example um I'm going to zoom out here is I'm saying if A and B are both zero and

my claim is that if C is zero which or C is one then our output should be B which is zero in this case. Um but it's a

little hard to distinguish because they're actually both zero. But let's let's verify that it's not one for sure

and that'll have you partially convinced. So, uh, what we do right here, um, is we have C, which is one.

And so, that means that we invert it. It's going to be a zero here, and it's going to be a one here. And then we have

these carried through from our our original logic gates. And so, for the first gate, we know 0 and 0 is zero. And

0 and one for the second logic gate, still zero. And so, we have two zeros flowing into an orgate, which means the

output is zero. Um, so we traced through the circuit and we our claim is verified so far. Uh, C is one and the output was

equal to B. But you should be confused because how do I know that it wasn't equal to A? Um, and or just it just

happened to be zero independently of what B was picked. Um, and uh, that's a great question. And

let's actually toggle whatever. Let's set B to a one and see what changes. So, I'm going to erase this. Um,

and everything I've left on the screen so far is un is unaffected by our changing of B from a zero to a one. But

now, if I set B to a one, then this AND gate over here is going to output a one, which means this or gate's going to

output a one. Uh, and and now we we do have a little more substance to our claim. So, we have the case here of uh A

is zero, B is one, and C is one, which is over here. And we know this output's going to be one. Um, so I'm going to

keep going through these examples. But what should be a little bit apparent by by now uh is