WEBVTT

00:00:00.000 --> 00:00:03.700
Welcome back to CSE 316 — Data Communication and Networking.

00:00:03.750 --> 00:00:12.120
This is the detailed video version of Session twelve, and it is your first contact with subnetting.

00:00:12.170 --> 00:00:18.790
Before anything else: how did the five timed runs go? Today re-uses that ritual once per subnet.

00:00:18.840 --> 00:00:27.790
Because the continuity is the content. There are exactly two new ideas in this session, and everything else is last session's ritual, run once per piece.

00:00:29.180 --> 00:00:38.130
If the ritual is still shaky, pause here and go back one video. It is quicker than pushing on.

00:00:38.367 --> 00:00:41.857
New problem, and it is a real one.

00:00:41.907 --> 00:00:50.857
The university was given one block. One nine two dot one six eight dot one dot zero, slash twenty-four. Two hundred and fifty-six addresses, delivered as a single piece.

00:00:54.127 --> 00:00:59.657
This building has four labs, and each lab has to be its own network.

00:00:59.707 --> 00:01:02.847
So, two questions. Where exactly do you cut?

00:01:02.897 --> 00:01:10.307
And once you have cut — what are the four pieces even called? They cannot all be one nine two dot one six eight dot one dot zero.

00:01:10.357 --> 00:01:19.307
Write down where you would cut, and what you would call each piece. Slide thirty-eight compares your answer with the design.

00:01:19.657 --> 00:01:24.977
And a promise about the shape of the hour: there are two new ideas today, and only two.

00:01:25.027 --> 00:01:31.759
Borrowed bits, and naming. Everything else you already have.

00:01:31.809 --> 00:01:34.059
Section one. Why cut at all.

00:01:34.109 --> 00:01:36.959
One route outside, many networks inside.

00:01:37.009 --> 00:01:45.959
Subnetting is not really about addresses. It is about how many networks a building has — and about keeping that fact private.

00:01:47.809 --> 00:01:51.379
Start with why the knife is needed at all.

00:01:51.429 --> 00:01:59.989
Routers deliver to networks. One network address means one entry in the campus router, and one entry means one destination.

00:02:00.039 --> 00:02:06.389
It cannot tell Lab A from Lab D, because as far as it can see they are the same place.

00:02:06.439 --> 00:02:15.389
So frames go everywhere. Every lab hears every other lab's traffic, and the four broadcast domains merge into one.

00:02:15.859 --> 00:02:24.809
Each lab needs its own network address. Which means four network addresses — out of a block that arrived carrying exactly one.

00:02:25.169 --> 00:02:34.119
And the shape of that matters. The problem is not "how do I get more addresses" — the addresses are already there, all two hundred and fifty-six of them.

00:02:34.469 --> 00:02:37.749
The problem is: how do I get more NETWORKS out of them?

00:02:37.799 --> 00:02:46.749
Subnetting never creates addresses. It creates boundaries between addresses that already exist.

00:02:47.155 --> 00:02:51.865
And here is the part that makes it elegant rather than merely useful.

00:02:51.915 --> 00:03:00.865
The Internet keeps one route. Everything for one nine two dot one six eight dot one dot zero slash twenty-four goes to the university.

00:03:01.455 --> 00:03:06.905
One line in a routing table — exactly as it was before the split.

00:03:06.955 --> 00:03:14.505
The four-way split exists only inside. It is the university's own business how many networks live behind that route.

00:03:14.555 --> 00:03:21.835
The split is invisible from outside, and that invisibility is the point, not a side effect.

00:03:21.885 --> 00:03:30.835
And it nests. You can subnet a subnet — faculties inside a university inside a country, sub-sub-networks all the way down, each level hiding the one below it.

00:03:32.945 --> 00:03:41.895
That is the same hierarchy idea you meet again in Session sixteen as aggregation, running in the opposite direction.

00:03:43.255 --> 00:03:50.295
So where do the extra networks come from? This is the first new idea, and it is one sentence long.

00:03:50.345 --> 00:03:59.295
The address is thirty-two bits, and it stays thirty-two bits. There is no thirty-third bit to invent, and no room to add one.

00:03:59.825 --> 00:04:07.905
The twenty-four network bits are untouchable. They name the university's block, and the outside world routes on them.

00:04:07.955 --> 00:04:15.175
But the eight host bits are yours. They are inside your block, and nobody outside cares what you do with them.

00:04:15.225 --> 00:04:24.175
So take two of them for a subnet id. Two bits give four names — and leave six bits, sixty-four addresses, for hosts in each subnet.

00:04:24.985 --> 00:04:33.069
"Borrow" is not free. Every bit you take is an address range you no longer have.

00:04:33.119 --> 00:04:41.519
You will see this written as a formula: n sub equals n plus log base two of the number of subnets.

00:04:41.569 --> 00:04:50.169
Twenty-four plus log base two of four is twenty-four plus two, which is twenty-six. So the new prefix is slash twenty-six.

00:04:50.219 --> 00:04:58.149
That is the only arithmetic in the formula, and it is the same arithmetic as "two bits give four names".

00:04:58.199 --> 00:05:06.129
The formula does not tell you anything new. It is bookkeeping for a sentence: two bits moved from the host part to the network part.

00:05:06.179 --> 00:05:10.429
If you can say the sentence, you do not need the formula.

00:05:10.479 --> 00:05:14.829
And it only works for powers of two. Three subnets is not a thing.

