GitLab has been working on support for ActivityPub/ForgeFed federation as well, currently only implemented for releases though.

Mercurial does have a few things going for it, though for most use-cases it’s behind Git in almost all metrics.

I really do like the fact that it keeps a commit number counter, it’s a lot easier to know if “commit 405572” is newer than “commit 405488” after all, instead of Git’s “commit ea43f56” vs “commit ab446f1”. (Though Git does have the describe format, which helps somewhat in this regard. E.g. “0.95b-4204-g1e97859fb” being the 4204th commit after tag 0.95b)

Well, Flatpak always builds the aliases, so as long as the <installation>/exports/bin folder is in $PATH there’s no need to symlink.

If you’re talking specifically about having symlinks with some arbitrary name that you prefer, then that’s something you’ll have to do yourself, the Flatpak applications only provide their canonical name after all.
You could probably do something like that with inotify and a simple script though, just point it at the exports/bin folders for the installations that you care about, and set up your own mapping between canonical names and whatever names you prefer.

In regards to sandboxing, it only gets as far in the way as you ask it to. For applications that you’re not planning on putting on FlatHub anyway you can be just as open as you want to be, i.e. just adding / - or host as it’s called - as read-write to the app. (OpenMW still does that as we had some issues with the data extraction for original Morrowind install media)

If you do want to sandbox though, users are able to poke just as many holes as they want - or add their own restrictions atop whatever sandboxing you set up for the application. Flatpak itself has the flatpak override tool for this, or there’s graphical UIs like flatseal and the KDE control center module…

Well, if you have any form of build script, makefile, or CI, then you can easily shove that into a flatpak-builder manifest and push the build repo anywhere you want. The default OSTree repository format can be served from any old webserver or S3 bucket after all.

I’ve done this for personal projects many times, since it’s a ridiculously easy way to get scalable distribution and automatic updates in place.

The majority of AppImages I’ve seen have been dynamically linked, yes. But it’s also used for packaging assets.

As long as your application is statically linked, I don’t see any issue with that.

Well, Flatpak installs aliases, so as long as your distribution - or yourself - add the <installation>/exports/bin path to $PATH, then you’ll be able to use the application IDs to launch them.

And if you want to have the Flatpak available under a different name than its ID, you can always symlink the exported bin to whatever name you’d personally prefer.
I’ve got Blender set up that way myself, with the org.blender.Blender bin symlinked to /usr/local/bin/blender, so that some older applications that expect to be able to simply interop with it are able to.

Ah, I had one of those wireless sticks from Netgear as well, probably a different model but still a royal pain to get it working.
Luckily ndiswrapper has become a thing of the past nowadays.

You’re lucky to not have to deal with some of this hardware then, because it really feels like there are manufacturers who are determined to rediscover as many solved problems as they possibly can.

Got to spend way too much time last year with a certain piece of HPC hardware that can sometimes finish booting, and then sit idle at the login prompt for almost half a minute before the onboard NIC finally decides to appear on the PCI bus.
The most ‘amusing’ part is that it does have the onboard NIC functional during boot, since it’s a netbooted system. It just seems to go into some kind of hard reset when handing over to the OS.

Of course, that’s really nothing compared to a couple of multi-socket storage servers we have, which sometime drop half the PCI bus on the floor when under certain kinds of load, requiring them to be unplugged from power entirely before the bus can be used again.

The predictable interface naming has solved a few issues at work, mainly in regards to when we have to work with expensive piece-of-shit (enterprise) systems, since they sometimes explode if your server changes interface names.
Normally wouldn’t be an issue, but a bunch of our hardware - multiple vendors and all - initialize the onboard NIC pretty late, which causes them to switch position almost every other boot.

I’ve personally stopped caring about interface names nowadays though, I just use automation to shove NetworkManager onto the machine and use it to get a properly managed connection instead, so it can deal with all the stupid things that the hardware does.

It’s somewhat amusing how Itanium managed to completely miss the mark, and just how short its heyday was.

It’s also somewhat amusing that I’m still today helping host a pair of HPE Itanium blades - and two two-node DEC Alpha servers - for OpenVMS development.

Go has a heavy focus on simplicity and ease-of-use by hiding away complexity through abstractions, something that makes it an excellent language for getting to the minimum-viable-product point. Which I definitely applaud it for, it can be a true joy to code an initial implementation in it.

The issue with hiding complexity like such is when you reach the limit of the provided abstractions, something that will inevitably happen when your project reaches a certain size. For many languages (like C/C++, Ruby, Python, etc) there’s an option to - at that point - skip the abstractions and instead code directly against the underlying layers, but Go doesn’t actually have that option.
One result of this is that many enterprise-sized Go projects have had to - in pure desperation - hire the people who designed Go in the first place, just to get the necessary expertice to be able to continue development.

Here’s one example in the form of a blog - with some examples of where hidden complexity can cause issues in the longer term; https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-ride

Go really does do well in the zero-to-hero case, that’s for certain. Unfortunately it doesn’t fare nearly as well in terms of ease when it comes to continued development.

Well, one part of it is that Flatpak pulls data over the network, and sometimes data sent over a network doesn’t arrive in the exact same shape as when it left the original system, which results in that same data being sent in multiple copies - until one manages to arrive correctly.

We’re mirroring the images internally, not just because their mirrors suck and would almost double the total install time when using them, but also because they only host the images for the very latest patch version - and they’ve multiple times made major version changes which have broken the installer between patches in 22.04 alone.

What is truly bloated is their network-install images, starting with a 14MB kernel and 65MB initrd, which then proceeds to pull a 2.5GB image which they unpack into RAM to run the install.

This is especially egregious when running thin VMs for lots of things, since you now require them to have at least 4GB of RAM simply to be able to launch the installer at all.

Compare this to regular Debian, which uses an 8MB kernel and a 40MB initrd for the entire installer.
Or some larger like AlmaLinux, which has a 13MB kernel and a 98MB initrd, and which also pulls a 900MB image for the installer. (Which does mean a 2GB RAM minimum, but is still almost a third of the size of Ubuntu)

If you’re going to post release notes for random selfhostable projects on GitHub, could you at least add the GitHub About text for the project - or the synopsis from the readme - into the post.

I’ve been looking at the rewrite of Owncloud, but unfortunately I really do need either SMB or SFTP for one of the most critical storage mounts in my setup.
I don’t particularly feel like giving Owncloud a win either, they’ve not been behaving in a particularly friendly manner for the community, and their track record with open core isn’t particularly good, so I really don’t want to end up with a decent product that then steadily mutilates itself to try and squeeze money out of me.

The Owncloud team actually had a stand at FOSDEM a couple of years back, right across from the Nextcloud team, and they really didn’t give me much confidence in the project after chatting with them. I’ve since heard that they’re apparently not going to be allowed to return again either, due to how poorly they handled it.

I’ve been hoping to find a non-PHP alternative to Nextcloud for a while, but unfortunately I’ve yet to find one which supports my base requirements for the file storage.

Due to some quirks with my setup, my backing storage consists of a mix of local folders, S3 buckets, SMB/SFTP mounts (with user credential login), and even an external WebDav server.
Nextcloud does manage such a thing phenomenally, while all the alternatives I’ve tested (including a Radicale backed by rclone mounts) tend to fall completely to pieces as soon as more than one storage backend ends up getting involved, especially when some of said backends need to be accessed with user-specific credentials.