Tell me what's wrong with it without bringing up trannies

Its syntax is ugly and different just for its own sake (fn?? why is that even needed as a keyword for example). Its supposed to be about safety but most meaningful programs seem to depend upon unsafe blocks. The notion that memory allocation issues are the significant source of bugs is itself wrong. It seems the culture around it is all about throwing out the past only to rebuild it more or less the same without learning from any mistakes. It's just another incompatible language that splits the industry. It provides no capabilities we didn't have before.

Not enough durga memes

maybe if they stop forcing people to recreate everything in this stupid fucking tranny lang and instead make new software on your own, it wouldnt be getting shit on. other than that? retarded shit like picrel

Attached: 1661243158058923.png (1320x275, 30.88K)

>(fn?? why is that even needed as a keyword for example)
Literal. unironic cnile brain damage.

>No memory model
>No language standard
>Forces stupid syntax rules
>Borrow checker is totally unnessary
> Zero production software is written using Rust
>Explicitly outlawed from certain projects like systemd and the BSDs
>Annoying community
>Woke Community conduct guidelines.

You'll try to refute these points. You'll fail. You'll sperg out. More people will hate you

It's immature. Missing packages, missing features, a few underspecified areas, limited platform support.
If it keeps going like it is now most of that will resolve itself though.

>retarded syntax
Nah
>god-awful compile time
Kinda, but it's manageable and improving over time.
>extremely limiting
Nah
>meme features that confuse whatever “standard” there is (e.g you can use emojis for variable names, but not a crab because that’s the rust mascot and he is sacred)
You can't use emoji for identifiers at all because they don't have the XID_Start/XID_Continue Unicode properties, they just added a funni easter egg for the crab.
>designed around making code concurrency safe by default, but in order to do anything practical you have to battle the borrowing system or use “unsafe”
FFI and low-level memory management like data structures need unsafe to implement but otherwise it's pretty smooth sailing.

>Its syntax is ugly and different just for its own sake
It's slavishly similar to C++.
>(fn?? why is that even needed as a keyword for example).
Prevents e.g. the most vexing parse. A keyword makes everything much simpler. (Most languages use one nowadays.)
>most meaningful programs seem to depend upon unsafe blocks
Everything depends on unsafe blocks if you dig deep enough. The idea is to put a safe interface on top of the inherently dangerous code.
All "memory-safe" languages do that. Python's list type is written in dangerous C but people's Python scripts don't segfault unless they're messing around with APIs like ctypes. Same principle. It works out for them and it works out for Rust.
>The notion that memory allocation issues are the significant source of bugs is itself wrong.
It's empirically proven for many kinds of software. Most vulnerabilities in web browsers are related to memory management. Rust was originally made for Firefox.

>Most vulnerabilities in web browsers are related to memory management
This is dishonest to the point of a lie. The problems are related to the Javashit web engine. Not "memory safety".

I can corrupt my RAM 100,000,000,000 times and it won't hurt the memory at all. Try harder

>The problems are related to the Javashit web engine.
And guess how those engine vulns usually manifest? Memory issues. Virtual machines are not airtight.

Look at all the use after frees: chromereleases.googleblog.com/2022/08/stable-channel-update-for-desktop.html?m=1

>llvm dep
>compilation speed
>cargo dumpster fire
>unstable and immature
>abhorent syntax choices
>community
other things are ok

it is too hard

Vile syntax that somehow manages to be even worse than C++.

Trainees use it

The borrow checker.
1. Data races are not bugs.
Avoiding them prevents your software from being scalable.
It's a bad concurrency paradigm.
2. Lifetimes and Ownership may stop use after free bugs, but this opinionated memory management effectively forces you into creating abstract stack machines. Which is inflexible and inefficient.

doesnt seem very useful to me. it doesnt prevent any real mistakes from happening and instead it helps you... check for array bounds or something meaningless like that

I'm firmware dev but the only people that I have heard talking about rust is web devs.