Pipelining is a computing concept which can be understood through an everyday analogue (taken from Wikipedia):
“Suppose that assembling one car requires three tasks that take 20, 10, and 15 minutes, respectively. Then, if all three tasks were performed by a single station [in the factory], the factory would output one car every 45 minutes. By using a pipeline of three stations [that operate in parallel], the factory would output the first car in 45 minutes, and then a new one every 20 minutes.”
A simple, fairly modern example can be seen at McDonald’s where, some years back, they began changing their drive-thrus in three ways: first, they created two lanes for making orders; second, they split the “making payment” and “getting food” functions by creating two service windows; third, they assigned some parking spots as waiting areas for large orders. This new setup lets orders get taken more rapidly by minimizing the amount of down time (e.g., from people taking a while to look at the menu) and it allows orders to be completed more rapidly (by allowing two functions — payment and food delivery — to occur at one time and by having waiting spots so that large orders don’t hold everyone else up).
The general idea here is to split tasks and functions into subtasks and subfunctions in a such a way that some can be done in parallel rather than serially. One key way to make use of this in your everyday life is to make good use of delegation. In other words, for any personal or work project that has multiple subparts, break it up into pieces that can either be delegated to other people (or to machines/computers) or done later by yourself. Then schedule the initiation and completion of all tasks in such a way that as much work as possible is being done in parallel by you, others, and the machines/computers.
For example, consider a business whose typical projects require in-person interviews and factual investigation, additional subject-specific background research, and final audio/visual/written presentations. The business has three current projects and three employees. Each could do one project, but, alternatively, one person could do most of the interviews and investigation, one could do most of the research (and start researching before all investigation and interviews are completed), and one could do most of the presentations (and similarly start preparing them before the other tasks are finished). By specializing and pipelining, multiple projects can be completed much more efficiently (and better) than the alternatives (i.e., having each person wait on the prior person to finish before starting their part of a project or having each person do an entire project by themselves).
In terms of my own work, I always try to hand off to a colleague any discrete work tasks that can be performed in tandem with what I’m working on. And sometimes that “colleague” is a machine. For example, I will often log into my home computer and have it do a computationally intensive task — such as OCR-ing a long document — while I keep working on my work computer.
A concrete — although mundane — example of pipelining is a way to make coffee with a Keurig machine. The typical procedure might be to put a pod in the machine, put a mug under the spigot, press start, wait for the brew to finish, remove the mug, then add sweetener, and then add cream. However, you can pipeline the process (saving ~10-12 seconds) if you position the slightly mug forward (so the coffee stream is very close to the back rim of the mug); this gives you room to add sweetener and cream while the coffee is still brewing.
You can even pipeline the process further (saving ~2-3 more seconds) by putting the pod in the machine and pressing start before you put the mug under the spigot. This works because it takes a few seconds for the coffee to come out of the spigot after pushing the start button. (If there weren’t such a delay, the coffee would spill everywhere until you positioned the mug!)
The time savings in this example are trivial, but it helps illustrate the pipelining concept of running multiple processes in an overlapping/parallel fashion.
One Idea 