LWN: Comments on "Living with the Rust trademark"

Avoiding Rice's theorem, Turing completeness etc in practice

farnz — Mon, 15 Aug 2022 12:58:56 +0000

To be clear, I'm not claiming that simply bunging "unsafe" into a program will cause the Rust compiler to accept it when it wouldn't otherwise; you do need to rewrite a program that fails to compile in Safe Rust into using the Unsafe Rust equivalents before the compiler will accept it - one of the nice features of Unsafe Rust is that anything that's Safe Rust behaves in exactly the same way whether you're using the Safe dialect or Unsafe dialect of Rust, it's just that in the Unsafe dialect, you have more ways to express the same basic computation. Hence, I'm talking about using unsafe superpowers like converting reference to pointer and then pointer back to reference to get a reference whose lifetime is independent of the original reference. This is unsafe for good reasons, and is rarely the right thing to do (since it's likely to have undefined behaviour), but you can do it if you have a valid program that the borrow checker rejects. Similar with bounds checks (get_unchecked(idx) or get_unchecked_mut(idx) instead of [idx]) and arithmetic on primitive types (unchecked_add(a, b) instead of a + b).

I'd be highly suspicious of any code I saw doing this, since checking it for correctness is deeply manual if you do this, and I'd prefer something compiler checked, but you can do it if you really are smarter than the compiler.

And the borrow checker, like everything in Safe Rust, is conservative - if you're using Safe Rust constructs (references not pointers, for example), the borrow checker should only accept programs that are definitely memory safe.

Avoiding Rice's theorem, Turing completeness etc in practice

tialaramex — Mon, 15 Aug 2022 11:57:46 +0000

You can't turn off Rust's borrow checker (this is one of the common misconceptions about what "unsafe" does, along with belief it disables bounds and overflow checks) and the borrow checker has both classification problems in principle but in practice it mostly can mistakenly conclude that your borrows aren't OK when actually they are.

So, Polonius will take some Rust programs which make sense but defy the current borrow analysis and so don't compile today - even if you were to sprinkle "unsafe" all over them, and make those programs compile fine as written.

The small number of unsafe "super powers" granted by the Rust unsafe keyword can of course introduce Undefined Behaviour, but that's distinct from the situation in C++ where you can in many cases write an invalid C++ program, one which simply doesn't mean anything under the C++ standard, and it will compile anyway, as allowed by the "No diagnostic required" rule.

Living with the Rust trademark

fest3er — Fri, 12 Aug 2022 18:02:57 +0000

«It's secretly still quite a rigid form of interaction, but on top of the technical issue it layers "we are all humans with different understandings of this problem, and the meta-problem is getting everyone on the same page".»

[digression]

This supports my assertion that natural languages (English, German, Swahili, et alia) are, indeed, programming languages in that the speaker/writer attempts to program the listener's/reader's neural net to at least understand the former's thoughts, if not to actually think the same thoughts. Those who take the time and make the effort to speak/write more correct programs are better understood in general.

[/digression]

Living with the Rust trademark

sammythesnake — Tue, 09 Aug 2022 23:59:29 +0000

I hadn't heard of the double empathy problem before, but it certainly chimes with my experience.

There have been many times when I've felt I'm doing a much better job of understanding an "NT" than they are at understanding me. I've generally assumed that my advantage in those situations is a massively greater amount of *experience* at dealing with people different from myself, because almost everyone I deal with *is* different from myself...

iceweasel

hummassa — Fri, 05 Aug 2022 13:51:10 +0000

I read "compromised" as a technical term. If you are a dissident in an autocratic country that bans the use of Firefox and the government has the means to pinpoint you by the telemetry traffic, the *fact* is that you are effectively *dead* before you can opt-out.

iceweasel

zdzichu — Fri, 05 Aug 2022 05:27:52 +0000

"Compromised"? Care to explain why have you used such heavy word?

iceweasel

brunowolff — Thu, 04 Aug 2022 20:48:42 +0000

For something more explicit, they are open about having telemetry on by default. Which means unless you know what you are doing, you are compromised before you can even opt out using the normal settings interface.

https://support.mozilla.org/en-US/kb/telemetry-clientid

Living with the Rust trademark

farnz — Thu, 04 Aug 2022 08:59:00 +0000

Scroll down to "Knocking out the Competition" in this account of NCR's early sales strategy. Or see if you can find details of the 1912 antitrust lawsuit against NCR, where some executives were found criminally liable for NCR's actions.

Living with the Rust trademark

ehiggs — Thu, 04 Aug 2022 07:10:54 +0000

> An absolutely perfect example is, in the early days, NCR reputedly made shoddy copies of competitors cash-registers, specifically with the intention of damaging said competitor's reputation and destroying their business.

Do you have more information on this? It sounds like a crazy story!

Living with the Rust trademark

anton — Mon, 01 Aug 2022 21:14:58 +0000

All the things we three have written is correct:

Yacc came first, then came Bison, and Bison was a pun on yacc, and it was originally incompatible with yacc. GNU adopted Bison and made it yacc-compatible.

Source

Living with the Rust trademark

mbunkus — Mon, 01 Aug 2022 18:27:27 +0000

I don't think this is quite correct. Back in the days there was a Unix parser generator called yacc (yet another compiler-compiler), and (GNU) Bison was written afterwards with the name bison being a play on the older project's name. However, Bison hadn't been a direct port of yacc, nor was it compatible with it in the beginning.

Living with the Rust trademark

farnz — Mon, 01 Aug 2022 18:24:40 +0000

GNU Bison is a reimplementation of traditional UNIX "yacc". As "yacc" is pronounced the same way as "yak", the name GNU Bison is a pun (since yaks and bison are related species of bovine).

Living with the Rust trademark

anton — Mon, 01 Aug 2022 17:42:25 +0000

GNU Bison is probably named that way because it is derived from a program called Bison.

Lots of other GNU programs were just called like their Unix counterparts, so I doubt that GNU Bison is named that way for legal reasons.

iceweasel

rahulsundaram — Sun, 31 Jul 2022 15:29:45 +0000

> That does not appear to be the case in Fedora. I don't know if it is a fork or if your information is out of date.

His information is correct, the Fedora maintainer has his own fork because upstream is dead.

https://gitlab.com/anto.trande/icecat

You can find it by looking at the spec repo in

https://src.fedoraproject.org/rpms/icecat

iceweasel

rahulsundaram — Sun, 31 Jul 2022 11:19:09 +0000

Firefox can enhance defaults is probably always going to be true although newer versions typically do better there. However your statement that Mozilla thinks it’s ok to violate privacy isn’t supported by this.

iceweasel

brunowolff — Sun, 31 Jul 2022 05:18:00 +0000

Read https://github.com/arkenfox/user.js/blob/master/user.js to get an idea of what could be improved. In some cases there is a trade off, in others Fitrefox just provides a poor default.

iceweasel

brunowolff — Sun, 31 Jul 2022 05:01:59 +0000

That does not appear to be the case in Fedora. I don't know if it is a fork or if your information is out of date.
Name : icecat
Version : 91.12.0

iceweasel

rsidd — Sun, 31 Jul 2022 01:10:43 +0000

The last release of icecat was in 2019, version 60.7.0. Using icecat means ignoring over three years of security fixes. Security holes are somewhat more of a privacy risk than anything Mozilla does.

iceweasel

rahulsundaram — Sun, 31 Jul 2022 00:52:21 +0000

> Mozilla thinks it is OK for them to violate users' privacy

Source?

iceweasel

brunowolff — Sat, 30 Jul 2022 17:31:36 +0000

There are important differences between firefox and icecat (which might not be the same as iceweasel). Mozilla thinks it is OK for them to violate users' privacy because they are the good guys doing it for good reasons. The changes for icecat provide a significant improvement in privacy and I think people should use icecat in preference to firefox until Mozilla changes their stance on privacy.

iceweasel

flussence — Sat, 30 Jul 2022 14:13:18 +0000

Fragmenting a browser between Official and Free editions doesn't seem to have hindered Chromium's adoption. Both that and Firefox are "free software" in the most worthlessly pedantic sense too: I can, right now, burn a whole lot of CPU compiling either in Gentoo without manually permitting a single non-free license in the config.

I count 41 packages in the distro repos that link against webkit-gtk, 75 that use qtwebengine, ~20 distinct binaries built on chromium, one that uses *dillo*. You know what's not in that list? Servo. XULRunner. Firefox. We really need an alternative but Mitchell Baker's $4 million salary sure isn't making that happen.

Living with the Rust trademark

ssokolow — Fri, 29 Jul 2022 02:40:46 +0000

Have we seen any examples of how he reacts when someone else with ASD calls him out? I doubt it'd be productive, but it might be satisfying.

Living with the Rust trademark

ssokolow — Fri, 29 Jul 2022 02:38:54 +0000

Rejection Sensitive Dysphoria can also be involved... though I usually see it brought up in correlation with ADHD.

Living with the Rust trademark

atnot — Thu, 28 Jul 2022 17:57:46 +0000

This is still how things like OpenGL, Vulkan work.

Living with the Rust trademark

dvdeug — Thu, 28 Jul 2022 14:57:01 +0000

The Ada specification had a trademark on Ada for a long time; you couldn't sell an Ada compiler unless it passed a battery of tests. That hasn't been in effect for sometime, though.

Living with the Rust trademark

tobiasvl — Thu, 28 Jul 2022 14:06:15 +0000

Funnily enough, "Ferrocene" is the name of a third-party Rust specification. https://ferrous-systems.com/ferrocene/

Living with the Rust trademark

madhatter — Thu, 28 Jul 2022 06:28:25 +0000

I am so going to add that to my toolbox of useful options for interactions, for all the reasons you've stated. Thank you.

Living with the Rust trademark

Jandar — Tue, 26 Jul 2022 22:39:34 +0000

> The "spaceship" operator is automatically derived. If your C++11 code is doing something weird with `<` and `<=>` is auto-derived for you, it can look very odd.

And the <=> operator is used instead of < in the STL. I had a very subtle error while using a set of pair<> (*). The result was searching a multi MLOC codebase and writing many new <=> operators to be sure to avoid this problem.

The new automatically derived <=> was an unexpected major pain during transition to -std=c++20.

(*) This concrete problem was facilitated thru the indirection of the comparison operator by pair<>. Why the pair<> was needed to trigger the problem I don't fully understand, the convoluted implementation of the g++ STL has left me addleheaded ;-)

Living with the Rust trademark

ttuttle — Tue, 26 Jul 2022 05:12:30 +0000

This sounds great! Let's argue about something someday.

Living with the Rust trademark

NYKevin — Tue, 26 Jul 2022 04:49:31 +0000

As an ADHD sufferer who can sometimes be a bit too systemic for my own good, I have found the phrase "help me understand" works wonders. For example, "help me understand what happens when X" instead of "your code is buggy because it doesn't handle X." This is good for several reasons:

* If I'm wrong, then I've explicitly invited the other person to explain that fact to me, they will hopefully do it in a calm and tactful manner, and neither of us loses face. This also gives me a good excuse to say "hm, should we put a comment here or maybe refactor it somehow?"
* If I'm right, having to explain something generally tends to engage the other person's critical thinking rather than their social status, and so it is more likely that they will agree with me rather than getting defensive.
* If the issue is more complicated than a simple right/wrong dichotomy, and needs further discussion, then it's easier to do that if we're both thinking in analytical terms rather than "who is right" terms.
* The important thing to keep in mind is that this is *not* a rhetorical strategy, it is a genuine invitation to have an open-ended discussion. I am not assuming that I know what the answer is going to be. I have occasionally noticed people interpret it as condescension, but it must be emphasized that I really do see this as a conversation opener, and not merely as a more gentle way to deliver a criticism. Unfortunately, it can be difficult to communicate this fact over a textual channel.

Of course, you don't want to just repeat the same phrase over and over again, so I've found that phrasing critiques as questions also works well (e.g. "could this pointer be NULL?")

Living with the Rust trademark

motk — Tue, 26 Jul 2022 02:15:44 +0000

Yep, every time he calls called out on his toxic nonsense he goes straight back the the "I have ASD, you have no power over me" thing and it's infuriating.

Living with the Rust trademark

ttuttle — Mon, 25 Jul 2022 15:48:40 +0000

Yeah, this absolutely goes both ways.

Thanks in large part to the double empathy problem, conflicts between autistics and non-autistics often go poorly.

Some autistics handle this by avoiding conflict, some handle it by consciously learning to navigate conflicts, and some handle it by barreling through conflicts anyway.

Living with the Rust trademark

ttuttle — Mon, 25 Jul 2022 15:45:31 +0000

Oh, the buckets are nowhere *near* that discrete -- autism, ADHD, and OCD overlap both in symptoms and in comorbidity.

Personally, I tend to think systematically, but communities are systems too. Rust's license might forbid using their trademark, but my social 'rules' forbid assuming I'm correct and assuming others' motives/reasoning/etc..

So I might have noticed the same issue that he had, but I would've framed my report more like "Hi, I was looking at A, and it seems like B, which I'm worried would cause big problem C for the project. Is this something that needs fixed, or a risk you're willing to take, or am I missing something? Thanks, me", and I would've framed my follow-ups as "Cool, can you explain why D thinks this is not an issue?".

It's secretly still quite a rigid form of interaction, but on top of the technical issue it layers "we are all humans with different understandings of this problem, and the meta-problem is getting everyone on the same page".

Living with the Rust trademark

atnot — Mon, 25 Jul 2022 13:07:48 +0000

Indeed, it has often noted by other people on the spectrum that a lot of the externally visible behaviors associated with their condition are also symptoms of them being put in emotional distress. Conflict avoidance, compulsive kindness ("masking") and other learned helplessness reactions are somewhat unsurprising when you're repeatedly being punished for behaving differently than people expect you to or struggle to receive sympathy for your needs.

(I shudder to think what CS would look like if being toxic online was actually a common reaction instead, given the amount of us here)

Avoiding Rice's theorem, Turing completeness etc in practice

farnz — Mon, 25 Jul 2022 11:49:41 +0000

As a side note on Rice's theorem (and Turing completeness, and other subsets of Rice's theorem): you can also avoid Rice's theorem by accepting some degree of inaccuracy from your classifier. It says you can't get perfection, but you can approximate it.

