/rust/ v1.36 released

But is it even implemented?
Doesn't it take 6 months before feature get stable?

I like rust but every single library add 20s of compile time. Will they ever improve on that?

Not improving that may be the way to avoid a node_modules-like situation: make dependencies cost, at least in terms of compile time, so that they won't be carelessly added.

Do they increase compile time of your code?
Dependencies gets compiled only once.

It's statically compiled so it would only add 20s seconds the first time compiling each library

I got a 10,000 line Rust project with 300+ dependencies that take 15 minutes to do

cargo build --release

with clean cache on a 9 yo i3 shitty computer

Attached: 10157156357.jpg (720x499, 82K)

a future is a buffered channel of length one; this should not need a stabilization period

Fuck this overrated, CoC sucking, trannie infested language. Learn C, C++, D, or Nim instead.

You will never be a woman.

seething

the future doesn't belong to c++tards

How does Coraline's CoC taste, Rustrannie?

Have sex.

>most overrated since Java
you kids are probably too young, but it was hyped as the second coming of jesus when it was first released

It was also praised as a safe language but, for a different reason, it managed to succeed in becoming very popular. I'd even say that is a very decent language.

Bend over

In about 3 months, there are blocker bugs so it will take time to iron them out and move to stable

holy shit, is this the absolute state of rust users? do they really belive this type of shit is acceptable.
GCC and LLVM are battling for fucking microseconds and you furries think that adding 20s per lib is fucking acceptable? wtf!! so Rust compiler will recompile everything all the time or what is happening here.

>so Rust compiler will recompile everything all the time or what is happening here

the absolute state of webshits, just because you lowlife spend your life debugging buttons and forms that doesn't mean you should have an opinion on anything related to programming languages

I'm not going to use your shitty language just because you posted a cute gif

XD hahaha the rustians are fucking mad!
Hey, how does it feel to learn a language that will be eternally irrelevant?

It could have been a decent language, it had the talent behind it.

Go away Rust shills.

>300 dependencies

sweet jesus why!

Rust is the Javascript of compiled languages.

Is the language itself stable enough that if I learn it it won't be totally different in a year? I'd like to get into rust but I'm not sure if I wanna put any time into it yet.

No. It doesn't even have a standard yet.

Yes, 1.0 has been out for ages.
t. never used rust and regurgitates what other morons say

Show me the standard paper then, I'm waiting.

>standard
Is that just paying the ISO boomers $5k and getting a piece of paper?

>Yes, 1.0 has been out for ages.
Okay, but are there any plans for a 2.0 anytime soon? Are people generally happy with 1.0? Seems like there's still a lot of strife, I mean you don't even have async await yet and that can cause sweeping changes in usage of the language.

No, it's writing a paper that dictates what Rust syntax should look like and what is considered to be defined behaviour.
Right now, Rust itself is one large pile of undefined behaviour that's susceptible to change.

It's not a stable language, I advise people to not use it until a proper standard gets written for it.

doc.rust-lang.org/grammar.html
doc.rust-lang.org/1.26.2/reference/behavior-considered-undefined.html

Attached: 1542629541459.png (1200x800, 43K)

What does standard have anything to do with stability?

Attached: thinksweat-thinking-emoji-discord-meme-clipart-594776-pinclipart-49616734.png (500x737, 70K)

Why does Jow Forums like to ignore technical issues of rust in favor of just pretending to be retarded and popular Jow Forums talk-points?

std::thinking(&mut self)

simply because anyone who really understands Rust wouldn't spend a minute shitposting in this retarded board. They actually among the most competent developers in the world.

I'm pretty sure that this doesn't count as a standard.
It specifies what features are there in a specific revision of it.
For example C11 has feature X, while C89 doesn't have that.
Or C11 does Y in a specific way, while C89 does the same thing in a different way.
Without a standard, the Rust team simply adds features to the rustc compiler, while leaving other implementations of Rust in the dust. It also means that you have to consistently use the latest and greatest features, even if that meant fundamental changes to the behaviour of the language. Therefore, Rust is not a stable programming language.

