Does this open the door for chameleon questions?

Question

Obj-C wrapper for OpenLDAP

The user originally posted the top half of the code there. An answer was posted.

After the answer had upvotes and a comment from the questioner (noting his appreciation for the answer as a good answer), the question was edited to "add more context".

No where does anyone hint that more context might be needed, nor does the questioner imply that the posted answer might be misunderstanding something based on a lack on context. Yet the extra code was added (making the existing answer less complete).

I rolled back the edit. The questioner undid the rollback. And I pointed a mod at the question. The response was this comment:

Modifying the code in your question in response to a review ("fixing things") is strongly discouraged on Code Review. I see that your actual edits do not change the code, but add more context to the code. This has not invalidated the current answer, but does make the current answer less complete. For future reference see what you may and may not do after receiving answers

Again, I must emphasize that no one involved in the question made any suggestion that additional context would be helpful or was necessary.

So with that in mind, does the failure to rollback this edit open the door for chameleon questions on Code Review?

What's a chameleon question? A chameleon question is a question that changes over time. It takes a lot of back and forth with the questioner to get him to finish the question and mark an answer as accepted because he wants a single question to answer all of his questions when the question should instead be multiple questions. For example:

Q: I'm trying to do X, but I ran into problem Y.

A: Try solution Z.

Q: Okay, solution Z solved problem Y, so now I'm successfully doing X, but when I try to do A now, I run into problem B.

... and it goes on.

Should we allow chameleon questions? Is this question a chameleon question?

Answer 1

I think the mods did the right thing here in this specific case, but I understand your concern. This could be a slippery slope, but all in all, I see nothing wrong with adding code without invalidating answers. After all, the reason we don't allow edits to the code is to prevent answer invalidation. The edit doesn't invalidate your answer. It just makes it less complete, and answers are under no obligation to be "complete" reviews. In fact, a complete review is likely to be nearly impossible to begin with.

I feel OP's actions are to be discouraged, but do not violate any of our community's policies. You are under no obligation to answer a question to begin with, so you are certainly not obligated to update your answer either. Simply stop helping when a question becomes a chameleon.

Answer 2

I don't think that answer invalidation actually occurred here. Invalidation would be: "You're right, I hadn't thought of that idea. Let me incorporate it sneakily and hope nobody notices."

You made a valid observation that accepting NSString would probably make the method more usable.

The author therefore felt compelled to show a use case demonstrating how it wouldn't actually make a difference. (Is it possible that the use case was contrived just to disprove your advice? Possible, but in accordance with the Assume Good Intentions principle, I would assume that the use case is genuine.)

Therefore, it looks like this is a case of miscommunication and clarification, rather than a deliberate effort to misappropriate your advice. Miscommunication happens — that's life. Clarifying miscommunication is a good thing. "Oops, I didn't phrase the question as clearly as I should have" happens all the time on all Stack Exchange sites, and it's usually not something to get upset about.

I wouldn't say that we are establishing a new rule to allow chameleon questions by allowing the clarification to stand. Rather, it just means that we are carefully thinking about the nuances of each edit rather than blindly enforcing a broad no-code-changes rule.

I would also add that answers do not need to address all of the code in a question, so there is no such thing as invalidating the completeness of your answer.

Answer 3

Does this open the door for chameleon questions?

No, it does not.

This is a question where the code to be reviewed is perhaps easier to review if the code is put in to a bigger context.

This is not an iterative review, the code to be reviewed was not changed. The context code is the same as what it was before it was posted.

The core question is unchanged, and there's no chameleon here. The context has not changed either, the only thing is that now the context is available for reviewers to see.