00:05:14.879 --> 00:05:22.679
You cut into two, four, eight, sixteen — because you are borrowing whole bits, and there is no half a bit.

00:05:22.729 --> 00:05:30.848
If a question asks for three equal subnets, it means four, and one spare.

00:05:30.898 --> 00:05:35.628
The exchange rate. Four words, and they never waver.

00:05:35.678 --> 00:05:43.088
Each borrowed bit doubles the number of subnets. One bit is two, two bits is four, three bits is eight.

00:05:43.138 --> 00:05:49.618
It is the same doubling as the block-size rule from last session, read from the other end.

00:05:49.668 --> 00:05:56.718
And halves the size of each. Two subnets of a hundred and twenty-eight, four of sixty-four, eight of thirty-two.

00:05:56.768 --> 00:06:02.758
You are not losing addresses. You are cutting them into more, smaller pieces.

00:06:02.808 --> 00:06:10.718
And the total never moves. Four times sixty-four is two fifty-six. Eight times thirty-two is two fifty-six.

00:06:10.768 --> 00:06:14.798
Borrowing redistributes; it never mints.

00:06:14.848 --> 00:06:23.378
Which means the cost of a network is real and immediate. Every extra lab you can name costs you half of what the previous split left.

00:06:23.428 --> 00:06:28.138
That trade is the whole of ISP allocation, three sessions from now.

00:06:28.188 --> 00:06:37.138
Write "doubles and halves" at the top of every subnetting answer. It is the check that catches arithmetic slips on this topic.

00:06:39.331 --> 00:06:45.311
Here is the whole exchange rate laid out for a slash twenty-four.

00:06:45.361 --> 00:06:54.311
Borrow one: two subnets, a hundred and twenty-eight addresses each. A hundred and twenty-six usable hosts per subnet.

00:06:54.481 --> 00:07:02.011
Borrow two: four subnets, sixty-four each. Sixty-two usable — and sixty-two is the number the exam wants.

00:07:02.061 --> 00:07:07.641
This is the four labs, solved, and we will do it properly in a moment.

00:07:07.691 --> 00:07:16.401
Borrow three: eight subnets, thirty-two each. Thirty usable, which is a small lab and a tight fit.

00:07:16.451 --> 00:07:25.401
Borrow four: sixteen subnets, sixteen each. Fourteen usable — and now the minus two is a fifth of the whole block.

00:07:25.961 --> 00:07:34.911
And down the middle, the total never moves. Two times one twenty-eight, four times sixty-four, eight times thirty-two, sixteen times sixteen. Two hundred and fifty-six, every time.

00:07:38.331 --> 00:07:46.361
Now look only at the last column, because it is the one that does something different: the usable count shrinks faster than the block does.

00:07:46.411 --> 00:07:55.361
The smaller the subnet, the larger the fraction of it you lose to the network and broadcast addresses. That matters in Session fifteen, where small sub-blocks go to real customers.

00:08:00.798 --> 00:08:05.688
Checkpoint one. Paper, pen, and stop the video.

00:08:05.738 --> 00:08:13.388
One. Why can a router not simply be told "these four labs are different" without subnetting?

00:08:13.438 --> 00:08:20.738
Two. You need eight subnets from a slash twenty-four. How many bits do you borrow, and what is the new prefix?

00:08:20.788 --> 00:08:27.988
Three. A colleague says subnetting "gives you more addresses". Correct them in one sentence.

00:08:28.038 --> 00:08:28.978
Answers.

00:08:29.028 --> 00:08:37.978
One. Because a router forwards on network addresses. Four labs sharing one network address are one destination as far as it can see, and there is nothing in the packet to tell them apart.

00:08:41.678 --> 00:08:50.628
Two. Three bits, because two cubed is eight. The new prefix is twenty-four plus three, slash twenty-seven, and each subnet holds thirty-two addresses.

00:08:52.798 --> 00:09:01.748
Three. It does not. It redistributes the same addresses into more, smaller networks — and it costs you two addresses per subnet in the process.

00:09:04.898 --> 00:09:07.328
Section two. The four labs.

00:09:07.378 --> 00:09:09.388
Cut it, and name the pieces.

00:09:09.438 --> 00:09:18.388
Two new ideas, and that is all: the borrowed bits become the subnet id, and each piece is named by its own first address with a longer prefix.

00:09:22.422 --> 00:09:29.922
Look at what physically happens to the thirty-two bits, because it is smaller than people expect.

00:09:29.972 --> 00:09:38.922
Before: twenty-four network bits, eight host bits. One flat network of two hundred and fifty-six addresses, with no internal structure at all.

00:09:40.502 --> 00:09:44.882
After: twenty-four network bits, two subnet bits, six host bits.

00:09:44.932 --> 00:09:50.692
The same thirty-two bits. Two of them simply changed which side they are on.

00:09:50.742 --> 00:09:59.232
And the two subnet bits are a name, not a quantity. Zero-zero, zero-one, one-zero, one-one — four names, in binary order.

00:09:59.282 --> 00:10:05.842
They identify WHICH subnet. They say nothing about how big it is.

00:10:05.892 --> 00:10:10.852
And inside any one subnet, the boundary simply sits at twenty-six.

00:10:10.902 --> 00:10:19.852
Which is to say: a subnet is a block. There is no new kind of object here — and that is the whole reason today is easy.

00:10:22.055 --> 00:10:27.305
The load-bearing sentence of the session: a subnet is a block.

00:10:27.355 --> 00:10:36.305
The ritual still applies, unchanged. N equals two to the thirty-two minus n. Mask from the slash. First equals address AND mask. Last equals first plus N minus one.

