Let's say we want to add additional changes to our add-readme branch

before merging our pull request into the master branch.

This is really simple.

All we need to do is make the changes we want in our text editor,

commit the changes, and push the branch.

In this video, however,

we're going to intentionally create a conflict by making our edits and

committing the changes on the GitHub website as well as on our local copy.

This will give you an idea of the editing abilities on GitHub.

When you're just getting started using Git and

GitHub, my suggestion is to not make any edits on the website.

Doing all of your work locally will help you avoid conflicts

like the one we're about to create.

If you're only pushing up changes from your local computer and

working by yourself, you'll always be in sync with the remote repository.

However, if you do start working with collaborators,

they might just push up a change to the remote branch while you're working on

the same file locally, resulting in a conflict.

This is a fairly common issue, and it's not the end of the world, but

it can be scary, so let's practice creating and fixing a merge conflict.

Okay, so I'm here in my code view and I want to change to the add-readme branch.

Let's say I want to add an image to my README.

I'll click into the README.md file and click the Edit button here.

So here's a little hack or a pro tip.

If I wanna add an image to a readme file,

the markdown syntax in the markdown cheat sheet will tell us how to do that.

But a little shortcut is I can go to Issues and

New Issue.

And if I have a file like I do here, then I can just drag and

drop it into the issue body and it creates this automatic URL.

Or it creates the Markdown syntax that we need.

So I'll do Preview.

Cool.

So I can copy and paste it back here

and I can preview the changes.

Awesome.

So the green shows what I've added and that looks good.

So I'll go back and edit my file.

I'll also want to adjust this typo here.

Files completed and then let's do a,

And cool, looks good.

So here I will add a commit messages and

I can just say update README.md

to add image and fix typo.

I can add an optional extended description, and then I can go ahead and

directly commit the changes to the add-readme branch by

clicking Commit changes here.

Back in the console, normally if we have any changes to a remote repository,

we would use the command git pull to pull in the remote changes.

As they say, always pull before you push.

But let's say I forgot that I had made the change on the remote repository, and

I'm gonna go ahead and add some information to my README here.

And I'll save.

So in the console, I'll run the commands.

Let's make sure I'm in the right branch.

I'm still in the add-readme branch, great.

And so I will add and commit my changes.

Cool.

And I'll go git push origin, add-readme.

Okay.

What's going on?

It said failed to push.

Updates were rejected because the remote contains work that you do

not have locally.

This is usually caused by another repository pushing to the same ref.

Okay, so that's right, I forgot to pull, right?

So now I type git pull origin add-readme.

And I get a new error message.

CONFLICT: merge conflict in README.md.

Automatic merge failed; fix conflicts and then commit the result.

Okay, so here we can refresh the text editor.

And we can see there's a bunch of stuff here.

It looks kind of scary but we'll get through it, I promise.

Okay, we can see there are a lot of errors or

conflict markers which show us where the conflict occurred.

There's an equals sign that separates the two versions.

On the top, the head is the most recent commit, and

the one I was trying to push up from my local computer.

And below the equals signs was the change that I made on GitHub.

I'll need to choose which to keep.

I wanna keep the one that has the image,

so I'll just have to delete all the rest of this here.

And all these conflict markers, and save.

And then back in our console,

we'll do a git status.

Cool, I'll do a git add.

git commit -m. We'll go, fixed

merge conflict,

and I'll go git push

origin add-readme.

Cool.

Now we'll go back to the Treehouse repository.

We'll go to the Pull Request.

You can see my commit history right here, updated README.md file to add

the image and fix the typo, added my profile locally.

And then another commit message where I fixed the merge conflict.

Also, if we go here, we can see this commit history.

Now that I've added our additional comments and fixed the commit,

let's go back to our pull request.

We can see the additional commits to the branch are shown here.

And let's take another look at the files changed view, too.

Commits, and the file's changed.

That's fine.

Okay, this looks good.

Now let's click Merge pull request and confirm the merge.

Confirm merge.

Pull request successfully merged and closed.

Woo hoo!

Congratulations.

You've completed your first pull request.

Since we won't be using the add-readme branch any longer,

we can delete the branch here.

If we revisit the issue page, we see that the add-readme issue is now closed.

Because we included fixes number one in our pull request body,

GitHub took care of closing that issue when the pull request was merged.

If we go to our profile, we'll see a green square on our contributions graph.

Great job.

Let's quickly review what we've done.

After we opened a pull request,

we made a change to the repository on the GitHub website.

Since we forgot to do a git-pull,

we made a change to the same file on our local computer and we created a conflict.

In the text editor, we deleted the lines we didn't want to keep and

then committed and pushed up to the remote repository on GitHub.

Problem solved.

In the next stage,

Kyle will show how to use these features to collaborate on a team.