IP addresses and subnetting in Year 4 at technical institute

Mid-September 2026, computer science and telecommunications track (Italian Informatica e telecomunicazioni, at technical institutes): in Year 4, the subject Systems and networks (Sistemi e reti) opens the year with the network layer, and in these weeks IPv4 addressing arrives, with subnet masks and subnetting. The first test falls five to eight weeks later, so between the end of October and mid-November — and it is almost always timed, because subnetting is assessed on speed of calculation, not just correctness.

It is the topic on which, in Year 4, half the class falls. Not because it is conceptually hard: because it requires you to reason in binary under time pressure, and in a test there is no room to redo the calculations calmly. The class splits into two groups: those who have understood that all of subnetting rests on reasoning about the bits, and those who try to learn mask tables by heart without understanding where they come from. The first group copes even when the exercise is different from those seen in class; the second gets stuck at the first variation. In this post we look at both methods — the bit method, which is always fine, and the shortcut of the “magic number”, which is faster but requires you to have understood the first in order to know when it applies.

It is worth adding, in two lines and without promising specific career paths: this is also the most directly usable part of the Systems and networks syllabus, because the same skills are the first step of any path as a systems administrator or in networking.

Structure of an IPv4 address

An IPv4 address is a 32-bit number, which for readability we write in dotted decimal notation: four decimal numbers (from 0 to 255, that is each one a byte) separated by a dot, like 192.168.10.5. Each group of 8 bits is called an octet. An IP address, on its own, doesn’t say which part represents the network and which the individual device (host): that information comes from the subnet mask.

Network part, host part, and the subnet mask

Every IP address is divided into two parts: a network part, which identifies the network the device belongs to, and a host part, which identifies the individual device within that network. The subnet mask says where the boundary between the two parts falls: it has all bits at 1 in the network part and all at 0 in the host part.

The mask is written in two equivalent ways:

• in decimal, like the IP address: 255.255.255.0;
• in CIDR notation, like /24, where the number indicates how many bits (counted from the left) are dedicated to the network.

/24 and 255.255.255.0 are the same mask: 24 bits at 1 (the first three octets) followed by 8 bits at 0 (the last octet, reserved for the host).

Why classes are mentioned only as historical context

The old classes A, B and C (with fixed masks /8, /16, /24 respectively) are now history: the network today works in classless mode, that is with masks of any length, decided according to how many addresses are really needed — not bound to fixed sizes. It is worth knowing as context to understand where the language comes from (“class C”), but it is not a syllabus to learn by heart: the rest of this post reasons in CIDR, which is how you will really work.

Network address, broadcast, usable hosts

Inside every block of addresses (a subnet), three values have a special role:

• the network address: the one with all the host-part bits at 0. It identifies the subnet itself, not a device.
• the broadcast address: the one with all the host-part bits at 1. It is used to send a message to all the devices of the subnet at once.
• the usable hosts: all the addresses of the subnet except these two extremes.

If a subnet has $h$ bits dedicated to the host part, it contains $2^h$ addresses in total, but only $2^h-2$ can be assigned to devices: the network address and the broadcast address are always subtracted, because they never identify a real host.

Bitwise AND: how to get the network from an address

To find the network address starting from an IP address and its mask, you perform a bitwise logical AND between the two: bit by bit, the result is 1 only if both bits are 1, otherwise it is 0.

Worked example — 192.168.10.130 with mask 255.255.255.192 (/26):

We convert the last octet to binary (the other three stay identical, because the mask has 1 on all their bits): $130_{10}=10000010_2$, and the mask on the last octet is $192_{10}=11000000_2$.

  10000010   (130, last octet of the address)
& 11000000   (192, last octet of the mask)
----------
  10000000   (128)

The bitwise AND gives $10000000_2=128_{10}$. The network address is therefore 192.168.10.128, with mask /26.

Subnetting: dividing a block into smaller subnets

Subnetting consists of “borrowing” bits from the host part of a block to create more, smaller subnets. If you borrow $n$ bits, you get $2^n$ subnets, each with the remaining host bits available for addresses.

The two formulas to always keep in mind:

where $n$ is the number of borrowed bits and $h$ the number of host bits left after borrowing.

The magic number method