>They actually among the most competent developers in the world.
This is one of the problems with Rust.

People don't care how good or bad a language is, they want ecosystem. Java and Javascript rules the industry because of the easy to use ecosystem. Rust has nothing.
If you look at tutorials for languages for say, kotlin, Go, Java etc, you'll find "how to do X with Y language". With rust it's always "learn rust"

Nobody's going to rewrite windows/linux/macos. Get over it. Give us a good ecosystem.

>I'm pretty sure that this doesn't count as a standard.
An ISO standard is nothing but a useless certificate. See how apple retards brag about being "Unix"? It's just a piece of paper.
>It specifies what features are there in a specific revision of it.
>For example C11 has feature X, while C89 doesn't have that.
Those are very well defined in each of the incremental updates of rust.
>Or C11 does Y in a specific way, while C89 does the same thing in a different way.
See above.

>while leaving other implementations of Rust in the dust.
Monoculture. Rust's development is centralized but open to contributions under a permissive license.
>It also means that you have to consistently use the latest and greatest features
Fake news.

> Rust is not a stable programming language.
I don't think you understand what stable means.

Every rust version "editions", are supported forever.
doc.rust-lang.org/stable/edition-guide/editions/index.html
The compiler has multiple levels of intermediate representations that eliminate redundancy in updates.

Attached: flow.png (2608x2054, 81K)

stop talking about shit you don't know, retard.

Go doesn't have these problems.

>It's not a stable language
>I advise people to not use it until a proper standard gets written for it.
Go doesn't have a standard, yet it is a very stable language.

>code has more gaping holes than tinder

Yeah and these fucking cunts can't stop spamming Jow Forums no matter how often we reject them.

The worst things about Rust for me:
- Memory "safety"[TM] above all has created a retarded model where perfectly valid code is declared "unsafe". ADA does not have this problem.
- Language keeps changing and there is no end in sight because the people developing it are autistic.
- Doing even the simplest thing requires careful consideration of the compiler model. I don't have this issue with C++ since I know it like the back of my hand
- Syntax looks so ugly, I don't want to even touch it.
- The community is led by LGBT and they are extremely hostile.
- It's supported by Mozilla, a Soros foundation.

Attached: 1562269251208.jpg (305x314, 27K)

>- It's supported by Mozilla, a Soros foundation.
wait, what? source?

steemit.com/freedom/@tell-me-a-vision/oh-no-mozilla-has-joined-up-with-george-soros
Damage control here twitter.com/firefox/status/1033016405749198855

>>>/cancer/

Attached: gotards.png (300x441, 25K)

Another programming language updates, great news. Everyone is losing their heads of love and happiness and good wishes for the future.

Now sage and move on.

a thread died for this

cope

can you stop forcing your tired sad sjw language here ? go back to your discord and stay there

Yes. It's pretty stable and they only add new features to it or expand old ones.

No. I don't think there is anything that could be considered a bad decision that would require 2.0 to fix.
Async await is not really that much of a change. Sure, you will be able to write async code in a new way, but it's well known paradigm.

You don't need some funny paper to not have undefined behaviour.

>Memory "safety"[TM] above all has created a retarded model where perfectly valid code is declared "unsafe". ADA does not have this problem.
You can't guarantee safety without these restrictions. If you can't comprehend these few rust rules, go back to Java or whatever.

>Language keeps changing and there is no end in sight because the people developing it are autistic
Like litery every other language? They do not change what is stable, only add new things.

>Doing even the simplest thing requires careful consideration of the compiler model. I don't have this issue with C++ since I know it like the back of my hand
Then stop being a brainlet and learn how lifetimes and borrow checker works.

>Syntax looks so ugly, I don't want to even touch it.
Then go back to ada where you have to write tons of keywords and LoC just to write a small program.

>The community is led by LGBT and they are extremely hostile.
It's a fucking language. You don't need to join their discord if you are so afraid of being called out for being an incel.

>"fearless concurrency" lang waits until 2019 to get futures
seriously?

>ADA does not have this problem
Ada is strongly considering implementing a borrow checker, quit being a retarded contrarian

