WEBVTT

0:00:04.980000 --> 0:00:09.140000
 In this section, I'd like to answer
 the fundamental question of why do

0:00:09.140000 --> 0:00:10.400000
 we need routing.

0:00:10.400000 --> 0:00:14.100000
 In other words, before we even know what
 routing is and what it accomplishes,

0:00:14.100000 --> 0:00:16.660000
 what problem was it
 designed to solve?

0:00:16.660000 --> 0:00:20.940000
 And I find that for myself, I always
 am able to better understand a topic

0:00:20.940000 --> 0:00:22.480000
 if I can answer that question.

0:00:22.480000 --> 0:00:27.540000
 What problem was this protocol
 or feature designed to solve?

0:00:27.540000 --> 0:00:29.280000
 So that being the case.

0:00:29.280000 --> 0:00:34.300000
 Let's imagine a network where
 routing is not necessary.

0:00:34.300000 --> 0:00:37.720000
 So we know that in, let's
 just take a laptop.

0:00:37.720000 --> 0:00:41.840000
 We've got smartphones and tablets and
 stuff, but just for the purpose

0:00:41.840000 --> 0:00:44.760000
 of simplicity, let's
 think about a laptop.

0:00:44.760000 --> 0:00:49.180000
 So the applications that are working in
 your laptop fall into two different

0:00:49.180000 --> 0:00:54.900000
 categories. You've got applications
 which are not network applications.

0:00:54.900000 --> 0:00:57.000000
 Applications have nothing
 to do with a network.

0:00:57.000000 --> 0:00:59.140000
 They don't even know
 what a network is.

0:00:59.140000 --> 0:01:02.420000
 For example, Microsoft
 notepad, right?

0:01:02.420000 --> 0:01:03.520000
 It's a text editor.

0:01:03.520000 --> 0:01:07.600000
 There's nothing in notepad that allows
 it to retrieve data from somewhere

0:01:07.600000 --> 0:01:10.060000
 remotely or push data remotely.

0:01:10.060000 --> 0:01:12.620000
 It's all self-contained
 within your laptop.

0:01:12.620000 --> 0:01:17.280000
 You could be not connected to a network
 at all and still take full advantage

0:01:17.280000 --> 0:01:21.860000
 of everything that notepad has to offer
 because it doesn't deal with networks.

0:01:21.860000 --> 0:01:25.520000
 Then you have the other applications
 which are the majority of what you

0:01:25.520000 --> 0:01:27.800000
 use, which are network
 applications.

0:01:27.800000 --> 0:01:33.600000
 These are applications that are client
 server based, usually, meaning

0:01:33.600000 --> 0:01:38.320000
 your laptop is the client and it has
 to either pull information from a

0:01:38.320000 --> 0:01:43.620000
 server somewhere or it has to push information
 up to that server somewhere

0:01:43.620000 --> 0:01:45.560000
 in order to get its job done.

0:01:45.560000 --> 0:01:47.500000
 Email, perfect example of that.

0:01:47.500000 --> 0:01:49.800000
 You have an email client
 on your laptop.

0:01:49.800000 --> 0:01:52.000000
 It might be Microsoft Outlook.

0:01:52.000000 --> 0:01:54.060000
 It might be Gmail.

0:01:54.060000 --> 0:01:56.940000
 Whatever it is, your
 laptop is the client.

0:01:56.940000 --> 0:02:01.040000
 In order to get your emails, you have
 to send a message to some server

0:02:01.040000 --> 0:02:04.680000
 somewhere that has your email stored
 on it and that server will respond

0:02:04.680000 --> 0:02:07.680000
 back and give those
 emails back to you.

0:02:07.680000 --> 0:02:11.200000
 That is a network
 aware application.

0:02:11.200000 --> 0:02:13.600000
 Let's focus on those for a second.


0:02:13.600000 --> 0:02:18.920000
 If an application is going to be written
 to serve on a network, then one

0:02:18.920000 --> 0:02:23.260000
 of the fundamental components of any
 device on a network is that device

0:02:23.260000 --> 0:02:25.800000
 has to have some kind
 of an address.

