Help:Change conflict

This article deals with the unintentional technical concept. For deliberate conflicts, see Wikipedia:Edit war.

The template for Change conflict is Template:Cc.

This page is about change conflicts, and what to do when they happen. To know how change conflicts happen and what they are, think about what will happen when:

• A user named Alice clicks "Change this page" on a page.
• Another user named Bob clicks "Change this page" on the same page while Alice is still changing the page.
• Alice finishes her changes and clicks "Save page". The page is saved with Alice's changes while Bob is still changing the page.
• Bob finishes his changes and clicks "Save page". Bob gets a page showing a "change conflict".

Layout of the change conflict page

At the top of the change conflict page is a box containing Alice's version of the whole page, even if Bob is only changing a section of the page.

At the bottom of the page showing the change conflict is a second box containing the text Bob was going to submit. This will be Bob's version of the page or section he was changing.

Between the two boxes is a diff that show the difference between Alice's and Bob's version of the article. For the section Bob is changing it shows Bob's changes and Alice's possible changes, except for sections where Bob and Alice have both made the same change. For the other sections it shows the full new text as if all that text was added.

Bob can change in the upper box and press Save. In the case Bob was changing only a section, this will be interpreted as the new version of the section, hence produce duplication of the other sections, unless Bob deletes them before saving. (This seems to be a bug.) The best solution in this case is to save your new text (e.g., to the clipboard), cancel out, then try again.

At certain times when pressing Save and the system is slow, one may be able to make multiple changes to the same page before the system responds. This produces a change conflict with oneself. In this case the upper text may be the old version instead of the one involving the first change, i.e., the system notices the earlier change but has not processed it yet. A moment later, while one is viewing the change conflict page, the first change is carried out in the background, and the upper text no longer is the current one. Hence, the diff shows the combined changes, and in the case of section changing, like before, the "addition" of the other sections. If you choose to save your work in this type of change conflict, it will result in the removal of your previous changing from the page.

Resolving a change conflict

If Bob only made small changes, and Alice made large changes, he may choose to work from Alice's version, and re-merge his changes in. Bob might choose to add some text like "by change conflict" to the change summary, or use template {{change conflict}} on a Discussion/Talk page, to warn Alice and others that he had to do this – Alice can then peer review his merging for accuracy.

If Bob made large changes, and Alice made small changes, he may choose to work from his version. One choice is for Bob to copy the bottom text into the top text (or just copy over the one section of the top text, if Bob was changing a section), with an appropriate change summary (for example, "via change conflict, will remerge"). Then Bob can view the page history, determine Alice's changes, and re-apply them to his version, in a separate change.

If both Alice and Bob made large changes, matters become complicated, and Alice and Bob just have to do the best they can. For example, if both Alice and Bob add a large section of text on the same subject at the same time, then it may be best for Bob to submit his changes, and then for Alice and Bob to both have a look at the two versions and decide between themselves which version is better.

Bob should not just post his changes over the top of Alice's. We assume good faith – mistakes are occasionally made, and newcomers may not understand the change conflict window. However, Bob must not routinely ignore change conflicts. It is absolutely not acceptable for Bob to overwrite Alice out of laziness. We encourage contributors to double-check their merges by using the diff feature.

Logical change conflicts

(This is a conflict between changers that is undetectable by the mechanism that decides whether to give the "change conflict" message.)

Some people change pages by copying the source text into a text changer, making lots of changes (reorganising, adding new content, etc.), and then, when they're done, pasting the whole thing back onto Wikipedia as a single (new) change. If someone else has made changes in the meantime these changes would get lost in the paste back. People who change pages this way should either:

• paste only into the same box that was originally copied from, or
• check the page history for such changes, and merge the changes before pasting back.

Mistakes

Sometimes mistakes will be made in the merging process, because Bob is human, and this may cause some of Alice's changes to be accidentally reversed. Logical change conflicts aren't always immediately visible. Sometimes Bob may have good reasons for thinking that Alice's improvements aren't useful. In these case, Alice and Bob are expected to resolve their differences amicably.

If Alice made a small change, which Bob accidentally reversed, then Alice must not revert to her version. It is absolutely not acceptable for Alice to reverse Bob's major improvements to the page out of a desire to protect her minor improvements, or to punish Bob for his carelessness. This is particularly important if the page has subsequently been changed by, say, Sarah and Jonathan.

The best approach for Alice in this circumstance is for Alice to change Bob's version, reinstate her minor improvements, and leave Bob's major improvements intact. She may also add something to the change summary to indicate that she had to do this – for example: "Reinstating link which Bob accidentally removed". Bob should then apologise to Alice for his mistake, and thank her for reinstating her improvement.

If Bob repeats his error, then the best approach is for Alice to have a friendly word on his talk page, point him to this page, and ask him if he could take a little more care in the future. This is particularly important for newcomers, who may not understand the correct way to resolve change conflicts, though even experienced users may need the occasional friendly reminder.

Reverting

When saving a previous version (i.e., when reverting) or a new version based on that (a modified reversion) the change conflict warning and prevention system is not triggered and a possible new change made in the meantime is unintentionally reverted also, see Reverting a page to an earlier version. To avoid this problem one can copy the text from the box of the old version into the box of the latest version. In some sense, this can cause hidden change conflicts: you may overwrite someone else's changes without realising that you are doing so. It's always wise to check the diff after performing a revert, just as you would after posting via change conflict. Preferably, one can simply try to avoid reversion wars.

Prevention

Because change conflicts are irritating and time-consuming, you may choose to alter your changing habits to render them less frequent: aiming to make more changes to pages that have not been changed recently.

Another means of avoiding change conflicts is to make a single larger change, rather than frequent smaller changes: this makes it more likely that you will get an change conflict, but less likely that you will cause others to get an change conflict. Using the "Show preview" button helps here.

To reduce the chance of change conflicts, Wikipedia has an "In Use" notice in its Template namespace that people may use when changing a page over a long period of time. Simply put {{inuse}} on an article before proceeding with a major change, and remove the template when the changing is complete.

New since v.1.3 is CVS-style change conflict merging, based on the diff3 utility. This feature will only trigger a change conflict if users attempt to change the same few lines. See also automatic merge.