DEV Community: Michael Saparov

Building a simple async scheduler with generators in Python

Michael Saparov — Sun, 12 Apr 2026 03:10:40 +0000

Asyncio in Python is built on coroutines and an event loop — a mechanism that manages their execution.

In this article, we’ll build a simplified model of this approach and recreate similar behavior using generators (yield). This will help us clearly see how tasks pause execution and hand control back to the scheduler — without any “magic” behind async/await.
In this article, we treat generators as coroutines.
We will:

build a primitive task scheduler
understand how tasks “pause”
add time-based waiting
and end up with a simplified version of asyncio

No magic — just yield.

The Simplest Scheduler

Let’s start with a minimal example:

def task1():
    print("Start Apollo-01")
    yield
    print("Start Apollo-02")
    yield
    print("Start Apollo-03")


def task2():
    print("Start Artemis-01")
    yield
    print("Start Artemis-02")
    yield
    print("Start Artemis-03")


tasks = [task1(), task2()]

while tasks:
    new_tasks = []

    for t in tasks:
        try:
            next(t)
            new_tasks.append(t)
        except StopIteration:
            pass

    tasks = new_tasks

What’s happening here

task1() and task2() are generator-based coroutines, not regular functions
yield is the point where a task pauses
next(t) resumes execution until the next yield
the while loop is our scheduler (event loop)

Output:

Start Apollo-01
Start Artemis-01
Start Apollo-02
Start Artemis-02
Start Apollo-03
Start Artemis-03

Tasks run in turns, yielding control to each other.

The Problem

This scheduler:

cannot wait (sleep)
does not handle time
simply switches tasks in a loop

There’s no way to say:
“wake me up in 2 seconds”

Adding a Wait Signal

Let’s allow tasks to communicate with the scheduler.

from enum import Enum, auto

class Op(Enum):
    WAIT = auto()

Now define sleep:

def sleep(delay):
    yield Op.WAIT, delay

Now a task can yield not just control, but also an instruction.

Tasks Control the Scheduler

def task():
    print("start")
    yield from sleep(2)
    print("end")

Now the task explicitly tells the scheduler:

when to pause
and for how long

Scaling Problem

Imagine we have 10,000 tasks:

one wakes up in 1 second
another in 3 seconds
another in 0.5 seconds

We need an efficient way to always pick the next task to run.

Heap (Priority Queue)

A heap allows us to efficiently retrieve the smallest element.

In Python — heapq.

We store:

(step_at, index, coroutine)

Where:

step_at — when the task should resume
index — prevents comparison issues
coroutine — the task itself

Final Example — Rocket Launches

import heapq
import random
import time
from enum import Enum, auto
from typing import Generator

Rocket = tuple[str, float, int]


class Op(Enum):
    WAIT = auto()


def random_delay() -> float:
    return random.random() * 5


def sleep(delay):
    yield Op.WAIT, delay


def now():
    return time.time()


def random_countdown() -> int:
    return random.randrange(5)


def launch_rocket(rocket_name: str, delay: float, countdown: int):
    yield from sleep(delay)

    for i in reversed(range(countdown)):
        print(f"{rocket_name}: {i + 1}...")
        yield from sleep(1)

    print(f"Rocket {rocket_name} is launched")


def create_rockets(n: int = 10_000) -> Generator[Rocket, None, None]:
    for i in range(n):
        yield (f"Artemis-{i}", random_delay(), random_countdown())


def run():
    rockets = create_rockets()

    work = [
        (
            now(),
            index,
            launch_rocket(name, delay, countdown),
        )
        for index, (name, delay, countdown) in enumerate(rockets)
    ]

    heapq.heapify(work)

    while work:
        step_at, index, coro = heapq.heappop(work)

        wait = step_at - now()
        if wait > 0:
            time.sleep(wait)

        try:
            op, arg = coro.send(None)
        except StopIteration:
            continue

        if op == Op.WAIT:
            step_at = now() + arg
            heapq.heappush(work, (step_at, index, coro))


if __name__ == "__main__":
    run()

How It Works

All tasks are placed into a heap
We pick the one with the smallest step_at
If needed — we wait (time.sleep)
Resume execution (send(None))
The task returns:
- WAIT → reschedule
- StopIteration → task is finished Calling send(None) is equivalent to next() — it resumes the coroutine until the next yield.

Conclusion

We’ve built a simplified model of asyncio:

yield — pause point
generator — coroutine
loop — event loop
heapq — time-based scheduler

And most importantly — no magic.

async/await is just a more convenient syntax built on top of these same ideas.

tmate: the fastest way to share your terminal

Michael Saparov — Fri, 13 Mar 2026 17:46:33 +0000

Sometimes you need to quickly share your terminal with someone — for debugging, pair programming, or helping a colleague.
Instead of setting up SSH access or screen sharing, you can use tmate.
tmate is a fork of tmux that allows you to share your terminal session over the internet.

Run the following command on the server you want to share:

tmate

After running the command, tmate will create a shared session and display connection links.

