WEBVTT

0:00:03.220000 --> 0:00:08.060000
 Hello and welcome to this video
 titled Network Math Binary.

0:00:08.060000 --> 0:00:11.000000
 Just as the title says in this video
 I'm going to give you an introduction

0:00:11.000000 --> 0:00:14.740000
 to binary. So by the time you're done
 with this you'll know how to count

0:00:14.740000 --> 0:00:20.260000
 in binary, how to translate decimal
 into binary and back again.

0:00:20.260000 --> 0:00:22.480000
 Alright, let's start
 with binary math.

0:00:22.480000 --> 0:00:26.040000
 So before we look at binary and hexadecimal,
 why do we need to learn these

0:00:26.040000 --> 0:00:27.780000
 things in the first place?

0:00:27.780000 --> 0:00:31.380000
 Well, if you're going to go into the
 world of computer networking you

0:00:31.380000 --> 0:00:34.560000
 need to know binary and hexadecimal
 for a couple of reasons.

0:00:34.560000 --> 0:00:39.060000
 Number one, once you start configuring
 networking devices you start changing

0:00:39.060000 --> 0:00:43.320000
 their operational characteristics
 and applying commands to them.

0:00:43.320000 --> 0:00:47.800000
 Some of those commands have to be entered
 in binary, some of them have

0:00:47.800000 --> 0:00:50.320000
 to be entered in hexadecimal.

0:00:50.320000 --> 0:00:53.660000
 And when you're monitoring or verifying
 network devices and seeing if

0:00:53.660000 --> 0:00:56.380000
 they're operating correctly or seeing
 if somebody else has configured

0:00:56.380000 --> 0:01:01.360000
 it correctly, once again sometimes the
 output of certain commands is displayed

0:01:01.360000 --> 0:01:04.080000
 in binary or hexadecimal.

0:01:04.080000 --> 0:01:07.640000
 So clearly we need to know these counting
 methods so we know what we're

0:01:07.640000 --> 0:01:10.680000
 doing. So let's start with binary.


0:01:10.680000 --> 0:01:15.500000
 So in order to explain binary I find
 it useful to start with something

0:01:15.500000 --> 0:01:20.720000
 we already know which is decimal, which
 is a base 10 counting system.

0:01:20.720000 --> 0:01:23.220000
 Now what do I mean by a
 base 10 counting system?

0:01:23.220000 --> 0:01:28.060000
 Well what that means is whenever you
 say a base something counting system

0:01:28.060000 --> 0:01:34.740000
 like base 8 or base 16 or base 3, what
 that means is if I give you a number,

0:01:34.740000 --> 0:01:38.200000
 let's say there's a single placeholder
 like this, there's a one digit

0:01:38.200000 --> 0:01:43.140000
 number, a base 10 counting system means
 that in that one slot right there

0:01:43.140000 --> 0:01:47.000000
 we have 10 possibilities of
 something we could put in.

0:01:47.000000 --> 0:01:53.020000
 We could put in a zero through a nine,
 giving us 10 possible digits we

0:01:53.020000 --> 0:01:54.760000
 could put in there.

0:01:54.760000 --> 0:01:59.080000
 If I had some imaginary counting system
 called a base 3, then that would

0:01:59.080000 --> 0:02:03.000000
 mean there were three digits that I could
 choose from to put in that single

0:02:03.000000 --> 0:02:07.180000
 slot. So that's base 10, zero
 through nine in each slot.

0:02:07.180000 --> 0:02:11.040000
 And we know that if we have a number
 that is multiple placeholders like

0:02:11.040000 --> 0:02:17.780000
 we see here in the box, we
 always represent the ones.

0:02:17.780000 --> 0:02:23.580000
 So in other words if I put a seven in
 here, that means seven ones or seven

0:02:23.580000 --> 0:02:26.220000
 times one, which gives
 me the number seven.

0:02:26.220000 --> 0:02:30.220000
 Now if they keep going, because we're
 base 10, that means that the next

0:02:30.220000 --> 0:02:34.720000
 available slot to the left
 is a multiple of 10.

0:02:34.720000 --> 0:02:39.100000
 So we have the ones and then we have going
 on next, we have the tens right.