0:02:25.800000 --> 0:02:29.200000
 In other words, if I'm going to be
 sending a request out to some other

0:02:29.200000 --> 0:02:33.480000
 device, whether that other device is
 two feet away from me or 2,000 miles

0:02:33.480000 --> 0:02:38.200000
 away from me, if I expect that device
 to send a reply back to me, I have

0:02:38.200000 --> 0:02:41.880000
 to have some kind of a name, some sort
 of an identifier so it can respond

0:02:41.880000 --> 0:02:47.580000
 back to me. Similarly, it has to have
 a name or an identifier so I can

0:02:47.580000 --> 0:02:52.400000
 talk to it. Network devices
 need some sort of address.

0:02:52.400000 --> 0:02:55.740000
 The idea is the same thing as when you're
 sending a letter to somebody.

0:02:55.740000 --> 0:02:59.780000
 You have a home address and you're sending
 a letter to your mom or your

0:02:59.780000 --> 0:03:01.060000
 brother's home address.

0:03:01.060000 --> 0:03:07.380000
 Without an address, there would be no
 way for you to send that envelope.

0:03:07.380000 --> 0:03:15.760000
 Now, a network address is that network devices
 know of as this is my identifier,

0:03:15.760000 --> 0:03:16.900000
 this is my name.

0:03:16.900000 --> 0:03:18.640000
 Follow the two different
 categories.

0:03:18.640000 --> 0:03:22.460000
 We have non-routable and
 routable addresses.

0:03:22.460000 --> 0:03:25.420000
 Not going to talk about routable addresses
 just yet, we'll get to that,

0:03:25.420000 --> 0:03:27.800000
 but what is a non
-routable address?

0:03:27.800000 --> 0:03:31.480000
 A non-routable address is
 sort of like your name.

0:03:31.480000 --> 0:03:32.980000
 Think about your name.

0:03:32.980000 --> 0:03:39.040000
 Your name says uniquely who you are,
 so if there's a crowd of people and

0:03:39.040000 --> 0:03:43.480000
 hopefully nobody else has your name,
 if somebody shouts out, John, well

0:03:43.480000 --> 0:03:47.700000
 then there's only one John hopefully
 in that crowd and that one John will

0:03:47.700000 --> 0:03:50.920000
 be able to identify
 himself by his name.

0:03:50.920000 --> 0:03:56.800000
 But a non-routable address like a name
 gives you no indication as to where

0:03:56.800000 --> 0:04:01.620000
 that device is. Just by your name alone,
 John, Sally, Sue, whatever it

0:04:01.620000 --> 0:04:05.220000
 is, doesn't tell me anything about whether
 you're in the United States,

0:04:05.220000 --> 0:04:09.880000
 Afghanistan, India, China, in a building
 under the sea, there's no way

0:04:09.880000 --> 0:04:14.520000
 for me to know. So in the world of
 networking, non-routable addresses

0:04:14.520000 --> 0:04:20.380000
 are similar. It's an identifier on your
 device that uniquely identifies

0:04:20.380000 --> 0:04:25.720000
 it from other devices but gives no
 clue, no indication about where in

0:04:25.720000 --> 0:04:28.460000
 the network it resides.

0:04:28.460000 --> 0:04:33.240000
 An example of this would be a MAC address,
 a media access control address,

0:04:33.240000 --> 0:04:37.520000
 which is a layer two non-routable address,
 a MAC address, if you look

0:04:37.520000 --> 0:04:40.660000
 at it, there's nothing in there that
 tells you where that MAC address

0:04:40.660000 --> 0:04:42.240000
 is sitting in the network.

0:04:42.240000 --> 0:04:44.900000
 It is non-routable.

0:04:44.900000 --> 0:04:51.620000
 Okay, so imagine for a moment that I
 had designed a network where every

0:04:51.620000 --> 0:04:58.100000
 single device in that network, everyone,
 had only a non-routable address,

0:04:58.100000 --> 0:05:02.560000
 some number that was a unique name or
 serial number for that device but

0:05:02.560000 --> 0:05:07.180000
 that gave no indications to where
 that device was in the network.

