Hint Eg git Pull Before Pushing Again

Conflicts

Overview

Questions

• What practice I do when my changes conflict with someone else's?

Objectives

• Explain what conflicts are and when they tin can occur.

• Resolve conflicts resulting from a merge.

As soon as people can work in parallel, it's likely someone's going to step on someone else's toes. This will even happen with a single person: if we are working on a piece of software on both our laptop and a server in the lab, we could make dissimilar changes to each re-create. Version control helps united states manage these conflicts past giving usa tools to resolve overlapping changes.

To see how we can resolve conflicts, we must offset create one. The file mars.txt currently looks like this in both partners' copies of our planets repository:

            Cold and dry, simply everything is my favorite color The two moons may be a problem for Wolfman Simply the Mummy will appreciate the lack of humidity                      

Permit's add a line to ane partner's re-create only:

            $ nano mars.txt $ cat mars.txt                      

            Cold and dry, but everything is my favorite color The two moons may be a problem for Wolfman But the Mummy will appreciate the lack of humidity This line added to Wolfman'south copy                      

and and then push the change to GitHub:

            $ git add mars.txt $ git commit -m "Add together a line in our habitation copy"                      

            [main 5ae9631] Add together a line in our dwelling copy  1 file changed, i insertion(+)                      

            Counting objects: 5, washed. Delta compression using up to 4 threads. Compressing objects: 100% (3/3), done. Writing objects: 100% (3/3), 352 bytes, done. Full 3 (delta 1), reused 0 (delta 0) To https://github.com/vlad/planets    29aba7c..dabb4c8  primary -> main                      

Now let'southward have the other partner make a unlike change to their re-create without updating from GitHub:

            $ nano mars.txt $ cat mars.txt                      

            Common cold and dry out, but everything is my favorite color The ii moons may be a problem for Wolfman But the Mummy will appreciate the lack of humidity We added a different line in the other copy                      

Nosotros can commit the change locally:

            $ git add together mars.txt $ git commit -m "Add a line in my copy"                      

            [master 07ebc69] Add a line in my copy  1 file changed, i insertion(+)                      

just Git won't let the states button it to GitHub:

            To https://github.com/vlad/planets.git  ! [rejected]        chief -> primary (non-fast-forward) fault: failed to push button some refs to 'https://github.com/vlad/planets.git' hint: Updates were rejected because the tip of your current co-operative is backside hint: its remote counterpart. Merge the remote changes (eastward.g. 'git pull') hint: before pushing again. hint: Come across the 'Note about fast-forrad' in 'git push --help' for details.                      

Git detects that the changes made in one copy overlap with those made in the other and stops us from trampling on our previous piece of work. What we take to do is pull the changes from GitHub, merge them into the copy we're currently working in, and then button that. Permit's start by pulling:

            remote: Counting objects: 5, washed. remote: Compressing objects: 100% (ii/2), done. remote: Total iii (delta 1), reused 3 (delta i) Unpacking objects: 100% (3/three), done. From https://github.com/vlad/planets  * branch            master     -> FETCH_HEAD Car-merging mars.txt CONFLICT (content): Merge conflict in mars.txt Automatic merge failed; set conflicts and then commit the result.                      

git pull tells us there'due south a conflict, and marks that disharmonize in the affected file:

            Cold and dry out, only everything is my favorite color The two moons may be a trouble for Wolfman Merely the Mummy will appreciate the lack of humidity <<<<<<< HEAD We added a dissimilar line in the other copy ======= This line added to Wolfman's copy >>>>>>> dabb4c8c450e8475aee9b14b4383acc99f42af1d                      

