He has made a large number of questionable comments, including the argument that the solution to human trafficking includes legalizing child prostitution:

27 April 2015 (Human Trafficking Act)

The Senate’s Victims of Human Trafficking Act is dangerous in several ways.

When it talks about having the customs agency do more to enforce “intellectual property”, I am sure that refers to something bad. Whenever that term is used, something nasty is afoot.

The way to protect children from being forced into prostitution is to legalize prostitution by licensed prostitutes. Customers could be required to check the prostitute’s license. If the customer fails to check, that concrete omission would be legitimate grounds for punishment.

Minors should not be denied prostitution licenses in a blanket way, but the state should ask them why they want one and probe their situation, then offer help so they can avoid prostitution.

https://www.stallman.org/archives/2015-mar-jun.html#27_April_2015_(Human_Traffickting_Act)

Frankly, it sounds like neither of the two should lead the FSF

sudo-rs is a different project than uutils

Well, maybe you’d better wait 10min instead of one, to make sure the led lightbulb heats enough, but still…

I tested this with a 5W IKEA LED light-bulb, since I was just doom scrolling, anyway:

• After 1 minute of being on, the bulb was still room temperature.
• After 10 minutes of being on, the bulb was lukewarm.
• After 10 minutes of being off, the bulb was room temperature, though the fitting maybe felt slightly warmer. That latter will probably depend on your installation, and how well it is able to disperse the heat.

This means that the solution either breaks down entirely, or is unreliable, since you are not (reliably) able to tell the first two buttons apart

That’s the case of for any optimization work, really

The way to really optimize Python code, is by reducing the amount of Python code in your program, since Python itself is dog slow. Instead, you want to offload as much of the work as possible to modules written in compiled languages. So completely switching to Rust, or another compiled language, is simply taking that strategy to its logical conclusion

Loop labels are rare, but they lead to much simpler/clearer code when you need them. Consider how you would implement this kind of loop in a language without loop variables:

'outer: while (...) {
    'inner: while (...) {
        if (...) {
            // this breaks out of the outer loop, not just the inner loop
            break 'outer;
        }
    }

    // some code here
}

In C/C++ you’d need to do something like

bool condition = false;
while (...) {
    while (...) {
        if (...) {
            condition = true;
            break;
        }
    }
    if (condition) {
        break;
    }

    // some code here
}

Personally, I wouldn’t call it ugly, either, but that’s mostly a matter of taste

C++ is even worse, due to templates and the so-called most vexing parse. Initializing with {} mitigated the latter somewhat, but came with its own set of woes

In practice, type inference in Rust is not a problem since the language is so strongly typed. In fact, it is more strongly typed than both C and C++, and will force you to cast values explicitly in cases where C and C++ will happily mess up your variables without warning. The absence of type inference would also be a major pain, since nested types such as iterators can get quite complex and very verbose. If you’ve programmed using older C++ standards, then you know this pain

I believe that it is useful in a few places. cppreference.com mentions templates as one case:

Trailing return type, useful if the return type depends on argument names, such as template<class T, class U> auto add(T t, U u) -> decltype(t + u); or is complicated, such as in auto fpif(int)->int(*)(int)

The syntax also matches that of lambdas, though I’m not sure that adding another way of specifying regular functions actually makes the language more consistent, since most code still uses the old style.

Additionally, the scope of the return type matches the function meaning that you can do

auto my_class::my_function() -> iterator { /* code */ }

instead of

my_class::iterator my_class::my_function() { /* code */ }

which is kinda nice

With Rust you safe 1 char, and gain needing to skip a whole line to see what type something is.

Honestly, the Rust way of doing things feels much more natural to me.

You can read it as

1. Define a function,
2. with the name getoffmylawn,
3. that takes a Lawn argument named lawn,
4. and returns a bool

Whereas the C function is read as

1. Do something with a bool? Could be a variable, could be a function, could be a forward declaration of a function,
2. whatever it is, it has the name getoffmylawn,
3. there’s a (, so all options are still on the table,
4. ok, that’ a function, since it takes a Lawn argument named lawn, that returns a bool

Amusingly, modern C++ allows you to copy the rust signature nearly 1:1:

auto getofmylawn(Lawn lawn) -> Option<Teenager> {
    return lawn.remove();
}

At this point the people complaining about Rust at every opportunity have become more annoying than the “rewrite it in Rust” people ever were

The article is about an internal kernel API: They can easily rename those, since they are not exposed to user-space.

But you seem to be talking about the kill command and/or the kill function, that are part of the POSIX and C standards, respectively. Renaming either would break a shit-ton of code, unless you merely aliased them. And while I agree that kill is a poor name, adding non-standard aliases doesn’t really offer much benefit

I set the timestamps of my music to its original release date, so that I can sort it chronologically… OK, I don’t actually do that, but now I’m tempted

How the fuck can it not recover the files?

Undeleting files typically requires low-level access to the drive containing the deleted files.
Do you really want to give an AI, the same one that just wiped your files, that kind of access to your data?

What do you want me to write?

To meet the bar set by onlinepersona, you’d need to write safe C code, not just some of the time, but all of the time. What you appear to be proposing is to provide evidence that you can write safe C code some of the time.

It’s like if somebody said “everyone gets sick!”, and some other person stepped up and said “I never get sick. As proof, you can take my temperature right now; see, I’m healthy!”. Obviously, the evidence being offered is insufficient to refute the claim being made by the first person

I’m surprised that you didn’t mention Zig. It seems to me to be much more popular than either C3 or D’s “better C” mode.

It is “FUD” if you ask why it’s still const by default.

I’d be curious if you could show any examples of people asking why Rust is const by default being accused of spreading “FUD”. I wasn’t able to find any such examples myself, but I did find threads like this one and this one, that were both quite amiable.

But I also don’t see why it would be an issue to bring up Rust’s functional-programming roots, though as you say the language did change quite a lot during its early development, and before release 1.0. IIRC, the first compiler was even implemented in OCaml. The language’s Wikipedia page goes into more detail, for anyone interested. Or you could read this thread in /r/rust, where a bunch of Rust users try to bury that sordid history by bringing it to light

Makes memory unsafe operations ugly, to “disintensivise the programmer from them”.

From what I’ve seen, most unsafe rust code doesn’t look much different compared to safe rust code. See for example the Vec implementation, which contains a bunch of unsafe blocks. Which makes sense, since it only adds a few extra capabilities compared to safe rust. You can end up with gnarly code of course, but that’s true of any non-trivial language. Your code could also get ugly if you try to be extremely granular with unsafe blocks, but that’s more of a style issue, and poor style can make code in any language look ugly.

Has a pretty toxic userbase

At this point it feels like an overwhelming majority of the toxicity comes from non-serious critics of Rust. Case in point, many of the posts in this thread

That’s not quite true: Yes, your $99 license is a life-time license, but that license only includes 3 years worth of updates. After that you have to pay $80, if you want another 3 years worth of updates. Of course, the alternative is just putting up with the occasional nag, which is why I still haven’t gotten around to renewing my license

I’ve started converting my ‘master’ branches to ‘main’, due to the fact that my muscle-memory has decided that ‘main’ is the standard name. And I don’t have strong feelings either was