A bit of background

I decided to start with quarterly patron/sponsor updates, going out public a week later than here. Going by my prior experiments at regular updates (I still keep a monthly blog post going but at this point it's more of a reading record with extremely occasional project and event notes for my own usage), monthly contains too little and takes too much time, and yearlies just end up either extremely summarised or a complete mess. Quarterlies are the next logical progression!

Yes, spring. It's spring here! Down with northern-hemisphere-temperate-region-centrism. Updates will be published sometime in the season, not at any boundary or precise date. Circulation is going to be pretty small to start with; content is also likely to remain light for the time being. [Welp, wrote this before I wrote the content; I don't expect it to be like that every time though.]

Season of change

In the middle of winter/summer, I took a month long vacation to Europe, the first part of which was dedicated to going to WorldCon, the poorly-named premier science-fiction and fantasy convention that happens in a different city every year. It's like the Olympics, except with no competition save for queue position, much lighter crowds (though still more than I usually willingly brave), very little international news coverage, and every time it happens outside of the USA, people complain that they won't be able to attend — fuck you very much, says the rest of the world. There's still fencing, though we call it “medieval sword fighting demonstration”, and there's still track and field, though we call that “trampling anyone in the way in your quest to get to the other side of the venue in time”, and there's still gymnastics, which is what you do when you're in the middle of a row and you find you didn't really want to be at a panel on the musical habits of fictional ghosts, and would much rather be next door listening to a reading of your favourite author's work in progress.

Anyway, I took a month off work, and most critically I took a month off project work. Before I left I deliberately paused, stopped, or dropped many small projects, and two weeks prior to the departure time I put a notice up on my larger and more popular projects saying, essentially, "I'm away, don't expect much." One of those projects was Notify. I'd had a lot of trouble putting work in that project, and one of my hopes with this break was to rest enough and put away enough other projects that I'd be able to have a jolly start anew on Notify once I got back.

Instead what happened is that without Notify weighing down, I felt a lot better. It gave me distance and with distance came perspective. So one week from coming back, I told this to someone I respect greatly and who had been doing some work with Notify recently and who also had some feet in some pies that I thought might be affected. I got an excellent response, and thought about it some more, and then I announced I was abandoning the project.

That provoked an outpouring (to my scale, anyway) of support and proposals for help which turned into concrete action which turned into Notify getting its own, completely new, team. I wavered, many times, but stayed firm to my goal of going out of the picture entirely. These were very emotional weeks. Notify has been my project, in a form or another, for almost five years. Even my non-technical friends and family know about it, just because of how much presence it held. Letting it go was the best thing I did, and also quite tough.

I think it's going to be okay, and I know now I'm going to be okay.

Renewal

Notify being gone helps not only my time available to work on other things, but also improves my motivation. During the almost-burnout, I had a mild adverse reaction to anything to do with Rust: while I still worked on some small Rust projects, I really felt a lot of guilt whenever I did anything touching Rust that wasn't working on Notify.

I have five Rust projects currently open, and I cycled through them during these past few months, making slow but enjoyable progress.

I decided fairly early on after the team around Notify started to take shape that I would wait until their own first release before really hacking on Cargo Watch and Watchexec. In the meantime I would focus on other things. That got short-circuited when several great pull requests were submitted to both projects, and I got into modernising watchexec a bit: bringing it up to Rust 2018, adding lints, revamping the build config, etc. That culminated in version 1.11.0 🎉 shortly followed by version 1.11.1 🚢 because I'd missed a spurious change in a PR.

I believe the change in question (changing an owned argument to be borrowed) was a misunderstanding of move semantics and the cheapness scale: there's this fuzzy understanding, especially coming from C/C++, that copies are expensive and refs are cheap, and that's true to an extent, but moves are cheapest. I don't have space in this margin to expand on this, though.

Watchexec has been a bit of an awkward maintainership for me, as the original maintainer/developer/creator is arguably permanently away at this point but set up policies that I'm not entirely behind and that are not ageing well — yet I haven't felt entirely comfortable taking over fully and repealing them or doing more in-depth refactoring. However, for the sake of the project I think I just need to get over myself on this, and, while still being thoughtful about the project direction, firmly take it forward to continue being great developer tooling.

