LWN: Comments on "The Rust language gets its own foundation"

Time for a Reckoning

moltonel — Mon, 31 Aug 2020 14:15:23 +0000

Prototyping in Rust isn't that hard: clone your objects or use a refcounting wrapper if you encounter lifetime issues, abort the program instead of handling errors, don't go multithreaded until you're ready, make liberal use of channels, etc.

Rust outsiders often overestimate the difficulty and frequency of borrow checker problems, and fail to see the benefits it brings like fearless refactoring or being able to trust function signatures without having to check code or docs.

Time for a Reckoning

moltonel — Mon, 31 Aug 2020 13:31:27 +0000

There's actually ongoing work in making the borrow checker more "forgiving", not by accepting minor programmer mistakes but by being smarter at recognizing correct code.

The most prominent released improvement was non-lexical lifetimes (NLL) which basically looks at lifetimes with a finer granularity. Other ones that come to mind are detection of match patterns that should use references, or making lifetime markers optional in more cases. Work is ongoing with the "polonius" borrow checker engine, which promises to be faster and smarter still.

Time for a Reckoning

nybble41 — Fri, 28 Aug 2020 15:49:54 +0000

The `unsafe` keyword does not overrule the borrow checker. It does enable dereferencing unchecked raw pointers, but then it's up to the programmer to ensure that all the borrowing rules are still met; if they aren't then the behavior of the program is undefined.

Time for a Reckoning

metreo — Thu, 27 Aug 2020 21:33:55 +0000

>The first and most uncomfortable change needed is to make the borrow checker less draconian. Allow beginners to know how many violations they have, yet run.

Rust has inline `unsafe` keywords and function declarations. So one can simply grep the codebase.

Time for a Reckoning

scientes — Thu, 27 Aug 2020 14:38:23 +0000

I know you are, but what am I?

jajajajajajajaja

The Rust language gets its own foundation

HelloWorld — Wed, 26 Aug 2020 18:14:10 +0000

They tried, it's called Perl.

The Rust language gets its own foundation

flussence — Wed, 26 Aug 2020 11:19:02 +0000

Not really looking to engage with any part of the thread up there, so I won't.

I must say though, it does sound like there's a small, loud and stubborn market for Magical Programming: where the programmer simply feeds the computer incorrect instructions and it always produces a correct result, without complaining about annoying details like mathematical and logical impossibility. I wonder why nobody's built such a language yet.

Time for a Reckoning

NYKevin — Tue, 25 Aug 2020 15:15:34 +0000

Oh, I could believe this is a real person. There are people who seriously, honestly believe that any use of a swear word in a debate means the person who used the word has no better arguments.

These people don't tend to last very long on LKML.

The Rust language gets its own foundation

ssmith32 — Mon, 24 Aug 2020 20:41:56 +0000

Happy news for Rust!

I was a little sad though: it was the first I heard of the Mozilla layoffs. The foundation has been in my "add to my monthly donation" queue for too long .. a good scare to get me going.

I haven't been able to talk my way into a real-world project using Rust, yet. We'll see. But I've quite enjoyed working through the Rust book: amazing props go to the creators of the book!

And while, overall, it's good to see more adoption, there is a part of me that enjoys solving completely useless and wholly entertaining problems - so it'll be a happy & sad day when I get to use it "for real".

Enough

corbet — Sat, 22 Aug 2020 14:30:16 +0000

I must say that the comment stream on this article is pretty seriously disappointing. I really thought we had grown beyond this kind of silly name-calling mudfest here. It stops now. My apologies to the rest of our readers who have been subjected to this.

Time for a Reckoning

MatejLach — Sat, 22 Aug 2020 14:06:35 +0000

* shipping a knowingly buggy program is one of the core things Rust tries to prevent.

A warning isn't s strong enough mechanism to do that, in my opinion and in the opinion of the Rust community at large.

Time for a Reckoning

MatejLach — Sat, 22 Aug 2020 14:03:45 +0000

Look, I think I get what you're trying to say, make borrow checker violations warnings instead of compile time errors. I have addressed it here https://lwn.net/Articles/829393 but to reiterate, I think it would be a mistake to do so as warnings get ignored way too often and shipping a knowingly buggy program is one of the core things Rust tries to do.

In fact, you can already make most C/C++ compilers warn you about many things that do not end up being fixed before release, precisely because they're "just" warnings and many interpret warnings as "something to get fixed on a boring weekend", rather than something to stop them from going to production.

A compile time error will do that.

Additionally, the borrow checker forces you to make certain, (correct), design decisions that you may otherwise not make, thus fixing the warnings would require a major refactoring/rewrite.

Time for a Reckoning

MatejLach — Sat, 22 Aug 2020 13:57:45 +0000

I am convinced this is a bot and that "You have presented your credentials" is a fallback catchall phrase to end any sub-thread it does not have arguments with.

Time for a Reckoning

anton — Sat, 22 Aug 2020 11:30:06 +0000

Use a garbage collector for the allocations that the compiler warns about. This also gives an incentive to programmers to get rid of the warnings: they get rid of the garbage collector. (Disclaimer: I am not a Rust programmer, so I may be completely wrong here).

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 08:33:27 +0000

> There is no practical reason for it not to be 10x faster.
And how the fuck would *you* of all people know that?

> The mistake seems to be in patching up the existing compiler. Starting fresh ought to have better results.
Bullshit again. Programs don't magically become faster by rewriting them from scratch. Scala has a similar problem, the compiler is not as fast as one would like it to be. They rewrote it for Scala 3, and while it is a lot better in many ways, it isn't much faster. What did yield significant speedups was optimization work in the 2.12 and 2.13 releases.

Time for a Reckoning