0:02:39.100000 --> 0:02:46.240000
 So if I put in four seven, that's four
 times 10, which is 40 plus seven

0:02:46.240000 --> 0:02:50.120000
 times one, which is 47 total.

0:02:50.120000 --> 0:02:51.320000
 And then we keep going.

0:02:51.320000 --> 0:02:53.080000
 Right, this is just a review
 of what you already know.

0:02:53.080000 --> 0:02:55.420000
 So the next one is another
 multiple of 10.

0:02:55.420000 --> 0:02:58.800000
 So we take 10 times 10,
 which gives us the 100s.

0:02:58.800000 --> 0:03:02.400000
 And then we have 100 times 10,
 which gives us the 1000s.

0:03:02.400000 --> 0:03:06.840000
 So as you learn back in elementary school,
 if I gave you the number two,

0:03:06.840000 --> 0:03:13.100000
 four, three, seven, the way you learned
 that way back when you're learning

0:03:13.100000 --> 0:03:16.980000
 your basic arithmetic at like kindergarten
 or first grade, you learned

0:03:16.980000 --> 0:03:23.700000
 that that was two times 1000, which
 is 2000 plus four times 100, which

0:03:23.700000 --> 0:03:28.900000
 is 400 plus three times 10, which is
 30 plus seven times one, which is

0:03:28.900000 --> 0:03:34.860000
 seven. And you added that
 all up and you got 2437.

0:03:34.860000 --> 0:03:38.480000
 All right, so let's use that same logic
 with now accounting system that

0:03:38.480000 --> 0:03:41.580000
 you may be unfamiliar
 with, which is binary.

0:03:41.580000 --> 0:03:47.640000
 Now binary is base two, which means
 that every available slot can only

0:03:47.640000 --> 0:03:51.420000
 have one of two combinations
 that you can put in it.

0:03:51.420000 --> 0:03:55.620000
 So this slot right here, I only have
 two things I can choose from, a zero

0:03:55.620000 --> 0:03:58.100000
 or one. That's it.

0:03:58.100000 --> 0:04:01.600000
 As a matter of fact, all these slots
 here, I can only put a zero or one

0:04:01.600000 --> 0:04:05.720000
 in them. I can do any combination
 I want of zeros or ones.

0:04:05.720000 --> 0:04:06.920000
 But those are my only options.

0:04:06.920000 --> 0:04:11.260000
 That's why we say it's
 binary or base two.

0:04:11.260000 --> 0:04:16.220000
 So with that, the first position
 is still the ones position.

0:04:16.220000 --> 0:04:21.900000
 So in all these counties, right, the very
 first value or the first position

0:04:21.900000 --> 0:04:28.200000
 is the ones. Now, here in this ones
 position, however, I can only put

0:04:28.200000 --> 0:04:30.020000
 two things, right?

0:04:30.020000 --> 0:04:33.800000
 I could put a zero, which means there
 are no ones or zero, or I could

0:04:33.800000 --> 0:04:38.640000
 put a one, which means there's
 one one, which is just a one.

0:04:38.640000 --> 0:04:41.640000
 Now, because we're in binary, you know,
 over here in base 10, in order

0:04:41.640000 --> 0:04:46.480000
 to get the next digit, we just took
 this, multiplied it by 10, and that

0:04:46.480000 --> 0:04:51.500000
 gave us this. And then to take it the next
 digit, we just took that, multiplied

0:04:51.500000 --> 0:04:53.440000
 it by 10, which gave us that.

0:04:53.440000 --> 0:04:55.760000
 So guess what? We're now going to be
 doing the same thing over here in

0:04:55.760000 --> 0:04:59.220000
 binary, but instead of multiplying by
 10s, we're going to be multiplying

0:04:59.220000 --> 0:05:06.700000
 by 2s. So one times 2 is the 2s position,
 two times 2 is the 4s, four

0:05:06.700000 --> 0:05:12.080000
 times 2 is the 8s, and we could keep
 going as far as we wanted to go.

0:05:12.080000 --> 0:05:19.640000
 So now in binary, if I gave you this
 number, if I gave you 1, 0, 0, 1

0:05:19.640000 --> 0:05:23.640000
 in binary, well, you start with the
 right, because you know this is the

0:05:23.640000 --> 0:05:27.420000
 1s position, so that's just 1.

