Yeah, at some point, I told Picard to just re-sort everything and that was not a good idea. Some songs got renamed or put under a different artist, because I guess, the actual song is not in the MusicBrainz database.
I do have a backup that I should restore actually, but yeah, difficult to notice such changes and especially to know how much damage was done.

I did also figure, I should just add the unknown songs into MusicBrainz, but boy, I added one album and that took more than half an hour…

Definitely leaning more and more towards that unsorted life…

There is Kid3 for Android as well. 😅

https://f-droid.org/packages/net.sourceforge.kid3

It’s not the smoothest Android app, I’ve ever seen, but seems serviceable…

I only managed to do it thanks to cargo zigbuild which is amazing. (And kind of embarrassing that Rust has to use Zig to get a nice cross-compiling UX, but hey it works.)

As in cross didn’t work for this?

Had to just think about why #[non_exhaustive] exists, so perhaps this helps you as well:

Imagine you’re developing a really important core library, something like TCP. And then other libraries depend on your library.
Now, if you change your implementation, you may need to introduce a new error case, even though the rest of the API still works the same.

You have two choices to deal with that:

• Release version 2.0, because that’s a breaking change. Each library that depends on you needs to manually upgrade to version 2.0. Some never will, because they’re unmaintained. Any application that ships your library as a transitive dependency will need to ship both, version 1.0 and version 2.0, for the next few years until the last of their direct dependencies has upgraded to 2.0 or been removed.
• Or: You’ve declared that error enum #[non_exhaustive] before going 1.0 and therefore forced all depending libraries to implement a default match case. You can sneak in the new error case in version 1.1 without all those depending libraries needing to manually upgrade. The ecosystem does not split in half between 1.0 vs. 2.0.

Obviously, if it’s a really egregious new error case that needs specific handling, then you might still want to release version 2.0, but by adding the #[non_exhaustive], you can decide later on and if you are such a central library, there’s definitely going to be situations where you want to make use of it.

Damn, this looks like it might solve my pain points with error handling. Will have to see, if it replaces them with new pain points, since error handling is fundamentally hard, but at least, it isn’t starting completely from scratch…

Hmm, in my case, it was certainly part of the problem that I tried to back up directly to an SMB share. It wouldn’t complete even after hours, and my best guess is that it somehow created the copy in/of the home-directory when the connection failed.

I’ve had that happen before when an rsync command for uploading backups was doing shenanigans. I think, it choked on a very large folder, but I just excluded that folder and then it was fine.

It’s funny when someone says “I want a solution besides X” and we all kinds to to say “uhhhh, srsly, X is the answer”

I mean, yeah, you kind of have to point it out. Newbies won’t be able to judge how much they’re making their life harder by wanting to do it their way. 🫠

Yeah, not a bad stance to have. When I switched to Linux (in the middle of a compsci minor), I thought I was the king of the world and that I knew everything about computers.

Then Linux showed me that I know fuckall, not because it was particularly hard, but rather because it’s an open library.
You can look at a random config file on your PC and it will explain you highly technical concepts for free.
You can look at the source code of anything you’re interested in. Well, or probably rather read an explainer from someone who read/wrote the source code.
And you can easily look at the logs of your applications to debug them.

Every so often, I run into folks that genuinely seem to know a lot about Windows, and I always wonder how. It doesn’t explain anything to you. 😅

Just to point it out: Having a USB stick with a Linux ISO laying around can be a lifesaver.

Even if you decide to go back to Windows or whatever.

Because you can actually boot off of the USB stick into a practically fully functional OS, so without installing, and then access the files on the hard drive, in case your installed operating system bites the dust (so long as the hard drive and filesystem is intact).

So yeah, might be worth the invest…

Yeah, I was gonna say, just a bunch of Markdown files would probably be fine. Use e.g. mdBook if you want a static webpage with search.

A dedicated service might have some advantages, but personally, I’d care much more about having my recipe collection in a format that I can access without specific software.

Small nitpick that I noticed while skimming the code:

Where you define your constants, you can change those comments to be doc-comments instead, so that your editor can display them when you hover over constants.

And personally, I would go one step further with the units, by putting them at the end of the name of the constant, like you did with some variables in the code. That way, the unit shows up inline while reading code that uses the constant, which makes it easy to see that units match up (or not).

Side-note: You don’t have to denote the unit for Duration. You construct it from milliseconds, but then it’s unitless and you decide where you use it in what unit you want the value. So, Duration is very cool and I would recommend using it for LRC_START_THRESHOLD as well.

But yeah, back to the comments-thing: Plain comments are kind of inherently crappy, because they only show up in one place in the code, so you’re less likely to see them and less likely to update them. By putting things into doc-comments, names, log statements, error messages etc., they show up in at least two places.
Plain comments only really make sense for explaining why the code does something. The what can generally be explained in other ways, at least in a sufficiently abstracted language like Rust.

You’re looking at it from the perspective of having coded a single application and wanting to deploy it. Try to think more like a sysadmin:

• You’ve got a whole bunch of applications to deploy. Some of them may use dynamic linking, too.
• You don’t know any of them too intimately, so want to just prevent them from interfering with each other, unless you allow it.
• You want a uniform tool to manage all these different applications, and especially also when they’re allowed to interact.

The result is deployment orchestration tools like Kubernetes, Docker Compose, Podman Compose etc… And as a dev, you have to provide a container image, if you want to play along in those.

With a webpage like that, I’m not surprised that no one takes it serious. Looks like it fell straight out of a startup. 😵‍💫

Did you maybe try to press Esc?
When it shows the pretty boot logo, you can do that to see the logs, so maybe it works here as well…

Ah yeah, that makes more sense, thanks!

Anyone using the national domain registrar? Does it only resolve nationally, if you buy from there, as the article implies…?

But you want your domain over the world. Cool, do you have enough clients to need this? Then you can hire a person in each country to buy you a domain from the local registry.

I’ve been interested in getting a domain name, but it always just felt like a scam to pay a monthly fee for an entry in a database. If the national registrar is good enough, that would be cool.

Although, I guess, if it is not, I’d at least still be somewhat more at peace with that, since it would mean the intermediate company actually does something…

Can you launch the original executable by itself?

So, if you run the command, that you put into the .desktop file, in a terminal, does that work?

I always feel like the much bigger challenge is whether anyone can still maintain the codebase afterwards. You throw away so much institutional knowledge by doing a conversion like this…

Yeah, those look really useful for gamedev or simulations, where you need the speed and don’t particularly care that it’s always the same result…