0:05:07.180000 --> 0:05:12.120000
 And yet, I wanted devices with other
 names to be able to talk to that

0:05:12.120000 --> 0:05:13.780000
 device with that name.

0:05:13.780000 --> 0:05:17.320000
 So I have a whole bunch of devices
 sitting in a network with a single

0:05:17.320000 --> 0:05:21.980000
 non-routable address, each device is
 offering some kind of a service or

0:05:21.980000 --> 0:05:24.820000
 information that other devices
 could make use of.

0:05:24.820000 --> 0:05:30.220000
 So the first question is, well, how
 does my laptop, if my laptop says,

0:05:30.220000 --> 0:05:35.640000
 okay, I'm going to assume there's a
 device out there, I don't know what

0:05:35.640000 --> 0:05:39.220000
 its name is, so that's number one, I
 need to resolve the name of a device

0:05:39.220000 --> 0:05:42.520000
 that provides a particular
 service.

0:05:42.520000 --> 0:05:46.080000
 Let's just say service X, whatever
 that is, maybe it's a print service

0:05:46.080000 --> 0:05:51.280000
 or maybe it's a fax service or
 take your pick, video service.

0:05:51.280000 --> 0:05:57.660000
 My laptop says, I need service X so
 I don't know who in the network owns

0:05:57.660000 --> 0:06:01.480000
 that service, so how would
 you find that out?

0:06:01.480000 --> 0:06:06.400000
 Well, in protocols that operate that
 way, in protocols that say, okay,

0:06:06.400000 --> 0:06:10.140000
 I'm in the sort of cloud which is a
 network, I've got a cable connected

0:06:10.140000 --> 0:06:13.300000
 to me, I don't know where that goes,
 but I know I'm connected to a network

0:06:13.300000 --> 0:06:16.760000
 and I need to find out if there's a device
 out there that has the service

0:06:16.760000 --> 0:06:21.600000
 I want. Well in that type of a network
 design, which is what we call a

0:06:21.600000 --> 0:06:25.160000
 flat network, a flat network is where
 everybody can talk to everybody

0:06:25.160000 --> 0:06:29.920000
 else, everybody is in the same room,
 everybody can hear everybody else.

0:06:29.920000 --> 0:06:34.740000
 So in a flat network like that, we typically
 utilize broadcasts, meaning

0:06:34.740000 --> 0:06:39.160000
 your laptop will basically shout out
 into the room, hey, is there anybody

0:06:39.160000 --> 0:06:43.780000
 out there who offers service X, if you
 do, can you tell me what your name

0:06:43.780000 --> 0:06:48.480000
 is? And then if there's a device out
 there that does have service X, that

0:06:48.480000 --> 0:06:53.720000
 device will say, oh yeah, my name is Juan,
 talk to me, or my name is 11254,

0:06:53.720000 --> 0:06:58.920000
 whatever the unique non-routable name
 is or identifier of that device.

0:06:58.920000 --> 0:07:01.580000
 So that's how things operate
 in a flat network.

0:07:01.580000 --> 0:07:05.460000
 So in a flat network, which means everybody
 can see everybody else, you

0:07:05.460000 --> 0:07:09.720000
 can talk to anybody in the network
 directly, speaking directly to them

0:07:09.720000 --> 0:07:11.760000
 without any intermediary.

0:07:11.760000 --> 0:07:16.540000
 Number one, you got to discover that
 they exist and you do that by sending

0:07:16.540000 --> 0:07:20.540000
 out a broadcast, just shouting out,
 once you learn their name, now you

0:07:20.540000 --> 0:07:21.520000
 can send data to them.

0:07:21.520000 --> 0:07:25.720000
 But once again, because this type of
 network by its very nature is the

0:07:25.720000 --> 0:07:29.900000
 kind where everybody can hear everything,
 you know, use this analogy.

0:07:29.900000 --> 0:07:33.740000
 Let's say that I was in the same room
 with all of you, and one of you

0:07:33.740000 --> 0:07:38.260000
 guys is, let's see, is Chad, and
 I say, and Chad has service X.

0:07:38.260000 --> 0:07:40.660000
 So I shout out, say, hey, is there
 somebody out there who does service

