Even before the Bcachefs file-system driver was accepted into the mainline kernel, Debian for the past five years has offered a “bcachefs-tools” package to provide the user-space programs to this copy-on-write file-system. It was simple at first when it was simple C code but since the Bcachefs tools transitioned to Rust, it’s become an unmaintainable mess for stable-minded distribution vendors. As such the bcachefs-tools package has now been orphaned by Debian.

From John Carter’s blog, Orphaning bcachefs-tools in Debian:

"So, back in April the Rust dependencies for bcachefs-tools in Debian didn’t at all match the build requirements. I got some help from the Rust team who says that the common practice is to relax the dependencies of Rust software so that it builds in Debian. So errno, which needed the exact version 0.2, was relaxed so that it could build with version 0.4 in Debian, udev 0.7 was relaxed for 0.8 in Debian, memoffset from 0.8.5 to 0.6.5, paste from 1.0.11 to 1.08 and bindgen from 0.69.9 to 0.66.

I found this a bit disturbing, but it seems that some Rust people have lots of confidence that if something builds, it will run fine. And at least it did build, and the resulting binaries did work, although I’m personally still not very comfortable or confident about this approach (perhaps that might change as I learn more about Rust).

With that in mind, at this point you may wonder how any distribution could sanely package this. The problem is that they can’t. Fedora and other distributions with stable releases take a similar approach to what we’ve done in Debian, while distributions with much more relaxed policies (like Arch) include all the dependencies as they are vendored upstream."

