technom

The egregious part in this is that Google presents RCS as an open standard to get carriers to adopt it. But then they retain enough control to exert their power over users like this. The same happened with Android. I don't know how long such exploitation is tolerated before such aggressors are split up into a thousand competing businesses.

Unsafe code, at least in Rust, is given special treatment and care. Such code is usually 5% or less of the total codebase. Such unsafe blocks are also commonly reused fundamental designs. This leads to them being designed as libraries that are shared.

You can of course give C++ the same consideration. But then 100% of that code base will have to be given special care. And the reusability of unsafe code goes out the window.

People who argue that Rust (not sure about GC languages) is equivalent to C and C++ because of escape hatches like unsafe, completely neglect the localization of unsafe code and the benefits it brings.

That works only if memory safety is optional. Additions of the language features needed for mandatory memory safety are backwards incompatible.

One of their sources is the NSA, which is both mandated to make such recommendations and has the competence to do so. And as for the safety of C++, it's possible to write unsafe code in modern C++. One of the best examples is multithreaded code. Modern C++ is far safer than C or pre-C++11, but it doesn't address the entire space of memory safety.

You don't have any evidence, much less anecdotal evidence. Things don't become true just because you insist.

So you're just spouting some cooked up theory. Not a practical scenario.

If that's so trivial to trigger, people would be doing so everywhere. Have you seen it in the wild or heard of anyone doing so?

This is definitely into the territory of misinformation.

I don’t write Rust, but lots of programs I use do and, as I said, they seem to crash about as much as any other compiled language tools I use are written in

I already addressed this before. Regular crashes are almost always (I can't remember any exceptions) due to panics or aborts chosen by the user - especially due to unwraps. Using that to equate Rust programs' stability to 'any other compiled language tools I use are written in' is very disingenuous - because it's just as easy to handle those errors and prevent a crash at all.

If not doing segfaults is what makes a language “safe,” then it seems to me most modern languages are as safe as Rust

You are unnecessarily conflating issues here. 'Most modern languages' are not a replacement for what C, C++ and Rust can do. Go most famously had to retract their 'systems programming language' tag, for example. If a GC language meets your requirements - then by all means, use it. But it's not without reason that many companies have rewritten even their web backends in Rust. Memory safety without GC is a very big feature that a lot of professionals care about. It's not something to dismiss as trivial.

And while at it, you neglecting what segfaults represent. It's just a benign example of memory safety bug. It's benign because it gets caught causes the program to crash. There are a whole lot of them that causes the program to continue running - causing serious vulnerabilities. This is why even the US government and agencies recommend memory safety languages and especially Rust if performance and other limitations matter.

If we include crashes, then as I said, I see Rust programs crashing about as much as any other proglang.

I really don't want to repeat the reason twice in a single comment and 3 times including in my previous comment. But the only way you are going to make Rust crash as much as 'any other prolang' is to neglect idiomatic Rust. That isn't surprising because crashing anything is possible if that's your intention.

You said bugs caused by 'memory problems'. And that Rust programmers vastly overestimate them. Those aren't generic logical bugs that you get in Go or Java. And Rust never claimed to solve logical bugs.

I don't know if you're talking about panics and abort or about crashes caused by memory safety errors. The latter class is very unlikely in safe rust, other than as rare compiler bugs. Panics and aborts are your call. You can easily write code that doesn't panic or abort.

Have you really used Rust or are you spreading FUD? I have not managed to cause even a single segfault in my 8 years of writing Rust code. Nor have I heard anyone else complaining about it, other than deliberately as proof of concept.

So you can't get a Rust program to segfault without trying really hard. I haven't observed a single segfault in the normal Rust code I wrote in the past 8 years.