00:10:38.905 --> 00:10:47.855
The only difference is which n you use. For a subnet, n is the new prefix — twenty-six, not twenty-four.

00:10:47.955 --> 00:10:53.175
Everything else is identical, and that is not a coincidence. It is the design.

00:10:53.225 --> 00:10:59.625
So you learned subnetting last session. You just did not know what it was for.

00:10:59.675 --> 00:11:07.062
Today is the application, and the application is where the marks are.

00:11:07.112 --> 00:11:15.192
So: the four labs. Two borrowed bits, four pieces of sixty-four, and let us do the first two slowly.

00:11:15.242 --> 00:11:21.982
Subnet one starts where the block starts: one nine two dot one six eight dot one dot zero.

00:11:22.032 --> 00:11:30.982
Size sixty-four, so the last address is nought plus sixty-three — dot sixty-three. That is last session's arithmetic, untouched.

00:11:32.172 --> 00:11:40.492
And its name — this is the second new idea — is its own first address, with the NEW prefix. Slash twenty-six.

00:11:40.542 --> 00:11:49.422
Not slash twenty-four. The slash twenty-four names the whole cake; this piece has a longer name because it is a smaller place.

00:11:49.472 --> 00:11:54.962
Subnet two begins where subnet one stopped, plus one. Dot sixty-four.

00:11:55.012 --> 00:12:03.962
Last address: sixty-four plus sixty-three, dot one twenty-seven. Name: one nine two dot one six eight dot one dot sixty-four, slash twenty-six.

00:12:05.002 --> 00:12:13.952
This is last session's arithmetic: first, plus N minus one, starting from a different first, four times over.

00:12:14.522 --> 00:12:23.388
Nothing new is happening in the arithmetic. The only new thing is the name.

00:12:24.478 --> 00:12:30.388
Forty-two seconds, and the whole of the borrowing idea, one step at a time.

00:12:30.438 --> 00:12:39.388
There is the starting position. Twenty-four network bits in blue, eight host bits in amber, and one network address for the whole building.

00:12:39.598 --> 00:12:44.518
Four labs, and no way for the router to tell them apart.

00:12:44.568 --> 00:12:51.148
And there is the constraint. You cannot invent a thirty-third bit. The address is thirty-two bits and it stays thirty-two bits.

00:12:51.198 --> 00:12:58.078
So the subnet id has to be carved out of something — and the only spare bits are the amber ones.

00:12:58.128 --> 00:13:03.528
Watch the two cells turn green. They were host bits; they are now the subnet id.

00:13:03.578 --> 00:13:12.528
That is the whole mechanism. The formula underneath — twenty-four plus log two of four is twenty-six — is bookkeeping for those two cells moving.

00:13:14.988 --> 00:13:21.478
And now the payoff. The two green bits count: zero-zero, zero-one, one-zero, one-one.

00:13:21.528 --> 00:13:29.308
Four names, in binary order — and each row is a subnet, named by its own first address with the new prefix.

00:13:29.358 --> 00:13:34.308
Which lands them at nought, sixty-four, one twenty-eight, one ninety-two.

00:13:34.358 --> 00:13:42.768
Nobody chose those numbers. The moment you said "four equal pieces", the borrowed bits chose them for you.

00:13:42.818 --> 00:13:49.588
The rate, in one table. Borrow one, two, three — and the total is two fifty-six every time.

00:13:49.638 --> 00:13:57.178
Four times sixty-four is still two hundred and fifty-six. Borrowing redistributes; it never mints.

00:13:57.228 --> 00:14:03.548
And the freeze frame. One borrowed bit, one cut. Names change, addresses do not move.

00:14:03.598 --> 00:14:12.548
Outside, the world still keeps one route: slash twenty-four, straight to the university. The split exists only inside.

00:14:15.081 --> 00:14:20.321
Here is the finished design, standing still.

00:14:20.371 --> 00:14:29.321
Subnet one: one nine two dot one six eight dot one dot zero, slash twenty-six. Last address dot sixty-three. Subnet bits zero-zero.

00:14:31.331 --> 00:14:40.281
Subnet two: dot sixty-four, slash twenty-six. Last address dot one twenty-seven. Subnet bits zero-one — and the start is one times sixty-four.

00:14:43.981 --> 00:14:52.931
Subnet three: dot one twenty-eight, slash twenty-six. Last address dot one ninety-one. Subnet bits one-zero, and the start is two times sixty-four.

00:14:56.441 --> 00:15:05.391
Subnet four: dot one ninety-two, slash twenty-six. Last address dot two fifty-five. Subnet bits one-one, and the start is three times sixty-four.

00:15:08.911 --> 00:15:17.861
And every one of them: sixty-four addresses, sixty-two usable hosts, mask two five five dot two five five dot two five five dot one ninety-two.

00:15:18.691 --> 00:15:27.641
Copy that table once by hand. Then cover it and rebuild it from "four pieces of sixty-four" alone. That is the skill — not the table.

00:15:31.746 --> 00:15:39.046
Before you hand any subnet design to anyone, two checks. They take about ten seconds.

00:15:39.096 --> 00:15:47.786
Every start divides by the piece size. Nought, sixty-four, one twenty-eight, one ninety-two — all multiples of sixty-four.

00:15:47.836 --> 00:15:53.516
That is the alignment rule from last session, doing real work for the first time.

