A network connects computers so they can exchange data. The Internet is a network of networks that works by packet switching: messages are chopped into small packets, each routed independently and reassembled at the destination. This is robust — packets flow around failures — and efficient, since links are shared rather than dedicated.

Complexity is tamed by layering. The TCP/IP model has four layers, each using the one below and serving the one above:

IP gives every device an address and routes packets, but makes no guarantee of delivery or order. TCP layers reliability on top — acknowledgements, retransmission and ordering — while UDP stays lightweight for speed. DNS translates human names like jupiter2u.com into IP addresses. HTTP is the request/response protocol of the Web.

Layering is the same abstraction principle as functions and objects, applied to communication. Each layer offers a clean service to the one above and hides its own mechanism. Your browser speaks HTTP without caring whether the bytes travel over fibre, Wi-Fi or satellite — the lower layers handle that. Swap Wi-Fi for Ethernet and nothing above the link layer changes. This separation of concerns is why the Internet could evolve for fifty years without a rewrite.

TCP's reliability is a beautiful illusion built on unreliable IP. IP packets can vanish, duplicate, or arrive out of order. TCP numbers every byte, waits for acknowledgements, retransmits what goes unacknowledged, and reorders arrivals — presenting the application with a clean, ordered stream, as if a private wire connected the two programs. It also does congestion control, backing off when the network is busy so the shared Internet doesn't collapse.

Since we can't run real hardware here, we simulate the two ideas at the heart of reliable networking: splitting a message into packets, and reassembling them in order despite arriving scrambled — exactly what TCP's sequence numbers achieve.

def packetize(message, size=4):
    """Split a message into numbered packets (like TCP segmenting a stream)."""
    packets = []
    seq = 0
    for start in range(0, len(message), size):
        chunk = message[start:start + size]
        packets.append({"seq": seq, "data": chunk})   # sequence number + payload
        seq += 1
    return packets

def reassemble(packets):
    """Reorder by sequence number, then concatenate -> reliable ordered stream."""
    packets_in_order = sorted(packets, key=lambda p: p["seq"])
    return "".join(p["data"] for p in packets_in_order)

msg = "HELLO INTERNET"
packets = packetize(msg)
print(packets)
# [{'seq':0,'data':'HELL'}, {'seq':1,'data':'O IN'},
#  {'seq':2,'data':'TERN'}, {'seq':3,'data':'ET'}]

# Simulate the network delivering them OUT of order:
scrambled = [packets[2], packets[0], packets[3], packets[1]]
print(reassemble(scrambled))     # -> "HELLO INTERNET"  (order restored!)

The sequence number is the whole trick. IP may deliver packets in any order, but because each carries its position, the receiver can sort them back into the original stream — and detect a gap (a lost packet) by a missing number, triggering a retransmission request.