A journey from Communication Engineering to Software Engineering
Sometimes, the most interesting ideas come from connecting two things that seem unrelated. While learning about concurrency in software engineering, I was reminded of something I had studied in Communication Engineering: Time Division Multiplexing (TDM).
One is about sending multiple signals through communication channels. The other is about managing multiple tasks in software. They are not the same thing, but they share an interesting idea: letting several independent activities use a limited resource.
1. When Multiple Voices Share One Channel#
Imagine that several signals need to travel through one communication channel. Instead of giving every signal a separate channel, we can divide the transmission time into small parts called time slots. Each signal gets its turn to use the channel. This is the basic idea behind Time Division Multiplexing (TDM).
Time
------------------------------------>
| A | B | C | A | B | C |
|-----|-----|-----|-----|-----|-----|
.
One shared communication channel
2. A Different World, a Familiar Idea: Concurrency#
Now think about a software application. It may need to fetch data from an API (Application Programming Interface), respond to user actions, and handle other background operations. Does every task need its own thread? Not always.
Concurrency means managing multiple tasks so that they can make progress during overlapping periods. It does not always mean that they run at the exact same moment.
Dart's Event Loop gives us a useful example. Code running inside one Dart isolate executes on one thread. When an asynchronous operation is waiting—for example, for a timer or a network response—the isolate can work on other available events. When the operation is ready to continue, its next part can be scheduled for execution.
Future<void> fetchData() async {
print('Fetching data...');
await Future.delayed(
const Duration(seconds: 2),
);
print('Data received!');
}
void main() {
print('Application started');
fetchData();
print('Processing other tasks...');
}
The main point is that the isolate does not have to stay blocked while an asynchronous operation is waiting. It can process other available work.#
3. Connecting the Dots: TDM and Concurrency#
Time Division Multiplexing | Event Loop Concurrency |
|---|---|
Multiple signals | Multiple tasks |
Shared communication channel | One isolate's execution thread |
Time-slot allocation | Event and callback scheduling |
Signals take turns using the channel | Callbacks run one at a time on that thread |
The comparison is useful because both ideas show how several activities can share a limited resource. But the way they work is different. TDM uses time slots. A typical Dart Event Loop does not give each task a fixed time slot; it processes events and callbacks according to its scheduling rules.
This is a simple way to compare the ideas, not a claim that they work in the same way.#
4. A Real-World Example: Mobile Networks#
We can also see time-based sharing in mobile communication. Second-generation mobile networks, such as GSM(Global System for Mobile Communications), use both FDMA (Frequency Division Multiple Access) and TDMA (TimeDivision Multiple Access).
In simple terms, FDMA separates the available radio spectrum into frequency channels. TDMA then divides time on acarrier into slots, allowing different users to take turns. A GSM carrier is organized into frames with eight time slots.
One GSM carrier — simplified view
| TS 0 | TS 1 | TS 2 | TS 3 | TS 4 | TS 5 | TS 6 | TS 7 |
|------|------|------|------|------|------|------|------|
User User User User User User User User
Modern mobile networks use newer methods. 4G LTE (Long-Term Evolution) and 5G NR (New Radio) use OFDMA(Orthogonal Frequency-Division Multiple Access) for downlink radio resources. In simple terms, the network shares resources across both time and frequency. The details are more advanced, but the main idea of sharing limited resources is still there.
5. Where the Comparison Has Limits#
TDM is a communication method, while concurrency is a wider idea in computer science. TDM gives signals time slots to use a channel. An Event Loop schedules events and callbacks without fixed time slots for each task. Also, concurrency does not always mean parallelism: parallelism means two or more tasks are actually running at the same time on separate execution resources.
6. A Thought Worth Taking Away#
The more I think about these two ideas, the more I realize that engineering is not always about learning completely new things. Sometimes, it is about looking at familiar ideas from a different point of view.
Back in Communication Engineering, we learned how multiple signals could share one communication channel by taking turns. Each signal had its own time slot, allowing everyone to use the same limited resource without needing a separate channel.
Later, while exploring concurrency in software engineering, I found myself thinking about that same idea again.
Of course, TDM and concurrency are not the same thing. They solve different problems and work in different ways. A communication channel and a CPU (Central Processing Unit) thread are not interchangeable resources, and an Event Loop does not work with fixed time slots like TDM.
But the comparison gave me a different way to look at concurrency. It reminded me that many engineering problems come down to a common question: how can several independent activities make progress when they need to share limited resources?
We see this idea in communication systems, where many signals share channels. We see it in software, where tasks share execution resources. The details are different, but the challenge of sharing a limited resource appears in both places.
Perhaps that is one of the most interesting parts of engineering: ideas do not always stay inside the field where we first learn them. A lesson from Communication Engineering can help us understand a concept in Software Engineering. Something we learned years ago may suddenly make sense in a completely different setting.
One channel, many voices. One shared resource, many independent tasks. Different worlds, but an interesting connection.#
Maybe the next time we find a new concept difficult, we can take a step back and ask: Have I seen a similar idea somewhere else, perhaps in a completely different field?
Because sometimes, the best way to understand something new is to connect it with something we already know.


