Are there any actual legitimate complaints about Rust...

you can literally use gcc to compile rust.

>Because C and C++ programmers love passing mutable state all over the place.

Are you suggesting they copy all of their data, including structs, onto the stack for each function?

good triple number

They haven't been finished yet tho. soon you will be able to basically make up your own language in your macro.
And yeah, it won't make it less complicated to write your own macros.

It was happening because they were doing transition to NLL. Now it would require maximum 300 mb if I am not mistaken.

Rust only copies types that implementats the copy/clone traits

>legitimate complaints about Rust?
The learning curve is really horrible.

Nobody wants to run around naked next to a river in some grass only to get shot so they can respawn naked again.

Macros are a bad thing and should be avoid desu. Abuse of them just leads to instruction explosion and horrible code cache performance.

Yes.
This is why traditional c fags suck at writing code in any modern language. They just can't leave their old way of thinking behind. Stop caring about if its stack or heap or 'how much memory is this gonna take' at each line of code.

In my last 2 workplaces I pushed Rust and made it an important part of multiple projects. Its a great language

That didn't answer the question. I would hope Rust doens't seriously copy over big structures or large arrays onto the stack for each function call using them.

I'm onto you.

Attached: 1438118308050.png (436x278, 158K)

What were the projects?

better question, why arne't you working at these 2 places anymore?

same problems as haskell which is that any complex program has state all over the place and you end up just hacking in unsafe blocks and mutability in to deal with performance

also shit language to develop libraries in because to ship to anyone you need to provide a C api which means you're forced to do garbage like also no C++ interop (see the ridiculous solution that mozilla chose in order to merge servo code back into gecko if you want to know why this is bad)

>don't care about how much memory it's gonna take, just write code until the borrow checker accepts it!
rustfags in a nutshell

wtf does this even mean lmao

>I would hope Rust doens't seriously copy over big structures or large arrays onto the stack for each function call using them.
it doesnt. only if you do .clone() because for some reason you need to edit the value after moving it.

majority of the time you can just pass in mutable references.

>Stop caring about if its stack or heap or 'how much memory is this gonna take' at each line of code.
Maybe systems programming is not for you.

>rustfags in a nutshell
Nah. Those of us who came to Rust from another systems programming language actually do like thinking about memory usage.

Maybe he is referring to the video game called Rust?

There's absolutely no reason to use it over C/C++.

Rust doens't force you to do everything as immutable. It's just the default since it's the smarter choice in most cases and easier to debug. You can always use `mut` without it being unsafe.

>Not writing your rust correctly.
what an absolute cuckold

wot

>Stop caring about if its stack or heap or 'how much memory is this gonna take
GC was right

rust does not copy unless you tell it to. It has move semantics by default

>game with the same name is equally merciless to newfags
kek

convenience is the reason we like it so much at work

