I think if you’re self-aware enough to post with trepidation, you’re OK.
The endless threads about Scala 3 syntax demonstrate that it’s impossible to know in advance what is a useful conversation. The team will helpfully intervene to say an issue is settled, let’s move on.
I never know when an issue is settled. In my favor, I’ve never shown up at anyone’s doorstep at midnight to explain my latest insight about how to improve the syntax. I do have some ideas about formatting comments, however.
A few notes:
Eyal, I read your post with the two CoC complaints, a few days ago, and I’ve been weighing how to respond, and I’ve also waiting to see what others in the Scala organization and others in the community think. So I’ve been reading all the followups, too. I’m sorry if it felt like I and the other forum moderators were just ignoring your complaint. (We respond faster when something is much more clearly over the line.)
Som has already apologized for his post where some humor didn’t quite hit the mark. I hope you can let that one go.
As for the “I wish there was a dislike button” post, I agree it was borderline. We don’t normally respond to brief, borderline posts like that individually. We take note of them and who posted them and keep an ongoing eye on the situation to see whether someone’s remarks are repeatedly pushing the CoC limit. If you feel you were wronged here, I part agree: we’d certainly step in someone posted things like that repeatedly, especially if they repeatedly targeted the same individual.
I agree that we could be using Discourse’s thread-splitting feature more. I haven’t used it in this thread, because this thread became a nebulous grab bag of not-very-closely-related discussions ages ago. Maybe it’s time — not today, but sometime this week — to just shut down the thread down entirely, since at this point it seems to mainly be producing bad feeling — though hopefully this meta-discussion is useful?
But, the existence of the thread-splitting feature isn’t an excuse for posters to take threads off-topic. I hope participants will take some responsibility for this themselves. It’s not that hard to post something like: “That’s an interesting point, and it prompted me to start a related thread about X, here’s a link to it, let’s discuss there if interested.”
Threaded discussions, like on Reddit, have their own disadvantages. We’re committed to Discourse (and to GitHub, which is also single-threaded), so we must ask that people take extra care to keep threads on-topic. If we all do that, the overall result is a higher quality of discussion. It does require participants exercise additional restraint, but I don’t think it’s too much to ask. The goal of this forum isn’t to be a gigantic free-for-all. The purpose is exactly to have threaded, focused discussions. If a thread (like this one) does turn into a free-for-all, participants can expect that many people will simply tune it out.
Morgen, your wish that rules about e.g. posting volume be formalized is an understandable but impossible wish. The existing Code of Conduct is about as specific as it’s possible to get, and it’s very similar to what other online programming communities use. Where the CoC leaves off, after that point all any of us can do is do our best to listen to the feedback, explicit and implicit, that we’re getting from other community members, from Martin on down, and then if problems arise, we do our best to deal with them sensitively and on a case-by-case basis. That’s just how groups of humans work.
All: receiving negative feedback in public is extremely difficult — for all of us, Martin not excepted. Feel free to contact the moderation team privately about these sorts of issues; sometimes it’s easier to take when the feedback is private.
Seth
That was an oversight. I’ve now corrected it by replacing that with the text from Community | The Scala Programming Language that Martin quoted.
Seth
After a little further reflection on how best to handle this, I’ve:
While that’s a bit reassuring, anxiety shouldn’t be a precondition for posting, and at least for me that’s become the case, as I am having trouble figuring out the norms I’m expected to follow.
My concern is that when I run into the invisible walls, the pushback is immediate and public (this seems to be the case for @eyalroth as well, though I don’t speak for him), while borderline violations of the CoC appear to be handled with opaque privacy. If these norms can’t be published, then I’m kind of stumbling around blind, and that’s not ideal for anyone - y’all get annoyed, and I get slapped around in public for stuff that I don’t know to avoid, and apparently can’t really be articulated.
Thanks, I appreciate the effort to make this more accessible.
It is just conflict of interests.
There are groups of people with different qualification, motivation and amount of contribution.
So there is no surprise in situation when there can be disbalance of profit in collaboration.
So we can see that COC is violated. But there are no clear answer what to do.
It is good in such situation:
It is bad:
It is cruelly:
When contributing to these types of open discussions (primarily at other organizations) I try to follow two rules:
I suspect that everyone who is choosing to give up their time posting to the Scala 3 forums are probably doing so for the right reasons, i.e. they are trying to make Scala 3 the best possible language that it can be. The conflict arises because there are many different interpretations of “best”, but arguably that is s a good thing.
Regards,
Rob
I accepted his apology, and further replied that I don’t take offense in it; but when 2 out of 13 replies in a discussion are negative, non constructive and borderline insulting, and when they receive most of the positive feedback (likes), I believe it’s not hard to see how this comes across as an attack (not from a specific individual).
This was just a symptom of a larger problem, in which some of us feel unwelcome in this community for reasons we believe are unjust. As I said earlier, I find some of the fault of this problem with my own communication, but I think it’s irresponsible to direct all the blame at me.
I think it’s worth considering why I am often being argumentative. Perhaps I’m not getting a clear response for questions or counter-arguments that I’ve made that I find valuable; perhaps others miss my points and respond in ways I find irrelevant; perhaps I’m being argumentative in response to others’ argumentativeness.
Communication goes both ways. It’s easy to hide behind the excuse of “we all find you argumentative and therefore you are in the wrong and we are not”, especially when this community is so small and so statistical arguments are almost meaningless. I’m not necessarily the only one who behaves in said negative ways; I just happen to be on the wrong side of the fence.
I don’t believe this is the right strategy here, but then I’m not an expert in this. I believe that such minor violations should be handled on the spot; by “handled” I mean removed or condemned (punishment such as banning is an entirely different thing).
I speculate that it would take far too long for a user to accumulate these violations and trigger a moderators’ response. That is because this community is small and the amount of comments is rather low, and also because it seem that for the most part the community share the same set of opinions (one might consider this an echo chamber), and these violations are generally directed towards those of opposing opinions.
Meanwhile, until moderators get involved, these violations slowly creep in, distancing other community members, further lowering the number of comments, discussions and variety of opinions.
I don’t think this is the major issue here; in fact, holding the belief that it is the major issue, is in my mind a symptom of the actual issue. It implies that the negativity and hostility is caused by people derailing discussions with off-topic comments; but rather, I would argue that the core of the problem here is the dismissal of others’ opinions as off-topic, even though these others see them as on-topic.
Telling someone that their arguments are irrelevant, off-topic, or based on factually incorrect positions, but without explaining why that is, comes off as an insult.
It’s hard for me too, especially when many of the “likes” to that feedback come from people who never interacted with me; it’s even worse when such people try and hand me advice on how to behave, and imply that I often make mistakes, despite never bothering to point them out and correct me. I’m not sure if that falls under “passive aggressive” behavior, but that is surely not a constructive feedback.
I don’t think so. It would be a large problem if people ignored such messages.
if the simple question(“could you explain what is funny, it seems hard joke”) were asked the would be no problem at all.
The little problem is when you asked to moderate it people remembered your negative behavior which had no relation to the question. It have caused a large confusion. It is just a mistake.
I don’t like messages like “I just disagree because it is not java”, actually it can be considered as micro trolling. But it also can be low qualification. So we should be more friendly, should we?
I think the root of the problem is not that people here are mean (at least, they are not on purpose). The root of the problem is that several people (me included) have come to the conclusion that you have only some superficial understanding of several subjects you talk about. Yet you talk about these things at great lengths, and without considering that you may simply be wrong about them, which is grating. The result is that people may not necessarily take you seriously, and you perceive this as an insult.
I’d argue that wile you as a person are entitled respect from the members of this community, your ideas themselves are not. And you cannot force people to take you seriously; this kind of respect has to be earned.
Apparently, I am not the only one here to think that your style of commenting has been diluting the quality of this forum’s discussions. I too have taken to mostly ignoring your messages, as I personally found them of little value (this is subjective; other people may disagree). Note that this is not an insult towards you personally; it is just spelling out the consequences of your attitude, from my point of view as a regular of the forum.
I am sure you have a lot of great ideas, but maybe some of these ideas are not as great as you think they are, and more experienced people will disagree with them. It is awesome that you feel so enthusiastic about programming language design, and it is clear that you spend a great amount of time commenting here. But perhaps you should try to channel this enthusiasm towards other activities too. For instance, contributing to community efforts such as Dotty, or to your own programming language projects (which could be macros, compiler plugins, etc. for Scala).
I definitely do not think that people here are being mean on purpose. I understand their frustration, and acknowledge that is partly due to my fault; especially what you just wrote (in the quoted text), which is something I have to work on.
I agree on that. I cannot force people to take my ideas seriously (or any ideas for that matter). I need to be working on the way I present my ideas, I believe; but, I also believe that this community is somewhat a-priori dismissive of many such ideas (being close minded), and that often leads me to my commenting style, as I’m trying to make people actually consider my propositions and evoke their attention.
What I do take partly as an insult are comments similar to that of yours (or approval of these comments) by people unlike you that have never (or almost never) engaged in conversation with me. If one think I’m wrong I would expect them to either correct me (which I prefer) or ignore me. That’s how I strive to behave – I don’t just go and trash someone’s opinion posted somewhere else – be it another post or their blog – without explaining why I find it wrong.
I do contribute my code to other projects – for instance, Scoverage’s gradle plugin – but it’s hard contributing to such a complex project as Dotty, which is an entirely new compiler for a highly rich language (which goes to show how talented are the people working on it).
One more thing to consider. If people who are not experts in Scala but are not beginners either – such that they cannot contribute meaningfully to the core of the language – find it difficult to comprehend and reason about its features, perhaps they are too complex? Perhaps part of the “short circuit communication” we’re discussing here is somewhat rooted in the lack of clarity regarding many core concepts in the language?
I don’t post often here, but I used to be a community moderator for Scala at a time when we were still figuring out what inclusion meant. I’m not going to directly address any of your points, but instead ask several questions (to each and every member of this mailing list):
These are the questions I ask myself before posting on a public technical discourse channel.
It can be surprisingly and offensively, if somebody really completely believe in COC:
Actually it is not so, if someone has not deserved enough respect he can be affected by micro coc violation. And there is as more risk as more actively he behaves.
This case is canonical.
Attempt to regularly attract moderators for micro coc violation is a mistake because such person highly likely will be considered as source of noise.
So I think the best way is just to not have illusions
I like the next advice:
The problem is that people do these things intuitively, and the “rules” aren’t accessible to declarative knowledge, at least not without an awful lot of introspection (and even that is unlikely to be reliable).
Of course, not everyone has the same intuition, and the intuition evolved in the social setting of small in-person groups, which isn’t where it’s being applied now. So this isn’t a terribly reliable way to run things. But it’s hard to think of another alternative, given the kind of creature that we are.
The best strategy I can offer is to echo @rgwilton with slightly different wording:
As with any implementation of a communications protocol, this sort of “strict writer, relaxed reader” policy will generally get one a pretty long way.
New ways of doing things have a cost in learning new skills and possibly changing old code. These costs can be substantial. So it’s actually appropriate to be “closed-minded” in the sense that one must fairly weight these costs.
This substantially raises the bar for how good an idea has to be to merit serious consideration, regardless of how it’s presented.
Design is difficult. Designing something simple but useful is especially difficult, because the interaction between individually simple features can yield a mess. (Example: goto is simple–just go somewhere else in the code; loops are simple–just do something over and over…goto into the middle of a loop is…AAAAAAAaaaa!!!)
So one should be prepared to accept that many aspects of language design require a great deal of expertise. It isn’t necessarily the case, but one should keep in mind that it may be in any particular case.
I think there is a notion in this discussion where one needs to have a high level of expertise in Scala and its internals, perhaps along with deep formal education in CS, in order to be able to discuss features – their motive, design, usage, etc.
It’s not about complexity more than it is about familiarly with non trivial and often undocumented concepts. If the average Scala developer cannot fully comprehend some of its features due to this lack of familiarity, then I’d argue that these features are unapproachable / unintuitive / not simple enough.
One example for such a feature are type members; the discussion on opaque types have led to a sub-discussion that focused on the meaning / semantics of type members. I believe that the gist of the discussion is a confusion of terminology, where on the one hand there is DOT’s view of things (which I’m not familiar with), and on the other hand there is the traditional OOP “abstract vs concrete” view, which is expressed in the official documentation.
It’s hard maintaining fruitful discussions when there isn’t a clear source of truth.
Well, we’re now off-topic because we’re discussing language details while supposedly in a thread about keeping topics focused and amiable…my intent was to give a justification for why it’s good to keep an open mind about the value of one’s suggestions.
And you are making a different point than I am. I was talking about feature interactions. This does almost by definition require a high level of expertise in Scala because you have to consider every potential interaction.
There are other areas–the type system, for instance–where a sophisticated theoretical underpinning can be necessary in order to preserve simple rules and properties for users. For instance, Java, I would argue, botched its handling of variance with generics. It’s both convoluted and incomplete, leading one to battle with the compiler at one turn, only to have to give up compiler support entirely at the next. This is the kind of result I would expect when one approaches such things without the requisite expertise and/or mindset. It’s fine if you don’t have deep formal education in CS, but you’d better have something or you’re inordinately likely to say obvious, sensible-sounding things that have significant flaws.
Some topics don’t, by construction, have this kind of flaw. (Choice of keyword, for instance.) But it’s easy to make a language that contains a such a vast number of individually easy-to-understand pieces that you cannot understand the language. So even in simple cases if there’s anything more to learn, there’s the possibility that greater expertise will reveal that this would be a bad move.
Fundamentally it boils down to respecting others’ intelligence and hard work, and also respecting different styles of solving problems.
When due diligence is performed in understanding the current state of affairs, proposals or criticisms based on that understanding should be (and generally are) welcome.
So, yes, sometimes things are unnecessarily complicated, and sometimes people are change-averse when they shouldn’t be; but automatically assuming that objections are for these reasons (instead of e.g. a failure to account for differing tastes, or an incomplete understanding) is not a good way to promote amicable discussion.
Correct, that is my fault. I was trying to make a different point that is indirectly related to this one.
What I was trying to say is that it is not uncommon for discussions in this forum to end up in something like “this is just the way things work”, or “I have tried experimenting with that which you are proposing in the past and have reached a dead-end”; but these are not very constructive arguments, and they do not help reach an agreement.
When this is coming from core contributors in response to non-core contributors who try and gain a deeper understanding of the reasoning behind some decisions, or try and give feedback to correct a proposal, this kind of dismissal is unwelcoming.
It feels as if it’s impossible to be involved in these discussions unless one has the secret knowledge that only the core contributors exhibit. Not to say that they purposely hide it; it’s more likely that it requires hard work to make it accessible. Still, it makes it hard to feel included when such clarity that is required in order to be involved is missing.
Perhaps try reading more, searching harder.
A lot of things you have asked about or complained are hidden are things I’ve learned by doing just this, without using any special access.
I believe I’m pretty proficient at searching the web, and I often find myself browsing old discussions from other sites or reading (free) academical papers.
The problem is in cases where references or hints are not provided, or when it is the case of someone’s own personal experience which there’s nowhere I could read about.