AQA A-Level Computer Science (7517)

## Learning Outcomes

- Explain how host-to-host communication works using the four-layer TCP/IP protocol stack
- Distinguish clearly between application, transport, internet, and link layer functions
- Identify the roles of port numbers, sockets, IP addresses, and MAC addresses
- Explain encapsulation and decapsulation step by step using a worked example
- Compare TCP and UDP in terms of reliability, ordering, overhead, and typical uses
- Avoid common exam errors such as confusing packets with frames or IP addresses with MAC addresses

## AQA A-Level Computer Science (7517) Syllabus

For the AQA A-Level Computer Science (7517), you are expected to understand host-to-host networking, with a focus on the following syllabus points:

![TCP/IP protocol stack layers in host-to-host communication, including encapsulation, decapsulation, port numbers, IP addresses, and MAC addresses.](https://static.pastpaperhero.com/images/aqa-a-level-computer-science-7517-communication-and-networking-host-to-host-networking_00.png)

_Host-to-host communication is organised into application, transport, internet, and link layers, each adding control information during encapsulation._

- Know that communication between hosts uses the TCP/IP protocol stack
- Identify the four layers of the TCP/IP stack: application, transport, internet, and link
- Explain how encapsulation adds data at each layer and how decapsulation reverses this at the destination
- Understand the difference between port numbers, sockets, IP addresses, and MAC addresses
- Explain how data is directed to the correct host and the correct application
- Compare TCP and UDP in terms of connection, reliability, ordering, and overhead
- Recognise well-known ports such as **80**, **443**, **21**, **22**, **25**, **110**, and **143**
- Distinguish between local delivery on a network and routing across multiple networks

## Test Your Knowledge

_Attempt these questions before reading this article. If you find some difficult or cannot remember the answers, look more closely at that area during your revision._

1. What is the difference between an IP address and a MAC address?
2. How does a port number help data reach the correct software on a host?
3. Name the four layers of the TCP/IP protocol stack in order.
4. Why is TCP more reliable than UDP?
5. What is meant by encapsulation?

## Introduction

Host-to-host networking means communication between end devices on a network. A host could be a laptop, phone, web server, games console, or printer. In exam questions, the key idea is not just that devices are connected, but how data moves from one host to another accurately enough to reach the correct machine and then the correct application on that machine.

This is why the TCP/IP protocol stack matters so much. It breaks communication into layers, with each layer handling one part of the job. AQA often tests this through short definitions, layer functions, comparisons such as TCP vs UDP, and worked explanations of how a web request travels across a network.

> **Key Term: host**
> An end device on a network that can send or receive data, such as a computer, server, or phone.

### The TCP/IP stack and the logic of layered communication

The TCP/IP protocol stack used by AQA has four layers:

1. application layer
2. transport layer
3. internet layer
4. link layer

Each layer has a separate job. This matters because network communication is too complex to manage as one single process. If every program had to handle physical signalling, addressing, routing, and error recovery by itself, networking software would be much harder to design and standardise. A layered model solves this by giving each level a clear role.

> **Key Term: TCP/IP protocol stack**
> A four-layer model of network communication made up of the application, transport, internet, and link layers.

The **application layer** deals with the format and rules needed by software such as browsers, email clients, and file transfer tools. Protocols here include HTTP, HTTPS, FTP, SMTP, POP3, IMAP, and SSH. This layer is closest to the user.

The **transport layer** manages communication between applications. One host can run many networked applications at once, so the transport layer adds a **port number** to identify which service should receive the data. It can also handle sequencing and reliability.

The **internet layer** handles host-to-host delivery across networks. It adds source and destination IP addresses and supports routing by routers. This is the layer that lets data move beyond a single local network.

The **link layer** handles local transmission over the actual network medium, such as Ethernet or Wi-Fi. It uses local hardware addressing and prepares data for the specific link being used.

A strong exam answer does more than list layers. It explains why each exists. For example, an IP address alone is not enough. It identifies the host, but not which application on that host should process the data. That is why the transport layer also needs ports.

> **Key Term: protocol**
> A set of rules that defines how data is formatted, transmitted, and received in a network.
>
> **Key Term: encapsulation**
> The process of adding headers, and sometimes trailers, to data as it moves down the protocol stack.

As data moves down the stack, each layer adds its own control information. At the destination, the reverse happens.

> **Key Term: decapsulation**
> The process of removing headers, and sometimes trailers, from data as it moves up the protocol stack at the receiving host.

You should also know the names of the data units at different layers:

- transport layer: **segment** for TCP, often **datagram** for UDP
- internet layer: **packet** or **IP datagram**
- link layer: **frame**

Students often use “packet” for everything. In some questions that may still gain credit, but precise wording is safer.

> **Test Tip:** If a question asks about a specific layer, use the correct technical term for that layer. Saying “frame” when the question is about the internet layer is a common accuracy error.

### Addressing and delivery: ports, sockets, IP addresses, and MAC addresses

AQA regularly tests the distinction between the main identifiers used in networking. This is one of the easiest places to lose marks through vague wording.

An **IP address** identifies a host or network interface across networks. Routers use destination IP addresses to decide where packets should go next. IP addressing is therefore about network-level delivery.

A **MAC address** identifies a network interface on the local network. It is a hardware address linked to a network interface card. MAC addresses are used for local delivery on a single link, not for routing across the whole internet.

> **Key Term: IP address**
> A logical address used to identify a host or network interface across networks.
>
> **Key Term: MAC address**
> A unique hardware address used to identify a network interface on a local network.

This distinction matters because packets often cross many routers. The source and destination IP addresses usually stay the same for the whole journey between hosts, but the MAC addresses change at each hop. Why? Because each individual link is a separate local delivery step.

For example, imagine a laptop on a home Wi-Fi network requests a web page from a remote server:

- the destination IP address is the server's IP address
- the first destination MAC address is the home router's MAC address, because the router is the next local hop
- once the packet reaches that router, the old frame is removed
- a new frame is created for the next link, with different MAC addresses

This is why routers primarily use IP addresses for forwarding between networks. MAC addresses do not identify the final device across the whole route.

A **port number** identifies the application or service on the host. A web server may listen on port **80** for HTTP or port **443** for HTTPS. An email server may use **25** for SMTP, **110** for POP3, or **143** for IMAP. SSH uses **22**, and FTP commonly uses **21**.

> **Key Term: port number**
> A number used at the transport layer to identify the application or service that should receive the data.

A **socket** is commonly described as an IP address plus a port number. This identifies a communication endpoint. For example, `132.41.160.10:443` means IP address `132.41.160.10` using port `443`.

> **Key Term: socket**
> A communication endpoint identified by an IP address and a port number.

Why are sockets needed? Because a host can run many network services at once. The IP address gets data to the correct host. The port gets data to the correct application on that host.

There is also an important distinction between server and client ports:

- **well-known server ports** are fixed and standard for common services
- **client ports** are usually temporary and generated for the session

Suppose a browser on `192.168.1.20` wants a web page from a server on `203.0.113.8`. The browser may use a temporary source port such as `50432`, while the server listens on destination port `443`.

So the request effectively goes from:

- source socket: `192.168.1.20:50432`
- destination socket: `203.0.113.8:443`

When the reply comes back, it is sent to `192.168.1.20:50432`, which lets the client machine give the response to the correct browser session.

Students often confuse ports with devices. Ports do not identify the computer. They identify the service or process.

> **Test Tip:** In 2-mark compare questions, write the distinction directly: “IP addresses identify hosts across networks; port numbers identify applications on a host.” That is much stronger than two separate vague statements.

### Worked example: sending a web page request from one host to another

A common exam task is to explain what happens when a client requests a web page. The best answers describe the journey layer by layer.

Assume a browser requests a page from `203.0.113.8` using HTTPS on port **443**.

#### Step 1: Application layer

The browser creates the request using the HTTPS protocol. At this stage, the data is application data: for example, a request for a web page resource.

The application layer decides the format needed for the receiving software. It does not handle routing or hardware transmission.

#### Step 2: Transport layer

The transport layer adds:

- source port number, such as `50432`
- destination port number, `443`
- if TCP is used, sequence information and other control data

Because web browsing usually needs reliable delivery, TCP is used. The data unit here is a **segment**.

Why does sequence information matter? A large web page may be split into many pieces. These can arrive in the wrong order. TCP allows the receiving host to reorder them correctly.

#### Step 3: Internet layer

The internet layer adds:

- source IP address, for example `192.168.1.20`
- destination IP address, `203.0.113.8`

This creates an IP packet. Routers examine the destination IP address and forward the packet towards the correct network.

This is the host-to-host part of the communication. The packet may pass through many intermediate routers, and different packets from the same transfer may even take different routes.

#### Step 4: Link layer

The link layer creates a frame for the current local network. It adds local source and destination MAC addresses.

On the first hop:

- source MAC address = laptop NIC
- destination MAC address = router NIC

The frame is transmitted over Wi-Fi or Ethernet. When it reaches the router, the link-layer data is removed, the destination IP is checked, and a new frame is created for the next hop.

This repeats until the packet reaches the destination network.

#### Step 5: Decapsulation at the destination

At the server, the process is reversed:

- link layer checks the frame and removes link-layer data
- internet layer checks the IP address and removes IP data
- transport layer checks the port number, sequence, and any errors
- application layer passes the data to the HTTPS service

The server then sends back a response using the client's IP address and temporary source port from the original request.

This reverse processing is why the stack is often described as working like “pass the parcel”: each layer unwraps its own part.

### TCP and UDP: reliability versus speed

The transport layer is also where students must compare **TCP** and **UDP**.

> **Key Term: TCP**
> A connection-oriented transport protocol that provides reliable, ordered delivery using sequencing, acknowledgements, and retransmission.
>
> **Key Term: UDP**
> A connectionless transport protocol with lower overhead that does not guarantee delivery, ordering, or retransmission.

TCP is used when accuracy matters more than speed. It establishes a connection, numbers data segments, checks that they arrive, and retransmits missing ones. This gives reliable, ordered delivery.

UDP is used when low delay matters more than perfect reliability. It does not set up the same level of connection management and does not guarantee that all data arrives or arrives in order.

A simple comparison is useful:

- **TCP**
  - connection-oriented
  - reliable
  - ordered delivery
  - acknowledgements used
  - retransmission possible
  - higher overhead

- **UDP**
  - connectionless
  - no guarantee of delivery
  - no guarantee of order
  - no retransmission by the protocol
  - lower overhead
  - lower delay

Why would anyone use UDP if it is less reliable? Because some applications care more about current data than perfect data. In live voice or video, one late packet can be less useful than no packet at all. Online gaming can also prefer lower delay.

By contrast, web pages, email, remote login, and file transfer usually need TCP because corrupted, missing, or wrongly ordered data would cause real problems.

A common student mistake is to write that UDP has “no error checking at all”. That is too broad. The key exam point is that UDP does not provide TCP-style reliability, ordering, and retransmission.

Another mistake is saying TCP is always better. It is not. It has more overhead, so it is better only when reliable delivery is worth that extra cost.

> **Key Term: packet switching**
> A method of sending data in separate packets that may take different routes and are reassembled at the destination.

Packet switching links closely to TCP. Since packets can arrive out of order, a reliable transport protocol is needed if the receiving application requires the original order to be restored.

> **Test Tip:** For “compare TCP and UDP” questions, do not just write “TCP is reliable, UDP is faster.” Add at least one mechanism such as acknowledgements, sequencing, or retransmission for TCP, and “no guarantee of order or delivery” for UDP.

## Key Point Checklist

_This article has covered the following key knowledge points:_

- Host-to-host networking means communication between end devices across a network
- The AQA TCP/IP model has four layers: application, transport, internet, and link
- Encapsulation adds control information as data moves down the stack
- Decapsulation removes that information at the receiving host
- The transport layer uses port numbers to direct data to the correct application
- A socket is a communication endpoint made from an IP address and a port number
- IP addresses identify hosts across networks, while MAC addresses identify interfaces on the local network
- Routers forward data using destination IP addresses, not internet-wide MAC addressing
- Transport-layer data is more precisely called a segment for TCP and a datagram for UDP
- Internet-layer data is commonly called a packet, while link-layer data is called a frame
- TCP provides reliable, ordered delivery using sequencing, acknowledgements, and retransmission
- UDP has lower overhead but does not guarantee delivery or order

## Key Terms and Concepts

- host
- TCP/IP protocol stack
- protocol
- encapsulation
- decapsulation
- IP address
- MAC address
- port number
- socket
- TCP
- UDP
- packet switching


Communication and Networking - Host-to-host networking