In the long run yes. Sure, many logic bugs happen in Rust programs as well, but memory safety bugs are another level of hell. At least many classes of exploits will mostly be impossible. Also, Rust program failures tend to be more predictable. For example, in C/C++, if you do out of bound writes in an array or writes in a freed memory block, the behavior is undefined. The program might crash, the memory might be silently corrupted, or nothing might happen at all. In a normal (non unsafe) Rust code these kinds of issues are either prevented by static checks or become explicit runtime panics.
While the migration could be done more gradually, 26.10 is not an LTS release and is not considered stabe enough. The next LTS is 28.04, so I hope there is 1.5+ years for things to stabilize.
Can you point to any outstanding, unfixable, memory safety bugs in the coreutils that justify such a rewrite? This is a cynical license issue, not a safety issue. I think there are much more severe security risks which come from behavior divergence of replacement tooling than memory safety bugs from 40 year old widely used/tested software.
The software world is littered with memory vulnerabilities and you’re here still asking for proof? You may not like Rust and that’s fine. But don’t continue propagating the attitude that got us here in the first place.
In theory yes, but it requires enough discipline and knowledge. A language that makes it harder to write bad code still has an advantage over a language that doesn't care about bad code.
Canonical has been pushing its own agenda for ages, how many examples do you need?
Microsoft making Rust tier 1 is great, it means probably one day we get a VS proper support instead of VSCode only.
If you head off to Microsoft official blogs, you will find out that Microsoft already has tier 1 support for Java (ironically), Python and Go, besides the usual .NET languages and C++.
Why does 'Ubuntu defaultism' still exist in the Linux world? Them replacing packages with shitty unworkable broken snap substitutes that can break the system when updating, and have a habit of reinstalling themselves...
"We are rewriting the mold linker in Rust and adding linker script support so that mold can link essentially anything GNU ld can, including kernels and embedded programs."
Legitimate question, why not just use GNU ld? Does link time take so long that it requires a complete rewrite?
GNU ld is indeed extremely slow, it is a very old codebase that isn't designed for modern systems, and it doesn't do any real work in parallel. GNU ld can be 2-10x slower than LLVM lld on real projects, and then mold is again ~5-10x faster that lld. The creator of mold is also the original creator of LLVM lld.
Traditionally the link time was a single-threaded step at the end of compilation, and it scaled very poorly. While compilation is embarrassingly parallel and has continued to scale. So link time was becoming a significant bottleneck, especially with incremental compilation. When you want to iterate on a large project, with GNU ld you might have to wait several minutes of link time on every dev build.
"...it doesn't do any real work in parallel." I think this is the biggest selling point.
Although, "with GNU ld you might have to wait several minutes of link time on every dev build." Meh, I might prefer to wait a few minutes and stick with something I know works.
"The creator of mold is also the original creator of LLVM lld" That's cool, why not implement these features in LLVM lld? Why not implement them in GNU ld? Is it a gatekeeping thing? Parallel ld would be very useful.
No, it's not a gatekeeping thing. You're coming at this with negative assumptions, so I don't think I can try to convince you. If you hate Rust and want something conservative, then use lld. It has some parallelism, but it's fairly coarse and still has single-threaded bottlenecks. It would have needed a pretty major re-architecture to modernize it.
As for trying to do that in BFD, patches welcome. Or maybe not welcome, I'm not sure the maintainers are really looking for a major redesign of GNU ld. But either way I'm not volunteering, it's much easier to start fresh than try to carve out and replace the entire guts of this old thing.
"You're coming at this with negative assumptions" not so much negative as skeptical. Everyone is pushing Rust and full rewrites, I'm still not convinced.
"But either way I'm not volunteering, it's much easier to start fresh than try to carve out and replace the entire guts of this old thing."
"I think this is long overdue, given that many large programs have already adopted mold. It has been used in production for years."
That's not a good reason to replace GNU ld with mold, I'm still skeptical about
rewriting EVERYTHING in Rust. What's the real reasoning? Who's pushing this so much?
Yes, I'm old now and have learned all the foundational computer and hardware engineering topics the hard way over 30 years. I've earned my AI tokens of freedom. :)
AI code increases productivity and reduces understanding.
If it is a project like this, that's cool. If you are deploying the safety control system on a power plant, you had better have a damn good understanding!
These technologies are cool and good and useful but they do something different than Rust: they catch problems at runtime and mitigate the bad effects, rather than preventing them at compile time.
CHERI doesn't exist (Morello isn't available) and memory tagging is not a thing on most processors (especially not server or embedded which are where most Linux runs). Apple's MIE needs Asahi to reach M5 which won't happen for some years, and ARM servers are still quite new.
Meanwhile, Rust structurally enforces memory safety. It's simply a better option than C in many cases -- C needs closer scrutiny, more third-party static and dynamic analysis, conventions differ much more wildly, far more expertise is required, the bar to safe contribution is much higher, code review is more difficult, I could go on and on but there are reasons to prefer Rust and it's not just cargo culting. Memory safety is a huge reason to want Rust, but also the type system, monomorphized generics, traits, the great first-party package manager and build system, better developer experience, clearer semantics, ... I could go on.
That said, there are also downsides to Rust, like hard reliance on LLVM, bad support for embedded or proprietary platforms, bad compile times, less flexibility in what is accepted by the borrow checker, more runtime checks and panics for safety, fragmented ecosystem, some basic things are "unstable", some semantics like pointer provenance still haven't been worked out after over a decade, semantics of borrowing are still in flux as well, bad interoperability with C++, etc.
Then there's the fanbase which can be absolutely insufferable, and show such zealotry that many people are turned away from Rust before even getting to honestly consider it, just because the fans can be so rabid.
I can image the moment Sir William Jones realized Sanskrit and Latin had a common origin. "Wait a minute...these can't all be coincidences." It's pretty mid-blowing.
My daughters are growing up bilingual in Persian and English. Totally fascinating to find the cognates; many are surprisingly close still (daughter/dokhtar, star/setare, cow/gav). It’s fun feeling like I could communicate basic ideas to a proto Indo European speaker based on those really distant cognates.
It gets complicated by the preponderance of French loan words, although they tend to be for newer concepts such as car, elevator, etc.
There do also seem to be some genuine coincidences, such as sock it/saket, both being a somewhat forceful way to tell someone to be quiet.
But yes, Persian people and culture in particular has fascinated me due to the ancient, but not prehistoric, traces of a shared identity with Europeans, in contrast with its neighbors. It’s not something that gets a lot of attention in popular culture
I'm learning Spanish now after studying French and while I'm not fluent at all in Hindi or Marathi which I sometimes heard my family speaking growing up, the cognates are fascinating. The numbers are the most obvious. But even words like 'tu' (you) are the same in all the languages. Same with English and me as the first person.
Not to mention the verbs. Truly wild stuff to think no one noticed.
People noticed. They just didn’t come up with a theory of a common ancestor language. Or, in some cases, they assumed other European languages were originally heavily debased forms of Latin/Greek.
Will this really make coreutils more secure? I doubt it, if anything there will be a river of new bugs.
So, again, why are they pushing Rust so much? Having Microsoft make Rust a 'Tier-1' language also doesn't bode well.
reply