Literally WHAT is wrong with Rust besides "muh tranny"? Can someone ELI5 it to me?

Slang for transvestite

wrong. transvestite is merely a cross dresser. crossdressing doesn't even require you to be. tranny is short for transsexual, someone who has surgically altered their genetalia. Trannies are mentally ill. Cross dressing alone is not mentally ill. Just a fetish.

nothing wrong, except the trannies

you don't actually believe this, right? all those points are complete memes. None of them even mean anything. Tell me specifically what you mean "no flexibility" and "picking what you need from the shelf".

it doesn't require surgery, that's a whole other category of mental illness

It's a fine language. It has the same "everything but the kitchen sink" problem that Java and C++ have, plus its own extra flavor of complexity from the borrow checker. I generally find that undesirable in a language, but compared to historical kitchen-sink languages, Rust is much better.

so then whats the difference between transexual, transgender, and tranny?

they believe gender can change based on your feelings so nothing physical even matters, obviously if a pre-op tranny can exist it doesn't depend on a surgery, idk all the faggot lingo ask

I love Rust threads

Attached: hot.jpg (600x900, 69K)

according to wikipedia, transgender is mental, transsexual is about cutting off penises except that transsexual also encompasses transgenders who want to cut off their penis, but haven't yet.

Checked
You can't post that here it's against the rules

souy boy detected

reutard detected

dilate
have sex
triggered
rekt

[_] assbusted
[_] ass is fine
[x] ass is sent to the moon and probed by michael jackson looking like red skull

>besides muh tranny

lol that's enuff for me you buttsniffer

Borrow checker is a fucking chore

Language just keeps adding more shit, every CS concept ends up being implemented which creates a massively sprawling language.

Ugliest syntax I've ever seen, it's like they deliberately avoid any kind of consistency, I mean shit like this:

VecDeque::rotate_right

Nothing is uglier than camel case coupled with snake case, just choose one.

at this point the syntax is the only thing stopping me from moving to rust. I mean its a pretty good language put the syntax makes it seem like c++ with random ascii gibberish mixed in

Despite the meme, I think there is an extremely high percentage of transexual and gay members of the Rust dev team. Does anyone know exactly how many trans/gays that are part of the Rust team?

>Nothing is uglier than camel case coupled with snake case, just choose one.
m8, have you ever programmed before? For one, thats not even camel case, and two, almost everyone, and I mean almost everyone, mixes styles to denote different syntactic elements. Most people use capitalized words for types, full caps for constants, and camelcase or snake case for variable/function names.

here ya go faggot: archive.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf
read it an internalize it. I don't trust rust

Fine, PascalCase then, and no, mixing PascalCase/camelCase and snake_case is hardly ever done, because it looks inconsistent and shitty.

Rust syntax is really terrible overall though, this is just the icing on the cake, it's like the developers looked at C++ and said 'we can do worse!'

>mixing PascalCase/camelCase and snake_case is hardly ever done
christ dude

Attached: 1563849431951.jpg (250x250, 14K)

I thought Rust looked interesting and started reading the manual and starter guides. Where I stopped reading and got disinterested was when I started realizing that the borrow checker is just completely unnecessary. It doesn't actually do anything except refuse to compile if you can't prove to the compiler that your code isn't unsafe, by one of many possible definitions of unsafe.
Frankly, I could have even been fine with that, if the borrow checker was just a simple mechanism, but when I started reading about explicit lifetime declarations and stuff, it just got retarded. It's frankly just stupid to be spending all that extra energy on merely convincing the compiler that its formalism isn't misunderstanding what you're doing.
I have a similar disregard for languages like Haskell or C++, where oftentimes half the code is just "type algebra" to prepare the compiler for what it is that you actually want to do, but at least those languages accomplish something with their formalism, rather than just being a glorified warning system.

Attached: a.png (445x720, 246K)

>anime poster
>thinks that they never make mistakes
>doesn't understand that "unsafety" in rust isn't arbitrary
>too dumb to even use statically typed languages like C++
stop watching anime. stop using python.

>doesn't understand that "unsafety" in rust isn't arbitrary
It literally is. There are many ways to write safe code, and Rust just picks one arbitrary way among those.
>too dumb to even use statically typed languages like C++
I use statically typed languages like C.

