Should we keep with older questions just because "they are already there"?

Question

Last words

What remains to be done?

In a reasonable world: merge the two questions.

In an utopia world: Join all answers in only one question, and select the best.

But not, we are not in that utopia world, not even in that reasonable world.
We are in stackexchange.

Update:

Both answers have been modified. Probably better now. A lot of misleading comments have been removed (well, some, others were put aside). But getting here from there included an edit war, a lot of commenting (a lot of which got erased by high rep users), Many interventions of the mods, strong arm twisting and a discussion on the chat.

All of that would have been avoided if the better (newer) question and answer had been selected as the one to keep, simple.

Is that fair with the questioner and the answer ? Of course it isn't.

Original

This question:

• awk operator precedence of `!a[$0]++`

A perfectly valid question, well written and specific to the issue to solve, got classified as a duplicate of:

• How does awk '!a[$0]++' work?

Which, on a first look seems like an (also) reasonable question of a quite similar concern.

But, looking a bit deeper, it happens that both answers in that second question have troubling (and incorrect) issues and very conflicting comments about the order of evaluation of the ++:

• The first answer (Archemar) claims that the negation ! is applied first and then the ++.
• Gilles claims that that error is actually correct:

the incrementation is indeed applied after the value of the expression is calculated

• G-Man reinforces that interpretation under the cuonglm answer (the second answer).

the ! operator is applied to the value of a[$0] before it is incremented

• And Gilles re-iterate the same in plain words:

This answer is wrong. The incrementation happens after the result of the ! operator is calculated.

At least, without taking any side, both answers result in confusion and noise.

Nobody has taken the time to address the problem and to make the answers clear, but yet, we are directing new questions to such conflicting answers.

Full disclosure: I do have a position. I believe that both G-man and Gilles are wrong. The only possible (valid) description is that the operator ++ is (as it must) be applied first to a lvalue and, ... later ... the ! operator is applied.

But the real issue to discuss here is: should we naively direct people to older answers that look (on first sight) the same but are fundamentally conflicting and confusing?

Note: this question has been written looking at what those answers look like NOW, they will probably be edited and changed. I, for one, will add another answer to try and address the (several) errors. Of course, after some time has passed to discuss this question.

Question

I hold that we should keep to higher standards than ("first look" or "apparently similar").

What do we think?

Answer 1

To answer the main question: the age of a post is irrelevant. We always want to use the best post (the one with the most clearly written question, best explained answers etc.) as the dupe target. We shouldn't care which one is older, we simply want the best. That doesn't mean we will always get it right, of course, and this sort of post on meta is always welcome when you find something you think hasn't been handled in the best way by the community.

So no, we don't keep older questions by default. If a new question is better written and/or gets better answers, then that should become the new canonical and we can close older ones as dupes of the new one.

In this case, given that the two questions are indeed asking the same thing, the closure seems reasonable to me. If you feel that the existing answers in the dupe are lacking, then the best course of action is to post a new, better answer on that question.

---

As for the specific issues you raise, I think we're getting lost in the minor details. But then, I am a biologist, not a programmer, and I don't claim to understand the internals of how any programming language works. So I don't doubt that there is indeed a valid technical point being raised here. However, I would argue that in the context of a site about Unix and Linux, one where most of us are closer to "sysadmin" than "computer scientist", the internals might be less important than the effect.

The effect of !a[$0]++, is that it will evaluate to false if $0 has not been seen before. So no matter which operation is applied first behind the scenes, and although ++ has two outputs and not one, the final result is that it acts as though the increment occurs after the ! is evaluated. So from the point of view of someone who just needs to understand whether !a[$0]++ will return false or true the first time this value of $0 is seen, the ++ is evaluated after the !. I don't doubt that you are right and internally, the ++ is applied first but the ++ returns the old value, but I would argue that isn't really relevant to the user of the language and only important if someone is trying to understand the internals of the awk interpreter.

All this to say that I don't actually think that the two answers are contradicting each other. They both say that the expression !a[$0]++ will result in awk printing the current line if it hasn't been seen before, and that is the core question. Yes, cuonglm's answer goes into more detail and explains the internals, but the essence of the two answers is the same: this expression will print the current line if it hasn't been seen before.

Answer 2

Should the new question be closed as a duplicate?

This feels wrong to me.

The duplicate is not necessary to provide an answer where we didn't already have one. ilkkachu wrote a perfectly great answer to the new question.

The "duplicate" is different: the new post is a more narrow question. I thought we liked questions that we can answer very specifically :-).

