The best holiday I could come up with for today (other than “Bastille Eve”) is the Ludi Apollinares or Games of Apollo, a solemn competition involving prophecy, horse racing, and theater, which is a courageous mix.

Apollo and the Muses

Obviously, many hundreds of years later, there isn’t much chance that the Roman July 13th is the same day of year as our July 13th, but like I said, it was either this or a Bastille Day reference. OK, actually, that’s a lie. Tomorrow is Netlabel Day, but every music label is now (basically) a Netlabel and we know I’m not going to set a day aside to celebrate large corporations.

Oh, well. It’s been an interesting week, regardless.

Uxuyu

As has been usual for a while, progress on Uxuyu continues apace.

Some changes were simple, like sorting the list of @mentions in descending order of date, so that the newest are always visible. Likewise, errors now go in a log file, instead of requiring the console open; this will hopefully make it easier to package the application as something easier to use, in the future. I was able to finally fix the code to show a specific user feed, so that it doesn’t accidentally retain highlights from prior selections.

Oh, I also discovered that it’s straightforward to accept the expired TLS certificates with the existing library. My request options now just look like the following.

const options = {
  headers: {
    'User-Agent': 'Uxuyu Prototype Testing',
  },
  rejectUnauthorized: false,
  url: the_url,
};

The rejectUnauthorized property is meant to protect users from viewing data that may have been tampered with, but it’s optional. It should go without saying that, by “optional,” I mean that it’s literally an option to turn it off and no real project that cares about security should do any such thing, ever.

The right way to handle this would be to maintain some configuration, where users can allow or disallow insecure connections for individual users. But for the sake of the experiment, this will do well enough for now.

Speaking of doing things poorly, I’ve kicked off the process of offloading some main application code into a separate class (and file) to quiet ESLint down about the long file. Until I refactor the monster, my expedient plan is to just move function bodies over and calling out to them before handling any state or communications updates. I don’t recommend doing this in production code, but as a first step towards refactoring, it should be close enough.

VSCode Rat

This worked out much better than I imagined. I didn’t originally realize that Visual Studio Code extensions were just a matter of generating the scaffolding and adding functionality.

It was also nice (though terrifying) to discover that there aren’t any fussy security restrictions on connecting to remote services.

You can try it out, if you like, by cloning the VSCode Rat repository and follow the process of writing it in Wednesday’s post on the topic, with another post arriving this coming Wednesday, to cover the configuration side.

I still need to give some thought about what I want to do with these extensions and what I might want the server to look like, but these results make me think that the level of personal monitoring might be useful.

Next

I have some cleanup to do on other projects, but I’d like to finish extracting the Uxuyu code and also look into using the last-access time to reduce the frequency of attempts to connect to peers.

In addition, as mentioned above, I need to add a configuration option for the destination URL in VSCode Rat, and maybe give some thought to what I might want to do with this kind of data, now that it’s easily available. I have a tiny fraction of a vision, but I need one more data source to work consistently, before I so much as consider implementing that vision.

Credits: The header image is Parnassus by Andrea Appiani, long in the public domain.