Once you have understood the reasoning on the bits, there is a much faster shortcut for listing the subnets: the magic number. It is calculated as $256$ minus the decimal value of the mask octet that contains the boundary between network and host. The subnets all start at multiples of that number, in the same octet.

For example, with mask /26 the last octet of the mask is $192$: the magic number is $256-192=64$. The subnets therefore start from .0, .64, .128, .192 — exactly every 64 addresses. The magic number works only when you have already understood why those jumps form: it is a calculation shortcut, not a way of skipping the understanding of the bits.

Private addresses: which they are and what they are for

Three blocks of IPv4 addresses are reserved for private networks (those not directly reachable from the internet, like a home or company network): 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16. Being able to recognise them lets you tell straight away, by looking at an address, whether it belongs to a local network or to the public internet — information that is useful outside this test too, every time you configure a router or read network logs.

Summary table: CIDR, mask, usable hosts

Three worked exercises (numbers checked twice)

Exercise 1 — dividing 192.168.10.0/24 into 4 subnets.

To get 4 subnets you need $2^n=4$, so $n=2$ bits borrowed from the host part. The new mask is $/24+2=/26$. The magic number is $256-192=64$ (with /26, the last octet of the mask is 192). The four subnets start every 64 addresses:

Each /26 subnet has $2^6-2=62$ usable hosts (6 host bits left out of 32-26=6). Consistency check: the last host of each subnet is always the broadcast minus 1, and the broadcast is always the address just before the start of the next subnet — here .63 precedes .64, .127 precedes .128, and so on. It matches.

Exercise 2 — finding the network and broadcast of 172.16.37.200/21.

With /21, the boundary between network and host falls inside the third octet (21 network bits = the first two whole octets, 16 bits, plus 5 bits of the third octet; so 3 host bits remain in the third octet plus the whole fourth: $32-21=11$ host bits in total). We convert the third octet, $37$, to binary: $37_{10}=00100101_2$. The mask on the third octet has the first 5 bits at 1 (they are the network bits left after the first two whole octets) and the last 3 at 0: $11111000_2=248_{10}$.

  00100101   (37, third octet of the address)
& 11111000   (248, third octet of the mask)
----------
  00100000   (32)

The AND gives $32$. The first two octets stay unchanged (172.16, all network bits), the fourth octet goes entirely to 0 in the network address: network address = 172.16.32.0. For the broadcast, the host bits (the last 3 of the third octet plus the whole fourth) all go to 1: the third octet becomes $00100111_2=39_{10}$, the fourth octet is $255$: broadcast = 172.16.39.255. The subnet therefore covers from 172.16.32.0 to 172.16.39.255.

Exercise 3 — at least 50 hosts per subnet are needed: which mask?

You need to find the minimum number of host bits $h$ such that $2^h-2\ge 50$. Let’s try:

• with $h=5$: $2^5-2=32-2=30$. Not enough (30 < 50).
• with $h=6$: $2^6-2=64-2=62$. Enough (62 ≥ 50).

So 6 host bits are needed, that is a mask with $32-6=26$ network bits: /26. The mask /27 leaves only 5 host bits, which give 30 usable hosts — not enough for 50 devices, even though the difference between 27 and 26 seems small: each host bit fewer halves the capacity of the subnet.

Typical mistakes that cost marks

For Systems and networks we don’t yet have a dedicated practice test; at /simulazioni/liceo/ you’ll find the high school maths and physics tests, the closest category for practising timed exercises — I’m not promising that a specific practice test on subnetting will arrive, but if it does you’ll find it there.

Whoever arrives at Systems and networks having already digested loops and arrays in Year 3 computer science usually has less difficulty here: step-by-step reasoning on bits requires the same discipline as reading an algorithm line by line before running it. And if at this time you are also preparing the databases, ER model and SQL exam, the method of preparing — sketching on paper before writing — is the same.

For the layers above IP addresses, look at the post on the OSI and TCP/IP model; the syllabus continues in Year 5 with VLANs and security.

Computer science lessons are online, one to one, and on this topic the typical work is exactly redoing the subnetting exercises by hand together, stopwatch in hand, until the bit method becomes automatic. If you’d like a hand, the first introductory call is free and lasts half an hour.