0:07:40.660000 --> 0:07:44.880000
 X and Chad responds back and says, yeah,
 my name is Chad, I can do that.

0:07:44.880000 --> 0:07:47.720000
 Okay, so now I start talking to Chad,
 we start talking, but because we're

0:07:47.720000 --> 0:07:50.140000
 in the same room, guess what?

0:07:50.140000 --> 0:07:53.080000
 All you guys also hear
 our conversation.

0:07:53.080000 --> 0:07:57.720000
 So I'm getting service X, you know, I
 can send data to Chad by addressing

0:07:57.720000 --> 0:08:00.260000
 my data to Chad coming from Keith.


0:08:00.260000 --> 0:08:03.540000
 He can send it back to me, but because
 we're talking about a flat network

0:08:03.540000 --> 0:08:08.720000
 here, a bunch of people all in one
 room, they hear my conversation, I

0:08:08.720000 --> 0:08:10.780000
 can hear other people's
 conversations.

0:08:10.780000 --> 0:08:13.840000
 So that's another characteristic
 of a flat network.

0:08:13.840000 --> 0:08:16.380000
 By design, there is no exclusion.

0:08:16.380000 --> 0:08:19.960000
 Everybody can talk to everybody.

0:08:19.960000 --> 0:08:24.100000
 So one example of this type of thing
 is something called zero conf or

0:08:24.100000 --> 0:08:30.800000
 zero config. So for example, this is
 an IETF standard, and zero config

0:08:30.800000 --> 0:08:36.560000
 is sort of this loose body of standard
 that says theoretically without

0:08:36.560000 --> 0:08:42.780000
 naming a particular vendor or particular
 service, how can we put devices

0:08:42.780000 --> 0:08:47.380000
 on a network and get them to communicate
 with zero configurations?

0:08:47.380000 --> 0:08:51.180000
 In other words, if we didn't want a
 human being to touch that device,

0:08:51.180000 --> 0:08:54.840000
 we just want that human being to be able
 to plug in a cable and then magically

0:08:54.840000 --> 0:08:57.160000
 everything works.

0:08:57.160000 --> 0:08:59.920000
 That is called zero configuration.


0:08:59.920000 --> 0:09:03.980000
 So in zero configuration, it's how
 do we answer questions like, okay,

0:09:03.980000 --> 0:09:06.200000
 well that device needs
 a unique name.

0:09:06.200000 --> 0:09:07.860000
 How do we give it that name?

0:09:07.860000 --> 0:09:09.820000
 You know, an address, for
 example, an IP address.

0:09:09.820000 --> 0:09:13.280000
 How do we get it an IP address when
 everything's on one big flat network

0:09:13.280000 --> 0:09:17.980000
 and we don't want to do that?

0:09:17.980000 --> 0:09:23.880000
 If that guy is saying, hey, I need service
 X, how's he going to do that?

0:09:23.880000 --> 0:09:25.780000
 Is that going to be
 via a broadcast?

0:09:25.780000 --> 0:09:27.540000
 And what does that broadcast
 look like?

0:09:27.540000 --> 0:09:30.100000
 So zero conf is an example.

0:09:30.100000 --> 0:09:33.960000
 If there's a protocol or a service
 that you read, for example, Bonjour

0:09:33.960000 --> 0:09:40.180000
 by Apple or Airplay by Apple, these are
 examples of software that is zero

0:09:40.180000 --> 0:09:42.000000
 config or zero conf.

0:09:42.000000 --> 0:09:47.140000
 Bonjour and Airplay are designed so
 that you can take a device that's

0:09:47.140000 --> 0:09:51.240000
 running Bonjour or Airplay, connect a
 cable to it or connect it to a network

0:09:51.240000 --> 0:09:56.060000
 and that's it. It will somehow magically
 get its own IP address or it's,

0:09:56.060000 --> 0:09:59.420000
 maybe it's not IP, maybe it's something
 else, it'll somehow be able to

0:09:59.420000 --> 0:10:01.960000
 resolve names to addresses.

0:10:01.960000 --> 0:10:04.800000
 You'll do all of this
 all by itself.

