Original subtitles

The biggest challenge of learning networking is the fact that, well networking is incredibly complicated

to date.

Now complicated is good, complicated means convenient.

For example I can fire my iPhone and I can get right onto the Internet and check the traffic, whatever

I need to do. My tv in my house is connected to the Internet and I can do Netflix and all kinds of cool

stuff. Even in my house.

the electric meter on the back of my house is connected to the Internet.

So networking today because of the Internet is fabulously complicated.

Well complicated is good but it's not a good way to learn about networking.

So to appreciate networking what I want to do is simplify things a little bit.

Let's go back in time and to do that I want to show you these old guys here.

This is a NIC or a network interface card.

Traditionally these are plugged into individual computers

and then we use this big chunk of cable right here to connect to a box, which at least for the moment,

I'm going to call a hub.

This box acts as the interface to allow lots of computers, well at least in this case eight computers,

to interconnect with each other so that they can share resources.

Now when I say share resources a resource can be anything from a web page to a Microsoft Word document

to a LAN server playing World of Tanks.

It doesn't really matter to me, but it's just something that somebody can share with somebody else.

As a matter of fact because this is only local,

this is where the term local area network came from,

we'll develop that more in other episodes in the series.

But for now that will work.

Now the thing is is that if I've got all of these computers connected to each other how are they actually

sending data.

If I've got one computer with a Microsoft Word document and I've got another computer where that person

wants to access that Microsoft Word document, how does the data actually move through all these little

cables? Now to appreciate how that works.

You have to go back a little bit and understand that we're talking about binary data being sent. Now

I don't care if it's a copper cable with electricity going up and down or if it's a fiber optic cable

with light turning on or off or even if it's a wireless network where radio frequency basically says

on and off it's always ones and zeros on and off.

So if you really want to see data being moved along these cables it looks kind of like this.

Wow that's really good there.

The idea is that it's kind of like a Morse code that's being sent between devices and these devices

understand that code and they can actually do things with it like recreate a Microsoft Word document

or whatever it might be.

Now the thing you really need to appreciate, and this is the cornerstone of everything that's networking,

if there's one thing I'm going to make sure you understand before you run away, is that this data is

not sent in big long continuous streams.

It's sent in discrete chunks that are called, traditionally they're called frame's although you hear the

word packets as well.

Again there is some difference and in other episodes in the series we'll qualify that.

So if you really want to understand what's going on what I need you to do is visualize discrete chunks

of ones and zeros that are flying back and forth across your wires on your network.

So they look, if you want to see what a frame looks like it looks something, well kind of like this. This

big stream of ones and zeros that are running across the screen,

now notice that they start and then they stop and then another chunk comes along and another chunk,

are what frames really are.

And we call this packetized data.

So in order to appreciate packetized data, and trust me packet data is the cornerstone of networking,

we need to do something to analogize the concept a little bit and,

well I like to play so let's use some blocks.

Yay! Fun blocks to play with.

Now this block is going to represent a frame so let's bring our frame back here.

OK.

Now if you take a look at this frame you'll notice it's all the ones and zeros like we saw before.

Now the thing you need to appreciate is that a single frame can be up to fifteen hundred bytes long.

So if there's 8 bits to a byte.

So that would be just around 10000 ones and zeros to represent one single frame.

So if we scale this down a little bit you can't even see the ones and zeros.

So because frames are relatively long so that's just how they show up.

And that's part of why we use these little blocks to represent individual frames.

So a frame is actually generated inside the network card data comes down, from whatever applications

Microsoft Word or web browsers or whatever it might be comes down, into the network card itself. The network

card creates the frame and shoots it out into the network. Equally

frames are eaten up by network cards. As a frame comes into a network card

the data is pulled away sent up to whatever software needs it and that it's actually wiped out within

the network card itself.

So to appreciate a frame what we need to understand is that we use blocks like this as a representation.

Frames are always going to be a maximum of fifteen hundred bytes and they have a discrete beginning and a discrete

end.

And remember frames are created and eaten up within the network card itself.