I know it's already established that duplicate questions should be closed but not deleted, so they can act as "pointers" to the one canonical answer.
However, I think there's one important aspect that is usually glossed over:
lately I've run into a number of instances where questions have been closed as duplicates even though they patently are not. Instead, those answering the question know that the answer is a duplicate of one presented, and to save them the trouble of copying that answer, they close the question as a duplicate.
At the most basic level, this is of course absurd. Many entirely different questions can have the same answer (would you close "what is 2+2" and "what is the square root of 16" as duplicates?), but of course most real-world examples aren't as clear cut.
In this case, the questions are genuinely different.
One question is simply "why doesn't my code work", and the other is "when should I use
typename to make my code compile". Of course the answer is "you should use
typename here to make your code work", so the answer is the same, but the question isn't. From the user's point of view, it seems to send the wrong message when such a question is "closed as a duplicate".
Doesn't this come across as "I can't be bothered answering your question, but here's a link to a generic cookie-cutter answer that might answer your question. Oh, and in the future, please don't ask questions here, it's already been done"?
I think it's important to note that the questions are so different that the person asking might not realize the relevance of the question he is being directed to. This isn't just a case of two people asking the same thing with slightly different wording, but two entirely different questions, where the answer just happens to overlap heavily.
It is also my understanding that "dupe" questions are deleted after a while, which of course means that all the effort that goes into marking such questions as dupes to avoid answering them, is really just generating more work for these people.
As I see it, there are two ways to look at this problem:
the "close as duplicate" text doesn't actually match what's happening. The first part, "This question covers exactly the same ground as earlier questions on this topic" is simply untrue. The second part, "its answers may be merged with another identical question", seems to threaten that the question may be eliminated which would be actively harmful. (Whether or not this merger ever does happen is (almost) irrelevant. What I'm concerned with is the message it sends to the person asking.
or the question probably shouldn't be closed as a duplicate at all, regardless of how you word it. The question is unique. Its answer just happens to overlap those for another question.
So what should be done in this case?
(some of these ideas are just user policy, others would require new functionality to implemented)
- leave everything as it is, and close the questions as duplicate when the answer is the same as that to another question,
- we could leave such questions open, and just answer them again,
- the textual description on "close as duplicate" could be revised to better cover these cases (and of course, the question being closed should never be deleted then),
- a new close reason could be created instead (a "duplicate answer" to complement the existing "duplicate question" close reason, which might make more sense to the OP whose question got closed),
- or we could try to streamline and automate the process of duplicating answers so that actually answering these questions isn't such a chore. Think of it as refactoring tools applied to answers.
To elaborate on the last item, the problem with duplicate answers is usually that we have to stop writing our answer, and go search out that other question which has an answer we can link to (and then someone else provides a less informative, but quicker, answer and we don't get any rep and sit in a corner sulking for the next week).
What if we could "factor out" commonly used nuggets of information from our answers, store them in some kind of wiki-like repository (or the usual Q&A format could work too, as long as it is made easy for us to reference), so that we can reference it easily when writing answers that rely on this information?
In the example I linked to above, what I really want to do is just provide a simple answer "shell" containing a bit of context which relates the information to the OP's problem, and then for the meat of the answer, I'd just like to reference some extremely commonly used information. And I'd like to be able to do so quickly, without having to search, and without having to type out an entire URL.
What I really want is to write an answer such as this:
you need to use the
typenamekeyword as described
and then have the
[here] transform into a link to the (currently fictive) SO-wiki article on the
typename keyword in C++. Or even better, it could expand into an inline copy of that article, making it easier and more convenient for the reader of the answer, while still allowing us to reuse things we already wrote, and allowing us to centrally keep this information nugget up to date.
Thoughts? How much of a problem do you think this is? And how do you think it should be dealt with?