00:15:53.566 --> 00:16:00.116
The last piece ends flush at dot two fifty-five. So the block is exactly spent: no gap, and no overlap.

00:16:00.166 --> 00:16:09.116
If either check fails, the design is not "slightly off". It is wrong, in a way a router would reject — or worse, silently misroute.

00:16:10.396 --> 00:16:16.976
And this is the answer to the hook: nobody chose those four numbers.

00:16:17.026 --> 00:16:21.816
The moment you said "four equal pieces", the borrowed bits chose them for you.

00:16:21.866 --> 00:16:30.816
These are the same two checks you will use to grade your own ISP allocation in Session fifteen, before anyone else grades it.

00:16:32.764 --> 00:16:39.774
Now the second new idea, on its own slide: naming. It is the half that gets dropped.

00:16:39.824 --> 00:16:46.974
A subnet's name is its own first address. Exactly like a block's name — nothing new there.

00:16:47.024 --> 00:16:53.124
And the prefix is the new one. One nine two dot one six eight dot one dot sixty-four, slash twenty-six.

00:16:53.174 --> 00:17:02.124
Writing slash twenty-four there is not a typo. It names a different, larger thing, and it is marked wrong.

00:17:02.524 --> 00:17:08.074
Longer prefix, smaller place. The prefix length is a measure of specificity.

00:17:08.124 --> 00:17:17.074
Slash twenty-four is the university; slash twenty-six is one lab inside it. The name literally encodes its position in the hierarchy.

00:17:17.564 --> 00:17:26.514
Hold on to that phrase. In Session seventeen it becomes longest-prefix match, and it is the same sentence.

00:17:28.698 --> 00:17:33.688
Drill. Ten dot zero dot zero dot zero, slash twenty-four, into eight subnets.

00:17:33.738 --> 00:17:42.688
How many bits do you borrow? What is the new prefix? How many addresses each? And what is the first address of subnet three?

00:17:44.248 --> 00:17:53.138
Two minutes, on paper, alone. Write the answers down before you restart — reading along is not drilling.

00:17:53.188 --> 00:18:02.048
Answers. Eight subnets is three borrowed bits, so twenty-four plus three, slash twenty-seven. Each piece holds thirty-two addresses.

00:18:02.098 --> 00:18:10.618
And subnet three starts at three minus one, times thirty-two. Sixty-four. Ten dot zero dot zero dot sixty-four.

00:18:10.668 --> 00:18:19.599
If you wrote ten dot zero dot zero dot ninety-six, the next slide is about that error.

00:18:20.619 --> 00:18:29.569
Subnet one starts at zero. Not at "size". The first piece begins where the block begins, and no addresses are skipped.

00:18:29.719 --> 00:18:35.289
So subnet three starts at three minus one, times thirty-two. Sixty-four.

00:18:35.339 --> 00:18:41.039
Two pieces along, not three. Count the gaps, not the pieces.

00:18:41.089 --> 00:18:50.039
Ninety-six is subnet four, not subnet three. Writing k times the size, instead of k minus one times the size, shifts every answer one piece to the right.

00:18:53.629 --> 00:18:58.139
And it is the same slip as plus-N from last session, pointing the other way.

00:18:58.189 --> 00:19:04.819
Both come from forgetting that the first thing is number zero. One habit, costing marks in two places.

00:19:04.869 --> 00:19:13.819
Engineers count from zero. Say it while you write the multiplication out, rather than counting pieces along the bar in your head.

00:19:15.682 --> 00:19:19.812
Checkpoint two. Stop the video.

00:19:19.862 --> 00:19:28.692
One. Cut two hundred dot ten dot five dot zero slash twenty-four into four. Give all four names, with prefixes.

00:19:28.742 --> 00:19:37.442
Two. In that design, what is the last address of subnet two, and how many usable hosts does it hold?

00:19:37.492 --> 00:19:46.442
Three. A slash twenty-four is cut into eight. Where does subnet six start — and how did you get there without listing the others?

00:19:47.812 --> 00:19:48.302
Answers.

00:19:48.352 --> 00:19:57.302
One. Two hundred dot ten dot five dot zero slash twenty-six, dot sixty-four slash twenty-six, dot one twenty-eight slash twenty-six, dot one ninety-two slash twenty-six. Four pieces of sixty-four, and every name carries the new prefix.

00:20:04.522 --> 00:20:13.472
Two. Subnet two runs dot sixty-four to dot one twenty-seven, so the last address is two hundred dot ten dot five dot one twenty-seven. Sixty-four addresses, sixty-two usable.

00:20:18.092 --> 00:20:27.042
Three. Six minus one, times thirty-two, is one hundred and sixty. Subnet k starts at k minus one times the piece size — no listing required.

00:20:31.146 --> 00:20:34.046
Section three. The slash twenty-two.

00:20:34.096 --> 00:20:36.816
The cut is not always in the last octet.

00:20:36.866 --> 00:20:45.816
The labs were gentle: a slash twenty-four, with everything visible in the last octet. Real allocations are bigger, and the knife lands somewhere else.

00:20:50.046 --> 00:20:58.996
Remember the block I made you write down last session? Eleven dot ten dot zero dot zero, slash twenty-two. A thousand and twenty-four addresses.

00:21:02.056 --> 00:21:04.166
Time to take the knife to it.

00:21:04.216 --> 00:21:12.116
One cut needs one borrowed bit, so n_sub is twenty-three. Each half holds five hundred and twelve.

00:21:12.166 --> 00:21:18.906
Same exchange rate, larger starting capital. Nothing about the rule changed.