MatejLach — Sat, 22 Aug 2020 07:52:15 +0000

C/C++ compilers generate plenty of warnings that, if followed, would prevent a lot of the bugs that end up shipping. Yet, they're not followed precisely because they're just warnings and hey, if the program compiles and *appears* to work, ship it.

If you have a "working" program, just taking care of some "warnings" and management wants to ship today vs you have a non-working program that doesn't compile and clearly needs more time, which one of the two do you think your average company would be willing to hold off on pushing to production?

The value of Rust is precisely in the fact that they're not warnings, but compile-time errors. And yes, the value of Rust is, in part, that you won't be able to ship a knowingly buggy program.

Time for a Reckoning

roc — Sat, 22 Aug 2020 06:41:55 +0000

There actually are good reasons. Compared to C++, Rust eliminates the need to "repeat yourself" by copying declarations into header files, and Rust eliminates the need to manually divide code into translation units to achieve build parallelism. The problem is that eliminating that manual work also eliminates developers' ability to hand-optimize the code and build process for maximum build speed.

Another issue is that trait type inference and checking and borrow checking are more expensive analyses than the work most other compilers do when configured for "fast" (i.e. non-optimizing) builds.

I don't believe "Compilers for other languages of similar or greater complexity are much more than 10x faster" for "other languages" with the above properties.

I think these issues can probably be fixed, and I talked about some of this recently:
https://robert.ocallahan.org/2020/08/what-is-minimal-set-...
However, some research is needed. It is certainly not as easy as "rewrite from scratch and it will be magically better". I certainly hope that some of the companies adopting Rust sponsor the Rust foundation to do this work.

Time for a Reckoning

Cyberax — Sat, 22 Aug 2020 03:40:19 +0000

I haven't been following this discussion, and just now opened it. The only misbehaving person in it is you, due to the sheer amount of trolling.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 03:23:49 +0000

You have presented your credentials, and so stridently! We get it.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 03:21:01 +0000

There is no practical reason for it not to be 10x faster. Compilers for other languages of similar or greater complexity are much more than 10x faster.

The mistake seems to be in patching up the existing compiler. Starting fresh ought to have better results. The language is quite different, and much less variable, than when the compiler was started, so choices made then are likely to be inappropriate to the language as it is now.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 03:07:50 +0000

If there were no reason for concern about Rust's future, there would be no motivation to try to derail discussion of its future. But certain people really, really don't want the problem mentioned at all, to the degree that they have actually taken to <i>actively lying</i> about what has been offered.

But it is clear that no other usable ideas are ready to hand, at least here.

Time for a Reckoning

Cyberax — Sat, 22 Aug 2020 01:59:14 +0000

Sorry, but you're the one trolling here...

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:57:21 +0000

There is no ”approaching oblivion“. Stop making shit up.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:56:00 +0000

”The Rust compiler should be 10x faster“ is not an idea that holds any more merits than ”I want a pony“.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:54:14 +0000

> The main answer here, though, seems to be "let it die".

No, the main answer here is ”you're wrong“, but you can't accept that because you're just too fucking full of yourself, so you need to pretend that everybody who disagrees with you is just a moron who refuses to acknowledge an obvious problem. The problem with that is that it's complete BS.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:53:23 +0000

Thank you, you have already revealed that you have no ideas to offer.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:51:15 +0000

You have already presented your credentials.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:48:21 +0000

You have presented your credentials.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:46:11 +0000

To answer your question: Attendance at C++ conferences has been exploding, right up until the lockdown. Applications to speak at C++ conferences likewise. Number of C++ conferences, likewise. For several years running, attendance at each tri-annual meeting of ISO C++ Standard conferences, regardless of how out-of-the-way the venue has been, has exceeded that at all previous meetings.

But this is off-topic. The only reason I even mentioned C++ was as an example Rust would not displace. But at issue here is what may be done to enable Rust ever to displace anything at all . (It would be super-great if Rust displaced Java.) The main answer here, though, seems to be "let it die".

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:29:21 +0000

You clearly have no fucking clue what makes or breaks a decent programming language. Stop wasting everybody's time, troll.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:27:36 +0000

> The topic is Rust, which is. Rust's adoption curve is still pretty good, although not good enough.

You keep saying that without presenting any evidence whatsoever, and besides, how would you even know if it's ”good enough“?

Go troll somewhere else.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:26:20 +0000

You have presented your credentials.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:25:37 +0000

Here, it would be, because it is of no relevance of any kind. Yet, you persist.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:24:05 +0000

Ok, a stupid troll it is.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:23:25 +0000

Turning the borrow checker off is *exactly* what you have proposed. Your pathetic attempts at denying it doesn't change that fact.

Time for a Reckoning

HelloWorld — Sat, 22 Aug 2020 01:21:45 +0000

You made up some bullshit about Oberon being used in production at large scale, then somebody called your bullshit and now you're trying to change the topic. You're just a pathetic troll. Please go waste somebody else's time.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:20:29 +0000

Ok, doom it is.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:19:25 +0000

You have become confused by noisy advocacy in a tiny puddle. There are well over two million programmers employed full-time developing C++. It would be surprising if there were fully two hundred paid to code Rust--before Mozilla's layoffs.

C++ is not in danger, so is off-topic. The topic is Rust, which is. Rust's adoption curve is still pretty good, although not good enough. When it starts leveling off (second derivative crosses zero), it will be too late to discuss how to save it.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 01:03:50 +0000

Once again: only Rust apologists have mentioned turning the borrow checker off, in apparent effort to derail productive discussion of measures to save Rust from oblivion.

Time for a Reckoning

ncm — Sat, 22 Aug 2020 00:52:30 +0000

I see that you have confused a mechanism to reveal borrow-checking mistakes with a policeman.