0:05:27.420000 --> 0:05:30.800000
 This is irrelevant, and this is irrelevant
 because nothing's turned on,

0:05:30.800000 --> 0:05:35.640000
 it's a zero. So the 2s and the 4s, we
 don't even add them into the equation.

0:05:35.640000 --> 0:05:38.520000
 And here we have 1, 8 turned on.

0:05:38.520000 --> 0:05:42.180000
 So that's 8 plus 1,
 which gives us 9.

0:05:42.180000 --> 0:05:47.660000
 So 1, 0, 0, 1 in this case, we just
 add up the values that are turned

0:05:47.660000 --> 0:05:49.900000
 on with a 1 bit.

0:05:49.900000 --> 0:05:54.140000
 Any corresponding value that has a
 0 bit, we don't care about that.

0:05:54.140000 --> 0:05:59.820000
 So similarly, if I gave you this,
 what do you think that would be?

0:05:59.820000 --> 0:06:04.240000
 Well hopefully you said, well, the
 only ones that are turned on is the

0:06:04.240000 --> 0:06:10.400000
 2 and the 1, so that's got to be a
 value of 3, and you'd be correct.

0:06:10.400000 --> 0:06:14.640000
 Well if I turned them all on,
 now what would that be?

0:06:14.640000 --> 0:06:18.480000
 Now as we start doing this, there's
 two ways to approach this type of

0:06:18.480000 --> 0:06:20.520000
 problem where all the
 ones are turned on.

0:06:20.520000 --> 0:06:23.140000
 Certainly if you want to, you
 could just add them up.

0:06:23.140000 --> 0:06:29.880000
 You could say 8 plus 4 plus 2
 plus 1, which would equal 15.

0:06:29.880000 --> 0:06:31.100000
 You could do that.

0:06:31.100000 --> 0:06:33.080000
 Or here's an easier way.

0:06:33.080000 --> 0:06:38.240000
 What would the next value be if
 I put another slot right here?

0:06:38.240000 --> 0:06:42.420000
 What would the value of
 that bit position be?

0:06:42.420000 --> 0:06:45.580000
 Wouldn't that be the
 16's bit position?

0:06:45.580000 --> 0:06:49.420000
 Because 8 times 2 is 1.

0:06:49.420000 --> 0:06:55.160000
 So if all the bits to the right of
 this are turned on, so if this was

0:06:55.160000 --> 0:07:00.520000
 a 0, and all the bits to the right of
 that are turned on, that is 1 less

0:07:00.520000 --> 0:07:04.460000
 than 16, which is 15.

0:07:04.460000 --> 0:07:07.020000
 For example, what if
 I gave you this?

0:07:07.020000 --> 0:07:14.820000
 0, 2, 3, 4, 5. All right, once again
 you could add those up, but here's

0:07:14.820000 --> 0:07:18.860000
 a faster way. You could say, all right,
 let's figure out my ultimate goal

0:07:18.860000 --> 0:07:24.260000
 here is to figure out what the value
 is of this bit position right there.

0:07:24.260000 --> 0:07:27.140000
 So I start on the right, which is the
 1's, and I just start multiplying

0:07:27.140000 --> 0:07:35.200000
 by 2's. 2's, 4's, 8's, 16's, 32's.


0:07:35.200000 --> 0:07:39.740000
 So this has to be
 the 64's position.

0:07:39.740000 --> 0:07:46.020000
 So if that's the 64 position as turned
 off, and everything to the right

0:07:46.020000 --> 0:07:51.340000
 of it is turned on, that means
 that all of this must equal 63.

0:07:51.340000 --> 0:07:56.860000
 And certainly if you add it up, 32 plus
 16 plus 8 plus 4 plus 2 plus 1,

0:07:56.860000 --> 0:07:59.860000
 that gets you 63.

0:07:59.860000 --> 0:08:05.520000
 So let me give you a few binary numbers,
 and then I want you to pause

0:08:05.520000 --> 0:08:09.800000
 the video, come up with the decimal
 equivalent is of, just like we've

0:08:09.800000 --> 0:08:12.880000
 been doing here, come up with the decimal
 equivalent, and then press play

0:08:12.880000 --> 0:08:16.340000
 and see if you came up
 with the right answer.