00:21:18.956 --> 00:21:22.706
And five hundred and twelve is two runs of two fifty-six.

00:21:22.756 --> 00:21:29.606
So each half owns two whole values of the third octet — not two halves of the last one.

00:21:29.656 --> 00:21:38.606
Subnet one: eleven dot ten dot zero dot zero, slash twenty-three. Third octet spans zero and one, so the last address is eleven dot ten dot one dot two fifty-five.

00:21:41.256 --> 00:21:50.206
Subnet two: eleven dot ten dot two dot zero, slash twenty-three. Third octet spans two and three, ending eleven dot ten dot three dot two fifty-five. The block is exactly spent.

00:21:51.986 --> 00:21:59.416
And here is where decimal intuition fails: the halves do NOT start at dot zero and dot one twenty-eight.

00:21:59.466 --> 00:22:08.416
The borrowed bit lives in the third octet, so the cut lands there. Mid-octet thinking from last session, still earning.

00:22:12.476 --> 00:22:19.716
Forty-two seconds. The same block, cut twice, with the third octet doing all the work.

00:22:19.766 --> 00:22:24.326
One block, one network address, a thousand and twenty-four addresses.

00:22:24.376 --> 00:22:33.326
And the third octet walks zero, one, two, three — that is what a slash twenty-two means in the octet where it lands.

00:22:34.076 --> 00:22:39.376
One borrowed bit, so slash twenty-three, and two halves of five hundred and twelve.

00:22:39.426 --> 00:22:47.246
Look at the fact strip: exactly the same four numbers you have been computing all session, on a bigger block.

00:22:47.296 --> 00:22:53.536
The gut says dot zero and dot one twenty-eight, because that is where a slash twenty-four would have been cut.

00:22:53.586 --> 00:23:02.536
But a half of a thousand and twenty-four is five hundred and twelve — and five hundred and twelve addresses cannot fit inside one octet. So the cut lands in octet three.

00:23:05.756 --> 00:23:14.706
Subnet one. Two clicks of the third octet: zero, then one. Last address eleven dot ten dot one dot two fifty-five.

00:23:15.636 --> 00:23:20.256
Counted, not added — exactly as last session taught you.

00:23:20.306 --> 00:23:29.256
Subnet two picks up where subnet one stopped, plus one. Third octet two and three, ending eleven dot ten dot three dot two fifty-five.

00:23:30.436 --> 00:23:34.756
No gap, no overlap: the block is exactly spent.

00:23:34.806 --> 00:23:43.756
Now cut each half once more. Two borrowed bits, and watch the third octet: zero zero zero zero zero zero, and then two bits that simply count.

00:23:44.686 --> 00:23:49.416
Zero-zero is nought, zero-one is one, one-zero is two, one-one is three.

00:23:49.466 --> 00:23:58.416
Four slash twenty-fours, named eleven dot ten dot zero dot zero, dot one dot zero, dot two dot zero, dot three dot zero.

00:24:00.026 --> 00:24:08.976
And the freeze frame: names change, addresses do not move. Eleven dot ten dot two dot seven was in the block before the cuts, and it is in the block after them. Only its street name got longer.

00:24:16.830 --> 00:24:21.700
The second cut is the cleanest illustration of the whole idea.

00:24:21.750 --> 00:24:26.850
Cut each slash twenty-three once more and you have four slash twenty-fours.

00:24:26.900 --> 00:24:35.850
Two borrowed bits now, and they live in the bottom two positions of the third octet — which is what zero zero zero zero zero zero b b means.

00:24:36.930 --> 00:24:45.000
And the two bits simply count. Zero-zero is nought. Zero-one is one. One-zero is two. One-one is three.

00:24:45.050 --> 00:24:54.000
So the names are eleven dot ten dot zero dot zero, dot one dot zero, dot two dot zero, dot three dot zero — each a slash twenty-four.

00:24:56.350 --> 00:25:01.350
Once you see subnet names as counters, you can never again cut in the wrong place.

00:25:01.400 --> 00:25:08.394
The names are not chosen and then checked. They fall out of the bits.

00:25:08.444 --> 00:25:14.284
The answer row for the slash twenty-two, so you can copy it.

00:25:14.334 --> 00:25:23.284
Subnet one: eleven dot ten dot zero dot zero slash twenty-four, last address eleven dot ten dot zero dot two fifty-five. Third octet zero, borrowed bits zero-zero.

00:25:26.714 --> 00:25:35.664
Subnet two: eleven dot ten dot one dot zero slash twenty-four. Third octet one, borrowed bits zero-one.

00:25:36.024 --> 00:25:44.974
Subnet three: eleven dot ten dot two dot zero slash twenty-four. Third octet two, borrowed bits one-zero.

00:25:45.454 --> 00:25:54.404
Subnet four: eleven dot ten dot three dot zero slash twenty-four. Third octet three, borrowed bits one-one, ending at eleven dot ten dot three dot two fifty-five.

00:25:59.054 --> 00:26:07.704
And outside: still one route. Eleven dot ten dot zero dot zero, slash twenty-two, exactly as before the cuts.

00:26:07.754 --> 00:26:15.694
One borrowed bit, one cut. Names change, addresses do not move.

00:26:16.744 --> 00:26:23.924
Here is the cutting, as something you can do with a mouse — including the cut it will refuse to make.

00:26:23.974 --> 00:26:31.204
It opens on the block as delivered. Zero borrowed bits, one network, two hundred and fifty-six addresses.

