Explain how network protocols, including TCP/IP and HTTP/HTTPS, package, address, route and reassemble data so that it is transmitted reliably between digital systems

What this dot point is asking

Data exchange depends on agreed rules for transmission, and those rules are protocols. The data exchange methods dot point introduces formats like JSON; this dot point goes a layer deeper into how the bytes actually travel. QCAA wants you to explain how TCP/IP and HTTP work together to package data into packets, address and route them across networks, and reassemble them reliably at the destination. This is the transport foundation under every API call and prototype data exchange in Unit 4.

What a protocol is and why it matters

A protocol is a shared standard that defines the format, order and error handling of transmitted data. Both ends must follow the same protocol or the exchange fails before any data is interpreted. Protocols are layered: a high-level protocol like HTTP relies on lower-level ones like TCP and IP, each handling one concern. This separation lets a web API request travel over any underlying network without the application caring about the physical path.

The TCP/IP model

QCAA frames internet communication around the TCP/IP model, which groups protocols into layers:

• Application layer: protocols the program uses directly, such as HTTP, HTTPS and FTP.
• Transport layer: TCP (reliable, ordered, connection-based) or UDP (fast, connectionless). TCP guarantees delivery and order, which is what most data exchange needs.
• Internet layer: IP, which addresses and routes packets between networks using IP addresses.
• Network access layer: the physical and link technologies that move bits across a medium.

Each layer adds its own header to the data as it goes down the stack, and strips it off on the way up, a process called encapsulation.

Packets, addressing and routing

TCP splits a message into packets, each carrying a slice of the data plus headers. IP attaches source and destination addresses so routers can forward each packet, possibly along different paths, toward the destination. Because packets can arrive out of order or be lost, TCP numbers them, acknowledges receipt, requests retransmission of missing packets, and reassembles them in the correct order. This is what makes TCP reliable, in contrast to UDP, which sends and forgets.

HTTP and HTTPS

HTTP (Hypertext Transfer Protocol) is the application-layer protocol for the web and most APIs. A client sends a request (a method such as GET or POST, a URL, headers and optionally a body) and the server returns a response (a status code, headers and a body). HTTPS is HTTP carried inside TLS encryption, so the data is confidential and tamper-evident in transit. Because APIs in your prototype run over HTTP, the status codes (200 OK, 404 not found, 401 unauthorised, 500 server error) are part of how you handle the exchange reliably.

How the layers combine in one request

When your program calls an API, the JSON body is handed to HTTP, which adds request headers; TCP splits it into numbered packets and opens a reliable connection; IP addresses and routes the packets; the network access layer moves the bits. At the server the layers unwind in reverse, the JSON is reassembled, and the application reads it. Understanding this stack lets you reason about where an exchange can fail: a format error is at the application layer, a dropped connection at the transport layer, an unreachable host at the internet layer.

How this appears in assessment

The external exam can ask you to explain how a protocol delivers data reliably, to compare TCP and UDP, or to justify a protocol choice for a scenario. In IA3 you justify the protocols your prototype uses and explain how they support reliable, secure exchange. Be ready to trace a message down and back up the TCP/IP stack and to name what each layer contributes.