Despite of all positive features of Rust, it still has a very limited use. Ubuntu team tried to make it a part next releases of the Linux version, but the limited usage of Rust immediately stroke back.
I am trying to use Rust everywhere, for example, I needed TOTP, I could use a perfect solution for that written in Go by Google, however I decided to use Rust. I needed IDE. I could use perfect solutions as VSC, VIM, and other written in C, but again, I used Rust. I needed a web server, so I wrote own in Rust. All these small efforts help to make Rust more stable.
So, review everywhere where you still use other languages, and rewrite solutions in Rust. Of course, do not become desperate, and do it only in a spare time.
I am a rust lover, I don't want to be a rust addict.
I like to use rust when I need to write new things, or when I have the chance to update/rewrite old/legacy programs.
I don't like rewriting perfectly working software in <insert your language> just for the sake of it, unless it's for entertainment purpose, which happens quite a lot, actually, because writing rust is very fun.
I don't understand some of the zealous people who worship <insert your language> as if it were a religion and became super defensive over anything related to it, I think it's bad for the sanity of themselves, and bad for the community too.
It's a huge sink of time and effort. One does not want to be doing all that work unless there is a pressing need for it. As for "spare time" I'd rather be doing something more interesting with that precious commodity.
A new implementation risks introducing bugs or committing features that will annoy somebody some where.
It adds yet another dependency to systems. Another twist in complexity and bloat. Which will annoy somebody else. For example I'd like to think I can build a linux system that pretty much only depends on C.
Bolting a new language onto an existing system, think Linux kernel, introduces a whole load of complexity in getting them to interoperate.
If you end up imposing your new Rust creation on people and it fails in any way that is going reflect badly on Rust.
Having said that I have no objection to people creating implementations of whatever they like in Rust. For example Ubuntu and the core utils. But that does not mean hasty replacement of things people have been relying on for decades. That seems like a really bad idea as Ubuntu discovered. But hey, Ubuntu has never been a stable Linux distro.
P.S. On discovering Rust I did reimplement a rather large C++ program in Rust. I had previously written the same functionality in C++ at a different company. When they fired us all and we got together as a startup they threatened to sue us for stealing their software. I needed a totally different language for this reimplementation so there could be no such accusation.
review everywhere where you still use other languages, and rewrite solutions in Rust
Absolutely not. Each language has its advantages, and Rust isn't the solution to everything. Also, there are areas where it's not a good fit.
More importantly, ever since programming was a thing, languages have influenced one another from their mistakes and strong points, so a good competition is more beneficial than pushing a language artificially.
Besides, such an attitude would only project a negative image of Rust and prompt developers of other languages to push back (see what's currently happening in the Linux core, for instance). The language has enough advantages of its own to gain momentum naturally.
As for tools, I'd avoid the "not invented here" syndrome. It's fine to redo something that already exists for learning or for one's own pleasure, or if that tool has issues that only Rust can fix, but if it's working perfectly and has already got a lot of scrutiny and improvements, it doesn't look like a priority, or even a good idea. Instead, that effort would be more productive if spent on contributing to Rust itself—the language, its libraries, and its tools.
PS: I suppose you meant intensify ("intesificate"?) or promote.
You mean, an unimplemented feature, with inadequate test coverage (subsequently rectified), broke a use case depending on that feature? The horror! Releasing software for wider use, where it's subjected to scenarios which can't be captured by test suites, however comprehensive, is the way to improve robustness. And that's precisely what Canonical has done. Of course the vocal opposition is on hair trigger to proclaim that the bug invalidates the entirety of the uutils project, since that fits their Manichean view of sofrware development landscape, but no one should take that seriously (in a technical way.)
I am trying to use Rust everywhere
Why? Depending on context, that may not make sense. Consider your own example:
I needed TOTP, I could use a perfect solution for that written in Go by Google, however I decided to use Rust
Did you need it as a standalone application? Or part of a workflow already written in Rust? Or...? Different scenarios suggest very different approaches. Here and elsewhere. There's no need for extremism.
Watch another video confirming my point. Rust doesn't eliminate issues, and a memory corruption isn't only one problem developers face. Tons of others issues we face and without the intensification of using Rust, we can't fix them.
I fail to see how Brian Lundukes video on Ubuntu's failures trying to use coreutils rewritten in Rust confirms your point. If anything the opposite.
Rust does illuminate issues. Particularly those related to misuse of types, object lifetimes and aliasing.
Anyone looking at Rust knows that there are an infinite number of ways to write software that fails to do what you want correctly, even in the face of Rust's memory and type safety. I hope that much is obvious.
We conclude then that reimplementing a huge pile of existing software is likely to introduce a lot of bugs and annoy people with missing or differently behaving features. Whilst at the same time being memory safe.
Thank you for a good grip of my view. I recently wrote that Rust can be used to write small system programs. Someone was not happy with the conclusion. But as you see, it perfectly confirmed; even rewriting an existing software in Rust generates huge amountnof problems. Certainly creation of a completely new software will generate much bigger amount of problems as well. And the way to get over of it is obtaining a good experience of using Rust that means just write more code in Rust. There is no other way to get Rust successful language.
We can't fix them without the intensification of fixing them. And this can be achieved in two ways: either someone will donate their time (provide not just a bug report, but at least a draft for the fix) or their money (just hire someone else to make the fix). "Intensification of using" by itself helps with neither - it may be a kind of reasoning for the latter, but not much, unless some big players (think Microsoft) are interested, and their attention is a dowble-edged sword.
It's another problem that my approach will help to address. Why we have so many problems in the code which more likely just a blind translation of C code to Rust? There is also an automatic conversion tool you need just to run and enjoy result. However Rust is a conceptually different language and programing in it very different than in C. I even created a guide based on my experience for fast adopting your development skills to Rust. So again, then more frequently you use Rust for different tasks, then your development ability gets polished and your code becomes a true error free. I do not tell - promote Rust. It's stupid. People already heard that Rust is great. We need to prove it now.
