This project has been created as part of the 42 curriculum by dlesieur
The 10 level*.json files at the root of this repository are my own exported configurations, verified and working.
NetPractice is a 42 project to "discover the basics of networking": for each of the 10 levels, a non-functioning network diagram is displayed and you must adjust the unshaded fields (IPs, masks, routes) until the network functions properly. The networks are simulated — the addresses are fictitious and not connected to any real-world configuration. To do so, it is necessary to understand the concepts below.
I think it is important to understand that the concepts learnt here are a first hands-on with network practice. There are still many concepts to grasp before we can really say we understand the big picture of networking. You'll find many more documents in wiki/ that push further the concepts we practiced. Hence, this exercise is purely a simplified simulation of configuring small-scale networks.
The level*.json at the root are the turned-in configs, one per level, exported with the Get my config button under my intranet login (dlesieur). All 10 levels were machine-verified as passing: each config was replayed through the simulator's own unmodified checking code (sim.js), and every goal of every level passes, forward and reverse paths included, under the dlesieur seed.
- TCP/IP addressing — an IPv4 address is 32 bits written as four dotted-decimal octets (0–255 each). It is hierarchical: the first bits (the prefix) name the network, the last bits name the host inside it, which is what makes route aggregation — and therefore the internet — scalable. Read more in wiki/ipaddress.md and the hub wiki/README.md.
- Subnet masks & CIDR — the mask is a stencil of 1-bits (network part) and 0-bits (host part);
/Nin CIDR notation just counts the 1-bits. Everything in subnetting reduces to one bitwise AND:network = IP & mask. The magic number shortcut (block size = 256 − interesting mask octet) lets you find any block boundary without binary. Deep dives: wiki/subnet.md, wiki/milestone_02.md, wiki/CIDR_FROM_DECIMAL_NOTATION.md, cheat sheet in wiki/milestone_03.md. - Network & broadcast addresses — the first address of a block (all host bits 0) names the network, the last one (all host bits 1) is the broadcast; neither is assignable to a host. Giving a host the
.0or the.255/block-end of its subnet is the number-one NetPractice error. Untangle the classic.127confusion in wiki/confusion_between_network_addresses_broadcast_size_block.md and wiki/milestone_02.md. - Private ranges (RFC 1918) vs public internet — 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16 are reserved for local networks; they only mean something inside their own LAN and are never routed over the internet (the simulator enforces this). Any segment that must be reachable through the internet node needs public addressing. See wiki/internet_ports.md, wiki/limit_of_ip.md, and the full reserved-ranges table in wiki/README.md.
- Loopback — the whole 127.0.0.0/8 range is short-circuited inside the OS: a packet to 127.x.x.x never touches the network card, so it can never reach another machine. That is why 127.x is never valid on a NetPractice interface (level 2 hands you one on purpose). See wiki/loopback_address.md.
- Switches — a switch forwards Ethernet frames by MAC address, never reads an IP, and has nothing to configure in NetPractice: when a level says KO, the switch is never the culprit. See wiki/switch.md and the layer-2 deep dive wiki/swtich2.md.
- Switch table (MAC/CAM table) — a real switch learns plug-and-play: it reads the source MAC of every incoming frame and records (MAC, port); known destinations go out one port, unknown ones are flooded out every other port, and stale entries age out. Story-style walkthrough in wiki/mac_address.md, the learn/forward/flood/age lifecycle in wiki/swtich2.md.
- Ethernet protocol (frames, MAC) — the frame is the layer-2 envelope: destination MAC + source MAC in the header, at most 1500 bytes of payload, an FCS trailer for error detection. A MAC is a 6-byte IEEE-guaranteed-unique identifier burned into each network card — it identifies a thing, while an IP identifies a place. See wiki/mac_address.md and wiki/swtich2.md.
- ARP (IP → MAC) — the routing decision picks which IP to send to; ARP then answers "what is that IP's MAC?" by broadcasting "who has X?" on the local segment and caching the reply. ARP never crosses a router: for a remote destination it resolves the gateway's MAC instead. See wiki/ARP.md and the two-line summary wiki/mac.md.
- Routers — a router is literally a computer with two or more network cards that forwards packets between them; each interface has its own MAC, its own IP + mask, and sits deliberately on a different subnet. The golden rule: those subnets must not overlap, or longest-prefix match will send packets out a dead interface. See wiki/router.md, hardware internals in wiki/router2.md, and the overlap post-mortem wiki/milestone_04.md.
- Routers vs switches — a switch connects devices inside one subnet (layer 2, MACs); a router connects different subnets (layer 3, IPs). If every host passes the same-subnet check, a switch alone suffices; the moment two network IDs differ, a router must carry the packet. Comparison tables in wiki/milestone_03.md and wiki/swtich2.md.
- Default gateway — the gateway a host is configured with is simply the IP of the router's interface on that host's own LAN; a next hop must always be an address the sender can already reach directly (this is exactly the check that fails with "no interface for gateway"). See wiki/router.md and wiki/GLOSSARY.md.
- Routing table — a list of rules
destination/CIDR → next hop. The destination is not a target but a filter (a catchment area): the packet's destination IP is ANDed against each rule, the longest prefix match wins (a /28 beats a /24 beats the default), anddefault=0.0.0.0/0matches everything. No match and no default = packet dropped, the #1 it-doesn't-ping cause in NetPractice. The mental-model breakthrough lives in wiki/milestone_05.md; mechanics in wiki/router.md; how LPM bites in wiki/milestone_04.md. - The IP protocol (packet, header, TTL) — every packet carries an IP header with source and destination IP that survives end to end, while the Ethernet frame around it is rewritten at every hop. At each router the TTL is decremented; at 0 the packet is discarded (with an ICMP Time Exceeded), which is what prevents routing loops. Underneath-the-hood detail in wiki/ipaddress.md and the full packet lifecycle in wiki/router2.md.
- ISP link & ISP default route — for a host or a router with exactly one exit, a
defaultroute ("shove unknowns upstream") is the clean choice. But the internet node is the top of the hierarchy: it has nothing above it to defer to, so NetPractice rejects a default route on it — you must give the internet an explicit route back down to each of your networks ("it just didn't know the way home until you told it"). See wiki/milestone_06.md and wiki/isp.md. - NAT — thousands of machines with private IPs share one public IP (the router's): the router records (private IP, source port) → (public IP, new port) in a NAT table, rewrites outgoing headers, and demultiplexes replies by port. This is the workaround that keeps IPv4 alive. See wiki/internet_ports.md and the motivation in wiki/limit_of_ip.md.
- Autonomous systems & BGP — the internet is not one network but a mesh of ASes (ISPs, Google, Cloudflare…) tiered by who pays whom for transit; inside an AS link-state protocols (OSPF + Dijkstra) build the map, between ASes BGP announces prefixes by policy, not distance. See wiki/AS.md, wiki/bgp.md, wiki/infrastructure.md.
-
OSI layers — the reference model that slices networking into 7 responsibilities; NetPractice lives almost entirely in layers 2 and 3:
# Layer Role NetPractice object 7 Application HTTP, DNS, SMTP… — 6 Presentation encoding, encryption — 5 Session dialog control — 4 Transport TCP/UDP, ports, reliability — 3 Network IP, routing, gateways IPs, masks, routing tables 2 Data Link Ethernet frames, MACs switches, interfaces 1 Physical bits as voltage/light/radio the drawn Ethernet cables Full table and TCP/IP-model mapping in wiki/README.md; how an interface spans layers 1–3 in wiki/interfac.md; how bits become voltage in wiki/physical_layer.md.
-
Also covered in the wiki (the long tail of what we studied): infrastructure, MAC, shadow routes, LPM (longest-prefix match), prefix & mask, forwarding & hops, NAT table, Ethernet vs internet layering, LSA, switch packets, modems, linked layers, AS, network cards, IEEE, frames, interfaces, broadcast & the recipient of a frame, local vs global networks, bandwidth, DNS, DHCP, containers networking, reverse proxies, API gateways, load balancing, BGP, OSPF, firewalls & ACLs, ABAC & RBAC, DMZ, ICMP.
Everything below is doable on paper in seconds — which matters, because during the defense a calculator is barely tolerated.
Network from IP (bitwise AND). network = IP & mask. Example: 192.168.1.32 & 255.255.255.224 = 192.168.1.32 — two interfaces can talk directly iff this AND gives the same network for both.
Magic number (block size). block size = 256 − interesting mask octet (the first octet that is neither 255 nor 0). For /30 → mask octet 252 → block size 256 − 252 = 4.
Network start by integer division. Round the host octet down to the nearest multiple of the block size: (octet // block) * block. With block size 4 and host octet 30: (30 // 4) * 4 = 28 → network .28, broadcast .28 + 4 − 1 = .31, usable hosts .29–.30.
Full worked example. 192.168.10.77/26 → mask 255.255.255.192 → magic 256 − 192 = 64 → (77 // 64) * 64 = 64 → network .64, broadcast .127, usable .65–.126 (62 hosts).
Usable hosts. h = 32 − prefix host bits → 2^h total addresses → 2^h − 2 usable (minus network and broadcast). /24 → 254 usable; /29 → 6; /30 → 2 (the classic router-to-router link).
"I need N hosts." Take the smallest power of 2 ≥ N + 2, then prefix = 32 − h. Need 300 machines → 302 ≤ 2^9 = 512 → h = 9 → /23 = 255.255.254.0 (510 usable).
CIDR → mask in 2 seconds. Divide the prefix by 8: quotient = number of 255 octets, remainder indexes the only 9 possible octet values 0, 128, 192, 224, 240, 248, 252, 254, 255. /27 → 27 = 3×8 + 3 → three 255s then 224 → 255.255.255.224.
More drills, proofs and the full /0–/32 tables: wiki/milestone_02.md, wiki/milestone_03.md, wiki/note_ex04.md.
With this inline command from the project root you can make the launcher executable and run it in one go — the web browser will open the page to interact with, and start the journey of net-practice:
$(cd net_practice; chmod +x ./run.sh; ./run.sh)
If run.sh does not function properly, launch the server manually and open the page yourself (the port can be changed):
python3 -m http.server 49242
# then browse to http://localhost:49242
- You can practice if you input your login in the field — Moulinette uses it to know your own configuration, so entering it is not optional before exporting.
- You can try the
correction(Evaluation) version if you leave the field empty: it generates a random configuration, perfect for rehearsing the defense.
Once entered, you'll find there are 10 levels available for training. For each level, a non-functioning network diagram appears. At the top of the window you will see one or more goals to achieve: the issues to solve so that the network runs properly. Only the unshaded fields can be modified. There are two buttons you can use:
- Check again to verify whether your configuration is correct or not.
- Get my config to download your configuration whenever you need to. It will be useful to turn in your assignment.
When you have successfully completed a level, a Next level button appears. Export your configuration with Get my config before clicking it — you need one exported file per level for your repository.
During your training you'll have logs at the bottom of the page, really useful to track down misconfigurations or things that went wrong during your work.
You'll often see errors like these in the logs — they are important to understand (some red lines are even normal):
| Error message | What it means | Typical fix |
|---|---|---|
loop detected |
The simulator's recursion guard fired while flooding — this line appears even in fully correct solutions. | Nothing, if the goal is OK. If the goal is KO, look for a routing loop (two routes pointing at each other). |
packet not for me |
Normal: the switch floods frames to everyone and non-target hosts drop them. | Nothing — hosts are doing the filtering. |
destination does not match any route |
The sender/router found no routing-table entry (and no default route) matching the destination. | Add a specific route or a default (0.0.0.0/0) route pointing at a reachable gateway. |
destination does not match any interface. pass through routing table |
Informational, normal on a router: the packet is not addressed to one of its own interfaces, so it consults its routing table. | Nothing — unless this machine was the intended target; then check masks and subnet membership. |
invalid IP address |
The IP is the network or broadcast address of its own block, is class D/E (first octet > 223), has an octet > 255 — or is simply not filled in. | Pick a host address strictly between network+1 and broadcast−1, in a valid public/private range. |
invalid netmask |
The mask is not one of the 33 legal masks (a contiguous run of 1-bits, 255.255.240.0-style or /0–/32). |
Use a valid mask — full table in wiki/milestone_02.md. |
loopback address detected on outside interface |
A 127.x.x.x address was typed on a real interface — loopback never leaves the machine. | Use any non-loopback address valid for that subnet (level 2 hands you this trap on purpose). |
duplicate IP (x.x.x.x) |
Two interfaces carry the same address — the simulator rejects it and delivery becomes ambiguous. | Make every IP unique across the whole diagram. |
route match but no interface for gateway / invalid gate IP, route … |
The configured gateway is malformed, or not inside any of the sender's own subnets, so it can never be reached directly. | Set the gateway to the IP of the router's interface on that host's LAN. |
invalid route on host X |
A route's destination or gateway field is malformed (bad CIDR, bad IP, empty). | Write routes as network/prefix (or default = 0.0.0.0/0) with a valid gateway IP. |
error on destination ip - multiple interface match / error on gate ip - multiple interface match |
Two interfaces of the same machine both contain the destination/gateway — their subnets overlap. | Re-mask that machine's interfaces so each owns a disjoint block (wiki/milestone_04.md). |
invalid destination IP for this way / invalid IP on input interface |
The interface that must receive the packet has an unset or invalid IP. | Give the target/receiving interface a valid host address first. |
invalid default route on internet |
The internet node may not carry a default route — it is the top of the hierarchy. |
Replace it with an explicit route down to your network: your.network/prefix → your router's public IP. |
private subnets not routed over internet |
A 10.x / 172.16–31.x / 192.168.x address would have to cross the internet node — RFC 1918 forbids it. | Use public addressing on every segment the internet must reach. |
KO - No reverse way, try again... |
The forward path works but the reply fails — usually overlapping subnets making longest-prefix match pick a dead interface. | Re-mask so every router interface owns a disjoint block, or move hosts into the unclaimed hole (wiki/milestone_04.md). |
KO - Correct IP reached but wrong host/interface |
The packet arrived at the right IP, but on the wrong machine — duplicate or ambiguous addressing. | Fix duplicated/overlapping addresses so exactly one machine owns the target IP. |
To complete this assignment it is important to understand the concepts cited above, otherwise you might get 0.
You are expected by 42 policy to turn in a README.md like this one, and to push the 10 exported level*.json — one file per level, at the root of the repository (./). Export each one with Get my config with your login entered, and double-check the file names before pushing: only the work within your repository is evaluated during the defense.
Although not mandatory, it is strongly advised to build yourself a wiki and a lot of notes about what you learn — you won't come back to this kind of practice before the outer core and you will obviously forget a lot. Just a matter of organization.
During the defense you'll have to succeed at 3 random levels, as mentioned on the training platform, within 12 minutes. The random levels are regenerated live, so your saved configs won't help you there — practice with the Evaluation tab (empty login) beforehand.
The use of external tools is not allowed; a simple calculator such as
bcis tolerated, but that is the limit — and it is not advised anyway, as it drastically shows your corrector that you are fragile on the mental math above.
The wiki/ folder is my study notebook for this project — the README explains, the wiki goes deep.
| File | What it covers | Read it when |
|---|---|---|
| wiki/README.md | The wiki hub: OSI/TCP-IP models, the full 33-mask table, every subnetting trick, reserved-IP tables, device comparisons, RFC index, Level 1 & 2 walkthroughs | You want the table of contents, or a full worked solution for levels 1–2 |
| wiki/milestone_01.md | Per-level walkthrough: first contact — two hosts on one /24, beginner debug checklist | Starting level 1, or when "invalid IP" makes no sense yet |
| wiki/milestone_02.md | Per-level walkthrough: the subnetting bible — mask tables, magic-number method, every NetPractice trap | Any mask/block-size question, before the defense |
| wiki/milestone_02_exercise.md | Self-drill: "do A and B connect?" on tricky mask/reserved-address cases (setups only, answers unwritten) | You want to test your AND-check reflexes |
| wiki/milestone_03.md | Per-level walkthrough: switch vs router, the /0–/32 cheat sheet, wildcard masks, CIDR history | You need to look up any /N, or why a switch doesn't route |
| wiki/milestone_04.md | Per-level walkthrough: "No reverse way" dissected — overlapping router interfaces, LPM to a dead port | A level passes forward but KOs on the reply |
| wiki/milestone_05.md | Per-level walkthrough: routing tables as filters/catchment areas; forwarding vs final delivery | Routes "point at" things but you don't know why they match |
| wiki/milestone_06.md | Per-level walkthrough: why the internet node rejects default routes, and the return route home | The log says "invalid default route on internet" |
| wiki/milestone_07.md | Per-level walkthrough: full hop-by-hop binary trace through two routers + the 5-step verification template | Two-router levels, or hand-verifying any topology |
| wiki/note_ex04.md | Quick total/usable host-count calc (beware: the "/30" label is a typo, the mask shown is /23) | One-glance formula reminder |
| wiki/subnet.md | The foundational deep dive: one bitwise AND produces everything; sender's-own-mask rule; simulator traps | You want to believe the magic-number shortcut, not just use it |
| wiki/ipaddress.md | What an IP is from first principles: prefix/host split, route aggregation, why the internet scales | Before everything else, honestly |
| wiki/CIDR_FROM_DECIMAL_NOTATION.md | Mechanical /N → dotted-decimal recipe (second example unfinished) | You freeze converting /23 to a mask |
| wiki/confusion_between_network_addresses_broadcast_size_block.md | Why x.x.x.127 is a broadcast, not a network, in a /25 | The block-boundary confusion strikes |
| wiki/loopback_address.md | 127.0.0.0/8: what it's for and why it's never valid on an interface | Level 2's poisoned default IP |
| wiki/router.md | How a router forwards: routing tables, LPM, a full Dijkstra/OSPF example, multi-NIC mental model | Routers stop being magic boxes |
| wiki/router2.md | Deep hardware dive: memory, ASICs, switching fabrics, packet lifecycle, CEF/TCAM, NAT/QoS/firewalls | Curiosity far beyond the subject's scope |
| wiki/switch.md | Why the switch is never the bug; reading "packet not for me" / "loop detected" without panicking | Red log lines scare you |
| wiki/swtich2.md | Layer 2 itself: framing, FCS, MAC learning, broadcast domains, L2 vs L3 switch vs router (filename typo for switch2) | You want the real switch, not the simulator's hub |
| wiki/mac_address.md | Story-style: how a switch self-learns MACs and forwards frames in a LAN | Before infrastructure.md |
| wiki/mac.md | Two-line definition of ARP as the IP-to-MAC bridge | You need exactly two lines |
| wiki/ARP.md | Routing-table-decides / ARP-resolves division of labor; the 5-step forwarding sequence | "But how does it know the MAC?" |
| wiki/interfac.md | What a network interface is, layer by layer (L1 port, L2 MAC, L3 IP); why VLANs need a router (filename typo for interface) | Interfaces feel abstract |
| wiki/tcp.md | TCP reliability: handshake, ACK arithmetic, retransmission, congestion sawtooth; UDP contrast | Layer 4 curiosity (some sections are stubs) |
| wiki/internet_ports.md | Ports, DHCP and the NAT table: how a whole LAN hides behind one public IP | NAT levels and "why does my router have one IP?" |
| wiki/limit_of_ip.md | One-minute motivation for NAT, private IPs and IPv6 | The "why" before internet_ports.md |
| wiki/infrastructure.md | Big picture: LANs → tiered autonomous systems → the internet, via the postal analogy | Zooming out from your diagram |
| wiki/AS.md | Autonomous systems and the Tier 1/2/3 hierarchy, transit vs settlement-free peering | "What is the internet cloud, actually?" |
| wiki/bgp.md | How a new AS's prefix propagates via eBGP/iBGP, and how BGP picks among routes | After AS.md |
| wiki/isp.md | Why real routing follows money and peering, not shortest path | The tier pyramid starts looking too clean |
| wiki/domain_name.md | Bare definition of what DNS does (stub) | You forgot what DNS stands for |
| wiki/physical_layer.md | Bits as voltages: NRZ, clock slip, DC balance, Manchester encoding | How the cable actually carries 0s and 1s |
| wiki/scrambler.md | How modern links keep clock sync and DC balance at full speed (LFSR scrambling) | After physical_layer.md |
| wiki/64b_66b.md | One-paragraph sketch of 64b/66b line coding | After scrambler.md |
| wiki/GLOSSARY.md | The postal-analogy vocabulary (router = post office, packets = letters…); mostly headers | You need a mnemonic |
| wiki/README copy.md | Level-by-level journal (duplicate copy) — richest on Level 1 subnet intuition and Level 4 route shadowing | Levels 1 and 4 |
| wiki/good_practice.md | Placeholder (one line) for subnet-sizing best practices | Not yet |
| wiki/index.md | Placeholder entry point, title only | Not yet |
(A handful of other files in wiki/ are still empty placeholders awaiting content.)
| Resource | Type | What we used it for |
|---|---|---|
| RFC 791 | RFC | IPv4 itself — the 32-bit / four-octet structure behind the 0–255 validation rule |
| RFC 950 | RFC | The original subnetting specification (subnet masks) |
| RFC 1122 | RFC | Host requirements — loopback 127/8 behavior and 0.x.x.x "this network" addresses |
| RFC 1812 | RFC | Requirements for IPv4 routers |
| RFC 1878 | RFC | The variable-length subnet (VLSM/CIDR) reference tables |
| RFC 1918 | RFC | The three private ranges (10/8, 172.16/12, 192.168/16) |
| RFC 3021 | RFC | /31 point-to-point links with 2 usable hosts |
| RFC 4632 | RFC | CIDR formalization — notation and supernetting |
| RFC 5735 | RFC | Special-use IPv4 addresses (reserved-ranges table) |
| IANA IPv4 special-purpose registry | Registry | The authoritative live list of reserved IPv4 ranges |
| freeCodeCamp subnet cheat sheet | Article | Quick CIDR/mask/host reference, source of the wiki's /0–/32 table |
| Practical Networking — Subnetting Mastery | Exercise series | Drilling subnetting until it's mental math |
| Subnetting Explained (video) | Video | Visual walkthrough of subnetting for level 2 |
| CIDR trick (YouTube short) | Video | Quick visual demo of the host-count calculation |
| How to calculate CIDR manually (Medium) | Article | Source of the 256-minus-mask-octet (magic number) trick |
| Exam-Labs subnetting guide | Article | The 2^(32−n) − 2 usable-hosts formula |
| CBT Nuggets — proper CIDR notation | Article | Supporting article for the CIDR host-count formula |
| Tencent Cloud techpedia — CIDR | Article | Supplementary CIDR/subnetting reference for the 32−N rule |
| r/CompTIA — learning CIDR without a chart | Community thread | The no-calculator 32−N mental method |
| Subnet mask reference table | Article | Inspired the wiki's 32-row host-bits-to-mask table |
| calculator.net IP subnet calculator | Tool | Verifying manual subnet math (training only — no tools at defense!) |
| subnet-calculator.com CIDR/VLSM | Tool | Checking CIDR block and aggregation math |
| Skyward — the four router memory types | Article | Flash/ROM/RAM/NVRAM breakdown in the router deep dive |
| LearnCisco — router internal components | Course page | CPU/memory/interfaces of a real router |
| GeeksforGeeks — router internals | Article | Router memory/CPU breakdown |
| GeeksforGeeks — bus vs crossbar vs multiport | Article | Switching-fabric comparison |
| Wikipedia — Virtual output queueing | Encyclopedia | The fix for head-of-line blocking |
| Cloudflare — what is the control plane | Article | Control vs data vs management planes |
| IBM — control plane vs data plane | Article | Same split, second source |
| Cisco Catalyst 3750 L3 switching guide | Vendor doc | Real-world hardware (ASIC) inter-VLAN routing |
| IEEE 802.1D | Standard | MAC bridges — the standard behind L2 switch learning/forwarding |
| Wikipedia — Router | Encyclopedia | General packet-forwarding reference |
| Fortinet — what is ARP | Glossary | ARP mechanics |
| Wikipedia — ARP | Encyclopedia | Protocol details and caching |
| Wikipedia — DHCP | Encyclopedia | The DORA handshake |
| Wikipedia — NAT | Encyclopedia | Translation-table fundamentals |
| GeeksforGeeks — PAT | Article | Port address translation / NAT overload |
| Cloudflare — what is BGP | Article | Path-vector routing and AS_PATH loop detection |
| AWS — Border Gateway Protocol | Article | How ASes peer |
| Wikipedia — OSI model | Encyclopedia | The 7-layer table and layer mapping |
| Wikipedia — Internet protocol suite | Encyclopedia | The 4-layer TCP/IP model |
| ISO/IEC 7498-1 | Standard | The official OSI model document |
| GeeksforGeeks — IPv4 vs IPv6 | Article | The IPv4/IPv6 comparison table |
| AWS — IPv4 vs IPv6 | Article | Header/checksum/config differences |
| Wikipedia — stateful firewall | Encyclopedia | Connection state tables |
| GeeksforGeeks — broadcast storms | Article | The problem segmentation solves |
| Cisco — networking basics | Article | Gold-standard networking-basics reference |
| HowStuffWorks — Ethernet | Article | How Ethernet works |
| Palo Alto — network segmentation | Article | Understanding segmentation |
| Cisco — VLAN configuration guide | Vendor doc | Physical vs virtual interfaces and VLANs |
| Computer Networking: Principles, Protocols and Practice | Free textbook | General course resource |
| Cisco Networking Academy | Course | Structured networking fundamentals |
| Wireshark documentation | Docs | The packet-capture tool from the troubleshooting section |
| Cisco CCNA | Certification | Motivation for the subnetting drills (core exam topic) |
| CompTIA Network+ | Certification | IP addressing, masks, troubleshooting coverage |
| Juniper JNCIA-Junos | Certification | Networking fundamentals track |
AI (Claude) was used as a study assistant and reviewer: reformulating and organizing the wiki notes, cross-checking my subnet arithmetic and worked examples, helping me trace the simulator's behavior (reading sim.js to understand what "loop detected", the private-range check, and the reverse-path verification actually do), and machine-verifying the exported level*.json against the simulator's own checking code. Every level was solved by hand in the training interface; every AI-assisted explanation in this README and the wiki was checked, tested and rewritten until I could defend it myself.