0:10:04.800000 --> 0:10:08.300000
 Well, a protocol that does that
 assumes a flat network.

0:10:08.300000 --> 0:10:12.680000
 It assumes that, okay, anybody I might
 ever need to talk to is within

0:10:12.680000 --> 0:10:15.400000
 shouting distance and they
 can talk back to me.

0:10:15.400000 --> 0:10:18.160000
 I can hear everybody out there
 and they can hear me.

0:10:18.160000 --> 0:10:23.120000
 So that's an example of a type of a
 network where routing would not be

0:10:23.120000 --> 0:10:26.180000
 necessary because everybody
 can talk to everybody.

0:10:26.180000 --> 0:10:27.740000
 We don't need routing.

0:10:27.740000 --> 0:10:31.200000
 But there's some definite
 downsides to that.

0:10:31.200000 --> 0:10:33.460000
 So that will work.

0:10:33.460000 --> 0:10:39.200000
 Devices will be able to
 talk to each other.

0:10:39.200000 --> 0:10:44.460000
 Two thousand devices between laptops
 and PCs and servers and phones.

0:10:44.460000 --> 0:10:48.720000
 And imagine if all of them were in
 one big flat network where they all

0:10:48.720000 --> 0:10:52.400000
 heard everybody's conversation, where
 they all had to broadcast out to

0:10:52.400000 --> 0:10:55.300000
 find the address of whoever it
 was they wanted to talk to.

0:10:55.300000 --> 0:11:00.840000
 It would work. But broadcast
 interrupt people.

0:11:00.840000 --> 0:11:03.740000
 The way broadcasts are designed is that,
 hey, if I put a broadcast into

0:11:03.740000 --> 0:11:09.080000
 the room, everybody
 put that broadcast.

0:11:09.080000 --> 0:11:10.400000
 They have to pay attention to it.

0:11:10.400000 --> 0:11:12.120000
 Otherwise it wouldn't
 serve its purpose.

0:11:12.120000 --> 0:11:13.820000
 It's meant for everybody.

0:11:13.820000 --> 0:11:18.660000
 So that means that if my laptop is getting
 hundreds of broadcasts every

0:11:18.660000 --> 0:11:22.320000
 single minute because there's just
 tons of devices in this network or

0:11:22.320000 --> 0:11:26.540000
 trying to discover things, that's going
 to really slow my laptop down.

0:11:26.540000 --> 0:11:29.620000
 What it wants to do, what it's CPU wants
 to do, will have to be interrupted

0:11:29.620000 --> 0:11:34.620000
 constantly to listen to these broadcasts
 because any one of them might

0:11:34.620000 --> 0:11:40.340000
 be for me. Each broadcast
 consumes bandwidth.

0:11:40.340000 --> 0:11:45.020000
 So if I'm taking an ethernet frame
 and putting it into this type of a

0:11:45.020000 --> 0:11:49.380000
 flat network and that ethernet frame
 consumes bandwidth, well, if you've

0:11:49.380000 --> 0:11:53.200000
 seen my series on ethernet, whether it
 be my video series or my CCNA series,

0:11:53.200000 --> 0:11:55.980000
 you know, one of the characteristics
 of ethernet is that when I'm talking

0:11:55.980000 --> 0:12:00.140000
 in a flat network where everybody can
 hear everybody else and if that

0:12:00.140000 --> 0:12:03.700000
 flat network is running ethernet, that
 means that when I'm talking, everybody

0:12:03.700000 --> 0:12:05.420000
 else has to be quiet.

0:12:05.420000 --> 0:12:07.920000
 So they might have frames, they might
 have data that they want to put

0:12:07.920000 --> 0:12:10.580000
 on the network, but they
 can't until I'm done.

0:12:10.580000 --> 0:12:12.520000
 It's one person at a time.

0:12:12.520000 --> 0:12:14.880000
 It's not a bunch of people talking
 over each other in a room.

0:12:14.880000 --> 0:12:16.820000
 It's one person at a time.

0:12:16.820000 --> 0:12:21.900000
 Well, that means that if I'm putting
 a broadcast onto that wire, that