0:08:16.340000 --> 0:08:24.100000
 So in order to do that, I'm going
 to give you, we'll start out easy.

0:08:24.100000 --> 0:08:31.420000
 I'm going to give you a binary
 values 8 bits long.

0:08:31.420000 --> 0:08:35.580000
 So right now, pause the video and see
 if you can figure out what the value

0:08:35.580000 --> 0:08:39.100000
 is of each and every one of those lines,
 starting with the first one,

0:08:39.100000 --> 0:08:43.200000
 which is the 1's position, what's
 the value of every single line?

0:08:43.200000 --> 0:08:48.020000
 Pause for a moment and then press
 play when you think you have it.

0:08:48.020000 --> 0:08:55.600000
 Okay, so hopefully you
 came up with this.

0:08:55.600000 --> 0:09:05.600000
 This is the 2's position,
 4, 8, 16, 32, 64, 128.

0:09:05.600000 --> 0:09:08.800000
 Hopefully you're able to
 figure all that out.

0:09:08.800000 --> 0:09:12.000000
 Okay, so now let me give you a binary
 value and see if you can figure

0:09:12.000000 --> 0:09:15.560000
 out what the decimal equivalent is
 based on which digits are turned on

0:09:15.560000 --> 0:09:20.220000
 with a 1, and which digits we can
 ignore are turned off with a 0.

0:09:20.220000 --> 0:09:22.520000
 So let's start with this.

0:09:22.520000 --> 0:09:28.640000
 All right, pause the video and see if
 you can figure out what the value

0:09:28.640000 --> 0:09:35.760000
 is of that in decimal.

0:09:35.760000 --> 0:09:38.700000
 Okay, hopefully you said, well, the
 only things that are turned on that

0:09:38.700000 --> 0:09:45.220000
 I have to consider is the 32 bit,
 the 4 bit, and the 1 bit.

0:09:45.220000 --> 0:09:51.380000
 So 32 plus 4 is 36 plus 1 is 37.

0:09:51.380000 --> 0:09:57.220000
 All right, let's do another one.

0:09:57.220000 --> 0:10:07.140000
 How about this? All right, pause the
 video right now and try to figure

0:10:07.140000 --> 0:10:10.160000
 out what that one is in decimal.

0:10:10.160000 --> 0:10:19.640000
 Okay, so hopefully in this one you said,
 well, the 128 bit is turned on,

0:10:19.640000 --> 0:10:26.600000
 the 32 bit is turned on,
 the 2 bit, and the 1 bit.

0:10:26.600000 --> 0:10:27.800000
 Well, I know that these
 are right here.

0:10:27.800000 --> 0:10:28.720000
 That's pretty simple.

0:10:28.720000 --> 0:10:30.800000
 That's just a value of 3.

0:10:30.800000 --> 0:10:35.660000
 128 plus 32, you may have had to think
 about that one a little bit, but

0:10:35.660000 --> 0:10:42.600000
 that is 160. So 160 plus 3, 163.

0:10:42.600000 --> 0:10:45.220000
 All right, I'm going to give you a
 couple more, but I'm going to make

0:10:45.220000 --> 0:10:46.380000
 a little bit harder.

0:10:46.380000 --> 0:10:49.640000
 I'm not going to populate my
 slots here with their values.

0:10:49.640000 --> 0:10:53.100000
 I want you to now figure
 out the values yourself.

0:10:53.100000 --> 0:11:03.400000
 01101000. All right, pause the video,
 see if you can figure out what the

0:11:03.400000 --> 0:11:05.640000
 decimal equivalent is of this.

0:11:05.640000 --> 0:11:14.600000
 Okay, so hopefully this one you figured
 out, well, going from right to

0:11:14.600000 --> 0:11:22.160000
 left, the 8 bit is turned on, the 32
 bit is turned on, and the 64 bit

0:11:22.160000 --> 0:11:38.180000
 is turned on. So 64 plus 32,
 that's 96, 96 plus 8 is 104.

0:11:38.180000 --> 0:11:45.200000
 Let's do one more.

0:11:45.200000 --> 0:11:54.760000
 How about this? Pause the video, and
 then press play when you think you've

0:11:54.760000 --> 0:11:56.740000
 got the solution.