00:26:31.254 --> 00:26:36.054
One bar, one name, and four labs with nowhere to go.

00:26:36.104 --> 00:26:45.034
One click, one borrowed bit. Two subnets of a hundred and twenty-eight, named dot zero and dot one twenty-eight, both slash twenty-five.

00:26:45.084 --> 00:26:54.034
Watch the four tiles across the top move together: borrowed bits, new prefix, subnet count, size. That is the exchange rate, live.

00:26:55.854 --> 00:27:04.804
Second click. Four subnets of sixty-four — and there is the four-lab design, complete, with sixty-two usable hosts each.

00:27:05.894 --> 00:27:12.174
Now the interesting one. Try to cut at dot one hundred — the proposal from minute one.

00:27:12.224 --> 00:27:21.174
Refused. And it gives the arithmetic, not an opinion: one hundred divided by sixty-four is one point five six two five, so no prefix length produces a piece that starts there.

00:27:24.124 --> 00:27:32.374
The interface physically cannot make that cut. Neither can a router, and neither will the grader.

00:27:32.424 --> 00:27:40.494
Eight pieces from a slash twenty-four. Look at subnet three: it starts at ten dot zero dot zero dot sixty-four, not ninety-six.

00:27:40.544 --> 00:27:46.784
Three minus one, times thirty-two. The tool will not let you count from one.

00:27:46.834 --> 00:27:53.654
And the slash twenty-two, halved. Watch the names: eleven dot ten dot zero dot zero and eleven dot ten dot two dot zero.

00:27:53.704 --> 00:27:58.934
The cut is in the third octet, exactly as the animation showed.

00:27:58.984 --> 00:28:07.904
Cut again, and the borrowed bits count: zero-zero, zero-one, one-zero, one-one — third octet zero, one, two, three.

00:28:07.954 --> 00:28:16.904
Open it after the lecture and try to produce a specific target. Predicting every name before you click is the best ten minutes you can spend on this topic.

00:28:21.389 --> 00:28:25.629
Checkpoint three. Stop the video.

00:28:25.679 --> 00:28:33.289
One. Cut one seventy-two dot sixteen dot four dot zero slash twenty-three into four equal subnets. Give the four names.

00:28:33.339 --> 00:28:42.289
Two. In the slash twenty-two cut into two, why is the second half eleven dot ten dot two dot zero and not eleven dot ten dot zero dot one twenty-eight?

00:28:47.379 --> 00:28:56.329
Three. Which subnet of the slash twenty-two cut into four contains eleven dot ten dot two dot seven, and what is that subnet called?

00:28:56.829 --> 00:28:57.759
Answers.

00:28:57.809 --> 00:29:06.759
One. Two borrowed bits, so slash twenty-five, a hundred and twenty-eight addresses each: one seventy-two dot sixteen dot four dot zero, dot four dot one twenty-eight, dot five dot zero, and dot five dot one twenty-eight — all slash twenty-five.

00:29:13.279 --> 00:29:22.229
Two. Because a half of a thousand and twenty-four is five hundred and twelve, and five hundred and twelve addresses cannot fit inside one octet. The borrowed bit is bit twenty-three, which sits in the third octet, so the cut lands there.

00:29:29.679 --> 00:29:38.629
Three. Subnet three, which is called eleven dot ten dot two dot zero slash twenty-four. The third octet is two, and the borrowed bits are one-zero — the counter reading two.

00:29:44.898 --> 00:29:47.588
Section four. Where you may not cut.

00:29:47.638 --> 00:29:49.388
The grader is a divisor.

00:29:49.438 --> 00:29:58.388
There is exactly one rule about where a cut may fall, and it is arithmetic rather than taste. Round decimal numbers have no standing.

00:30:01.658 --> 00:30:05.578
A cut is legal if the piece it starts divides by the piece size.

00:30:05.628 --> 00:30:14.578
Nought, sixty-four, one twenty-eight, one ninety-two for four pieces of a slash twenty-four. Those are the only four, and there is no fifth.

00:30:16.098 --> 00:30:25.048
Because a subnet is a block, and blocks are aligned. The alignment rule from last session is not advice — it is what makes the AND work at all.

00:30:26.088 --> 00:30:32.588
So dot one hundred is not a cut. A hundred divided by sixty-four is one point five six two five.

00:30:32.638 --> 00:30:41.588
No prefix length produces a piece that starts at dot one hundred, so no mask can find it, and no router can be told about it.

00:30:41.658 --> 00:30:49.058
The splitter you just watched physically cannot make that cut. That is not a limitation of the tool; it is the specification.

00:30:49.108 --> 00:30:58.058
And the exam will offer you a cut at a pretty decimal number, dressed as common sense. Decline it, and say why in one line.

00:31:01.249 --> 00:31:07.889
Somebody always proposes giving each lab a round hundred addresses. It is the perfect wrong answer.

00:31:07.939 --> 00:31:16.889
It is generous, it is round, it is what a human would say — and it cannot be expressed as a prefix, so no router can implement it.

00:31:17.819 --> 00:31:24.389
The sizes must be powers of two, because they come from borrowed bits, and bits come one at a time.

00:31:24.439 --> 00:31:31.589
A hundred is not a power of two — and neither is any number of addresses you would pick by instinct.

00:31:31.639 --> 00:31:37.469
So you round up. A lab of a hundred machines gets a hundred and twenty-eight addresses, not a hundred.

00:31:37.519 --> 00:31:42.379
The waste is real, and in Session fourteen it is the whole design problem.