0:12:21.900000 --> 0:12:26.400000
 is consuming bandwidth that could be
 used by somebody else, you know,

0:12:26.400000 --> 0:12:28.360000
 but that's the nature
 of a flat network.

0:12:28.360000 --> 0:12:31.680000
 I got to send out that broadcast to
 discover who it is I want to talk

0:12:31.680000 --> 0:12:32.660000
 to in the meantime.

0:12:32.660000 --> 0:12:35.120000
 You guys want to talk to each
 other, but you can't.

0:12:35.120000 --> 0:12:38.060000
 You can't talk to each other
 until this broadcast is done.

0:12:38.060000 --> 0:12:40.620000
 So this broadcast is consuming bandwidth
 that could be used for other

0:12:40.620000 --> 0:12:44.740000
 things. And clearly,
 there's no security.

0:12:44.740000 --> 0:12:51.060000
 Every device can see every other device,
 which might be a concern of yours.

0:12:51.060000 --> 0:12:54.400000
 And fault isolation is very difficult
 to diagnose, right?

0:12:54.400000 --> 0:12:58.460000
 In a network like this where everybody
 can talk to everybody, it's non

0:12:58.460000 --> 0:13:06.300000
-routable. If my laptop can reach Sally's
 server, but it can't reach Bob's

0:13:06.300000 --> 0:13:09.960000
 server, that's kind of difficult
 to troubleshoot.

0:13:09.960000 --> 0:13:12.880000
 Where do you start with
 something like that?

0:13:12.880000 --> 0:13:17.480000
 What could be, you can troubleshoot it,
 but it's not as easy as troubleshooting

0:13:17.480000 --> 0:13:21.720000
 a network that has been segmented
 into a routable network.

0:13:21.720000 --> 0:13:24.500000
 So what is the solution?

0:13:24.500000 --> 0:13:28.620000
 Let's break this network up into
 different broadcast domains.

0:13:28.620000 --> 0:13:32.780000
 In other words, instead of having everybody
 able to hear everybody else,

0:13:32.780000 --> 0:13:34.360000
 let's subdivide it.

0:13:34.360000 --> 0:13:37.680000
 Let's say, okay, you people over
 there have something in common.

0:13:37.680000 --> 0:13:39.360000
 Maybe you're all in
 the same department.

0:13:39.360000 --> 0:13:41.340000
 You're all in payroll.

0:13:41.340000 --> 0:13:43.820000
 And you people over here have
 something else in common.

0:13:43.820000 --> 0:13:45.360000
 You're all in marketing.

0:13:45.360000 --> 0:13:49.000000
 So rather than having all of you in one
 giant flat network where everybody

0:13:49.000000 --> 0:13:53.740000
 hears everything, let's put you in
 two completely different networks.

0:13:53.740000 --> 0:13:57.760000
 So all of your broadcast payroll will
 stay with you guys and they won't

0:13:57.760000 --> 0:13:59.100000
 go over to marketing.

0:13:59.100000 --> 0:14:01.720000
 And marketing, all of your broadcast
 and everything you're doing will

0:14:01.720000 --> 0:14:04.980000
 stay with you and not
 go over to payroll.

0:14:04.980000 --> 0:14:06.780000
 We'll keep you separate.

0:14:06.780000 --> 0:14:12.200000
 And then we'll have some device that
 can rout, send information back and

0:14:12.200000 --> 0:14:14.400000
 forth between these two networks.

0:14:14.400000 --> 0:14:18.940000
 Now in order to do that, each device
 in these broadcast domains now has

0:14:18.940000 --> 0:14:22.320000
 to be able to identify what
 broadcast domain am I in.

0:14:22.320000 --> 0:14:27.340000
 In other words, your laptop, your tablet,
 your smartphone, every time

0:14:27.340000 --> 0:14:33.140000
 it creates data to put onto the network,
 every time it asks itself one

0:14:33.140000 --> 0:14:34.840000
 fundamental question.

0:14:34.840000 --> 0:14:39.840000
 It says, is this data I'm creating
 destined for the network I live on,

0:14:39.840000 --> 0:14:45.360000
 my broadcast domain, my room,
 or is it destined elsewhere?

