Ha! A few years back when I was choosing a language for my library, it was a toss up between GO and Rust. I went for Rust for a variety of reasons, but if I tell the truth not wanting to mix tabs and spaces was high on the list. When you don't behave tine to try them all, software engineering is just as much matter of chance as it is reflection.
Have a good holiday also.

I've written Rust for quite a while now. I expect the compiler to help stop me from writing some bad code. It doesn't always run correctly after compiling, but there are a whole class of errors that it doesn't make.

It sometimes stops me from writing what I think is perfectly good code. I could understand if all the objections you hear were about that.

Well, it seems to me that you are disagreeing with the notion of memory safe languages at all.

I can see that, but I feel that "memory safe" is still a useful classification of programming languages; we have been distinguishing between those that *routinely* require memory management, such as C, and those that do not through GC like lisps, java and so forth or lifetime management as in Rust, even if they exceptionally have a mechanism around that, either through extension over an FFI or as in Rust, through "unsafe".

Yeah, I read a few more of Lunduke's stories. He seems far from objective and reasonable. They are rather highly politicised and often mean-spirited. The whole thing feels like a translation of a shock-jock show to the technology and the web. In the current day, I can see how that it likely to succeed, but it is not somewhere I will go again.

This sort of site is bound to attract some extreme views; if I were him, I think, I would welcome that whether it happens by chance or design. I wouldn't draw any conclusions about the rust community from this.

Can you give me an example of a programming language that you think is memory safe?

Okay. Do you think lisp, java or python are memory safe? All of them have guaranteed extension points which allows you to easily break any memory safety? Is "the memory error happened in the C extension not in python" an excuse or a single than python (lisp or java) are not memory safe.

My other point that someone got hate on twitter is not that it is okay, but that you learn more about twitter from this than about Rust.

I can't think of a memory safe language that doesn't have at least one way of breaking safety, whether that is in the library itself or through an extension layer and FFI.

Well, I read his reasonable post entitled Rust is a cult. I am not sure I would draw too many conclusions from him getting death threats on twitter, you can get death threats from posting about flower arranging. But again it is not my experience and the rust forums are very nice. Certainly less aggressive than here.

Thank you, I hadn't seen that before. I did have a good look to see if I could come up with other people saying this and there are a few.

That post seems to boil down to Rust and C having different aliasing rules. I am a little unconvinced at the moment that this is "harder" and not "different" but don't have enough experience to make a judgement for myself.

The type checker rather than the compiler per se. But, yes, the amount of reasoning the compiler can do is limited. It doesn't reason about the whole program, so might think that something could break while in practice other parts of the code prevent this.

I have written a fair bit of Rust, and spent a fair bit of time on the Rust forums as a result. I found it highly supportive, as well as polite and kind.

I've always tried to be polite on all social media, even as it has collapsed into its current state. But I still learned something from the Rust forums about this.

I am always surprised that people speak so negatively of the community.

The programmer made a mistake. Happens in C, happens in Rust. Unlikely that the programmer felt that everything in Rust is safe, especially after typing "unsafe" into their code.

Why is unsafe Rust worse than C? There is still a strong type system, integrated macros and low levels of undefined behaviour.

That is how it feels at first. But you get used to it. It's like languages with immutable data structures. It seems implausible at first but works okay.

I don't get the Rust hatred. C has implicitly had an "unsafe" mode for much longer than Rust.

If you're a C kernel developer, you can jump on the Rust bandwagon very easily: just put the keyword unsafe in your comments and you can write code just like Rust developers.

Maybe, just maybe, this mistake was caused by the fact that the same sort of people who are likely to write bugs into their code are the same types of people who prefer "safe" languages because understanding the subtle nuances of how computers work is difficult. They would prefer a system where they couldn't make mistakes, rather than a system where they had to understand the code and the machine to a high level. There's a place in the world for these sorts of people, but it's not in OS/kernel development. The sort of I-can't-make-mistakes-with-Rust mindset probably lulled the coder into a false sense of security, with the predictable outcome.