Networking & the Internet — from your first packet to a service on the open web

Every program that talks to another machine — a browser, an app, a server, a scanner streaming audio across the house — leans on the same handful of networking ideas. This path demystifies them. Start with what a network even is and follow one web request end to end, then learn the addressing that makes it work — IP, DNS, and ports — and the protocols that carry it — TCP, UDP, HTTP, and TLS. From there you'll cover the pieces that connect and protect real systems (firewalls, NAT, VPNs, proxies), pick up the command-line tools to inspect and debug a connection, and finish able to put your own service on the network safely, including reaching GopherTrunk across your home network or the internet. No prior networking knowledge required; the Linux & the Command Line path pairs well for the hands-on parts.

Start lesson 1 →Jump to glossary

Every program that reaches another machine — a browser, an app, a server, a scanner streaming audio across the house — leans on the same handful of networking ideas. Most developers pick them up in scattered fragments and never see the whole picture. This path draws it for you, one short lesson at a time, until you can reason about a connection, debug it from the command line, and put your own service on the network without getting burned.

Who this is for. Anyone who’s used the internet but never learned how it works underneath. No prior networking knowledge is assumed. The hands-on modules use the terminal, so the Linux & the Command Line path pairs nicely, but isn’t required.

How the path works. Six modules build from the ground up. The first three are the theory every developer should own — how data moves, how machines are addressed (IP, DNS, ports), and the protocols you actually build on (TCP, HTTP, TLS). The next module covers the infrastructure that connects and protects real systems — firewalls, NAT, VPNs, and proxies. The last two get practical: the command-line tools that turn “it won’t connect” into an answer, and how to run, secure, and reach your own service — including GopherTrunk’s web interface across your network. Mark lessons complete as you go — your progress is saved in your browser. New here? Start with lesson 1: What is a network?

Module 1 — How Networks & the Internet Work

The big picture: what a network is, how data is chopped into packets and routed, the layered model behind it, and one web request traced end to end.

  1. What is a network? Nodes, links, and the leap from a home LAN to the internet — a network of networks — the one idea everything else builds on. beginner 8 min
  2. Packets & switching Why data is chopped into packets, how switches and routers pass them along, and what "best-effort" delivery really means. beginner 9 min
  3. Protocols & layers The layered model — link, internet, transport, application — and why splitting networking into layers makes the whole thing work. beginner 10 min
  4. Clients, servers & peers The request-response model most of the internet runs on, and the peer-to-peer alternative — who asks and who answers. beginner 8 min
  5. How a web request works, end to end Type a URL and press Enter — DNS, TCP, TLS, HTTP, and back — the whole journey in one trace that the rest of the path unpacks. beginner 10 min

Module 2 — Addressing: IP, DNS & Ports

How machines find each other: IP addresses and subnets, the DNS name system, ports and sockets, and how home networks share one public address.

  1. IP addresses & subnets IPv4 and IPv6, public vs. private addresses, and what a subnet (and CIDR /24) actually means — gently. intermediate 10 min
  2. DNS — names to addresses How a name like example.com becomes an IP address — resolvers, records (A, AAAA, CNAME, MX, TXT), and caching. beginner 10 min
  3. Ports & sockets How one machine runs many services at once — ports, well-known port numbers, and the socket that ties an address to a program. intermediate 9 min
  4. NAT & private networks Why every device in your home shares one public IP — network address translation, private ranges, and what it hides. intermediate 9 min
  5. DHCP & joining a local network How a device gets an address the moment it connects — DHCP, the default gateway, and what your router is doing. beginner 8 min

Module 3 — The Transport & Web Protocols

The protocols you'll actually build on: TCP vs. UDP, HTTP and its methods and status codes, TLS/HTTPS, web APIs, and real-time connections.

  1. TCP vs. UDP Reliable-and-ordered vs. fast-and-lossy — the handshake, what each is for, and why voice and video often pick UDP. intermediate 10 min
  2. HTTP — the web's protocol Requests and responses, methods (GET/POST/…), status codes, and headers — the language nearly every API and site speaks. intermediate 10 min
  3. TLS & HTTPS How HTTPS encrypts traffic and proves a server is who it claims — certificates, the handshake, and why the padlock matters. intermediate 10 min
  4. Web APIs & REST Programs talking over HTTP — REST, JSON, endpoints, and how an app, a server, and a browser exchange data. intermediate 9 min
  5. WebSockets & real-time connections When request-response isn't enough — long-lived, two-way connections for live updates, streaming, and push. advanced 9 min

Module 4 — Connecting & Securing Networks

The infrastructure that connects and protects real systems: firewalls, port forwarding, VPNs, proxies and load balancers, and the security basics.

  1. Firewalls & controlling access Deciding what traffic is allowed — default-deny, open vs. closed ports, and where a firewall sits in the path. intermediate 9 min
  2. Port forwarding & dynamic DNS Reaching a service behind your home router from outside — port forwarding, dynamic DNS, and the risks of opening a door. intermediate 9 min
  3. VPNs & tunnels What a VPN actually does — an encrypted tunnel — what it hides and what it doesn't, and when to reach for one. intermediate 9 min
  4. Proxies, reverse proxies & load balancers The middlemen of the web — forward and reverse proxies, load balancers, and CDNs — and what each is for. advanced 9 min
  5. Network security basics The everyday threats — interception, spoofing, and floods — and the defenses that counter them, from encryption to least exposure. intermediate 10 min

Module 5 — Networking from the Command Line

The tools that turn 'it won't connect' into an answer: inspecting your own network, testing connectivity, making requests, tunneling, and capturing packets.

  1. Inspecting your network What's my address and what's listening — ip, ss, and friends for seeing your own machine's network state. intermediate 9 min
  2. Testing connectivity A repeatable way to diagnose "it won't connect" — ping, traceroute, and dig, from the machine outward. intermediate 9 min
  3. Making requests with curl curl and wget — sending HTTP requests, reading headers and status codes, and testing an API or a site from the shell. intermediate 9 min
  4. SSH tunnels & transfers Reaching a remote service securely — SSH port forwarding (local and remote tunnels) and copying files with scp and rsync. advanced 10 min
  5. Packet capture basics Watching the actual traffic — tcpdump and Wireshark — to see what's really on the wire when something misbehaves. advanced 10 min

Module 6 — Putting a Service on the Network

Everything applied: run a server and understand what it's bound to, expose it safely, self-host on a home network, and reach GopherTrunk across the network.

  1. Running a server — binding & reachability localhost vs. 0.0.0.0, binding to a port, and the difference between a service running and a service you can actually reach. intermediate 9 min
  2. Exposing a service safely Putting a service online without regret — a reverse proxy, TLS, a firewall, and authentication in front of it. advanced 10 min
  3. Self-hosting on a home network Running your own services on your own connection — the practical setup, the pitfalls, and when to keep it on the LAN. intermediate 9 min
  4. GopherTrunk on the network Putting it together — reaching GopherTrunk's web interface across your LAN or the internet, and streaming to other tools, securely. intermediate 9 min
  1. Glossary of networking terms Plain-language definitions for every term in the path — packet, protocol, IP, subnet, DNS, port, NAT, TCP, UDP, HTTP, TLS, firewall, VPN, proxy, and more — cross-linked to the lessons.