[rustfreeforme]

> Yes, except imagine the distance in correctness between Assembly and C, and triple it.

* laugh track deafening *

> The sentiment of "if it compiles it probably works" for languages like Rust and Haskell is there for a good reason.

It could compile and still have 10,000 logic errors.

Rust is not a major advance over C/C++, only an incremental and quite limited one, which will require decades of rewriting perfectly good code to gain its dubious benefits, in the process introducing numerous other errors.

But don't take my word for it, I'm just the guy who--as usual--is aware right now of facts the rest of you will slowly figure out over the next 20-30 years, after the hype has worn off and you're left with the sad mess that is Rust.

[whytevuhuni]

> * laugh track deafening *

No shallow dismissals please, tell me why you think I'm wrong.

> Rust is not a major advance over C/C++

Rust adds the borrow checker (and especially with non-linear lifetimes it's an implementation like the world has never seen before, not even in Cyclone). That alone raises it leaps above both C and C++.

But even without it, it still has a Hindley Milner type system (which most people considered superior to multiple inheritance), it has Sync/Send traits, the concept of UnwindSafe, proper destructive moves and affineish types, proper sum types and matching, sane iterators, lack of UB on uninit/overflow/etc, a sane module system, hygienic macros, and that's just the things I was able to pull of the top of my head right now.

Not to mention, the design of its stdlib is absolutely lovely compared to what C++'s stdlib has become, and it focuses on correctness much more than most other popular languages.

[rustfreeforme]

> No shallow dismissals please, tell me why you think I'm wrong.

Tell me why you think you're right.

Hint: you're wrong.

> Rust adds the borrow checker (and especially with non-linear lifetimes it's an implementation like the world has never seen before, not even in Cyclone). That alone raises it leaps above both C and C++.

No, not really. It's an incremental improvement at best.

In time you will learn about all of the faults and flaws in Rust, after you've suffered the pain of trying to rewrite the entire universe in it just to fix one single class of problem you are obsessed about--inevitably introducing many new bugs in the process, because that always comes with the territory.

I know exactly what the successor to C/C++ looks like, and it's not Rust.

> But even without it, it still has a Hindley Milner type system (which most people considered superior to multiple inheritance), it has Sync/Send traits, the concept of UnwindSafe, proper destructive moves and affineish types, proper sum types and matching, sane iterators, lack of UB on uninit/overflow/etc, a sane module system, hygienic macros, and that's just the things I was able to pull of the top of my head right now.

Blah blah blah. Most of that is just added runtime complexity that I could add to C if I wanted, but why would I? None of that crap is needed. Most of it is wankery, the sort of stuff that 20-somethings salivate over but which in the end is meaningless, just change for the sake of change.

> Not to mention, the design of its stdlib is absolutely lovely compared to what C++'s stdlib has become, and it focuses on correctness much more than most other popular languages.

Ada is the language to emulate, not Rust or C++. Again, the actual successor to C/C++ looks nothing like Rust.

[fluffybucktsnek]

> In time you will learn about all of the faults and flaws in Rust, after you've suffered the pain of trying to rewrite the entire universe in it just to fix one single class of problem you are obsessed about--inevitably introducing many new bugs in the process, because that always comes with the territory.

Good thing Rust doesn't just fix that one class of problems, but also provides better tooling to fix other classes too. Classes of problems that could be fixed with the other features of Rust mentioned later like the Hind...

> Blah blah blah. Most of that is just added runtime complexity that I could add to C if I wanted, but why would I?

...the vast majority of these features don't even run at compile time. Some of them can't even be implemented in C. For starters, show me an example of a Hindley Milner type system implemented for C (how can someone improve a strictly compile time feature, static typing, with a runtime implementation is beyond me). Or proper destructive moves in C or C++.

> Ada is the language to emulate, [...]

Good thing Rust also takes from Ada.

> Again, the actual successor to C/C++ looks nothing like Rust.

And that would be...?

[rustfreeforme]

> Good thing Rust doesn't just fix that one class of problems, but also provides better tooling to fix other classes too. Classes of problems that could be fixed with the other features of Rust mentioned later like the Hind...

Wow, what a magical language! [ waves hands vigorously ] will fix all the problems which are inevitably introduced by auto-porting from one language to another, or by manually rewriting everything from scratch. Rust doesn't obey the same laws of the software universe as other languages, it seems.

Rust will even automatically rewrite itself to use its own special idioms rather than whatever loser idioms it has sadly inherited from the C/C++ code which the developer, in his infinite benevolence, has decided to lift from its Dark Ages level of inadequacy to Modern Language Standards, with nothing but joy and happiness as the result. Miraculous.

Or is this a "just use magic AI to do it all bro", type situation?

In the latter case, why don't I just use the magic AI to auto-magically solve my C/C++ problems, rather than rewrite the entire universe from scratch? You know, like Google claims to have done for Chromium C++ sources in this very news article?

> ...the vast majority of these features don't even run at compile time. Some of them can't even be implemented in C. For starters, show me an example of a Hindley Milner type system implemented for (how can someone improve a strictly compile time feature, static typing, with a runtime implementation is beyond me)

What part of "I don't care about any of that crap" aren't you grasping?

This is the type of shit noobs are always wringing their hands about, as they want new toys to play with and/or maximum guardrails to cover for their ineptitude. Which is exactly why Google wants these kind of things, as their median developer is some kid fresh out of college. They want a magic language that will protect the idiot programmer from himself and eliminate all errors, so that any trained monkey can use it, as they plan to train actual monkeys to do this if they can somehow get away with it.

Well, that isn't Rust. Not even close. It's just the next horror show masquerading as a "fix."

[Aeolos]

It is obvious that you are just trolling, but for other readers: our production app went from 50-100 unexplained sentry errors in typescript to 0 sentry errors in rust.

The language absolutely helps fix logic errors.

It's something that becomes immediately clear as soon as you start using the language in earnest.

[rustfreeforme]

What if I told you TypeScript sucks?

[fluffybucktsnek]

> Wow, what a magical language! [ waves hands vigorously ] will fix all the problems which are inevitably introduced by auto-porting from one language to another, or by manually rewriting everything from scratch. Rust doesn't obey the same laws of the software universe as other languages, it seems. Or is this a "just use magic AI bro", type situation?

Nope, that's just your own prejudices speaking. We already cited features (seen in and inspired by other languages) and you handwaved them away with "I don't care". You are the one fixated on C and C++. You are a C evangelist, if I were to make a guess. And that's on you.

> In the latter case, why don't I just use the to auto-magically solve my C/C++ problems, rather than rewrite the entire universe from scratch? You know, like Google claims to have done for Chromium C++ sources in this very news article?

You certainly can. But to spin this the other way around: in lieu of the Bun case, why not use it to rewrite the project in Rust, Zig, D or any language of your choice (yes, even C)? Given the role harnesses have in keeping agents in check, it seems plausible that languages with stricter safety features help agents avoid common issues.

> This is the type of shit noobs are always wringing their hands about as they need maximum guardrails to cover for their ineptitude.

You seem to be forgetting that proper software engineering is just as much about managing developers and their skills as the actual code structure. If a tool helps noobs produce better quality code, specially ones without as many vulnerabilities, why not employ it? Also, it's not like experts are immune to mistakes either.

[rustfreeforme]

> if I were to make a guess

This is your problem. You keep guessing, and guessing, and guessing, constantly missing the mark. You keep arguing, and arguing, and arguing, because you just really, really, really want to be right, but you just really, really, really aren't.

> But to spin this the other way around: in lieu of the Bun case, why not use it to rewrite the project in Rust, Zig, D or any language of your choice (yes, even C)?

Because as I just explained to you -- pay attention -- there is no way to magically do that, without introducing bugs. Period. Bun being the canonical example of the sort of dumpster fire that comes from trying to hop from one language to the next like a woman changes shoes. Their code is notoriously junky and they switched to Rust as if it was the actual solution to their problems, rather than just a hype-chasing marketing stunt.

The actual solution is to hire competent engineers and write quality code. Idiots do not write good code in any language.

> Given the role harnesses have in keeping agents in check, it seems plausible that languages with stricter safety features help agents avoid common issues.

lol

I thank God that none of the shit code you and your pet AI write will ever touch my PC.

> You seem to be forgetting that proper software engineering is just as much about managing developers and their skills as the actual code structure.

You keep missing the point, over and over and over again, in your zealous desire to Be Right.

As I said about 15 times already: the problem with Chromium IS GOOGLE, not C++.

GOOGLE desires to own the entire world.

GOOGLE wants Chromium to run on everything, everywhere, and be everything to everyone.

GOOGLE wants to track and monitor everything everyone does, at all times.

Chromium, as a result, is a giant, bloated, buggy heap of shit, THAT CANNOT be properly maintained IN ANY LANGUAGE, due to the extreme level of bloat.

GOOGLE is the author of their own misfortune here, not C++. Making their project into an unholy chimaera of C++/Rust isn't going to solve any of their problems, but only worsen them.

Everything else is just noise. No, Rust isn't some magic language that just magically makes everything better, as I already told you that you will learn over the next couple decades. But don't take my word for it, just keep doing what you're doing.

[fluffybucktsnek]

> It could compile and still have 10,000 logic errors.

It could. Switch that to C or C++ and the amount of logic bugs is likely going to triple.

> Rust is not a major advance over C/C++, only an incremental and quite limited one, [...]

"Nothing ever happens." I guess you could consider borrow checking, an actual module system, type classes, enum variants, compiler-integrated macros, async/await, etc. to be just small increments. (Theoretically, you can reimplement most of this in C++, like std::variant, but they don't integrate well into the language - having to declare a type just to use std::visit is certainly not as simple as using match).

> [...] which will require decades of rewriting perfectly good code to gain its dubious benefits, in the process introducing numerous other errors.

"Introducing numerous other errors"? Would be interesting to see an citation on that. From what I've seen, these "new errors" were already present in the original "perfectly good code", except the original also had instances of undefined behavior and logic errors from poor type modeling.

> But don't take my word for it [...]

Why would anyone other than your friends take your word? You could have substantiate your claims with actual evidence.

> [...] after the hype has worn off [...]

Which already did. Nowadays, I see more posts about Zig and Fil-C.

>[...] left with the sad mess that is Rust.

I went to read your comment history to see if you elaborated on this "sad mess" of Rust, but you didn't. How about you do it here?