Fundamentals of Network Engineering

Explore how client-server architecture separates heavy workloads to beefy servers, with lightweight clients calling them through remote procedure calls for scalable, multi-component applications.

Understand the OSI seven-layer model and how applications, proxies, and network devices map to it; explore why standardization enables agnostic, decoupled networking and media-wide deployment.

Demonstrates host-to-host communication from MAC addresses to IP routing, explains why IP addresses are needed, and covers networks, subnet masks, routers, gateways, and ports.

Explore the IP building blocks, including IPv4 addresses, subnet masks, and the network and host portions, with concepts like default gateway, routing, and DHCP assignment.

Explore the anatomy of the IP packet, including the header and data, and the impact of 20-byte headers, up to 60-byte options, MTU, fragmentation, TTL, and ICMP.

Explore ICMP, the layer 3 protocol behind ping and traceroute, including TTL, fragmentation, and destination unreachable messages, and how ICMP informs reachability without ports.

Explore how the address resolution protocol maps ip addresses to mac addresses to deliver frames, using arp tables and broadcast requests in local networks.

Master tcpdump to capture IP, ARP, and ICMP packets on a chosen interface, observe IP headers, ICMP echo requests and replies, and apply filters to focus traffic.

Discover how IP packets route from local to internet networks via switches and routers, using ARP to map MAC addresses and gateways, and NAT for internet delivery.

Understand UDP, a lightweight stateless layer on top of IP that uses ports to address host processes, enabling simple, no-connection data delivery for video streaming and WebRTC.

Explore the udp data structure by examining its 8-byte header, 16-bit source and destination ports, and how the payload sits in an ip packet, using DNS as an example.

Examine the UDP protocol’s pros and cons, highlighting its simplicity and low latency, its stateless design, and lack of guaranteed delivery or ordering, including denial of service risks.

learn to build a UDP server in Node.js using the dgram library, binding to localhost port 5500 on IPv4, handling incoming messages via a message event, and testing with netcat.

build a udp server in c by creating and binding an ipv4 socket on port 5501 to receive datagrams into a 1024-byte buffer and print the source address and data.

Demonstrate capturing UDP traffic with tcpdump, issuing a DNS query to 8.8.8.8, filtering for UDP port 53, and inspecting UDP datagram and DNS query IDs.

Explore the transmission control protocol, a reliable, stateful transport that uses ports and a three-way handshake to establish connections, ensure ordered delivery, and manage flow and congestion.

Explore the tcp segment anatomy: 20-byte header, optional fields, 16-bit ports, sequence and acknowledgement numbers, flow control windows, and flags such as syn, ack, and fin, plus mss/mtu context.

Explore how flow control avoids receiver overload using the receiver window, sliding window, and window scaling, to manage TCP data and acknowledgements.

Analyze how congestion control manages network capacity using the congestion window, slow start, and congestion avoidance, while accounting for receiver window and ECN signals to reduce drops.

Explore slow start and congestion avoidance in TCP, from exponential growth starting at one MSS to threshold-based, round-trip driven adjustments, with details on acks, flight size, and resets.

Learn how NAT lets private devices share a public IP despite IPv4 limits by mapping private addresses and ports via a gateway, enabling port forwarding and layer four load balancing.

Explore TCP connection states and the four way handshake, including fin, time wait, and last acknowledgement, and discuss strategies to manage lingering connections and avoid session resumption attacks.

Analyze the pros and cons of tcp, including guaranteed delivery, connection setup, flow and congestion control, and the head-of-line blocking and header overhead that affect latency.

Learn how sockets and connections are implemented in the kernel, including listening, syn and accept queues, the three way handshake, and how backends manage file descriptors and backlog.

Build a TCP server in Node.js using the net module, log handshake, capture remote address and port, send a hello, and handle multiple connections on port 8800.

Build a tcp server in c by binding, listening, and accepting connections. Create new sockets for each client, send a hello message, and leverage backlog and multithreading.

Capture and inspect a web transaction with tcpdump to see the tcp/ip handshake, http request on port 80, and server response, including syn/ack, mss, window scaling, and headers.

Discover how the domain name system resolves domain names to IP addresses through recursive resolvers, root and authoritative servers, enabling DNS records like A and CNAME, load balancing, and geo-DNS.

Explore how networking concepts bridge fundamental theory to daily practice, examining performance, latency, and effectiveness through real-life examples, and compare tcp and udp configurations across client and back-end applications.

Explore how MTU limits TCP segment size, and how MSS, PMTUD, and fragmentation shape data transmission, headers, and network efficiency.

Understand the cost of connection establishment, latency from distance, and how slow start, congestion and flow control shape performance. Use connection pooling to keep open, warm back-end connections.

Explore tcp fast open, sending data during the handshake with a pre-authenticated cookie, and learn how this reduces latency after dns and tls.

Explore how servers listen on ports and IP addresses, choosing loopback, private, or all interfaces, and understand IPv4 and IPv6, port reuse, and security implications.

Explore tcp head of line blocking: a single missing segment stalls the entire stream, and selective acknowledge could help when multiple streams share one tcp connection.

Explain the difference between proxy and reverse proxy, and how proxies enable anonymity, caching, logging, and load balancing for APIs, gateways, and microservices.

Compare layer 4 and layer 7 load balancers, explaining how stateful TCP connections, reverse proxies, and NAT mode affect performance, security, and back end routing.

Explore how devices use MAC addresses and data link logic to send and filter frames, then learn how IP routing uses subnets, gateways, and routing tables to reach across networks.

Explore docker networking by building custom networks, connecting containers, and testing communication with curl, ping, and DNS, including gateway, bridge, and route concepts.

Learn to use Wireshark to sniff UDP packets, capture traffic, filter for a DNS UDP packet to 8.8.8.8:53, and read frame, IP, UDP details including MAC, TTL, and payload.

Demonstrate tcp http capture with wireshark by curling example dot com and examining the handshake, http get request, and basic ip/tcp headers.

Explore how layer 4 proxies handle tcp segments versus layer 7 processing, including buffering strategies, sticky back-end routing, and when to buffer for fragmentation and mtu considerations.

The Linux kernel maintains a syn queue and an accept queue for each listening socket, allowing multiple processes to accept connections with FIFO ordering and occasional contention.