Connecting to ssh.tmate.io...
Note: clear your terminal before sharing readonly access
web session read only: https://tmate.io/t/ro-ptJWCzDvxntCGkfhZSU37HrXg
ssh session read only: ssh ro-ptJWCzDvxntCGkfhZSU37HrXg@lon1.tmate.io
web session: https://tmate.io/t/JH3vTLhbGeUfX8TPdZCTCx4Yr
ssh session: ssh JH3vTLhbGeUfX8TPdZCTCx4Yr@lon1.tmate.io

Press q or Сtrl-c to continue
Then run the following command from another machine:

ssh JH3vTLhbGeUfX8TPdZCTCx4Yr@lon1.tmate.io

That's it.
Now multiple users can work in the same terminal session in real time.
P.S. tmate is a fork of tmux that adds the ability to share terminal sessions over the internet. If you're interested in tmux, I wrote about it here.

watch — underrated Linux command

Michael Saparov — Fri, 06 Mar 2026 21:39:25 +0000

Many Linux users write small scripts to monitor system state — CPU usage, disk space, open connections, and more.
But there is a much simpler tool built into most Linux systems: watch.
It allows you to run any command repeatedly and see the output update in real time.

Basic usage

The syntax is simple:

watch command

By default, the command runs every 2 seconds.

Example: monitoring the mail queue

watch mailq

This refreshes the list of outgoing messages every two seconds so you can see the mail queue shrink or grow in real time.

Example: watching network connections

watch ss -tuln

This is useful when debugging network services or checking if a port becomes active.

Example: monitoring processes

watch "ps aux | grep nginx"

This lets you observe whether a process starts, stops, or changes.

Changing the interval

You can change the refresh interval with -n.

watch -n 1 mailq

This runs the command every 1 second.

Highlighting differences

One of the most useful options is -d, which highlights changes between updates.

watch -d netstat -tuln

This makes it much easier to see what changed since the previous refresh.

Conclusion

watch is a small but powerful tool.
It can turn almost any command into a simple real-time monitoring dashboard without writing scripts.
Sometimes the best tools in Linux are also the simplest.

tmux: a modern replacement for screen

Michael Saparov — Thu, 26 Feb 2026 11:04:45 +0000

Tmux is a terminal multiplexer. It lets you run multiple programs in a single terminal, detach them (so they keep running in the background), and later reattach from another terminal.
If you’ve used GNU screen before, tmux will feel familiar — but more flexible and actively maintained.
Tmux has three core concepts: session, window, and pane.

Session — groups one or more windows together.
Window — groups one or more panes; a session can have multiple windows.
Pane — a split area inside a window that contains a terminal with a running program.

Sessions.

Start a session.

To start working with tmux, create a session. If you don’t specify a name, tmux will assign one automatically:

tmux

To create a session with a custom name:

tmux new -s session_name

After creating a session, tmux attaches you to automatically.

Leaving a session.

There are two ways to leave a tmux session:
Detach from the session — the session keeps running in the background:

Ctrl+b d

Exit the shell — the session will be destroyed if no windows remain:

Ctrl+D

Managing sessions.

To see all running sessions:

tmux ls

To attach to a session: Attach to the only (or last used) session:

tmux attach

Attach to a specific session by name:

tmux attach -t session_name

Windows.

A window in tmux is similar to a tab in a terminal emulator.

Create a window.

To create a new window, use:

Ctrl+b c

Switching between windows.

Switch to the next or previous window:

Ctrl+b n
Ctrl+b p

Switch to a window by number:

Ctrl+b 0
Ctrl+b 1
Ctrl+b 2

Show the window list:

Ctrl+b w

Panes.

A pane is a split area inside a tmux window. Each pane runs its own shell or program.

Split panes.

Split the current window vertically:

Ctrl+b %

Split the current window horizontally:

Ctrl+b "

Switching between panes.

Move to the next pane:

Ctrl+b o

Switch to a specific pane using arrow keys:

Ctrl+b ←
Ctrl+b →
Ctrl+b ↑
Ctrl+b ↓

Resize panes.

Resize the current pane:

Ctrl+b Ctrl+←
Ctrl+b Ctrl+→
Ctrl+b Ctrl+↑
Ctrl+b Ctrl+↓

Closing panes.

Close the current pane by exiting the shell:

Ctrl+D

entr: run commands when files change

Michael Saparov — Tue, 24 Feb 2026 07:59:46 +0000

entr is a tool I found by chance, and it pleasantly surprised me. It allows you to run commands when files change. I found very few articles about it, so I decided to write this note.
A basic usage example looks like this:

ls nginx.conf | entr nginx -t

When the configuration file changes, entr runs nginx -t again. This is especially useful when editing configuration files, as it allows you to validate them immediately after saving.
Some flags make entr more comfortable to use.

Restart a long-running process (-r)

ls *.py | entr -r python my-server.py

The -r flag restarts the command every time a file changes. This is important for long-running processes like development servers, because without -r the previous process would keep running.

Clear the screen before each run (-c)

ls *.conf | entr -c nginx -t

The -c flag clears the terminal before running the command.

Watching new files (-p)

find . -name '*.conf' | entr -p nginx -t

The -p flag also reacts to newly created files. This is useful when files are added dynamically.

Conclusion

If you often edit files and rerun commands manually, entr is a great tool.