Is this situation ideal? No. The context should have been provided before any reviews were added. But, it would also be wrong to deny other people the context that would perhaps be helpful for their reviews. Asking it as a new question would be a duplicate (there's no code change).

So, the bottom line is that now people who choose to review the code have a bit more context than the early review. That gives others an advantage (or not).

As much as that may be seen as 'unfair' to the early reviewer, it's also unfair to prevent the asker from clarifying the context of his code (whether he was asked to clarify the context is not significant).

So, in this case, two wrongs do not make a right: it was wrong to exclude the context, and it would also be wrong to deny the asker the opportunity to provide it.

There is no perfect (or even good) solution here, and my assertion is that allowing the added context results in the best quality for the site.

What you choose to do with that additional context is up to you. Providing a second answer, extending yours, or doing nothing all seem like reasonable options.

Note that many questions on Code Review provide code to contextualize the core code that is there for review. For example, I often include a 'main method' to run the code, and I don't want that main method reviewed. Other people offer test harnesses to run the code. Adding code as a context does not mean the code needs to be reviewed.

I have satisfied myself that the current situation is the best resolution, and that no, it does not open the door to 'chameleon' questions.

I will unlock the question, and move on.

Answer 4

In my view, any question that has any upvoted answer should be considered frozen unless comments have asked for additional context. That's in keeping with this meta-post

Answer 5

Chameleon questions should not be allowed. It's why we don't allow editing of the code.

Should we allow chameleon questions?

No.

Is this question a chameleon question?

Well, it looks like one, but I don't think it was intended as such.

---

Adding context is fine.

However, context should be in text, not in code. By making the context in code, you put it up for review, and that's not what we want to achieve.

Thus if you have only code-context, please transcribe its meaning and significance to English text (a set of passed test cases becomes "I have tested my code for x y and z and it passes the tests."). If you want to add the code to the question, please transcribe as above, then post a LINK to the code in the question.

If I have received an answer that states "you should use more comments, I can barely tell what these functions do", and I see that I do use comments, but I only put them in the header files, why should I be restricted from editing my question to add that "each of these functions has a description with its definition in the header"? With a link to the header files on github.

The header files existed before I posted the question, I just didn't think of them as significant for review. Now they do seem to be relevant.

What about invalidating answers by adding context?

How? How can you invalidate an answer by adding context? I know how. If that answer made assumptions.

Those assumptions should be allowed to be broken. "You don't deal with unicode" -> "Sure, but it doesn't have to support unicode. Our database doesn't support unicode either, and that's where the input comes from."

Had someone dispelled the assumption before the answer was there "This code doesn't have to support unicode" then the answer "You don't deal with unicode" would both be obvious and irrelevant. Yes, I know it doesn't support unicode, but as per the problem description, it doesn't have to. To make a point like that would be to say that "finding the smallest item in an array" doesn't print a list of primes. Yes it's true, but that's not a flaw of the code. It doesn't have to do that.

Adding context cannot invalidate an answer without breaking assumptions that the answerer made. Those assumptions are made because there's a lack of context, not because of the code under review.

Answer 6

Even if this isn't a chameleon question, the code added in the edit is at least an attempt to invalidate the existing answer.

In this specific case, the added "context" code is only added in direct response to the existing answers comment on NSString objects versus C-Strings. If that answer doesn't include that commentary, does the context get added? Almost certainly not.

But the commentary was included, and the questioner disagrees that assessment. Rather than simply not implementing that suggestion (no questioner is even remotely close to being under any obligation to implement anything suggested in any answer ever posted), or questioning my suggestion in a comment, or inviting me to chat, or any other question, the questioner posted "additional context" in what can be perceived as nothing more than an effort to make every comment I made on NSString versus C-String completely invalid.

Now, as someone who donated my time to helping some random stranger on the Internet write better code, I'm left with a few options:

1. Do nothing to my answer. If the questioner was right and that the additional context invalidates some of my comments, then I look like an idiot in a month because it is very unclear to anyone reading this even a week later that my answer was written without this additional context.
2. Update my answer (or add a new one) to demonstrate that even with the additional context, my original point still stands.

If scenario 1 is the case, then I'm going to be highly discouraged from posting answers, because I'd rather not open myself up to the opportunity to look like an idiot because someone changed the context in which something I posted.

If scenario 2 is the case, then why don't we allow people to edit a revision of their code into questions? Why do we force them to open new questions? It's because Stack Exchange isn't a forum. We don't want a massive back and forth of questions and answers. We want clear questions and clear answers.

Allowing users to add context (especially in this specific case where it actually adds literally nothing) means that we're adding reviewable code to the question. And when a new review gets posted about the added context, why won't the questioner post even MORE context to clarify the context that was supposed to clarify the original... and so on and so forth.