As Isaac pointed out, the result looks really strange. The accepted answer on the old page does not attempt to address the narrow question. Because the old question does not explicitly ask the narrow question. In fact, reading the old answer tends to confuse and suggest the opposite of the correct answer to the narrow question.

---

extended ranting which is not relevant to the above

I am frustrated by the older page. StackExchange tradition argues this can be addressed by a couple of approaches.

Problem 1: one considers the accepted answer to be "wrong"

To me: it is a question about a programming language. (One which is on-topic for Unix.SE). The expression !x++ is evaluated as !(x++). To answer the old question "exactly", as it requests, this can be broken down into x++ first, then the ! operator. It is a mistake to break it down into !x, followed by the ++ operator.

-> What should be done with accepted, yet wrong, answers?

One of the approaches is "provide a correct answer [...] You can also add a comment to point out what's wrong with the answer."

Sometimes the accepted answer will remain unchanged. This is a longstanding annoyance (search "accepted wrong answer" on Meta.SE). But we don't want mods to work around it and judge lots of complex cases. I don't want mods to have to delete accepted answers or allow special edits, unless there is quite an obvious justification (example). You could set more site-specific standards. But I'd like moderators who manage people problems, not who pretend they know everything about Unix.

Problem 2: comment chaos

Tradition says "comments are not for extended discussion". If a comment has not convinced the answerer to edit, the solution is to write an alternative answer. (In this case, this has already been done).

When necessary, use a short comment to criticize the answer. It would be most convenient to link to the alternative answer. Though if I see a clear critique, I'm probably going to scroll down to look for the alternatives anyway.

The traditional answer to comment chaos is "comments are transient".

For example, shouldn't we lean towards cleaning up by removing the following comment? Since @Gnouc deleted their comment, it is hard to work out what the reply to @Gnouc means :-). I.e. nominate the comment for deletion, by flagging it as "no longer needed" ("this comment is outdated"). If the comment is deleted, it will be easier to read and understand the comments. The critique will be easier to see, so it will be clearer that one should look at the alternative answers.

@Gnouc I don't see any serious error in this answer. If that is what you're referring to, the incrementation is indeed applied after the value of the expression is calculated. It's true that the incrementation happens before the printing, but that's a minor imprecision which doesn't affect the basic explanation.

Does that feel like exploiting the system? I concede it devalues the comment-writer and their effort... but isn't the system supposed to hold comments as lower value? and this comment-writer is surely experienced enough to expect it...

Answer 3

Even though it was done in the question above, I'm not really one of those beings that appear when you chant their name three times in a row...

But I also did get this meta post linked to me, so I took a look at the posts it was about, and ended up editing two answers from the 2014 Q -- the top two ones. One of them seemed ok, but I felt it could be phrased a bit more clearly. I don't know if I succeeded in that, feel free to revert if you like.

---

As for the other, the edit wasn't that light, and I was also indirectly called for it, so perhaps I should answer for that.

The way the answer stood when I saw it, after all the edits made to it lately, it honestly was just confusing to read. In particular, the last two lines put two very different things side-to-side as equals: the printing of the line, which is conditional on the value of the expression; and the effect of the post-increment, which is not conditional.

An earlier version of the answer seemed better in that it made it clearer that only the printing is conditional on the prior status of a[$0]. Though even here, what happens when the next identical line comes is only brushed upon. That, I think is a rather important part of how the program works, and the question also did ask "how exactly this notation is interpreted", which does all for some detail.

(Though to be honest, the question is somewhat difficult to answer. In the title it just asks how the program works; and later in the post itself, it mentions that the basic idea is already known, but question is in fact about details...)

Now, I do admit that my edit ended up rather more invasive than the intention was. But faced with a +40 accepted answer, the alternative of just downvoting and walking away didn't seem very useful for any future readers either.

Answer 4

I "fixed" my answer on old question about a[$0] not "defined".my answer's got a life of its own now.

about: ++

• As I mention in chat, one shouldn't use a+=a++*a++ and expecting to know result.
• ++ is to be used in a = foo + i++ or a = foo[i++] like operations, whatever language, unless you are competiting in codegolf.
• last I had to implement ++ operator was at university, my work is gone with my computer of that time (that was about 2**5 years ago). To be hosnest I didn't remember any form of "forking" (setting value and evaluation of expression).

about answers

• at the time of first post, I was merely happy to explain this little trick, altough I was confused by Cuonglm's comment and Cuonglm's answer.

• (nowdays) I was about to came here and asked my answer to be deleted, however not all user came here with perfect knowledge on how does ++ compile in pseudo-code.

• I am sorry to have offended thoses who knows.