0:11:56.740000 --> 0:12:09.760000
 Okay, so in this one, the 2 bit is turned
 on, the 32 bit, the 64 bit is

0:12:09.760000 --> 0:12:13.100000
 turned on, and the 128
 bit is turned on.

0:12:13.100000 --> 0:12:18.460000
 Now, at first, when you start adding
 this up, this is a little challenging

0:12:18.460000 --> 0:12:23.480000
 because you're probably not used
 to adding 128 plus 64 plus 32.

0:12:23.480000 --> 0:12:26.760000
 Now, as you do this over time, because
 you'll see these numbers again

0:12:26.760000 --> 0:12:31.440000
 and again and again, adding them up
 will become a lot easier because you

0:12:31.440000 --> 0:12:33.000000
 will just done it by memorization.


0:12:33.000000 --> 0:12:37.200000
 For example, I've done this often enough
 that I know that whenever I see

0:12:37.200000 --> 0:12:40.920000
 these first three bits turned on, I
 know that's automatically the number

0:12:40.920000 --> 0:12:49.740000
 224. 128 plus 64 plus 32 is 224, and
 if I add 2 into that, that gives

0:12:49.740000 --> 0:12:55.640000
 me 226. Which leads me into the last
 thing I want to say with regards

0:12:55.640000 --> 0:13:00.860000
 to binary. In the world of networking,
 there are certain binary patterns

0:13:00.860000 --> 0:13:07.960000
 like this one, 1110, that you're going
 to see over and over and over again.

0:13:07.960000 --> 0:13:11.200000
 And certainly if you're going to pursue
 any certification tests like network

0:13:11.200000 --> 0:13:15.900000
 plus or Cisco certification or Juniper
 or anything else, you need to be

0:13:15.900000 --> 0:13:20.340000
 able to spot those patterns and memorize
 them and instantly recall what

0:13:20.340000 --> 0:13:23.960000
 they are in decimal.

0:13:23.960000 --> 0:13:27.460000
 So let's just talk about those
 patterns real quickly.

0:13:27.460000 --> 0:13:32.940000
 Here is a chart, and I recommend actually
 that you either write this down

0:13:32.940000 --> 0:13:36.620000
 or you pause this video right now and
 you take a screenshot of that chart.

0:13:36.620000 --> 0:13:41.680000
 So right there, you've got about seven
 or eight different binary patterns.

0:13:41.680000 --> 0:13:46.760000
 All of those you will see over and
 over and over again in the world of

0:13:46.760000 --> 0:13:47.420000
 computer networking.

0:13:47.420000 --> 0:13:51.220000
 So I would absolutely emphasize to
 you that you should memorize those

0:13:51.220000 --> 0:13:57.880000
 patterns to the point where if I gave
 you the decimal number of 248, you

0:13:57.880000 --> 0:14:01.240000
 should instantly be able to tell me
 Keith that has five ones turned on.

0:14:01.240000 --> 0:14:04.600000
 From left to right, from left to right,
 the first five ones are turned

0:14:04.600000 --> 0:14:09.300000
 on in 248. If I gave you the number
 192, you should instantly be able

0:14:09.300000 --> 0:14:13.020000
 to tell me, okay, Keith, from left to
 right, the first two ones are turned

0:14:13.020000 --> 0:14:16.340000
 on, the 128 and the 64 bit are
 turned on, everything is off.

0:14:16.340000 --> 0:14:20.220000
 Or vice versa. If I gave you any of
 those patterns in binary that you

0:14:20.220000 --> 0:14:24.340000
 see on the left, you should instantly
 be able to just whip quickly look

0:14:24.340000 --> 0:14:28.140000
 at how many ones are turned on and
 come up with what that pattern is.

0:14:28.140000 --> 0:14:30.000000
 Is it 192? Is it 248?

0:14:30.000000 --> 0:14:34.700000
 Is it 255? So absolutely you want
 to memorize those patterns.

0:14:34.700000 --> 0:14:41.220000
 Now, where do we actually see some examples
 of binary math used in networking?

0:14:41.220000 --> 0:14:45.340000
 Well, in networking, very rarely will
 you actually see binary numbers

0:14:45.340000 --> 0:14:48.220000
 of like 1011, 001.