00:31:42.429 --> 00:31:51.379
A request for a hundred addresses names the constraint exactly: a hundred is not a power of two, so it rounds up to a hundred and twenty-eight.

00:31:54.296 --> 00:31:58.556
The same trap as last session, one level down.

00:31:58.606 --> 00:32:06.396
The first address is the subnet's own name. It names the network, so it cannot also name a machine on it.

00:32:06.446 --> 00:32:15.396
The last address is its broadcast address — everyone on this subnet — and it is reserved for that at every prefix length.

00:32:15.536 --> 00:32:20.926
So a slash twenty-six seats sixty-two machines. Sixty-four minus two.

00:32:20.976 --> 00:32:29.926
A slash twenty-seven seats thirty. A slash twenty-eight seats fourteen — and notice the fraction you lose grows as the pieces shrink.

00:32:30.646 --> 00:32:36.086
But a block has N addresses, full stop. Forouzan counts all sixty-four.

00:32:36.136 --> 00:32:45.086
"Usable", or "hosts", is the signal word that switches you to N minus two. Read the question twice and underline it.

00:32:47.396 --> 00:32:53.696
Three sentences from last session, and every one of them survives today untouched.

00:32:53.746 --> 00:33:00.076
N equals two to the thirty-two minus n. Still true — but n is the new prefix.

00:33:00.126 --> 00:33:08.936
A slash twenty-six subnet holds sixty-four addresses, exactly like any slash twenty-six block anywhere.

00:33:08.986 --> 00:33:15.276
First address equals address AND mask. Still true, and still one octet of real work.

00:33:15.326 --> 00:33:24.276
One nine two dot one six eight dot one dot two hundred, ANDed with two five five dot two five five dot two five five dot one ninety-two, is one nine two dot one six eight dot one dot one ninety-two.

00:33:27.326 --> 00:33:34.026
Last equals first plus N minus one. Still true, and still minus one.

00:33:34.076 --> 00:33:40.916
One ninety-two plus sixty-three is two fifty-five — the end of subnet four, and the end of the block.

00:33:40.966 --> 00:33:49.916
If you can run the ritual, you subnetted today without learning anything new. That was the design of the whole fortnight.

00:33:52.750 --> 00:33:58.720
One look over the fence before we finish, because you can already see the next problem.

00:33:58.770 --> 00:34:06.020
A lab of a hundred, an office of fifty, a server room of ten. Three different sizes, from one block.

00:34:06.070 --> 00:34:14.750
Equal-size subnetting cannot express that without enormous waste — everything would have to be as big as the biggest.

00:34:14.800 --> 00:34:23.750
So you cut unequally. One slash twenty-five, one slash twenty-six, two slash twenty-sevens — from a single slash twenty-four, and every piece still lands on a legal boundary.

00:34:27.870 --> 00:34:36.820
The rule that makes it work is "largest first". Allocate the biggest sub-block at the start of the space, then the next, and alignment takes care of itself.

00:34:38.930 --> 00:34:43.100
That is Session fourteen, and it is worth twelve marks on the final.

00:34:43.150 --> 00:34:49.120
Everything you need for it is in this session and the last one. The only new thing is the ordering.

00:34:49.170 --> 00:34:57.898
Do not attempt unequal sizes yet. Get equal-size cutting to the point of boredom first.

00:34:58.908 --> 00:35:07.188
And here is the drill for the two questions this session actually asks: what is a piece called, and where does an address live?

00:35:07.238 --> 00:35:12.108
It opens with the four labs and one question: what is subnet three called?

00:35:12.158 --> 00:35:21.108
Subnet three is showing question marks, and the four rules sit across the top the whole time. You are meant to work from the piece size, not from the picture.

00:35:23.458 --> 00:35:29.508
Correct. One nine two dot one six eight dot one dot one twenty-eight, slash twenty-six.

00:35:29.558 --> 00:35:37.268
Three minus one, times sixty-four, is one twenty-eight — and the name carries the new prefix.

00:35:37.318 --> 00:35:43.308
And here is the classic slip, marked red: dot one ninety-two, which is subnet four.

00:35:43.358 --> 00:35:50.478
The tool names the mistake rather than just failing you — that reason line is the thing you are practising.

00:35:50.528 --> 00:35:54.818
Second question type. Which subnet does dot two hundred belong to?

00:35:54.868 --> 00:36:01.678
Watch the amber line drop onto the bar — the address lands visibly inside one piece.

00:36:01.728 --> 00:36:09.168
Subnet four. Two hundred divided by sixty-four is three, and engineers count from zero — so add one.

00:36:09.218 --> 00:36:13.958
That is the same division you did for naming, run backwards.

00:36:14.008 --> 00:36:19.678
And the third type: how many usable hosts? Sixty-two, not sixty-four.

00:36:19.728 --> 00:36:26.838
Three question types, one skill, and the streak counter is the number to chase.

00:36:26.888 --> 00:36:33.778
Last one, on the slash twenty-two: subnet three is eleven dot ten dot two dot zero, slash twenty-four.

00:36:33.828 --> 00:36:42.778
Same arithmetic, bigger block, and the piece size is two fifty-six instead of sixty-four. Nothing else changed.

00:36:44.248 --> 00:36:48.458
Checkpoint four. Stop the video.

00:36:48.508 --> 00:36:55.838
One. How many usable hosts are in one subnet when a slash twenty-four is cut into eight?