you write much less code to get things done most of the time (especially when you're fucking around with lists and stuff) and cargo takes a lot of the pain out of dependency management and builds that one gets with C and C++

The borrow checker sucks basically. It's too strict and doesn't infer enough. I spend more time fighting against it than I gain in productivity by using it over C++. And don't give me that
>unsafe!
Bullshit because it's even more of a pain in the ass to annotate literally everything.

Otherwise I prefer it to C++. I think it's missing some features and the ecosystem needs to develop but the language itself is solid.

>The borrow checker sucks basically
it only sucks if you dont know how lifetimes work. once you get used to it, its great. ive probably saved myself dozens of bugs just by cucking to the compiler

You're doing yourself a disservice by claiming everyone who disagrees with you is ignorant. I know the rules. They're just too limiting.
Why can't I get multiple mutable references to a thread local object?
>oh but here's 500 lines of boilerplate to make it go away
And that's the root problem, Rust is not a tool but a nanny. Tools are used by an engineer, they don't prescribe how they are meant to use. The Rust compiler has so little faith in its users that it would rather they write out mountains of boilerplate than just do what it's told to do.

The syntax in general is a problem everyone agrees on, mainly because the borrow checker doesn't seem to integrate very well with it.

Rust is basically a C-like language that was tortured until it resembled an ML. Because of this Rust programs become very hard to reason about, it doesn't have the clear semantics of C, neither the nice denotational ones of something like OCaml, also this leads to very fucked up and weird compilers.

The syntax is pretty bad, yeah. Lifetime annotation is easily the worst part, but it's pretty bad in general. Other highlights include mandatory curlies on imperative statements and keyword soup.

At least it's more consistent than C++ though. Who knows what a statement like f(x); means in C++, there's so much necessary context.

Its Ada for hipsters

>but you can simply ignore both of those.
no you can't. their political retardation went into the language design. using rust will turn you into a genderqueer faggot commie over time.

>Rust is not a tool but a nanny
which makes sense when you look at who designed the language: hardcore leftists. they abhor individual free will and they love their nanny instances watching people's behavior punishing them for being bad goys. a disgusting, totalitarian language.

>Who knows what a statement like f(x); means in C++
if it's const correct code then no one should care. if it's not const correct it's time to change your job or team

This is true

>Because C and C++ programmers love passing mutable state all over the place.
Bad C|C++ programmers do.

so does Swift yet the language is not a chain of brainfucks and retardisms. it's almost as if Apple got the better engineers and fucking Mozilla is a scheme to distribute donation money among a small clique of bay area lefties.

Only hipsters love LARPing as 1970's neckbeards and obsess over deprecated garbage

in what way is Rust a chain of brainfucks and retardisms?

If you want to use mut at all, you can look forward to wrapping literally everything in Cell.

asked the retarded potatobabby

So you *are* the retard of Jow Forums

you really dont think youre going to get a rational answer do you? why dont you read the thread, the C++ luddites repeat the same thing over and over, they think that Rust will take away their 'control' over the language and is a nanny, etc, etc. The actual fact is that C++ is a language that provides job security because its a language that ignores compiler process and puts programmers in charge of busy work which means a lot of code that does stupid simple memory management that only the programmer can understand. C++ programmers complain that Rust will make programming to easy, like somehow having humans do the work a compiler can do without error, repeatable and understandably is a bad thing. There is no reasoning with luddites, they are just clutching on to 40 year old technology because they know that making fast systems code will be open to any competent programmer and no longer an archaic skill of using an old fashioned language that has no control over code and required programmer to manage everything by hand.

You can't spell trust without rust.

ah, he was onto you about the lefties, so you deflected

this... is actually right on

>hehe if it's OLD it's automatically BAD :^D

The learning curve with lifetimes (and borrows) is pretty harsh, other than that it's just retards complaining about the creators as opposed to having anything to say about the language itself, and also having never used it.

Attached: AYAYA.jpg (240x240, 9K)

No good Linear Algebra libraries (BLAS/LAPACK etc.) and just awkward handling of multidimensional arrays in general. I was going to choose rust for my new project but this was a deal breaker. It's not an intrinsic problem to the language, but also there doesn't seem to be anyone working to improve the situation currently.

>hehe if it's OLD it must be GOOD :^D

Can't make a doubly linked list in safe Rust.

doc.rust-lang.org/src/alloc/collections/linked_list.rs.html

>doc.rust-lang.org/src/alloc/collections/linked_list.rs.html

Might as well write it in assembly.

Attached: lol.png (1440x1103, 69K)

Unsafe rust is still rust, m8.

And?

It's just so awkward that you're better off using C or C++.

Also, seat belts are uncomfortable so don't bother wearing them
When you're about to get in a car wreck just wear leather and open the door and jump out

You actually can make a doubly linked list in Rust, "unsafe" doesn't make it another language.
What do you mean "awkward"? Unsafe rust is as safe as C or C++.

Unsafe removes the only reason to use rust - and this for something as trivial as a double linked list.
You really don't see the problem?

I mean it takes twice as much work to use unsafe Rust as it does to use C or C++.

Tools are meant to make your life easier.

I've used Rust a lot and I really don't see the problem, a double-linked list is a tricky case to reason about lifetimes.
> it takes twice as much work to use unsafe Rust as it does to use C or C++.
What?

Have you coded Ada?

>I've used Rust a lot and I really don't see the problem, a double-linked list is a tricky case to reason about lifetimes.

This raises an interesting point. I've heard people complain about the standard library being limiting/small compared to C++, do you think it's because certain things have just not been implemented yet? Or perhaps these are things that are not truly amenable to Rust?

I don't think it's limited. Rust has networking IO in the standard library. But yeah, you would expect some things to be in the stdlib, like rng. I think the main difference here is that Rust was developed with a packet manager and packet repository in mind, so there's no urgency to put everything in stdlib, since using an external library is extremely easy.

Who pays you to spread FAKE NEWS in Jow Forums?

It’s a new language and we don’t need any more. All new languages are created by someone with an agenda.

guy who made swift also made rust

does ada have webframeworks?

how many times you pasted this phrase the last month?

It's Shepmaster.

not the guy you replied to but pascal syntax and related are actually fucking vomit and are only usable by grandpas

What are you smoking?

>Macros
>horrible code cache performance

The compiler is extremely slow. To compile a medium-sized project can take 10 mins+. Compiling a medium-sized C project takes 10 seconds.

Just imagine if something like the Linux kernel was written in Rust. You'd have to build on a server farm just to get it to build in under a week.

Is the compiler self hosting?

Yes although it depends on LLVM.

this, if it's using a million cargos that is

No wonder it's so fucking slow. I heard the compiler can't even incrementally build objects, it just dumps a serialisation of the AST to disk for each compilation unit.

LLVM is used commonly for programming languages. Nothing to do with compile time. It does have incremental compilation yet it's still slow as molasses.

Yeah, the lack of real incremental compilation is the problem. Supposedly it's something they're working on. IMO it's a bit silly to not have it working from the start.

It's pretty hard to have proper incremental compilation with monomorphised generics. C++ does it and it fucks up the compilation model. But there's no point having monomorphised generics if you won't actually use them for e.g. specialization. Otherwise polymorphic generics should be the default with monomorphisation as a possible optimization.

One other thing that pisses me off is the lack of namespaces packages. crates.io is on course to be NPM 2.0. There's already thousands of crate names being squatted. It's only a matter of time before somebody imports 'rayo' instead of 'rayon' and ends up getting a huge production app backdoored.

NLL transition appart, this is a problem that all sufficiently complex compilers for sufficiently complex languages suffer. Traditionally compilers didn't free memory at all as a trade off to compilation speed, but now that it has become totally unacceptable eg. gcc includes a garbage collector where you can even tune memory usage. I mean, you can always fail worse, like Hasklel did with their lazy evaluation problems in their compiler, but even with the languages best optimized for compilation you will hit a limit soon enough. Turns out, reserving and releasing memory for all these IRs, tracking stuff in PGO and loading all those objects in LTO is fucking expensive.

Eh, probably still better than reverting to joke-tier optimization.

No complaints. Nice pre-alpha language. If by chance it becomes production-ready by 2025 I'll sign up for it.

It actually does. There is no language that hasn't had problems with making LLVM compile stuff fast. Not C++-tier or yet-Rust-tier bad Creating a shitton of internal IR - even if you don't apply optimizations - simply isn't designed to be fast.

It wasn't built with tooling in mind. That said, it's still one step up from C++.

kek

ok, you got me
t. steve

namefag of truth
>old ones weren't