This is an excerpt from the #cat-v IRC channel on freenode taken around late Feb 2021
Text of interest is that of Aram's opinion on the rust programming language.
This is reproduced at the request of a few users in the ##9fans channel by taw.

<curiousgay> Aram: https://doc.rust-lang.org/book/ch13-00-functional-features.html
<curiousgay> I read that entire book just to become dissapointed when trying to seriously use rust
<Aram> I have been doing too much rust the past year, you don't have to link me to that awful "documentation".
<Aram> also interators are not a FP "feature" wtf.
<Aram> closures as well.
<tane_> curiousgay, care to elaborate on "why"? I consider boarding the rust plane..
<Aram> rust is the most awful programming language I had the displeasure to use.
<Aram> worst than C++.
<tane_> why?
<curiousgay> Aram: iirc FP languages use recursion instead of iteration, it's just rust claims to support FP and in fact confuses people
<curiousgay> still even with those shortcuts rust's code is more verbose than haskell's
<tane_> "iirc" => you're arguing about a term you have no clear conception of at all. Can you even say what "support FP" would imply?
<curiousgay> tane_: int foo(int i) {if(i>0) {return foo(i-1)} return i;}
<curiousgay> iteration is different than recursion in that it requires mutation
<tane_> Indeed, realizing loops with recursion is a property of purely functional programming, but not a requirement for what the term "functional programming" usually implies
<Aram> tane_: too much to complain about in a short IRC discussion, but
<Aram> 1. its safety guarantees are bullshit as real life code uses unsafe every 20LOCs or so, and this is unavoidable.
<Aram> 2. in fact #1 is worse than you think, because unsafe in rust is much more unsafe than "regular" unsafe C, and much harder to make correct than C.
<Aram> 3. because of #1 and #2, the effort required to program with affine types is not worth it, because it gives you literally nothing.
<Aram> 4. the standard way to get out of the aliasing problem is to use arrays instead of pointers. if you do that, you trade memory safety for logic safety. yes, your program is memory-safe in rust terms, but all use after free, etc, become logical bugs instead of segfaults, which is strictly WORSE.
<Aram> 5. affine types are not good even for non-memory things, like file descriptors; because they are affine instead of linear, they can leak, so rust doesn't even help you with THAT.
<Aram> 6. rust and rust programmers don't understand the difference between abstraction and wrappers. rust gives you almost no abstraction. in a certain sense it's even more low-level than C. it just gives you wrappers.
<Aram> 7. everything that happens in the rust ecosystem, from decisions around langiage evolution, to things like tooling, auxiliary tools like cargo, etc, are decided exactly the opposite of a normal person would decide. cargo itself is the most frustrating piece of software I have ever used.
<Aram> 8. if you think perl looks like line noise, you haven't seen rust.
<Aram> 9. because of far away impl block and self/Self, you never know what a local piece of code refers to.
<Aram> 10. etc.
<Aram> C++-like compile times and multi page compile error messages.
<curiousgay> Aram: 2 years ago I had a funny situation when I wrote safe code which rustc considered unsafe
<tane_> Aram, thanks for the points
<Aram> rust is just C++ done by people pissed they were not invited on the C++ standards commitee.
<tane_> Aram, one question w.r.t. the unsafe use, what kind of programming were you doing, embedded stuff?
<Aram> I am writing a hypervisor in rust.
<tane_> without any further knowledge I'd guess that is rather low level :)
<Aram> the problem is that rust requires the use of unsafe even for implementing linked lists.
<tane_> I have yet to program a larger piece in rust to get a feeling for its pros and cons - to this days I have been put off mostly by what "the rust community" entails
<tane_> Aram, have you had a look at "zig" at any point in time?
<curiousgay> Aram: add to that rust takes a fuckton time to compile, is not portable) astronomicly hard to bootstrap on different OSes and hardware) and consumes so much memory it can't build itself on i386
<Aram> I looked at zig, I didn't like it.
<curiousgay> s/portable) /portable (/
<Aram> zig introduces red/blue functions because of async.
<Aram> (also a problem in rust).

The saga gently continues a day or so later... 
<curiousgay> Aram: https://www.boringcactus.com/2021/02/22/can-we-please-move-past-git.html
<curiousgay> Aram: pijul being written in rust did segfault :)
<Aram> of course it did.
<Aram> if you take a look at rust, you will see that it has many CVEs.
<Aram> all caused by the same type of problems as they claim C has.
<Aram> unsafe is ubiquitous in real life rust code.
<curiousgay> at least rust is not popular in my country :)
<qeed_> software without boundaries