A description of my projects on GitHub

Of course a GitHub pages personal site, at least in my case, should be something illustrating my own projects that live here on GitHub, and maybe showing my comments on anything interesting I found while lurking around the repositories.

As a matter of the projects I am mostly working on at the time are the following:

• When, and
• whenever,

the latter being the evolution of the first one, and the first one having become a mere frontend for whenever.

When

When used to be an automation tool mostly aimed at Ubuntu workstations: that was my desktop environment until some years ago, and I actually needed something to run background jobs in an easy way that shouldn't consist in updating the crontab and write complex scripts. When was really developed with Ubuntu in mind: it used Gtk natively to blend with the desktop environment, many of the events that it could handle were specific to the distribution. Some people managed to make it work on other distros, but part of the functionality was not available. When I switched to Windows, the development of When slowed down, mostly because it was quite hard to catch up with the changes in the environment (especially DBus interfaces) in order to be compatible with new releases that I was not actively using.

On Windows I tried to use the builtin Task Scheduler which, in fact, is not a bad tool: when I first started the development of When, it was because Linux lacked such an UI tool and just relied on cron, which, moreover, only takes time into account to schedule jobs. However, the Task Scheduler is a system management tool on Windows, it relies on the system management console, and, in some of its parts, is quirky and overly difficult to use. After a few years I started missing When, and decided to revive it.

When was (and still is) written in Python.

whenever

I already had in mind to separate the core of When from its UI, in order to make it easier to adapt to other Linux distributions while maintaining all of its features. Also, I wanted to remove all the hardcoded DBus interface reference, and only have DBus listeners (or inspection calls) that could be configured for specific platforms: in When all of the variants for an event or a call that involved DBus had to be kept, in order to support subsequent releases of Ubuntu (not to mention other distributions): this was a thorn in one's side, because it messed up the code, and made the program bigger in the memory, and event slower to some extent. And the icing on the cake was, that the new interfaces were not easy to discover in the first place.

After I discovered Rust, it was quite an easy choice to implement whenever using it: whenever, being the separate core of When that I was aiming at, could be more lightweight than in Python, and faster at the same time. And, possibly, could be cross-platform and support Windows as well. Of course it wasn't as easy to implement all the features that were available in the old When, and it wasn't easy to cope with nontrivial things (such as event listeners) in Rust. At the end, however, after some initial difficulties, whenever was born and grew up, to satisfy all the goals that I had in mind:

• being agnostic with respect to the available DBus interfaces
• all the basic conditions, available in the old release of When, that trigger tasks and jobs
• lightweightness and stability in terms of resource consumption, for both CPU and RAM
• support for both Windows and Linux (Mac might be supported as well, but I don't have a Mac so I don't know)
• speed.

whenever (with a lowercase w) has even more features than the old When: it sports a builtin Lua interpreter, can listen to WMI on Windows, can inspect DBus and WMI in addition to listening to events. It is also more flexible in handling spawned processes. The only thing it lacks is an UI. But there is When for that: while maintaining a surface (which is platform independent btw) very similar to the previous UI/UX, and while implementing most of the system-specific features as configurations, it just manages its whenever core in a consistent way across the supported platforms.

Other stuff

Of course I have been working on other projects, but at the time I am not following them so closely: some projects, such as PyCLIPS, may have lost some usefulness because of the advent of LLMs that, without any strict context definition (which is needed in fact/rule based inference systems), almost achieve the same results. Even though rule-based inference systems are deterministic, it looks like people, nowadays, are OK with quite fuzzy results, and are content as well when the machine infers something without them providing a coherent set of constraints. This new "mentality" made me less interested in inference systems and therefore abandon the PyCLIPS project. Nevertheless, there are some interesting forks that make the original project compatible with current toools and current versions of the code base.