8 ms·
Alternatively the sheer weight of the Linux kernel's influence means that the GCC implementation of Rust becomes the dominant one, altering the way people insta
by cmrdporcupine 4y ago
Alternatively the sheer weight of the Linux kernel's influence means that the GCC implementation of Rust becomes the dominant one, altering the way people install and manage Rust.
Rust is good, but I also do not like the trend in every language and/or build system having its own package management with its own third party dependencies and its own custom installers separate from the distro. I understand the pragmatic problems this solves, but I think it has serious ramifications for reproducibility, security, auditing, etc.
- ImprobableTruth 4y agoThe reproducibility story with system package managers is an absolute nightmare. In general, language package management systems, containerization and fully statically linked distributions (appimage, flatpak, snaps, etc.) are all a direct response to system package managers being woefully inadequate in all sorts of ways. And unless something like Nix takes over which actually allows reproducible builds, we'll continue to see alternative solutions continue to encroach on system package managers.
- cmrdporcupine 4y agoAbsolutely, I understand why these systems are there. And see the issue. The problem is the rapid propagation of them. There's too many, and they live outside the purvey of the distribution management, and often (... NPM, etc.) have poor auditing and moderation. I see why they happen. I don't blame the people to make them. I just think it's a potentially awkward situation when it comes to something as core as the kernel; which has traditionally only required GCC.
- jupp0r 4y agoRapid propagation? Fully statically linked binaries have been a thing for decades. The practice only got broken under most Linux distros when glibc decided to make it impossible to be linked against statically.
- SubjectToChange 4y ago> I just think it's a potentially awkward situation when it comes to something as core as the kernel; which has traditionally only required GCC. Clang is starting to leapfrog GCC here. IIRC, some features are better supported and/or more advanced on Clang, other features (e.g. LTO) are exclusive to it. Not to mention it's almost a certainty for Clang to land kernel PGO support long before GCC, in fact Google already uses it in production Android kernels. Anyway, rust or not, linux is being decoupled from GCC.
- dralley 4y agoLTO is not exclusive to clang. "thin" LTO is. It just happens to be more commonly used, since it's faster and uses less memory.
- SubjectToChange 4y ago> LTO is not exclusive to clang. This is in the context of the Linux kernel, which only mainlined Clang LTO support in 5.12. AFAIK, GCC LTO has yet to be accepted.
- corrral 4y agoIMO distros shouldn't be packaging the world anymore, anyway. Base system from the distro, everything else from a separate, probably cross-distro package manager. The trouble, of course, is that this is hell for a Linux desktop system, because you can't cleanly put the GUI stack in either "base system" or "everything else", especially with all the shared libs and such.
- mamcx 4y agoThe problem of package managers is that are too many in too many OSes (and most varied on linux). Having one for Rust reduce a lot of complexity (Same operation across all OS), and is the best place to take decisions (Rust developers know Rust needs, debian ones who knows?).
- im3w1l 4y agoLet's say for the sake of argument that I whipped up some software over the weekend. It's 9pm Sunday night and I want to publish my work so other people can play around with it. My friends being true nerds all have different opinions on which distro is the best. Let's consider my alternatives. 1. I can (and will) publish the source and give instructions on how to build it. This works but is a bit inconvenient for the user. They have to manually install and manually check for updates and manually install updates. 2. I can publish on language-package-manager. This is a simple and easy process. It can be figured out in less than 30 minutes. For the user they put the name of my project into a config file and that's it. 3. I can publish on top-5 system package managers. This will take days or maybe even weeks of labor. So basically, it's just not viable for hobbyists. It can only work for companies that pay people a salary to deal with it.
- nextaccountic 4y agoRust actually works fine with distros. See for example https://github.com/kornelski/cargo-deb https://github.com/kornelski/cargo-deb and https://wiki.archlinux.org/title/Rust_package_guidelines https://wiki.archlinux.org/title/Rust_package_guidelines I use Arch Linux and Most Rust programs I use are installed from the Arch repositories or AUR. Rust packages are very well integrated with the distro, they depend on distro packages and have other packages depend on it. As far as the user is concerned, the Rust build system is just a developer-only stuff like CMake or autotools or ninja or whatever. Anyway I would like to point out that C++ also do something similar to what Rust libraries typically do, which is to use header-only libraries that don't appear as separate distro packages. It's as if every Rust library meant to be used by Rust programs (as opposed to libraries that expose a C API that can be called by other languages) were a header-only library. And this is actually great because Rust (like C++) monomorphizes generics, that is, if you call a generic function defined on another crate, the compiler actually generates a new function just with the type parameters you supplied, and there's no way the library can know upfront which generic instantiations will happen over all programs that use it. On the reproducibility front, I think it would be great if C program actually did what Rust does and pinned the exact damn versions of all libraries they use (like Cargo.toml does)