We are first going to take a look at how we can think about systems as divided into pieces, and then start thinking about the kinds of delays involved both inside each piece, and moving between pieces.
Our model for thinking of systems as made up of pieces is the WISE model: the World as Interfaces Between Systems and Environments.
Anytime we start thinking about what is going on in a particular place, we should start trying to view the situation in terms of what we can control (which we call the System), and what controls us (which we call the Environment). We may very well be trying to get more and more of the environment under our control (either by using systems of our own design, construction, and operation, or by signing agreements with others regarding what their systems will provide). So a WISE decomposition is an important goal.
We need to break each System into parts: the pumps are the processing pieces, and the pipes are passive, although once we analyze the construction of a pipe we find it will itself be made up of pumps and pipes. And it may be easier for our thinking if we view these as pushes or pulls.
If we now return to the model we showed last time of networking, as made up of channels which follow a UPA model within the origin system, a PPPPP model across a network, and a UPA model at the target system, we can then start thinking of where delays might occur, that is, where the communications time is spent.
Of course there is the processing time within each provider. We can view the provider as a simple pump, and estimate how long it takes to do its work.
However there is also the time spent communicating between user and provider, and between provider and agent. Although we often tend to think of these connections as similar to that of a program and a subprogram, they are really not of that sort at all. A subprogram is usually thought of as dedicated to the program that is calling it, and we do not consider having to wait for the subprogram to become available for us.
In networking, however, each provider may be subject to the call of many users, and similarly each agent may be acting on behalf of multiple providers, and thus the connections between "write by a user-input by a provider", "send by a provider-accept by an agent", "deliver by an agent-receive by a provider", and "output by a provider-read by a user" are all subject to delay. We call these sorts of delays "queuing" delays, and see that the connections between User and Provider and Agent can be viewed as simple pipes.
Going across a network the same thing happens: there is the communications delay between sender-receiver of pairs associated with peers in the network, and don't forget at each intermediate node such as a router there may be intermediate UPA stacks to climb on the way in, and descend on the way out. Although the processing of each of these may take only a small amount of time, a busy node may be subject to quite a bit of delay moving between its UPA layers.