Networking Fundamentals
A beginner-to-advanced series on how computer networks actually work, from what happens during an HTTP request to DNS, IP addressing, and routing.
Foundations
Post 1•Ch.1: What Happens When You Do an HTTP Request?
What actually happens when you type a URL into your browser and hit enter: DNS resolution, the TCP handshake, IP packets, and MAC addresses, explained step by step.
IP Addressing & Subnetting
Post 2•Ch.2: Understanding the Structure of an IP Address
A beginner-friendly guide to the structure of an IPv4 address, octets, dotted quad notation, and binary representation.
- Post 3•
Ch.3: Networks, Hosts, and CIDR Notation Explained
Demystifying how IP addresses are structured into Network and Host portions, and understanding CIDR notation like /24 and /16.
- Post 4•
Ch.4: Subnet Masks and the 'Same Network' Test
Discover how your computer uses Subnet Masks and bitwise AND operations to figure out if another device is on the local network or far away on the internet.
- Post 5•
Ch.5: The Default Gateway (Your Network's Exit Door)
What happens when your computer needs to talk to a device on a completely different network? It sends the data through the Default Gateway.
- Post 6•
Ch.6: Putting It All Together (Routing In Action)
A practical walkthrough of how IPs, Subnet Masks, and Default Gateways work together to move data across local and remote networks.
MAC Addresses & ARP
Post 7•Ch.7: Understanding MAC Addresses
What is a MAC address, how is it structured, and why do we need it if we already have IP addresses?
- Post 8•
Ch.8: IP Address vs. MAC Address
Understanding the key differences between an IP Address and a MAC Address, and why a network requires both to successfully route data.
- Post 9•
Ch.9: Address Resolution Protocol (ARP)
Understanding the Address Resolution Protocol (ARP), how it acts as a link between IP addresses and MAC addresses, and how devices use it to communicate.
OSI Model, Routing & Diagnostics
Post 10•Ch.10: OSI Model vs TCP/IP Model
Understanding the 7 layers of the OSI model, how they compare to the TCP/IP model, and how a request travels through these layers over the network.
- Post 11•
Ch.11: Routing in Detail
A deep dive into how routing works across different network scenarios, from local switches to internet-wide hops reaching AWS.
- Post 12•
Ch.12: ICMP, Ping, and Traceroute
A comprehensive guide to Internet Control Message Protocol (ICMP), how Ping measures RTT, how Traceroute cleverly uses TTL to discover intermediate routers, and why asterisks (***) appear in traceroute output.
UDP
Post 13•Ch.13: User Datagram Protocol (UDP)
A deep dive into User Datagram Protocol (UDP), exploring connectionless transport, port addressing, UDP vs TCP performance trade-offs, DNS over UDP mechanics, TCP meltdown, and real-time use cases.
- Post 14•
Ch.14: Anatomy of a UDP Datagram and Checksum
A detailed breakdown of the UDP datagram header fields, RFC 768 specification, the math behind 16-bit checksum calculation, and how receivers detect in-flight packet corruption.
TCP
Post 15•Ch.15: Transmission Control Protocol (TCP)
A comprehensive overview of Transmission Control Protocol (TCP), exploring connection-oriented transport, 3-way handshakes, stateful tracking, segment fragmentation, reliability, in-order delivery, TCP vs UDP comparisons, and real-world application use cases.
- Post 16•
Ch.16: TCP 3-Way Handshake (SYN, SYN-ACK, ACK)
A clear walkthrough of the TCP 3-way handshake: why a connection has to be established before any data is sent, the SYN, SYN-ACK, and ACK exchange step by step, and why TCP is called a stateful protocol.
- Post 17•
Ch.17: TCP Connection Termination (4-Way Handshake)
A detailed breakdown of TCP connection teardown: exploring why 4-way termination with FIN and ACK is required, half-closed connections, state machines, TIME-WAIT state, and RST reset aborts.
- Post 18•
Ch.18: TCP Sequence and Acknowledgment Numbers
A detailed breakdown of TCP Sequence and Acknowledgment numbers: how bytes are numbered across segments, how receivers reorder out-of-order data, detect loss and duplicates, and how initial sequence numbers are negotiated during the 3-way handshake.
- Post 19•
Ch.19: Anatomy of a TCP Segment
A detailed breakdown of the TCP segment header down to the bit level: Source/Destination Port, Sequence/Acknowledgment Numbers, Data Offset, all 8 control flags (CWR, ECE, URG, ACK, PSH, RST, SYN, FIN), Window Size, Checksum, Urgent Pointer, and the Options field, including why the header can grow up to 60 bytes.
- Post 20•
Ch.20: MTU, MSS, and Path MTU Discovery
How large a single IP packet can actually be: the Maximum Transmission Unit (MTU), what happens when a packet exceeds it (IP fragmentation), how TCP's Maximum Segment Size (MSS) is calculated to avoid that fragmentation, and how Path MTU Discovery (PMTUD) uses the Don't Fragment flag and ICMP to find the smallest MTU along an entire network path.
- Post 21•
Ch.21: TCP Flow Control, Sliding Window, and Window Scaling Explained
How TCP prevents a fast sender from overwhelming a slow receiver: the Stop-and-Wait problem, cumulative acknowledgments, the receive buffer and Window Size field, the sliding window technique, and how Window Scaling works around the 16-bit Window Size limit.
- Post 22•
Ch.22: TCP Congestion Control, Slow Start, and Congestion Avoidance
The difference between flow control and congestion control, how a router's limited buffer can drop segments even when the receiver has room, TCP's congestion window and slow start threshold, the Slow Start and Congestion Avoidance algorithms, how TCP detects congestion via retransmission timeouts, triple duplicate ACKs, and ECN, and how the sender's window is always the minimum of the receiver window and congestion window.
DNS
Post 23•Ch.23: DNS, the Domain Name System
What DNS actually solves beyond just being unable to remember IP addresses: dynamic IPs, GeoDNS, and load balancing. The hierarchy behind a URL (root zone, TLD, domain, subdomain), how a DNS resolver walks the root, TLD, and authoritative name servers to resolve a domain, and how caching and TTL keep most lookups fast.
- Post 24•
Ch.24: DNS Record Types, A, AAAA, MX, CNAME, NS, TXT, and PTR
What each DNS record type actually stores and why: A and AAAA for IPv4/IPv6, MX and the full SMTP delivery flow with priority failover, CNAME aliasing and its no-dead-end rule, NS records and DNS delegation across providers, TXT records and how SPF stops spoofed mail, and PTR records for reverse DNS and sender reputation.
- Post 25•
Ch.25: Anatomy of a DNS Message
A field-by-field breakdown of the DNS message header: the Transaction ID, all ten flag bits (QR, Opcode, AA, TC, RD, RA, Z, AD, CD, RCODE), and the four count fields that define the Question, Answer, Authority, and Additional sections, including what glue records are and why they exist. Ends with a real Wireshark capture showing DNS falling back from UDP to TCP mid-query.
HTTP
Post 26•Ch.26: HTTP, the HyperText Transfer Protocol
What HTTP actually is, broken down from its own name: hypertext, transfer, and protocol. Why it's an application-layer protocol built on top of TCP, why it's stateless, why it's media-independent, and what it deliberately leaves to other protocols like TLS.
- Post 27•
Ch.27: HTTP/1.0 vs. HTTP/1.1
Why HTTP has multiple versions, and what each one fixed. HTTP/0.9's lack of headers, HTTP/1.0's optional keep-alive, HTTP/1.1's persistent connections by default, and why pipelining exists but stays disabled because of head-of-line blocking.
- Post 28•
Ch.28: Structure of an HTTP Request and Response
A field-by-field walkthrough of what an actual HTTP request and response look like: the request line (method, path, version), common request headers like Host, Referer, and Cookie, the response status line and headers like Content-Length and Server, and how ETag plus If-None-Match lets a server answer with a bodyless 304 Not Modified instead of resending the same JSON.
- Post 29•
Ch.29: HTTP/2 and Multiplexing
How HTTP/2 solves HTTP/1.1's head-of-line blocking with multiplexing and Stream IDs: multiple requests fly over a single TCP connection simultaneously, responses can arrive in any order, and a numeric Stream ID on every frame ties each response back to its request without relying on arrival order.
- Post 30•
Ch.30: HTTP/2 Frames in Depth
An in-depth look at HTTP/2 frame architecture: RFC 9113 frame header format, HEADERS vs DATA frames, END_HEADERS and END_STREAM flags, and Wireshark traces of GET and POST requests.
- Post 31•
Ch.31: Why HTTP/2 Is a Binary Protocol
A deep dive into why HTTP/2 is called a binary protocol: contrasting HTTP/1.1's text-based line-by-line string traversal and split-by-delimiter parsing with HTTP/2's fixed 9-byte binary frame header that is parsed by reading raw bits at predefined offsets.