That's because you're a stupid faggot
search for "reflections on trusting trust" if you don't know how to read a url, retard

>Rust just picks one arbitrary way among those.
anime posters
>I use statically typed languages like C.
read: i like throwing the type system out the window and using void pointers whenever I need something generic

The rust syntax is cancerous.
The borrow checker is just busy work. Writing TPS reports is actually more productive than satisfy the rust borrow checker.
Whole project smells like a PhD thesis that somebody actually took seriously.
The dev team is infested with trannies.

Its not arbitrary, Rust chooses zero cost abstractions which is literally zero cost, when you limit yourself to one mutable borrow there is literally no cost to that, compared to C++ that uses (((smart pointers))) which uses reference counting which has cost.

Zero cost abstractions in C++ is a lie, it merely means that you are using abstractions that are hand optimized, not abstractions that have no run cost.

>read: i like throwing the type system out the window and using void pointers whenever I need something generic
Yes, that is exactly my point. Why should I spend twice the time and effort on convincing the compiler that I'm doing the right thing, when I can just do it without having to convince the compiler of it?

>when you limit yourself to one mutable borrow there is literally no cost to that
You could still do that, without having a whole compiler system trying to verify that for you.

>Rust chooses zero cost abstractions which is literally zero cost, when you limit yourself to one mutable borrow there is literally no cost to that
What are you even talking about? The borrowing restrictions aren't an "abstraction", they're just a set of rules.

how about you go the fuck back

In a nutshell: It's misguidedly designed for teams of programmers of differing skill levels, when it should have been designed for godlike prodigies who singlehandedly create and maintain multi-million-line codebases by themselves. The borrow checker is supposed to protect you from your idiot coworkers who can't dereference their way out of a plastic bag. Most programmers simply don't need such a thing, because they don't have coworkers.

>Most programmers simply don't need such a thing, because they don't have coworkers.
But most programmers *do* have coworkers, and having a single genius programmer in charge of the entire codebase is a massive liability. What happens if the prodigy programmer gets killed by a drunk driver on his way home from work?

I think the people saying the borrow checker is a net waste have never tried maintaining programs mixing string and string_view in C++.
And I don't mean just writing them I mean maintaining them.

>and no, mixing PascalCase/camelCase and snake_case is hardly ever done, because it looks inconsistent and shitty.

You've clearly never programmed in a professional setting.