Splash (still private as I decide what license and direction to take it in) is about HF radio propagation, with a literate re-documentation and Rust port of the Irregular Terrain Model, later plans being SIMD and GPU accelerations of the algorithm, and a modern, coherent tool interface. I started splash about 18 months ago, and dropped it earlier in the year after moving house; it was a real pleasure picking it up again.

Garrīre is a Discord bot that's originally a command-by-command reimplementation of Rogare, the same Discord bot but in Ruby. Discord bots have an interesting property where several applications using the same token running on completely separate machines can speak and respond as one bot interface, so it is entirely possible to have one set of commands handled by one implementation, and a different set handled by another, without users noticing anything. That's probably also really useful for scaling, but that's not really a concern at my scale.

Storq is a small but core component of several larger systems I've been drafting for a while. It's pronounced like "stork", and the Q is for queue. It's based on sled, an in-beta advanced embedded key-value store written in Rust by the incredible spacejam. I actually find various key-value stores every so often just through following other devs or bumbling about, and Storq requires such a particular set of features that it couldn't actually run on most others I find: if it's not the ordered iteration that's missing, it's the keys-are-bytestrings; if it's not the transactions, it's the namespacing. I've been calling Storq a construction over sled for this reason, rather than a generic component. The purpose of Storq is to store and manage collections of items that present as queues with configurable and re-configurable orderings. As a more concrete example, say you've got a work queue that, in normal times, operates as a FIFO: jobs get worked on in the order they went in. You want to tune this and pull jobs with a specific tag to be completed faster, but all other jobs also need to stay and be completed, and you don't want to bring down job processing for the tuning. With Storq, you could create a view into the queue that's ordered using a completely arbitrary function (in this case, scanning the payload for the tag and prioritising items that have it), and then swap it in as the feed for the worker farm. It is very much low-level: not concerned at all with what the indexes and items are used for. Every part of Storq is simple, and the concept itself is pretty small, too: working on it is relaxing more than challenging.

Not being able to express what it's about in less than one wall of text is maybe not a good sign, but I'm hoping that will improve as I get it working and then start using it in a larger context!

Stumblings

Me rambling about stuff I did is nice and all but wouldn't you like some actual value strewn about here? Here's some interesting things and projects I found while wandering (aka procrastinating):

https://github.com/SOF3/dirmod Dirmod is what Rust modules may have looked like if internals had gone for entirely filesystem-based resolution rather than the hybrid explicit mods with implicit paths we have. The idea is to call dirmod::all!() once in your crate root and everything just works without any mod statements. I don't see myself using it, but it is a very neat idea that could really help those struggling with the Rust module system.

https://github.com/nrc/clyde Clyde is apparently an experiment (marked wip, but hasn't seen commits beyond the initial sprint) by nrc (formerly of rust core) around querying Rust programs. It looks like jq for Rust. While heavily unfinished, it's a fascinating idea with a lot of potential.

https://github.com/millardjn/rusty_sr Super-resolution is upscaling 2.0: instead of using algorithms, you use The Algorithm, aka a machine learning model trained for the task. This is a relatively recent thing: appeared for the general public around 2016, although as with most """futuristic""" concepts it was first written about in the 50s. I actually used this and it works pretty well with the default corpus for casual work... and in terms of convenience it definitely beats using some random online service.

https://github.com/henrywallace/netwatch This is, if nothing else, a cool concept: instead of intercepting traffic for analysis (tcpdump), or sending out probes (nmap), you just listen to whatever background radiation makes it to your interface. Networks are loud even when "idle", especially home networks where UDP and multicast are generally unrestricted. While not a particularly useful tool for non-infosec programmatic purposes, it's a captivating glimpse into all this computer gossip that we don't usually see — or think about.

The end?

I wanted to write some kind of footer but I forgot what and I didn't note it down, so... thank you for your support! And as the next update will be next year: have a good one, and happy solstice.


Félix Saparelli released this post 6 days early for patrons.   Become a patron
Tier Benefits
Recent Posts