• 0 posts
  • 64 comments
Joined 2 months ago
Cake day: October 3rd, 2026
  • Both ZFS and BTRFS require having at least 2 copies for healing, however, unlike a standard RAID1 that is oblivious to which of the 2 copies is healthy, the 2 filesystems use CRC checksums to figure out which is corrupt and recover the good one. As long as you have at least 2 copies, they will check the checksum on every read and heal it if corruption is detected. Besides that, you’d schedule a periodic scrub to also check the data that hasn’t been read in a while.

    In ZFS you can tell it to keep 2 copies of everything even if you only have 1 drive, which would give you the healing effect, but this obviously halves the drive capacity, and does not save you if that 1 drive dies, hence spreading it on multiple drives is better.

    Personally, I find ZFS easier to use than BTRFS, it’s not that complicated once you get the hang of it, plus LLMs can help anyway. It does have many dials that can be tuned, but unless you are trying to optimize it for a specific usecase, the generally recommend setting are fine for most use cases.

    It’s not built into the kernel, but server distros (e.g. Ubuntu) build it as a loadable module, which is kept in step with the kernel, so generally no issues there. On distros like Arch it can be really annoying though.

    “Slightly lower” is a bit of an understatement, both for ZFS and BTRFS. Those are CoW (Copy on Write) filesystems, so they are much slower to write, which is a traid off for the benefits of CoW. On the other hand, reads are only slightly slower (since CRC is always checked), and thanks to transparent compression, they can be even faster to read.

    One downside of ZFS over BTRFS is fragmentation, all CoW filesystems suffer from it, but BTRFS allows you to defragment in place (takes a while though) unlike ZFS.

    If you can’t afford storage, the data you want to store is generally compressible, and speed is not critical/priority, it might be woth using ZFS/BTRFS just for the transparent compression to save on space and get more out of the drives you have. I’m using BTRFS on a Fedora system for this reason alone, helps me avoid buying a new SSD 😬

  • Every solution has its pros and cons. If you rely on something that requires public access (like randomly sharing access with others) than this is not a solution for you. With that said, you can go hybrid, anything high risk that you will never share with others (or only with a few predefined set of people that you can share a VPN config with) can go behind a VPN, anything you intend to share with others stays public but goes into a VM on a separate VLAN with restricted access to stuff to minimize the blast radius should sh*t go down. Personally this is what I’m trying to do, most things have been moved behind VPNs, only a few things remain public and I’m slowly moving them to separate VMs in a restricted network.

  • Firstly, not legal advice here, I’m not a lawyer.

    A license is just a set of terms that dictate what you can and cannot do, so you can write whatever you want there (though I’d advise the help of a lawyer if you do so). However , only those licenses that satisfy certain requirements can officially be called and considered Open Source_, among which, one of the most important ones is that you cannot control how and for what the downstream users use the code, so a if you use a true open source license, you can prohibit someone from forking, adding ads and such to it and distributing wherever they want. If you want such clause, your license can’t be “open source”, but if you are fine with that, it’s your choice, so do whatever you want.

    PS. Note that the license is only important as long as it is actually enforced, so doesn’t matter what it says if everyone ignores it. For example, uBlock Origin is licensed under GPLv3, so any derivative should provide the modified source code to the users, but most commercial ad blocking browser extensions are based on it and violate this clause, but the uBlock creators stopped caring about it since the legal headaches are not worth it.

  • The crux of the issue, at least as I understand it, is that traditionally you’d build the system components in a way that they were interchangeable by defining some standard-ish API. While you can interchange some Systemd components, since “ststemd-xyz” is just the umbrella name of the project as a whole, so some components are completely independent, the core ones can’t really easily be swapped, and it’s only getting worse, especially as systemd is starting to become a hard requirement, a lot of people are rightfully feeling peeved. There’s a great talk made by a BSD developer that admits the virtues of Systemd while bringing the downsides, so no blind hate, you can google for the video “The tragedy of systemd”.