00:36:55.888 --> 00:37:03.188
Two. Borrow three bits from a slash twenty-two. How many subnets, at what prefix, of what size?

00:37:03.238 --> 00:37:12.188
Three. A design cuts a slash twenty-four into four and names the third piece one nine two dot one six eight dot one dot one twenty-eight slash twenty-four. Give two separate reasons that is wrong.

00:37:17.138 --> 00:37:18.068
Answers.

00:37:18.118 --> 00:37:26.118
One. Eight subnets means slash twenty-seven and thirty-two addresses each, so thirty usable hosts per subnet.

00:37:26.168 --> 00:37:35.118
Two. Three bits gives eight subnets at slash twenty-five, each holding a hundred and twenty-eight addresses. Same exchange rate, different starting capital.

00:37:37.538 --> 00:37:46.488
Three. First, the prefix is wrong: the name must carry the new prefix, slash twenty-six. Second, slash twenty-four names the entire original block — so that same name would apply to all four pieces at once, which is exactly the confusion subnetting exists to remove.

00:37:57.985 --> 00:38:04.055
Five ways to lose marks. Every one of them showed up in a drill today.

00:38:04.105 --> 00:38:09.875
Wrong: cut the slash twenty-four at dot one hundred so each lab gets a round hundred.

00:38:09.925 --> 00:38:18.875
Right: cuts land on multiples of the piece size — dot zero, sixty-four, one twenty-eight, one ninety-two. A hundred does not divide by sixty-four, so no mask can find that boundary.

00:38:24.025 --> 00:38:29.085
Wrong: subnet three of eight starts at ten dot zero dot zero dot ninety-six.

00:38:29.135 --> 00:38:38.085
Right: dot sixty-four. Subnet k starts at k minus one times the size, and engineers count from zero.

00:38:38.985 --> 00:38:45.685
Wrong: the second lab is called one nine two dot one six eight dot one dot sixty-four slash twenty-four.

00:38:45.735 --> 00:38:53.565
Right: slash twenty-six. The name carries the new prefix — longer prefix, smaller place.

00:38:53.615 --> 00:38:58.215
Wrong: a slash twenty-six subnet holds sixty-four machines.

00:38:58.265 --> 00:39:07.215
Right: sixty-two. The first address is the subnet's name and the last is its broadcast. Watch for the word "usable".

00:39:07.535 --> 00:39:11.655
And wrong: subnetting gives the university more addresses.

00:39:11.705 --> 00:39:20.655
Right: it gives more networks from the same addresses — and costs two per subnet. Borrowing redistributes; it never mints.

00:39:23.012 --> 00:39:26.512
Back to the two questions from minute one.

00:39:26.562 --> 00:39:34.242
Where do you cut? Only on multiples of the piece size. Zero, sixty-four, one twenty-eight, one ninety-two.

00:39:34.292 --> 00:39:42.462
And you never actually chose those numbers. The moment you said "four equal pieces", the borrowed bits chose them for you.

00:39:42.512 --> 00:39:47.582
What are they called? Each piece's own first address, slash the new prefix.

00:39:47.632 --> 00:39:56.582
One nine two dot one six eight dot one dot zero slash twenty-six, dot sixty-four slash twenty-six, dot one twenty-eight slash twenty-six, dot one ninety-two slash twenty-six.

00:40:00.462 --> 00:40:07.172
Longer prefix, smaller place — and the name encodes its position in the hierarchy.

00:40:07.222 --> 00:40:14.422
And the world outside never hears any of it. Still one route, slash twenty-four, still pointing at the university.

00:40:14.472 --> 00:40:23.422
Say the motto once, out loud: one borrowed bit, one cut — names change, addresses do not move.

00:40:24.970 --> 00:40:29.830
Four things you should be able to do now.

00:40:29.880 --> 00:40:38.830
Cut a block into two, four, eight or sixteen equal subnets and name every piece. Borrowed bits, new prefix, first address, last address — in that order.

00:40:40.040 --> 00:40:48.650
Say where subnet k starts without listing the others. k minus one, times the piece size, counting from zero.

00:40:48.700 --> 00:40:57.650
Refuse an illegal cut and give the arithmetic reason — it does not divide by the piece size, so no prefix can express it.

00:41:00.100 --> 00:41:08.170
And audit your own design in ten seconds: every start a multiple, the last piece flush with the end of the block.

00:41:08.220 --> 00:41:17.170
Homework: one seventy-two dot sixteen dot four dot zero slash twenty-three into four, on paper. The eleven dot ten halving from memory. And read Example eighteen point five.

00:41:22.370 --> 00:41:23.990
That is Session twelve.

00:41:24.040 --> 00:41:29.860
Borrow a bit: double the subnets, halve their size — and the cuts choose themselves.

00:41:29.910 --> 00:41:36.510
Every piece is a block, named by its own first address with the NEW prefix. Longer prefix, smaller place.

00:41:36.560 --> 00:41:45.510
And that was the design of the fortnight: if you can run last session's ritual, you subnetted today without learning anything new.

00:41:45.710 --> 00:41:52.740
Before the next session: the slash twenty-three into four, on paper, and the eleven dot ten halving from memory.

00:41:52.790 --> 00:41:59.750
And read Example eighteen point five — three sub-blocks of different sizes, allocated largest first.

00:41:59.800 --> 00:42:08.750
Because real customers do not want equal pieces. One block, three sub-blocks, largest first — and that one wrinkle is worth twelve marks on the final.

00:42:10.070 --> 00:42:14.143
I will see you there.