that would be a mistake

seething trannie

Have sex

I tried it once and I fucking hated it.

The terminal I use (alacritty) is made in it though, so maybe I'm just fucking stupid and can't program.

lil crabby fella

discord is that way>>>>>>>

Are most rust developers left-wing, centrist, right-wing or far-right?
(Pic not-related)

Attached: noice.jpg (1080x1369, 1.05M)

far left

You decide.

Attached: Screenshot_20190604182313.png (1080x1920, 278K)

>Memory "safety"[TM] above all has created a retarded model where perfectly valid code is declared "unsafe". ADA does not have this problem.
The ownership model is very simple and provides automatic memory management without garbage collection. By using Rust you get safety guarantees at the cost of conforming to the needs of the compiler. There are some memory operations that you just can't expect the compiler to reason about.
The set of valid Rust programs is smaller than the set of valid C programs, but one is much safer than the other. There is a trade-off, but it's very reasonable.
>Language keeps changing and there is no end in sight because the people developing it are autistic.
The language keeps changing because it's new, not because the developers are bad. The language has only really existed since 2015. It doesn't make sense to immediately standardise your language. By allowing the language to develop they managed to revert bad additions such as classes and green threads.
>Doing even the simplest thing requires careful consideration of the compiler model. I don't have this issue with C++ since I know it like the back of my hand
Again, it's a normal trade-off and choosing C is a valid choice. I want to emphasise that the ownership model isn't flawed in any way, it's just a third alternative to manual memory management and garbage collection. There are tasks suited for each of the three.
>Syntax looks so ugly, I don't want to even touch it.
In my experience its very ergonomic and expressive. It might seem "over the top" because it utilises so many symbols, but I've never felt like the syntactical choices were ever actually wrong.
>The community is led by LGBT and they are extremely hostile.
Well "extremely hostile" is an overstatement, but I agree.
>It's supported by Mozilla, a Soros foundation.
Rust was created by Mozilla in the same way that C was created by AT&T. Good people working at shady companies that have no power over the language.

>niche language for hobbyist
>requires autism to be actually understood and appreciated
>can't be used for code monkey tasks like webdev and mobiles
What do you think?

>implying discord community full of non-coders is representative sample of rust developers.

>Ada is strongly considering implementing a borrow checker
Why do you keep this repeating this lie based off a 2 year old post on comp.lang.ada from an intern at Adacore talking about SPARK that went no where? A borrow checker is no where in the Ada 202x spec. A borrow checker doesn't even make sense in the Ada language. Ada, unlike Rust, is okay with you allocating memory, managing it, aliasing it, and freeing it. Ada has no need for "unsafe" blocks. Adding in a borrow checker would quite literally break so much code that it would be retarded to put in. Ada is a committee language that doesn't just knee jerk in changes like retards like Rust does.

>You can't guarantee safety without these restrictions. If you can't comprehend these few rust rules, go back to Java or whatever.
Go fuck yourself Rustie, I can write C++ code without memory leaks just fine.
>Then stop being a brainlet and learn how lifetimes and borrow checker works.
nah, I'm not autistic and I still have my dick.
>incel
There it is. That's the hostility you can face from discord trannies running Rust

>The ownership model is very simple
That's the problem retard.

>I can write C++ code without memory leaks just fine.
That's not the point. People use Rust for the same reason why they use C over assembler. Who cares if you can write safe assembler code, it's better to have a language guarantee safety for zero-cost.

>I'm not autistic and I still have my dick.
Yet you are a brainlet.

>There it is. That's the hostility you can face from discord trannies running Rust
I didn't call you an incel. I just said that you don't have to visit the Discord. Just go to IRC or do not get involved with the community if you are so afraid of being called out.

>People use Rust for the same reason why they use C over assembler
Nonsensical subjective argument.
> it's better to have a language guarantee safety for zero-cost.
My time is not zero.
>Yet you are a brainlet.
Says the person that can't write non-leaky code.
>just don't get involved
C++ doesn't have this problem.

