You Don't NEED to Oxidize Your Life

A blog about Linux, POSIX scripting, Computer Hardware, Cars, and Anything In-Between

The Language (mostly) Doesn’t Matter!

There has been a new trend across the programming world: RWIR (Re-Write it In Rust). While this trend is not inherently BAD per se, there is not a real reason for it to exist.

“If it ain’t broke, don’t fix it.”

–Every Redneck, Engineer, and Sane Person

While a common quote among almost every aspect of society, Rust developers do not conform to this inherent law. See a program written in Go? Re-write it in Rust. Python? Rust! C++? Rust! Scratch? Rust (probably)! And when this does happen, these re-writes usually make a worse project, specifically from a productivity standpoint.

Rust Does Not Always Mean Better

Let’s start out with a fairly common program shipped and used in almost every single Linux distribution: Tmux. For those living under a rock Tmux is a Terminal MUltipleXer, meaning that it can split off different terminal sessions, have them run in windows (not the operating system) and even daemonize them to run in the background. This is especially useful for SSH sessions and other enterprise level work that cannot be halted but musn’t be actively monitored through a terminal all of the time.

Well, Tmux has committed the horrible, inexcusable crime of–being written in C (and a bit of C++). To remedy this blemish upon our society, Rust developers created a worse version: Zellij. Zellij is not necessarily BAD, but it does not replace the niche filled from Tmux. First off, it takes up WAY too much screen real estate. It has these pretty borders and headings, but when you’re stressed for screen space and don’t want it to go unnecessarily wasted, you might be a little off-put from that.

Another project to point out is Joshuto. Written to replace LF which is written in Go and a fantastic program, has fallen short and is just a crappy re-write. This is not to attack these projects, they have a perfectly reasonable start, however, there is no reason to switch to an inferior program just because of the language it is written in.

But Why?

Why did this trend start? Did people just run out of ideas or did these tools legitimately fix a problem? Well, sort of. Rust advertises a couple main features: modern language features, multiple paradigms, and–most importantly–low level with memory safety. This is a great feature! As many Rust devs like to point out, 30% of all CVEs (that is, documented security exploits) are due to memory leaks, overflows, and general vulnerabilities.

This eventually sparked many things to be re-written in rust for the sake of security, but this trend quickly died out due to many respectable people saying that just because the language is changed doesn’t mean people will change. No matter what, everyone will always write code with bugs, unless it is super trivial.

Does the Language Matter?


Well, maybe. Many people tend to bash Python for being slow, inefficient, and catering to newbies. But consider this: many popular, very relied-upon applications are written in Python. The most prominent example would be CertBot.

Certbot allows the easy creation of signed SSL keys for your personal server or website. Certbot is also written in Python, is very effective, and it substantially decreases time to write code, while at the cost of the code running a bit slower.

A case not to use Python would be for performance-based programs, such as video games or simulations. People still make these in Python, but in a professional setting it would be better to use something along the lines of C, Rust, Go, or any others.

But there are many cases to use these such languages. You don’t need to fight the borrow checker or memory safety, you just write code that works without being coerced into dealing with memory directly. Python is great for these applications because the language can read almost exactly like English, except when you get into some more low-level stuff.

But for doing simple tasks or a small project, Python, Bash, or even Perl (dare I say it) can work perfectly in these environments.


If you like Rust programs, and you want to use them, that’s perfectly fine–I’m not going to tell you how to live your life. However, do not be dismayed when something isn’t written in Rust, or C, or Odin or whatever. The language should not really matter unless you are using it for a specific reason. Use the programs because you love them and they genuinely improve your life.