With this in mind (not even considering some hostile emails that I recently received from the upstream developer or his public rants on lkml and reddit), I decided to remove bcachefs-tools from Debian completely. Although after discussing this with another DD, I was convinced to orphan it instead, which I have now done.

  • solrize@lemmy.world
    link
    fedilink
    arrow-up
    24
    arrow-down
    10
    ·
    4 months ago

    Oh man, that isn’t a good luck for Rust. What do those tools do and how much code is there anyway? If they are userspace tools, what is the benefit of writing them in Rust?

    • kbal@fedia.io
      link
      fedilink
      arrow-up
      44
      arrow-down
      1
      ·
      4 months ago

      Rust is a good language. There is no reason not to use it for userspace tools if you manage dependencies with sufficient care. As with most other currently fashionable languages they make it easy to not do that.

      • InverseParallax@lemmy.world
        link
        fedilink
        English
        arrow-up
        13
        arrow-down
        1
        ·
        4 months ago

        It’s a great language, and I even like their deployment/packaging system.

        But oh my god it assumes everything follows its rules, and does NOT play well with others.

        We need a rust-based distribution, there can be only one.

    • unknowing8343@discuss.tchncs.de
      link
      fedilink
      arrow-up
      39
      arrow-down
      9
      ·
      edit-2
      4 months ago

      Everything is better in Rust. Faster, safer… And also the developer experience is amazing with cargo.

      The problem here is not Rust, it’s the humans, it seems.

      The dependencies are set manually, of course, and the dev was enforcing something too strict, it seems, and that is causing headaches.

      But, as the debian dude has learned… Rust programs will 99.999 % work if they can be compiled.

      • gencha@lemm.ee
        link
        fedilink
        arrow-up
        8
        arrow-down
        1
        ·
        4 months ago

        5 nines imply a downtime of 6 minutes a year, or every 100,000th operation failing. That’s not great for a file system. I assume you picked the number arbitrarily, but still think about it.

      • atzanteol@sh.itjust.works
        link
        fedilink
        English
        arrow-up
        10
        arrow-down
        4
        ·
        4 months ago

        Rust programs will 99.999 % work if they can be compiled.

        It’s the same in C. Most programs don’t test against the exact versions of most C libraries either. I’m not sure why he’s so amazed at this.

        • MrPoopyButthole@lemmy.world
          link
          fedilink
          English
          arrow-up
          22
          ·
          4 months ago

          Debian is the most stable distro and downstream loads of distros rely on Debian being clean. This dev has to be strict if they want to maintain the status quo. Rather let the user DL this as a standalone package and still use it, instead of it being included by default with the possibility of breaking.

          And another thing. Version pinning should be normalized. I just can’t bend my mind around code which has to be refactored every 12 - 24 months because dependencies were not version pinned and a new thing broke an old thing. Unless this code is your baby and you stare at every day, constantly moving forward, you should write code that lasts.

        • unknowing8343@discuss.tchncs.de
          link
          fedilink
          arrow-up
          5
          arrow-down
          2
          ·
          4 months ago

          The thing is that, in C the API could be slightly different and you could get terrible crashes, for example because certain variables were freed at different times, etc.

          In Rust that is literally impossible to happen unless you (very extremely rarely) need to do something unsafe, which is explicitly marked as such and will never surprise you with an unexpected crash.

          Everything is so strongly typed that if it compiles… It will run without unexpected crashes. That’s the difference with C code, and that’s why Rust is said to be safe. Memory leaks, etc, are virtually impossible.

          • atzanteol@sh.itjust.works
            link
            fedilink
            English
            arrow-up
            3
            arrow-down
            3
            ·
            edit-2
            4 months ago

            The thing is that, in C the API could be slightly different and you could get terrible crashes, for example because certain variables were freed at different times, etc. In Rust that is literally impossible to happen unless you (very extremely rarely) need to do something unsafe, which is explicitly marked as such and will never surprise you with an unexpected crash.

            What? That’s utter BS. Maybe the kernel devs aren’t wrong about the “rust religion”. Not every bug in C is a memory bug.

            We’re talking about a future version having regressions or different-than-expected behavior from what your application was built and tested on. I guarantee you that can happen with rust.

            • Dave.@aussie.zone
              link
              fedilink
              arrow-up
              1
              ·
              edit-2
              4 months ago

              If library devs do versioning correctly, and you pin to major versions like “1.*” instead of just the “anything goes” of “*”, this should not happen.

              Your unit tests should catch regressions, if you have enough unit tests. And of course you do, because we’re all operating in the dream world of, “I am great and everyone else is shit”.

      • P03 Locke@lemmy.dbzer0.com
        link
        fedilink
        English
        arrow-up
        6
        arrow-down
        1
        ·
        4 months ago

        But, as the debian dude has learned… Rust programs will 99.999 % work if they can be compiled.

        That’s a dumb statement. Every tool needs unit tests. All of them!

        If grep complied, but always returned nothing for every file and filter, then it’s still not “working”. But, hey, it compiled!

        • LeFantome@programming.dev
          link
          fedilink
          arrow-up
          4
          arrow-down
          1
          ·
          4 months ago

          You are not wrong of course but it does not really refute what they are saying.

          Many people have had the experience with Rust that, if it builds, the behaviour is probably correct. That does not prevent logic errors but those are not kinds of bugs that relate to dependencies.

          These kinds of dependency shenanigans would be totally unsafe in C but Rust seems to handle them just fine.

    • merthyr1831
      link
      fedilink
      English
      arrow-up
      1
      arrow-down
      1
      ·
      4 months ago

      This isn’t Rust’s fault lmao, this is distro maintainers trying to fuck with dependencies on software which has been proven to be a horrible way of managing software distribution for years.

      When it’s a problem with other languages, we don’t pin the blame on them. However, because Linux and its developer community is being dragged by its heels to accept ANYTHING more modern than C99 and mailing lists, the typical suspects are using any opportunity to slow progress.

      The same shit has happened/is happening with Wayland. The same shit will happen when the next new technology offers a way for Linux to improve itself. A few jackasses who haven’t had to learn anything new for a lifetime are gonna always be upset that new Devs might nip at their heels.

      • solrize@lemmy.world
        link
        fedilink
        arrow-up
        2
        ·
        4 months ago

        If whatever they are doing has been working for stuff written in languages other than Rust, we have to ask what makes Rust special. Rust is a low level language, so its dependencies if anything should be simpler than most, with just a minimal shim between its runtime and the C world. Why does any production software have a version <= X constraint in any of its dependencies anyway? I can understand version >= X, but the other way implies that the API’s are unstable and you’re going to get tons of copies stuff around. I remember seeing that in Ruby at a time when Python was relatively free of it, but now Python has it too. Microsoft at least understood in the 1990s that you can’t go around breaking stuff like that.

        No it’s not all C99. I’m using Calibre (written in Python), Pandoc (written in Haskell), GCC (written in C, C++, and Ada), and who knows what else. All of these are complex applications with many dependencies. Eclipse (written in Java) is also in Debian though I don’t use it. Bcachefs though is apparently just special.

        Joe Armstrong (inventor of Erlang) said of OOP, “you wanted a banana but what you got was a gorilla holding the banana, and the entire jungle”. Rust begins to sound like that too. It might not be inherent in the language, but it looks like the way the community thinks.

        I also still don’t understand why the Bcachefs userspace stuff is written in Rust. I can understand about the kernel part, but the concept of a low level language is manual resource management that a HLL handles for you automatically. Writing the userspace in a LLL seems like more pain for unclear gain. Are there intense performance or memory constraints or what?

        Actually I see now that kernel part of Bcachefs is also considered unstable, so maybe the whole thing is not yet ready for production.