Two computers, one wire, and the fundamental question: how do they talk? The layered model of networking and why abstraction is essential for sanity.
Networking Fundamentals
44 lessons
Demystify computer networking from first principles. Learn how data travels across networks, from electrical signals to HTTP requests. Packets, sockets, routing, DNS, TLS - all with hands-on Linux tools. The course for developers who want to understand what actually happens when they curl an endpoint.
what you'll learn
- How data actually travels — from electrical signals to HTTP requests
- TCP/IP stack — packets, segments, datagrams, and frames layer by layer
- Sockets and socket programming — what happens when you call connect()
- DNS resolution — recursive queries, caching, and why NXDOMAIN matters
- TLS handshakes — certificates, cipher suites, and how HTTPS works
- Hands-on Linux tools — tcpdump, ss, netcat, dig, and traceroute
Network Foundations
Data doesn't flow - it's chopped into pieces. Why packetization exists, what headers are for, and the difference between frames, packets, segments, and datagrams.
The local network layer. Ethernet frames, MAC addresses, and how switches learn which port leads where. Building a mental model of your LAN.
Stop guessing, start observing. Using tcpdump and Wireshark to see what's actually happening on the wire. Your most valuable debugging skill.
The Internet Protocol
The global addressing scheme. IPv4 structure, CIDR notation, private vs public addresses, and the math behind subnet masks. Finally understand /24.
How packets find their way. The routing table, default gateways, and the hop-by-hop journey across the internet. See your packets' path with traceroute.
How one public IP serves many private hosts. Network Address Translation demystified, port forwarding, and why NAT breaks things (and how to work around it).
The control messages of the internet. How ping works, ICMP error messages, and why 'destination unreachable' tells you more than you think.
128-bit addresses and a cleaner design. IPv6 addressing, auto-configuration, and dual-stack operation. What you need to know for the transition.
TCP & UDP
Fire and forget. UDP's simplicity, when unreliable is actually fine, and the applications that choose speed over guarantees.
The protocol that makes the internet work. TCP's guarantees, sequence numbers, acknowledgments, and why reliability has a cost.
SYN, SYN-ACK, ACK. How TCP connections are established, why three packets are necessary, and what you see in tcpdump.
Don't flood the receiver. The sliding window, receive window advertisements, and how TCP adapts to receiver capacity.
Don't flood the network. Slow start, congestion avoidance, and the algorithms that prevent internet meltdown. Why your downloads start slow.
FIN, ACK, and TIME_WAIT. How connections close gracefully, the four-way termination, and why TIME_WAIT exists (and causes problems).
Sockets & Network Programming
The application's window to the network. Socket API fundamentals, the socket file descriptor, and the abstraction that unifies TCP, UDP, and Unix domain sockets.
socket(), bind(), listen(), accept(), connect(). The dance of TCP socket programming, server vs client roles, and what each syscall does.
Netcat: The Network Swiss Army Knife
The most useful network tool you've never learned. Using nc for testing, debugging, port scanning, and quick network experiments.
How one IP address serves many applications. Port numbers, the socket 5-tuple, ephemeral ports, and why you can have 65535 connections (sort of).
SO_REUSEADDR, TCP_NODELAY, and friends. The socket options that matter, when to use them, and common mistakes.
DNS & Name Resolution
Names are for humans, addresses are for machines. The domain name hierarchy, why distributed lookup is necessary, and the birth of DNS.
From your browser to the root servers. The recursive resolution process, caching, TTLs, and what actually happens when you type a URL.
A, AAAA, CNAME, MX, TXT, and more. The record types you'll encounter, what they're for, and how to query them with dig.
When names don't resolve. Using dig, nslookup, and understanding /etc/resolv.conf. Common DNS problems and how to diagnose them.
HTTP & Application Protocols
The protocol of the web. Request/response cycle, methods, headers, status codes, and why HTTP is just text over TCP.
Keep-alive, pipelining, and HTTP/2 multiplexing. How HTTP evolved to reduce TCP overhead and why connection reuse matters.
The developer's HTTP client. Using curl effectively, verbose output, timing breakdowns, and debugging HTTP issues.
TLS & Security
The internet is hostile. Encryption, authentication, integrity - the three pillars of TLS and why HTTPS is non-negotiable.
How trust is established. Certificate verification, cipher negotiation, key exchange, and the roundtrips before encrypted data flows.
Who vouches for whom. X.509 certificates, certificate authorities, chain of trust, and why Let's Encrypt changed everything.
Certificate errors, cipher mismatches, and SNI problems. Using openssl s_client to diagnose TLS failures.
Network Debugging
ss & netstat: Socket Statistics
What's listening, what's connected. Using ss and netstat to understand socket state, connection counts, and port usage.
Beyond basic captures. Advanced filters, reading complex output, performance considerations, and capturing in production.
A systematic approach. Layer-by-layer diagnosis, the questions to ask at each layer, and building a debugging mental model.
Linux Network Internals
How Linux processes packets. The journey from NIC to application, sk_buff, and the kernel's networking architecture.
Software-defined networking primitives. veth pairs, tun/tap devices, and the building blocks of container and VM networking.
A software switch. How Linux bridges work, creating bridges, and connecting network namespaces. Your first step toward container networking.
Linux's firewall and NAT engine. Tables, chains, rules, and the packet flow through netfilter. Essential knowledge for any Linux admin.
Container Networking
Isolated network stacks. Creating network namespaces, why containers see different networks, and communicating between namespaces.
Connecting Containers with veth
Virtual ethernet cables. Creating veth pairs, connecting namespaces, and understanding how containers talk to each other.
Building a Container Network from Scratch
Put it all together. Create a bridge network like Docker does, with namespaces, veth pairs, iptables rules, and NAT. No Docker required.
Outbound connectivity with SNAT. How containers reach the internet, masquerading, and why 172.17.0.0/16 can talk to 8.8.8.8.
Inbound connectivity with DNAT. Port forwarding to containers, how Docker publishes ports, and why -p 8080:80 works.
Debugging Container Networking
When containers can't talk. Using nsenter, tcpdump in namespaces, and systematic debugging of container network issues.