Transexual: penis cut off or sown on
Transgender: wants to be the other gender
Tranny: mean word :(

I've met more trannies that both use the word tranny and are okay with other people using it, than I have non-trannies.
This is all some nigger-tier double standard bullshit.

Personally, the 'ownership' model of security is kind of useless for creating real software. It involves potentially expensive copies or other workarounds. The problem is not ownership, the problem is usership, but the borrow checker instead chooses to check for ownership via lifetimes instead of actually conflicting use cases. Up until a recent version you couldn't even obj.set(obj.get() + 1) for example.

Rust doesn't have any working development tools

>archive.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf
"Trusting trust" attacks were solved a decade ago:
dwheeler.com/trusting-trust/

Attached: DDC.png (636x295, 16K)

It is though.
is right

Also fuck camel case

Rust Community is full of retard left wing trannies that larp as good programmers and mock straight white males (I.e non-mentally disabled people) for being straight white males. As a whole the community is toxic and low IQ

>hello world takes 10 seconds to compile into a 3mb binary
Nah it's totally better than c bro

As of now:
>still not faster than C++ compiler yet
>just one fully functional compiler exists yet
>no feature parity with C yet, according to their C parity working group
>minor neglect for beautifully designed syntax
>probably pointless for 1bit mcus that run on portable finger limes
>questionable approach to library ecosystem and it isn't yet entirely clear what a good Rust API looks like
>does neither cater Python fizzbuzzers, wannabe C 1337 haxxorz (people that shit up some double frees) or enterprise tards, which lowers its chances of success somewhat

>t. all openssl devs ever

>burden of proof

why should I care about rust, there are no job opportunities, there are more interesting languages if I want to fuck around

borrow checkem

retarded go family syntax

dilate

>(There should be a way to avoid it tho)
nix

thats an extreme over exaggeration of everything.

can the borrow checker check deez dubs

Attached: 1541967802430.png (688x720, 349K)

SJWs

Microsoft is migrating some of their projects to Rust. That's enough for its success.

I have been using Rust professionally for 4 months now and I have no real technical complaints, Rust is the most well designed language I've ever seen. I just have lesser complaints that I know will be mitigated in the future

1. The current async state is a total mess (futures 0.1, 0.3, etc...), this will need at least a more couple of years before all major crates migrate to the standard async/await

2. compilation times are very large and get bigger as your crate gets bigger

Cargo ships crates, haha. Get it?

>Rust is the most well designed language I've ever seen
>async/await is good
lmao get fucked

>promote language for years
>still can't even break the one percent
>no one important uses it instead of some few sponsored tweets.

It will go the way of Ruby.
Soem artificial buzz and in the end completely irrelevant.
It is already infested with SJWs like Ruby and they will keep it breathing until it fades away.

It's bloated, slow, and there has been some very odd syntax choices. They should have built the compiler to output raw machine code instead of LLVM, then the compile times wouldn't be as bad.

>here's a language that does what C already does
why would i change then ?
>because you get some features that are already implemented in some other library
ok. But i already have those
>yeah, but this language does them too
so ?
>fuck you, spend months learning this shit to do things that work perfectly well on C
nah

Ruby is literally alive and well and used in a fuckload of projects. The rails fad hasn't been relevant for over a decade already.

LLVM isn't the problem here, it's the whole compilation model. It's literally worse than C++.
>dude just make everything a template lmao
>except don't even compile modules to machine code when you can
>just serialise the whole AST and load it up again in any dependent modules
absolute retardation

wtf, why is nobody fixing this?

I've just used it for a couple of moths so far, and it's quite nice.
However, trying to use futures 0.1 is an exercise in pain. I've been trying to use streams and sinks for writing a websocket game server, and the ergonomics are horrible.
I'm considering scraping the code so far, and using something like actix-web instead.

It's not microsoft, it's only one rust tranny shill who infiltrated microsoft research as a diversity hire.

To everyone in this thread

>le borrow checker is TOO HAWD
There's a reason why it exists, and when you understand what it's doing it really isnt that difficult to write code without it getting in the way. Lifetimes should be rarely used anyways

>le syntax BAD
I dont really get this. The one objection I have is macros being retarded to make and look retarded. Anyone care to actually give examples why the syntax is bad?

>le MEME REASON
Dilate

Attached: EC_5q72XkAAc95m.png (496x534, 348K)

I used to like Rust but the more time passes the more I realize that they took a few good ideas (ownership and borrowing, ADTs and pattern matching) and completely fucked up the delivery.

Attached: inoperable.png (571x618, 29K)

Attached: e43.png (571x618, 53K)

>satisfying the borrow checker is extremely tedious for productivity and doing so can result in less efficient programs
You just suck. The BC makes perfect sense and is only enforcing what all C++ programmers should do.

C++ programmers should make all references to thread-local objects immutable?

>The only real issue for me is that you have to redownload every single crate if you start a new project
Wrong. Look into ~/.cargo

Unless they need to be mutable, yes.

>Unless they need to be mutable
Ah, so you agree that the borrow checker is deficient.

How so? The borrow checker 100% allows you to have mutable references to thread-local objects.

Can I make video games with it?

>That's enough for its success.
Unless they decide to create vrc, no.

Not more than one. The BC disallows you from referring to a mutable object from multiple different threads, fairly, but it's too dumb to let you do it when there's zero concurrency involved.

This. They are cached but they have to be compiled everytime they get built :/

Yes of course.

>what are mutexes?
>what is message passing?

you can fuck up references even with one execution path (i.e. no concurrency and no parallelism), google it

single threaded contexts can also contain errors with multiple mutable references, like iterator invalidation

Attached: 1508188164396.jpg (1200x858, 110K)

Alternatives that incur runtime performance costs

Just another example of how the BC isn't granular enough.

Sure you can, but that just demonstrates how the borrow checker's idea of "ownership" is too coarse.

How would you propose the borrow checker determine if multiple mutable references won't cause errors?

It looks like person you're talking to isn't offering an improvement to BC, he's saying the entire BC concept is flawed.