0:14:45.360000 --> 0:14:50.600000
 Well, in order to answer that question,
 your laptop, your tablet, your

0:14:50.600000 --> 0:14:55.200000
 smartphone, now it can't answer that
 question with a non-routable address.

0:14:55.200000 --> 0:14:59.640000
 A non-routable address gives no indications
 to where a device is living.

0:14:59.640000 --> 0:15:04.120000
 Now it needs another kind of an address,
 a routable address, and a routable

0:15:04.120000 --> 0:15:09.980000
 address by its very nature gives an
 indication as to where you live.

0:15:09.980000 --> 0:15:13.780000
 And it can answer that question, is
 this data, if I look at the routable

0:15:13.780000 --> 0:15:18.420000
 destination of this data, and I compare
 it with the routable address of

0:15:18.420000 --> 0:15:23.560000
 myself, and I look at those two, are
 they on the same network or they

0:15:23.560000 --> 0:15:25.160000
 on different networks?

0:15:25.160000 --> 0:15:30.240000
 So in order to break a network up into
 different broadcast domains, we

0:15:30.240000 --> 0:15:35.900000
 need to be able to give devices
 the ability to do that.

0:15:35.900000 --> 0:15:39.940000
 So end-to-end reachability with different
 broadcast domains requires a

0:15:39.940000 --> 0:15:41.620000
 routable address.

0:15:41.620000 --> 0:15:45.840000
 So a routable address is an address,
 it's some sort of numeric, it's a

0:15:45.840000 --> 0:15:51.200000
 number, it's a digit, you know, an identifier,
 that some portion of that

0:15:51.200000 --> 0:15:56.800000
 address is common with all the other devices
 in your room, in your broadcast

0:15:56.800000 --> 0:15:58.200000
 domain, in your network.

0:15:58.200000 --> 0:16:02.120000
 So for example, if all those people
 over there are in payroll, they're

0:16:02.120000 --> 0:16:05.220000
 all going to have routable addresses
 on their laptops and smart phones

0:16:05.220000 --> 0:16:09.460000
 and tablets. Some portion of that routable
 address is going to be the

0:16:09.460000 --> 0:16:11.520000
 same for all of them.

0:16:11.520000 --> 0:16:14.800000
 There's going to be some series of bits
 or some numbers which every single

0:16:14.800000 --> 0:16:19.140000
 person payroll has the exact same sequence,
 because they're all in the

0:16:19.140000 --> 0:16:23.160000
 same network. And then the other portion
 of their address is going to

0:16:23.160000 --> 0:16:28.120000
 be like a unique serial number or
 identifier just for their device.

0:16:28.120000 --> 0:16:32.260000
 So that's what makes an address a routable
 address, there's a portion

0:16:32.260000 --> 0:16:36.060000
 of it that's shared among devices that
 identifies this is the group that

0:16:36.060000 --> 0:16:40.020000
 we're in, and then there's another portion
 of it that says, this is unique

0:16:40.020000 --> 0:16:44.500000
 just for me, this is my own number,
 my own serial number.

0:16:44.500000 --> 0:16:48.500000
 So if we are going to now do this,
 if we're going to take our networks

0:16:48.500000 --> 0:16:52.900000
 and break them up in a different broadcast
 domain, now we need to introduce

0:16:52.900000 --> 0:16:55.340000
 a routable protocol.

0:16:55.340000 --> 0:17:02.200000
 For example, this is what IP is, the
 Internet Protocol is a document that

0:17:02.200000 --> 0:17:07.820000
 defines how do we get devices to recognize
 what network they're in, to

0:17:07.820000 --> 0:17:12.940000
 recognize other networks, to know how
 to get to other networks, to resolve

0:17:12.940000 --> 0:17:19.300000
 them. So a routable protocol must provide
 all these things, it must provide

0:17:19.300000 --> 0:17:21.420000
 a method for obtaining an address.


0:17:21.420000 --> 0:17:24.780000
 Do I have to type it in or
 does it get it dynamically?

0:17:24.780000 --> 0:17:27.580000
 A method for determining
 the local network.

