This, to me, seems like the standardization vs optimization argument. So much of the tech world could be optimized like crazy, but the more complex it gets, the hard it is to communicate with others and keep things consistent. This complexity actually hinders production overall. Standardization, even if it’s not the most optimized, allows us to create vastly more complex and reliable systems because we can ensure we are all on the same page. Even if that standardization isn’t the best way to do it.

Standardization is the reason why systems collapse or are more prone to attacks. Just think about a monoculture vs an organic mixed culture. Also, the impact on standardized systems is much bigger, because it affects the entire system. But on the other hand, yes, it requires more time and people. When reading comments from Rust people, I have always the impression that in the best case everything is replaced with Rust code. If this is indeed their intention, I disagree.

I mean, if you want to talk about absolute control over your code, why don’t you write in assembly? Are all programming languages not virtually assembly with training wheels?

Perhaps difficulty to learn, apply, and make changes? Also no interest, trigger and coolness among people? Assembly are considered the old nerds aka the hated boomers, while Rust people are sometimes the hipsters, the new generation. I do not like this attitude of exclusion. BTW, if you want to try out an OS written in assembly look at Kolibri OS.

Writing in code that is not memory safe is going to mean you are substantially more likely to have mistakes that lead both to user annoyance and straight up security vulnerabilities.

Depends on your skills.

Having applications written in a memory safe languages, especially when worked on by large swaths of people, is absolutely the best route.

I am sorry but I am unable to mix “safe language”, “large swaths of people”, and “best route” somehow in my brain. I just see “tilt, tilt, tilt”, because it does not make sense to me as there are no connections between all three points.

It provides a secure standard way to write memory safe code. This will reduce security vulnerabilities, decrease program crashes, and allow for more efficient developers.

The secure I put in question mark (aka time will show) and are you serious about efficient developers? In case you mean producing a larger program faster, yes, I agree. Memory safer? Very likely (although you can write safe programs in C as well). But more efficient in terms of more competent? I would not say this.

Changing a bike tire is something for a single person, maybe two at most. Writing code is often a team effort. And the more people that are involved, the more likely mistakes are going to happen.

Does not change my intention: either you know the in and outs, or you are a slave of others - in the case of Rust, the slave of the compiler.

People absolutely can still learn the complexities, and still choose to use Rust because honestly, it’s the smart thing to do.

Haven’t said anything against, but the smart thing to do is up to the personal choice, not because there is a loud community of followers.

And it doesn’t need to be rust. Any memory safe language would accomplish the same goal.

This is the point I would underline. It is not only Rust, but there are many languages out there worth regards and time, even for low level and systems.

Ah, right! This is among the reasons why Russia has the lowest share of seats held by women in politics (won’t go into business) in Europe (Statista).

I found the article, or better opinion. My bed that it wasn’t a Finn, but an America, Alan Ward. The metaphor is taken from him, while he explains in his article much better than me. Please, see his opinion on page 48-49 in the linked PDF of the current Full Circle issue #215 below:

Full Circle #215

I find his metaphor very apt.

@Flipper, if you just learn from one master, you cannot become a master in the field. As I said above: relying heavily on the compiler, even when this may be the best „teacher“, does not make you - I do not speak about you personally, but you in general, so all programmers - a good programmer. This is my major critic about Rust, while I do also understand its advantages.

Thank you for your explanation and I understand it well, as well the advantage to find bugs quicker (which however does not mean that a safe code cannot be also a bad code). However, I do think that writing safe code without being guided by a compiler is indeed a skill. And the question how safe the code written with the help of the compiler will be is another interesting one. Perhaps we will find out in the future.

In my opinion, Rust is a language dictated by the compiler rather than one that allows you to use your brain, knowledge, and skills to deepen your understanding. Rust is essentially a programming language with training wheels. Unfortunately, the preference to finish tasks quickly is nowadays the mainstream. The understanding of the deeper stuff falls behind.

A related example from real life: bike tyres that have a flat. Less and less people can change the tyres on their own, and even do not understand the construction and characteristics of different tyres, only believing what the vendor in the shop is telling them. Bad surprises then happen.

Alas, when there is no difference between unsafe wrapper in Rust and C, then why learning Rust, if one wants to go for managing the memory manually? Especially when considering the complex way of coding in Rust? Another problem: going the easy way and forgetting the tricky parts - if Rust allows for unsafe code, but it is safer to put it into a « safe » mode, so why I need to take the burden and deal with unsafe code? This will evidently lead to the situation that less and less unsafe blocks will be used, which finally leads to a situation where the programmer forgets the in and outs of manual memory management. You can see it as the principal aim of writing memory safe code, but to me it is also a way of « delearning » by learning. I see here the reason why so many young programmers are opting for Rust, because manually managing the memory in larger projects like in C is a question of knowledge and experience which does not come in one day. I also doubt that following just the compiler is a good approach. I agree totally with your last points though! Coding should mean to have fun and be the same time mentally challenged due to complex algorithms or demand for better code in general.

I like the description by a Finn who said: Rust is like a car with automatic, while in C (or Zig) you need to change the gears. In Rust you literally follow the compiler, which allows many young developers to program at low level, while C demands more time to avoid bugs. It is up to each person what he/she prefers. I would prefer to control myself the stuff and learn the in and outs of memory management.