Theory of disagreeing (aka To flame or not to flame)

[bgeron]

I agree that we should soon move on, but for the record I definitely disagree with @mgeisler. It's not just the tone. Often "feelings" were aired without arguments, and alternative "ideas" were presented as great solutions even though they were poorly thought through or presented in a rather imbalanced way. This corresponds to the following two rules in the CoC:

• Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
• Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.

Let me take an example post that violates the second point, and explain my interpretation. In post 5, @peter_bertok writes:

Collapsed

@peter_bertok

I’ve observed that successful languages take some core mathematically sound theory and produce a concrete, applied implementation of it. Relational theory became SQL, typed lamba calculus became functional programming, object oriented theory is wildly popular, etc…

I feel like Rust came >this< close to implementing something similarly ‘pure’, for a want of a better word, fell short, and is slowly sinking into the same messy quagmire that makes C++ so repulsive to me now after having used it for over a decade and then abandoned it for vastly more productive languages.

I think part of this is that most of the Rust core development team comes from a C++ background, and to them, Rust is a huge improvement relative to what they’re used to. This is true, but it feels like a step backwards for everyone else used to elegant languages with a more consistent underlying logic.

The most telling aspect is the general disregard for IDE integration in Rust. It’s been, what, 8 years and there still isn’t a first-class integration with any development environment out there! Tab-complete is woeful at best, and refactoring is basically hopeless.

So… lets all assume that deep IDE integration really is a goal. How is this going to happen? Having poked through the source of the standard library, I’ve noted that huge chunks of it is implemented with macros. The language is a littered with automagic landmines, and from what I’m seeing this is just getting worse. The IDEA team, known for their fantastic tooling across a range of languages, is struggling to make Rust work after over a year of effort. For example, the line use nom::* breaks their IDE, making it forget what str is. I don’t even…

So what’s the fix? I feel like automatic deref is already one step too far in the wrong direction. Compile-time-lifetimes are brilliant, but the fact that NLL took this long indicates that there is no sound underlying theory that can be analysed, understood by humans, or refactored by IDEs.

I’m going to keep poking away at some toy Rust problems as a learning exercise, but I just can’t see any utility in it at the moment. There’s too many ‘undefined behaviors’ for it to feel safe, not enough SIMD to make it truly performant, and it’s not productive enough to replace C# or its ilk at the moment…

There is very little technically in that post. And I take this as an indirect and poorly motivated complaint that

• As opposed to other successful languages (which?), Rust is not based on "mathematically sound theory"
• Rust is "impure"
• Rust is a failure (it "fell short")
• Rust is sinking into a messy quagmire
• Rust feels like a step backwards for everyone else used to elegant languages (again, I don't know what mainstream languages count count as elegant).
• Rust is littered with landmines
• The situation is getting worse
• There is no sound underlying theory behind Rust
• There are too many undefined behaviours in Rust

There is no need for such descriptions of Rust. They were overly harsh conclusions, and this alienates other users. It is fine if users vent negative emotions, but we should strive to use much milder words than these. And there is definitely room to use the CoC more proactively, as @BatmanAoD suggests above.

I can see that not everyone in the thread took @peter_bertok's words in the same way. I think that's fine on both sides: the community is open to a wide range of personalities. But that underlines how valuable the role can be of bystanders who do notice that people are getting offended (+1 @juleskers).

I regret having to analyse @peter_bertok's post so deeply here as I'm sure he didn't mean it poorly. But I do think violations of the CoC in that thread were common and we need to prevent this stuff from happening again. And we can.