Rust Hate Thread

Anyone else regret wasting their time learning this awful meme language? Why did they have to make it practically unusable without spamming unsafe blocks all over the place? Who the hell enjoys having the compiler shout at them for writing perfectly good programs? What is wrong with Rustlets?

> spamming unsafe blocks

What's wrong with you that you can't write good code?

What's wrong with rustlets? Why do they unironically believe that every program that Rust can't grok due to its deficiencies is somehow inherently bad?

If you want to sling memory around like some shit-flinging monkey, you can do that in any old language. If you want machine guaranteed correctness and not just squishy promises from your squishy meat brain, you can use a good language like Rust.

Your level of delusion is just astounding. You unironically seem to believe that there's a one-to-one correspondence between the set of programs that a shit-tier compiler designed by incompetent rustlets can verify and the set of programs that are provably correct.

Not just Rust, Haskell, Erlang or any other good language will reject programs they can tell are unsound.

Keep writing memory bugs and undefined behavior into your code, or get gud and learn to write better programs that pass borrowck.

>Haskell, Erlang or any other good language will reject programs they can tell are unsound
Haskell, Erlang and any other good language will reject programs that are perfectly sound and provably correct, because even good languages with rich type systems have a limited set of rules that won't allow all correct programs to be expressed. However, Rust is shit-tier, and its simplistic rule set will reject most sound and provably correct programs. To make matters worse, its userbase is made up of subhuman fizzbuzzers like you, so the designers have zero incentive to improve the compiler. The only people who care about this language would eat the shit straight of Steve Klabnik's asshole and ask for desert.

When it comes to borrowing and lifetime analysis, Rust is analogous to nightmare version of C where you have to use "unsafe" blocks every time you have to resort to void* and casts to get around its inexpressive type system, with a userbase that screeches autistically every time you do so because it's full of people who think that any program that can't be expressed by Nightmare-C's type system is of the devil, and who can't even begin to conceive of basic extensions like subtyping, let alone something more advanced like Haskell's type system.

void* is worse than null pointers, and good programs in any half decent language should never need them

Rust is really good. About the same performance as C++, significantly better at avoiding memory bugs and immutable by default.

You're just angry you can't learn how to use it.

>Writes code so shit that even dumb compiler knows it's terrible
>Blames the language

Hate the player, not the game

>in any half decent language
I see the point flew miles over your head, but that's to be expected from a rustlet.

>hurrrrrr any code that can't be expressed in rust without unsafe blocks is bad and broken
Why are rustlets so subhuman? Have they never heard of data structures with cycles, or do they seriously believe that having to use two layers of indirection and suffer performance penalties to implement them is somehow superior to doing it the normal way?

>suffer performance penalties

It's as fast as C++. I think you need to research more, user.

>It's as fast as C++.
And by that you mean going through multiple layers of indirection with redundant reference counting is as fast as Rust as it is in C++. As much as I hate C++, at least you can implement data structures with cycles or have multiple mutating references when you need to without jumping through redundant hooks or having to use unsafe blocks and getting screeched at by absolute mongoloids.

Like many alzheimer patients, he doesn't understand the idea of creating safe abstractions around an implementation with a couple of carefully marked operations the compiler can't guarantee the safety of; and thinks the only way to implement cyclic structures is with smart pointers or by leaking unsafe all over his codebase.

Let's watch you implement a cyclic structure without indirection or unsafe blocks then, retarded monkey. I know you're not going to do it. I just want to watch you deflect repeatedly. Your extreme reluctance will speak for itself.

You should consult your doctor about your declining reading comprehension.

>a couple of carefully marked operations the compiler can't guarantee the safety of

One module with be op
> can't write code "without spamming unsafe blocks all over the place"
> blames compiler and not literally rotting brain

What's that, rustlet? You can't write a cyclic structure without using unsafe or suffering a performance penalty? Thanks for the confirmation. I can give you more examples, but we all know what your response is going to be:
>well, it's only this one unsafe block in this one place
>well, it's only those other two unsafe blocks in those other two places
>it's only 4 unsafe blocks
>etc.
Any serious program is going to have dozens of them, but a subhman Rust fizzbuzzer wouldn't know.