>Nonsensical subjective argument.
Yet you keep saying "muh code is 100% safe and correct, so I need no Rust".

>My time is not zero.
If you weren't a brainlet you would write correct Rust code without any additional time cost in comparison to C++.

>Says the person that can't write non-leaky code.
I've been using C++ probably longer than you. People do not use Rust because they can't write non-leaky code, just like people do not use C over asm because they can't manage stack manually. It's always better to have your compiler enforce safety if it doesn't cost you much. Runtime memory corruptions and hazards are hard to debug.

>If you weren't a brainlet you would write correct Rust code without any additional time cost in comparison to C++.
The borrow checker will force you to rewrite code which is both correct and efficient. Whether or not you know the rules, it's time consuming and suboptimal to follow them.

If you can write correct Rust code, you won't have to rewrite anything to begin with.

You will if you want it to be efficient, correctly exploiting memory locality and avoiding unnecessary allocations and copies.

All memory models are simple.
Garbage collected: N/A
Manual: allocate and free
Ownership model: one mutator at a time
What you mean is "restrictive", i.e. the compiler produces more errors. C and Rust are both valid choices but to say that Rust is "too restrictive" is wrong, in the same way that saying C is "too dangerous" is wrong. The borrow checker doesn't stop you from writing programs or force you to write inefficient programs. You can write an operating system in Rust. The fact that you personally find it cumbersome to write Rust programs doesn't mean that Rust is incorrect or insufficient.
The fact of the matter is that the set of existing Rust programs is much safer than the set of existing C programs. And you can't just say that safety is unnecessary. Valuing safety is just as valid as valuing performance.

>one mutator at a time
if this particular code path isn't concurrent then it's absolutely a barrier to efficiency dumbass

How so?

having at most one mutable reference to an object encourages pointer chasing; being unable to share a mutable and immutable reference requires defensive copies where they would otherwise not be necessary. this is particularly important in rust where it's a pain in the ass to use case specific allocators and everything defaults to malloc with comparatively high overheads.

>having at most one mutable reference to an object encourages pointer chasing
I don't see how that follows.
>being unable to share a mutable and immutable reference requires defensive copies where they would otherwise not be necessary.
It's common for beginners to resort to cloning objects to avoid the borrow checker but that's not the case in idiomatic Rust. The project I'm working on right now uses 0 clones and everything is either passed directly, as a reference or as a mutable reference.
"Requires" is a huge overstatement.

They had futures before, but the API was changed slightly.
It's stable now.

are you retarded or just baiting? in any language you should NOT have multiple references to the same object in concurrent/parallel paths, this is why mutexes and CSPs exist

>multiple references
technically multiple references with at least one with write access

After first project or two, I've never had any problem like that.
99% it's a problem with the architecture of your program. You should not write code in a way you might often write in C++. You need to learn how to think about your programs in a Rust way.
It reminds me of students trying to force prolog to work in a imperative way because they are so used to it. Don't do that.

>if this particular code path isn't concurrent

all this demonstrates is that rust is opinionated and does not allow you to write programs in the most appropriate way for the task at hand, only the Safe™ way.

No, it's not a deficiency in the ownership model. This happens in functional programming too, where imperative programmers start learning Lisp and immediately try to write for loops. If you sit down with the Rust book and learn the ownership model you won't have a problem.

manishearth.github.io/blog/2015/05/17/the-problem-with-shared-mutability/

I have a question for you, this is an example of multiple references:
let mut v = vec![1, 2, 3];
let r = &v[1];
let mr = &mut v;
mr.push(4);
println!("{}", r);

What do you think will happen if you run it(assuming rust allows you to compile it)

That's the point of literally every high-level programming language.

so... is there r34 of that crab thing?

I know, that's the sad thing.

Lisp isn't functional retard, not even scheme if I'm being perfectly honest. It doesn't have functional features beyond just encouraging purity.

you have to try hard to get into situations like that, harder than you would to e.g. construct a reference cycle. it's the same problem as the ocaml value restriction,

wrong, the entire point of dynamic langs (especially those like lisp) is to trust the programmer means what he says.