0:17:27.580000 --> 0:17:33.160000
 In other words, if I give my laptop
 the series of bits, and I say this

0:17:33.160000 --> 0:17:37.340000
 is your name, this is your routable
 address, some of it is going to be

0:17:37.340000 --> 0:17:41.560000
 the network you're on and some it's going
 to be your unique serial number,

0:17:41.560000 --> 0:17:45.840000
 your host ID. Well that address, something
 about it has to be able to

0:17:45.840000 --> 0:17:48.800000
 tell the device, where's
 that dividing line?

0:17:48.800000 --> 0:17:53.300000
 You know how many of the bits from
 left to right represent my network,

0:17:53.300000 --> 0:17:54.900000
 where do I stop?

0:17:54.900000 --> 0:17:58.960000
 And then everything after that
 is my own unique serial number.

0:17:58.960000 --> 0:18:04.520000
 We need a method for determining the
 address of off network destinations.

0:18:04.520000 --> 0:18:08.700000
 So for example, when you bring up your
 web browser and you type in Google

0:18:08.700000 --> 0:18:16.540000
.com or CNN.com, we type that in because
 as humans we rely on names and

0:18:16.540000 --> 0:18:20.620000
 human readable stuff, but everything's
 done in numbers in the world of

0:18:20.620000 --> 0:18:23.620000
 networking, addresses
 are all numerical.

0:18:23.620000 --> 0:18:29.180000
 So there has to be some way to take that
 name and convert it to the actual

0:18:29.180000 --> 0:18:34.460000
 routable address of who we want to talk
 to, the destination routable address.

0:18:34.460000 --> 0:18:38.440000
 And we need a method for sending
 packets off network.

0:18:38.440000 --> 0:18:44.160000
 If my laptop says okay, I've created some
 data, here's my routable address,

0:18:44.160000 --> 0:18:48.640000
 here's the destination routable address
 and by comparing them we're not

0:18:48.640000 --> 0:18:51.220000
 on the same network, we're
 on different networks.

0:18:51.220000 --> 0:18:55.040000
 Now the question is, what
 do I do with this thing?

0:18:55.040000 --> 0:18:57.040000
 The protocol has to answer
 that question.

0:18:57.040000 --> 0:18:59.760000
 What do you do with
 it in that case?

0:18:59.760000 --> 0:19:03.720000
 And then we need a device that can rout
 packets between networks, a device

0:19:03.720000 --> 0:19:08.300000
 that can take in a packet from one
 network, recognize that it belongs

0:19:08.300000 --> 0:19:12.440000
 on a different network and know what
 to do with that, know where to send

0:19:12.440000 --> 0:19:15.420000
 it and how to send it.

0:19:15.420000 --> 0:19:20.560000
 So that concludes this particular
 section on why do we need routing?

0:19:20.560000 --> 0:19:23.780000
 We need it because we don't want
 these big flat networks.

0:19:23.780000 --> 0:19:27.280000
 We don't want everybody sending
 broadcast to everybody else.

0:19:27.280000 --> 0:19:32.160000
 We don't want everybody seeing and hearing
 everything for security reasons,

0:19:32.160000 --> 0:19:34.440000
 for bandwidth conservation.

0:19:34.440000 --> 0:19:38.540000
 We want to break it up into
 multiple broadcast domains.

0:19:38.540000 --> 0:19:41.940000
 But now that we have multiple broadcast
 domains, if something's in broadcast

0:19:41.940000 --> 0:19:43.540000
 domain A, which is a very simple thing,
 we want to break it up into multiple

0:19:43.540000 --> 0:19:43.560000
 broadcast domains.

0:19:43.560000 --> 0:19:48.180000
 So this is a payroll, let's say, it needs
 to know how to get to the other

0:19:48.180000 --> 0:19:51.980000
 broadcast domains and routing is what
 answers that question of how to

0:19:51.980000 --> 0:19:55.580000
 do that. And so in the next section
 we're going to start looking at what

0:19:55.580000 --> 0:20:01.140000
 actually happens to a packet when it
 gets routed, when it enters a router,

0:20:01.140000 --> 0:20:01.800000
 what happens to it?