> geriatric doesn't understand encapsulation
> can't learn from 50 year old mistakes
> can't into zero-overhead abstractions

Keep writing everything in asm if you want, the rest of us will be over here writing in languages designed by people who actually learned something over the last half century.

Where were you when seppleslets were blown the fuck out by Rust in just 2 years?

>absolutely fails to address the fact that Rust is deficient and requires you to use unsafe blocks for many tasks unless you want to go through multiple layers of indirection

>implying I care about sepples
>fails to address rust's deficiencies
Rerard.

>>absolutely fails to address the fact that lesser languages are deficient and require your entire program to be unsafe and full of null pointer errors, memory leaks, and buffer overruns because their authors forgot to include a good type system and borrow checker.

>IF I CAN'T CONTROL MY MEMORY NOBODY CAN
Spoken like a true rustee

>> I DON'T UNDERSTAND NEW THINGS
>Spoken like a true geriatric who writes code full of exploitable memory bugs

I have nothing against "safety". The problem is that Rust is a memelang that offers safety only to fizzbizzres like you, and little to no safety for the tasks where it's needed the most. It only saves retarded kiddies like you from kindergarten-tier memory errors.

> static type systems are memes, only offer safety to script kiddies, add little to nothing to real programs

I'll bet you don't run static analysis or linters either.

>tfw sjws literally take over a programming language

You're a mentally retarded subhuman. Refer back to the following analogy if you want to talk about static type-checking and see if you can recognize yourself in this zoological portrait:

>but i know my code is correct even though the compiler rejects it!!
so use unsafe
>i used unsafe and then it crashed!!!!
it wasn't correct then, was it?

>tfw dlang is so godlike it's not visible in the image, off the charts

>it crashed
It didn't, you retard, but where's the "safety" if you have to opt out of Rust's retarded static checks to do anything non-trivial? Haskell has even more extreme "safety" measures, but it actually provides you with alternatives to mutability that have some merits in their own right besides being "safe" at the cost of performance. All Rust gives you is stuff like Rc

>Holy shit perl slow as fuck
>slower than lua, ruby
How will I ever recover

>you have to opt out of Rust's retarded static checks to do anything non-trivial
False.

wew thanks user, don't know what we'd have done without your solid evidence!

I know fizzbuzz counts as "complex" for a rustlet, but let's pretend otherwise. Show me how to implement a mutable cyclic graph without performance penalties, redundant reference counting and without using unsafe blocks. I'll wait.

>you can't do one non-trivial thing without unsafe
>therefore you can't do any non-trivial thing without unsafe

>one non-trivial thing
Except it's not one thing. It's a problem with any data structure that involves cycles or multiple mutable references, so basically anything that isn't an immutable tree. That's not "one thing". That's most things.

struct Node {
parent: Weak,
children: Vec
}
Boom, cyclic data structure in Rust without unsafe blocks or weird tricks.
Now tell me, are you retarded or just too fucking dense to Google the point you're arguing?

>without unsafe blocks and without performance penalties
>Rc
Make it mutable and you get back to Rc as mentioned before. You're subhuman, like every other rustlet. Thanks for playing.

You're just another brainlet who refutes rust because you're too retarded/old/outdated you can't be assed to learn something completely before deeming it evil.
Go read some rust docs in my table cyclic structures and educate yourself, because we shouldn't have to.
You're obviously out of your element and aren't going to provide any real arguments besides these claims you make without providing any concrete evidence besides your own word.
Thanks for trying to educate us, but go educate yourself first please.

>more butthurt driven
The nodes in your example are immutable and there is a performance penalty. Implement a mutable cyclic graph without performance penalties, without, redundant reference counting and without using unsafe blocks. I'll wait.

>moving the goalposts at the speed of light

>moving the goalposts
Please refer back to the following posts before you further expose yourself as subhuman, rustlet:
You "people" just can't help lying and leaking autism all over the place.