You can, for example, accept all good programs, but also misclassify 0.01% of bad programs as good, and avoid being bitten by Rice's theorem; same applies in the other direction (reject all bad, misclassify some good). One of the things Rust appears to be trying to do is to have it both ways; in the Safe Rust dialect, the compiler will reject all bad programs, but will misclassify some good programs as bad. In the Unsafe Rust dialect, it goes for the opposite error - it will accept all good programs, but will misclassify some bad programs as good.

iceweasel

rsidd — Mon, 25 Jul 2022 06:07:58 +0000

Firefox is the only viable free-software browser, fragmenting it really won't help. Plus we really need an alternative to the chrome engine, which has even taken over Microsoft now.

Living with the Rust trademark

jezuch — Mon, 25 Jul 2022 05:23:11 +0000

> I thought it was a trait of Aspergers (and autism in general) that you AVOID conflict.

I believe it's just a coping strategy for people who don't want to be assholes but still inadvertently run into conflicts. It's not an inherent trait.

(At least that's *my* coping strategy.)

iceweasel

ballombe — Sun, 24 Jul 2022 20:26:06 +0000

Really, Debian should have kept the name iceweasel. Dealing with trademark license is not worth the trouble of using them.

Living with the Rust trademark

Wol — Sun, 24 Jul 2022 07:37:23 +0000

I thought it was a trait of Aspergers (and autism in general) that you AVOID conflict.

Unfortunately, it also seems to attract the assholes who foment conflict who claim to have it ...

(Although there's also the OCD angle where people on the spectrum just can't let go ... Aspergers should be able to recognise that and deal with it, though ...)

Cheers,
Wol

Living with the Rust trademark

ttuttle — Sun, 24 Jul 2022 00:09:45 +0000

I'm autistic, and I'm mad that he's using Asperger's (currently considered a presentation of autism) as an excuse. It perpetuates a harmful stereotype, and plenty of us are awkward or blunt but still capable of handling differences of understanding or opinion by asking questions or clarifying thoughts rather than lashing out.