This week’s article is about how we spend the time while code is compiling, a web app is being deployed, a neural network is learning or a job sent to an HPC facility is being executed. Some of these tasks might take quite some time, but in the day-to-day life of a programmer, there are a lot of tasks that take something between 20 seconds and 5 minutes. One can stare idly at the blinking console cursor and wait for the prompt to reappear, or follow Randall Munroe’s suggestion:

'Are you stealing those LCDs?' 'Yeah, but I'm doing it while my code compiles.'

Usually, I divert my attention to other, small tasks like checking my emails. The issue is, that one small task quick leads to another (let me quickly try this…), and the initial job I was waiting for gets forgotten. While browsing for a solution, I discovered that my issue is not to stay focused (although they used the same xkcd comic). My issue was a missing notification when the initial task was done. The solution is a program called universal notifications. Let’s look at it in more detail with four real-life examples:

  • Receive a notification when a new process finishes,
  • Receive a notification when an already running process on a remote machine finishes,
  • Receive a notification when the CPU usage of a running process drops below a threshold and
  • Receive a notification when a GitLab CI pipeline is done.

Use-case 1: New process

Let’s assume we want to compile our latest and greatest program using make. It takes about 2 minutes to compile it. To prevent the issue mentioned above, run

$ un make -j4

instead of just make -j4. The code will compile as expected—or it won’t. In any case, you will receive a GUI notification once the process terminates. Under the hood, universal notifications uses notify-send.

Use-case 2: Running process on a remote machine

Assume you’ve started an extremely involved build a remote machine with more resources than your laptop could offer. One could assume, that sending notifications over SSH channels is complicated. Well, it might be, but with universal notifications it’s doable. All you need is the id of the parent build process. For the sake of this example, assume the id is 7098.

$ un -s 7098

This line will use SSH to log on to and send a notification to your laptop once process 7098 terminates.

Use-case 3: CPU usage drops below threshold

Assume you are working in a jupyter notebook. Let’s say you are training a neural network. It’s not too large, neither is the training set, so it should be trained within a few minutes. Jupyter is running in a Firefox tab while waiting, you switch to another tab, and the happily learning network completely disappears from your mind. How can you receive a notification once the training is done? One method is to receive a notification once the CPU usage of the process in question drops below a certain threshold. This can be done with universal notifications and it’s plugin uwait.

$ un uwait -t 10 7098

The line can be dissected into two independent programs. By now, you know already what un does. uwait watches the process with id 7098 and terminates once the process’ CPU usage drops below 10%. Since un waits for its argument to terminate, you receive the notification once the neural network is trained.

Use-case 4: Notification once GitLab CI is done

With yet another plugin, you can use un to scream at you once a GitLab CI pipeline or job is done. The ciwait plugin must be installed independently. You will need an API token to give the plugin access to the GitLab server. Assume the id of the pipeline is 53124, the id of the GitLab project is 245.

$ un ciwait frank 245 53124

Once all jobs are done (either success, canceled, skipped or failed), you’ll receive a notification.

Obviously, there are other use-cases such as waiting for a local process already running in the background or a new remote process. Furthermore, may other tools may can be combined with un. You could, for example, extend it with a plugin to query the queue of an HPC facility to receive a notification once all your jobs are done.

This very short command-line tool greatly improved my productivity and keeps me focused on the main task. On the other hand, when I needed to wait 5 minutes or so, I can now shift my attention to other tasks with the certainty that I will not forget to go back to the main task.