Our alter—the one in HEAD—is preceded by <<<<<<<. Git has so inserted ======= as a separator betwixt the conflicting changes and marked the end of the content downloaded from GitHub with >>>>>>>. (The string of letters and digits after that marker identifies the commit we've just downloaded.)

It is now upward to usa to edit this file to remove these markers and reconcile the changes. Nosotros can do anything we want: go along the change fabricated in the local repository, continue the modify made in the remote repository, write something new to replace both, or get rid of the change entirely. Let's supersede both so that the file looks like this:

            Cold and dry, but everything is my favorite color The ii moons may be a problem for Wolfman But the Mummy will appreciate the lack of humidity We removed the conflict on this line                      

To finish merging, we add mars.txt to the changes being made by the merge and then commit:

            $ git add mars.txt $ git status                      

            On branch master All conflicts fixed merely you are still merging.   (use "git commit" to conclude merge)  Changes to be committed:  	modified:   mars.txt                      

            $ git commit -m "Merge changes from GitHub"                      

            [principal 2abf2b1] Merge changes from GitHub                      

At present we can button our changes to GitHub:

            Counting objects: 10, washed. Delta compression using up to 4 threads. Compressing objects: 100% (half-dozen/6), done. Writing objects: 100% (6/6), 697 bytes, done. Total 6 (delta 2), reused 0 (delta 0) To https://github.com/vlad/planets.git    dabb4c8..2abf2b1  master -> chief                      

Git keeps track of what we've merged with what, so we don't have to fix things by paw over again when the collaborator who made the first change pulls again:

            remote: Counting objects: ten, done. remote: Compressing objects: 100% (4/4), washed. remote: Total 6 (delta 2), reused 6 (delta 2) Unpacking objects: 100% (6/six), done. From https://github.com/vlad/planets  * branch            master     -> FETCH_HEAD Updating dabb4c8..2abf2b1 Fast-frontward  mars.txt | 2 +-  1 file changed, i insertion(+), 1 deletion(-)                      

We get the merged file:

            Cold and dry out, merely everything is my favorite color The two moons may be a trouble for Wolfman Simply the Mummy will appreciate the lack of humidity We removed the conflict on this line                      

Nosotros don't need to merge again considering Git knows someone has already done that.

Git'due south ability to resolve conflicts is very useful, simply conflict resolution costs time and effort, and tin introduce errors if conflicts are not resolved correctly. If you find yourself resolving a lot of conflicts in a project, consider these technical approaches to reducing them:

• Pull from upstream more ofttimes, peculiarly earlier starting new work
• Use topic branches to segregate work, merging to master when complete
• Make smaller more atomic commits
• Where logically appropriate, pause large files into smaller ones so that it is less likely that two authors volition alter the same file simultaneously

Conflicts can too exist minimized with project management strategies:

• Clarify who is responsible for what areas with your collaborators
• Discuss what order tasks should exist carried out in with your collaborators so that tasks expected to change the same lines won't be worked on simultaneously
• If the conflicts are stylistic churn (eastward.yard. tabs vs. spaces), establish a project convention that is governing and utilise code style tools (due east.k. htmltidy, perltidy, rubocop, etc.) to enforce, if necessary

Solving Conflicts that You Create

Clone the repository created by your teacher. Add together a new file to it, and modify an existing file (your instructor will tell you which ane). When asked by your teacher, pull her changes from the repository to create a conflict, then resolve it.

Conflicts on Non-textual files

What does Git do when there is a conflict in an image or some other not-textual file that is stored in version command?

A Typical Piece of work Session

You sit downwards at your reckoner to work on a shared project that is tracked in a remote Git repository. During your work session, you lot take the following actions, just non in this order:

• Make changes by appending the number 100 to a text file numbers.txt
• Update remote repository to match the local repository
• Celebrate your success with beer(south)
• Update local repository to match the remote repository
• Stage changes to exist committed
• Commit changes to the local repository

In what order should you perform these actions to minimize the chances of conflicts? Put the commands above in club in the action column of the table below. When you lot have the order right, see if yous can write the corresponding commands in the command column. A few steps are populated to get you started.

order	action . . . . . . . . . .	command . . . . . . . . . .
1
2		echo 100 >> numbers.txt
3
four
5
6	Celebrate!	AFK

Cardinal Points

• Conflicts occur when two or more than people change the same file(s) at the aforementioned time.

• The version control system does non allow people to overwrite each other's changes blindly, but highlights conflicts so that they tin be resolved.

westluch1978.blogspot.com

Source: http://homepages.cs.ncl.ac.uk/matthew.forshaw/teaching/csc8627/versioncontrol/09-conflict/