0:14:48.220000 --> 0:14:50.120000
 You won't see that very often.

0:14:50.120000 --> 0:14:54.260000
 But there's a lot of situations where
 you will see what looks like a decimal

0:14:54.260000 --> 0:14:59.040000
 number and you'll need to be able to
 have the skill to mentally figure

0:14:59.040000 --> 0:15:03.580000
 out what the binary equivalent
 is of that decimal number.

0:15:03.580000 --> 0:15:06.880000
 Because the ones and the zeros in the
 binary number will mean certain

0:15:06.880000 --> 0:15:10.840000
 things. But if you saw the decimal
 number and you did not know how to

0:15:10.840000 --> 0:15:15.320000
 convert it into binary, and
 actually, let's do that.

0:15:15.320000 --> 0:15:16.680000
 We didn't do any examples of that.


0:15:16.680000 --> 0:15:18.460000
 Let's do some examples of that.

0:15:18.460000 --> 0:15:22.740000
 I'm going to give you
 a decimal number.

0:15:22.740000 --> 0:15:24.580000
 Let's do two of these.

0:15:24.580000 --> 0:15:27.680000
 And I want you to see if you can come
 up with the binary equivalent of

0:15:27.680000 --> 0:15:29.360000
 this decimal number.

0:15:29.360000 --> 0:15:30.960000
 So here's the first one.

0:15:30.960000 --> 0:15:34.400000
 How about the number 22?

0:15:34.400000 --> 0:15:38.480000
 One, two, three, four, five,
 six, seven, eight.

0:15:38.480000 --> 0:15:42.700000
 So populate this with various ones and
 zeros that will add up to the decimal

0:15:42.700000 --> 0:15:44.160000
 equivalent of 22.

0:15:44.160000 --> 0:15:45.600000
 Go ahead and pause now.

0:15:45.600000 --> 0:15:47.940000
 Press play when you
 think you've got it.

0:15:47.940000 --> 0:15:57.720000
 Okay, well, with the number 22, once
 again, we want to put our values

0:15:57.720000 --> 0:16:02.220000
 in here so we know what
 we're dealing with.

0:16:02.220000 --> 0:16:04.280000
 We don't even have to go
 up any higher than that.

0:16:04.280000 --> 0:16:07.640000
 As a matter of fact, these ones we
 know are going to be turned off.

0:16:07.640000 --> 0:16:13.080000
 Because the 128, the 64, and the
 32-bit are not part of 22.

0:16:13.080000 --> 0:16:18.900000
 So if we turn on the 16-bit, okay, well
 22 minus 16, that gives us 6 left

0:16:18.900000 --> 0:16:23.460000
 over. So with 6 left over, that means
 the 4-bit and the 2-bit are turned

0:16:23.460000 --> 0:16:26.580000
 on, so we zero out
 everything else.

0:16:26.580000 --> 0:16:38.120000
 So 0, 0, 0, 1, 0, 1, 1, 0 gives
 us the value of 22 in binary.

0:16:38.120000 --> 0:16:48.980000
 Let's do one more.

0:16:48.980000 --> 0:16:54.380000
 Okay, 176. Pause the video, figure
 out what the binary representation

0:16:54.380000 --> 0:17:04.100000
 is of this, and then press play.

0:17:04.100000 --> 0:17:08.300000
 Okay, so in this one, let's
 just start with the left.

0:17:08.300000 --> 0:17:10.760000
 We know that this is the 128-bit.

0:17:10.760000 --> 0:17:14.460000
 Well, 128 is certainly
 part of 176.

0:17:14.460000 --> 0:17:19.280000
 Okay, now let's keep moving on.

0:17:19.280000 --> 0:17:22.100000
 I know the next bit is the 64-bit.


0:17:22.100000 --> 0:17:25.420000
 Well, if I turn that on,
 that would be too high.

0:17:25.420000 --> 0:17:27.680000
 128 plus 64 is 192.

0:17:27.680000 --> 0:17:29.720000
 That's one of those patterns
 that we just saw.

0:17:29.720000 --> 0:17:32.320000
 So we definitely do not
 want that turned on.

0:17:32.320000 --> 0:17:34.040000
 What about the next bit?

0:17:34.040000 --> 0:17:35.900000
 Which is the 32-bit?

