Now that you know how important version control is and

how fundamental Git is to development, let's focus on the first level tasks and

terminology you'll need to know.

To begin with, Git projects are known as repositories or repos.

Simply put,

repositories contain all of the project files as well as their revision history.

You can think of them as a folder that holds the whole project over time.

Repos can be yours alone, or shared with others.

Repos house on GitHub can either be private, as in invitation only, or

public for all GitHub users to see.

Unless you have a good reason to keep your repos private, like proprietary concerns,

you should just begin with public repos, as there's no charge on GitHub.

Private access comes with a fee.

To begin working on a repository,

you will clone a copy on your system or check it out as we'll show you in Xcode.

When you make changes to the project, you'll usually want to save them and

that's called making a commit.

A commit is one or more changes to one or more files.

Commits are accompanied by a brief commit message from the user,

as well as an optional description, which can be longer.

Every time a commit is made, a unique ID hash or SHA is created so

we know which changes were committed when and by whom.

Now mind you, you probably won't want to commit every little thing you try out.

But when it's something that might be worth preserving for the future,

that should be committed.

Most often, you'll have a remote copy of the repository housed on GitHub and

a local copy on your machine.

When you push, you're sending your local committed changes to the remote repo.

When you pull, you're getting changes from the remote repo and

simultaneously merging them into your local copy.

It's worth highlighting that distinction.

When I push my changes to a remote repository, it won't automatically merge

into everyone else's active branch unless they decide to pull the changes.

However, when pulling, the merge happens at the same time.

I'll talk more about merges in a minute but

they're pretty much what you would expect.

A branch is a parallel version of a repo.

It's actually housed within the repo itself, but

when you change it, it doesn't affect other branches.

The main branch is most often referred to as the master branch.

And the latest commit is known as the tip of the branch.

You can have as many branches as you want and

it's often a good idea to create new branches for new features.

Though be sure to name them descriptively, keep them tidy, and

merge back in when appropriate.

Having too many branches can quickly become a huge mess.

A merge is when you take the changes from one branch and insert them into another.

A merge can happen automatically, like when you pull, or

by explicitly merging one branch into another.

You may also have heard the term pull request,

which is essentially a request to merge your code in.

By the way, Git doesn't simply overwrite one whole file with another,

rather it sees only what has changed and decides which changes to keep.

When Git can't figure that out on its own you get a merge conflict and

you'll need to resolve that manually, by deciding which code to keep.

Sometimes it will just be one or the other.

Sometimes a mix of the two.

A diff is simply the difference between two commits.

When you view a diff, you can see what has been removed, added or

changed since the previous or other commit.

A gitignore is a file that tells Git to intentionally exclude certain files or

folders from tracking.

You don't have to use gitignore, but it can be helpful if you don't

want to track certain user settings, large assets, things like that.

I've included a link below that goes into lots more details on gitignore.

And just as a reminder, Git is the open source program for tracking changes.

GitHub is the social and user interface which uses Git as its primary machinery.

Join me in the next video where we'll put all that I mentioned into action when we

create a GitHub account and start working with repos for a real live Xcode project.