0:17:35.900000 --> 0:17:39.760000
 128 plus 32? Yeah, that'll work.

0:17:39.760000 --> 0:17:41.920000
 That gives us 160.

0:17:41.920000 --> 0:17:44.900000
 So far, we're at 160 with that.

0:17:44.900000 --> 0:17:46.640000
 Now it's getting pretty easy.

0:17:46.640000 --> 0:17:50.500000
 176 minus 160, that leaves
 us 16 left over.

0:17:50.500000 --> 0:17:51.520000
 Hey, guess what?

0:17:51.520000 --> 0:17:55.860000
 The next bit is the
 16-bit, right there.

0:17:55.860000 --> 0:18:02.660000
 So that gives us 176, and now we just
 populate everything else with zeros.

0:18:02.660000 --> 0:18:08.080000
 So that gives us our binary
 representation of 176.

0:18:08.080000 --> 0:18:13.460000
 So like I said, in the world of networking,
 very rarely will you see numbers

0:18:13.460000 --> 0:18:16.940000
 like this in their binary form.

0:18:16.940000 --> 0:18:20.160000
 But there will be many situations where
 you'll be given a number like

0:18:20.160000 --> 0:18:24.640000
 this, and you'll have to be able to conceptualize
 where are the ones turned

0:18:24.640000 --> 0:18:27.480000
 on in here, and where
 are the zeros in that?

0:18:27.480000 --> 0:18:31.080000
 Because the ones and zeros, depending
 on where they are, will determine

0:18:31.080000 --> 0:18:35.660000
 certain things. So let's see
 some examples of that.

0:18:35.660000 --> 0:18:42.500000
 So here we see three commands in Cisco
 iOS, and this is just Cisco's version

0:18:42.500000 --> 0:18:47.180000
 of software that use
 binary numbers.

0:18:47.180000 --> 0:18:52.940000
 For example, on an interface, when you
 configure an IP address, when you

0:18:52.940000 --> 0:18:58.040000
 add this component right here,
 this is called the subnet mask.

0:18:58.040000 --> 0:19:01.140000
 And once you start learning a little
 bit more about IP addressing, this

0:19:01.140000 --> 0:19:03.280000
 will take on some
 more significance.

0:19:03.280000 --> 0:19:06.660000
 But you would need to be able to conceptualize,
 okay, this subnet mask

0:19:06.660000 --> 0:19:11.440000
 and the corresponding IP address, the
 device that this was configured

0:19:11.440000 --> 0:19:16.740000
 on, like a router or a switch,
 it visualizes this in binary.

0:19:16.740000 --> 0:19:19.240000
 Computers operate in binary.

0:19:19.240000 --> 0:19:23.360000
 This is how computers see numbers as
 a string, a long string of ones and

0:19:23.360000 --> 0:19:28.220000
 zeros. So the computer this was configured
 on, a router in this case,

0:19:28.220000 --> 0:19:30.340000
 knows that it has an IP address.

0:19:30.340000 --> 0:19:35.720000
 It converted this into a string of binary
 characters, and whatever that

0:19:35.720000 --> 0:19:39.220000
 string of binary characters is, it compared
 it against this thing called

0:19:39.220000 --> 0:19:43.820000
 a subnet mask, which means something
 very specific to this device.

0:19:43.820000 --> 0:19:47.900000
 Once again, here's another case where
 an IP address and a subnet mask

0:19:47.900000 --> 0:19:51.840000
 are used. In this case, we're putting
 a route into the routing table of

0:19:51.840000 --> 0:19:57.400000
 a router. Here's another case where
 an IP address and a subnet mask are

0:19:57.400000 --> 0:20:01.020000
 used. Both the IP address and the subnet
 mask, even though we're typing

0:20:01.020000 --> 0:20:06.160000
 it in as decimal values, are being interpreted
 in the back end as binary

0:20:06.160000 --> 0:20:10.760000
 values. And if we don't know how the
 device is doing that and what it

0:20:10.760000 --> 0:20:15.180000
 means to the device once it sees the
 binary values, these commands will

0:20:15.180000 --> 0:20:16.740000
 be kind of useless to us.

0:20:16.740000 --> 0:20:18.340000
 So that's binary.