And I completely agree.

This is why I created this video to tell you exactly why I get is so important.

Explain how get works and, most importantly, show you everything you need to know.

In order to get started, we get in only 20 minutes.

Let's first start with what kit is get is a version control system more specifically, a distributed version control system and makes tracking changes to your code overtime.

Painless get tracks.

Every change has ever been made to the code you tell it to manage unless you easily switch between versions of your code or even undo changes.

It also makes it easy for teams of people to work on the same project and even the same file.

Since each team member has their own version of the code saved locally on their computer, get also saves.

The full version has drowned each team member's computer, which is what makes it a truly distributed version control system.

This is all great, but teams need a place to store their code remotely so that all the team members have this central place to save their changes to and pull down other team members changes.

This is where get have comes in.

Many people get confused when they first formed about get and get help thinking that they're the same thing.

However, get Hub is just a website where developers can store their projects for other developers to access.

Get on the other hand, as we talked about, is just a version control system for tracking and managing changes to coat.

Now that we have a basic understanding of what it is, let's jump into why get is so important and why you should be using it on all of your projects.

Imagine this scenario where you're working on a multi part YouTube tutorial to learn the basics of hte e mail.

Such was my introduction to HTML course, and you just finished writing all the code for one of the middle videos in this series, only to find out that something you did broke everything without get, you'd have to resort to trying to remember what you change since the previous video and then search there each of those files to determine what exactly is wrong.

If you're lucky, you remember all the changes that you made.

But most likely you'll have to go through all the files of the project looking for a single mistake with get though this is a trivial problem to solve.

Since get tracks all the changes that you make, you would simply have to tell Get to show you all the changes that have occurred since the previous videos code and get will not only show you what files have changed, we'll also assure you the exact changes that have occurred in each file.

This bank's finding what went wrong, more enjoyable and quicker get also allows you to change back to previous versions of your coat with a single command.

This is extremely useful for any project, since if you deploy your changes to the world and realize later that something major is broken, you can simply tell Get to change back to the previous non broken version of your code without get.

This is an impossible task, since nobody will perfect remember all the things that need to be reverted to get back to the previous version.

Lastly, get is used by nearly all developers, with Stack overflow reporting that nearly 90% of their 75,000 developers they surveyed used get as their version control system.

This means for anyone looking to get a job in programming they will need to know Get.

Lastly, you need to ensure that get is installed on your system and configured with your getup account.

If you do not already have get installed or do not have get linked with get Hub, then check out my video on the introduction to what Development Right?

Cover Installing and setting up.

Get with get hub.

This will be linked in the description below.

Now that you have get properly installed and set up with get hub, we can begin talking about how to use get.

The first thing you need to do is initialize.

Get in your existing project or clone a remote project from a Web sites such as Get Hub In order to initialize, get in a project that already exists on your computer.

Simply run the gettinit grant in the terminal from the full that contains all of your project files.

This will add a dot get folder to your project that get well used to track all the changes you made to your project.

Get also uses the word repositories or repo for short to describe the entire project being managed by GID.

The second option of cloning of repositories could be done by going to get help and either creating a new repositories clone or finding an existing repositories and coffee and the link to clone the project.

If you set up, get and get hub using the method from my video, make sure to call me the s S h u r r o and not the http.

You are all now with that euro copied type that command get clone into the terminal with the copied euro at the end of the command.

This will copy all the code from the depository onto your computer and set up get to track the changes.

This also adds the remote repositories to your git config for the project so that when you were ready to push your changes to get home get will already know where to push them too.

Now that we have a project set up on our computer, let's talk about the structure of get, get tracks changes through three stages.

The working directory, indexed and head.

The first stage is the working directory.

The working director is simply all the files in the local repositories in their current state.

None of the changes in the working directory attractive I get.

In order to attract these changes, we first need to add them to the index, which is commonly referred to as staging.

This could be done by using the get ad command.

This process of adding changes to staging tells get that we want to track all the changes that we have made in our working directory.

This still does not make these changes an official version of your code that you can change between, though, in order to add these changes as an official version, we need to scale get to commit these changes from the index to the final stage.

The head this tells get the changes are final and requires a message to be saved with the committee.

This could be done by using the get commit command.

The head is simply the most recently committed version of your code.

After committing changes to the head there, saved as a version on our computer, but they are not in our remote depository on get home.

In order to get these changes to our remote repositories on get hub, we need to push them to get up using the get push command.

If you set up your project using get clone, think it will already know where to push the files to.

But if you use to get in it to initialize the new project, then get will need to be told where to push these changes, too.

This could be done by creating repositories on get Hub and copying the shur o for cloning.

After that has done, you can simply use the git remote at Origin Command with the copy d'Oro at the end of the command, this tells, Get that we have remote repositories called origin at the copy of your own with the remote depository added, you can use the get pushed command to push the changes to the remote repositories and get help.

We now are able to create a repositories, make changes to it, save them and push those changes to get home.

But what if another one of our team members wants to pull down the changes that we pushed to give her onto their local computer.

This is where they get pole command comes in by simply typing the command, get pull into their terminal.

All of your changes from get up will be pulled onto their local computer and murdered any of the changes that they have.

That is all you need to know about get in order to get started.

But there is one more big concept and get called branches.

Branches are essentially a copy of the code at a point in time that has its own separate history from the main branch, which is called Master.

Imagine you're in a company with two teams and one of the teams is creating feature A of a website and the other team is creating feature B for the same website.

These features will have multiple commits in order to be fully completed, but both teams are working out of the master branch.

Then whenever the team working on feature A pushes their changes to get hope, the other team will get those changes for feature A.

When they try to pull.

This will cause problems because now the team working on future be we'll have parts of feature A in their code.

This is where branches coming.

If the team working on future A creates their own branch off of master and the team working on feature be creates their own branch off of master.

Then when the team's pushed the changes to get hope, they will only be pushing their changes to their own branch and not the master branch.

This can be done using the command get branch with the name of the branch being created at the end of the command.

This will create a new branch, but in order to switch to that branch, they get check out.

Command will need to be used with the name of the branch at the end of the command.

Since this is such a common operation, there's a parameter you can pass to the checkout command to create a new branch and swap to it.

This command is get check out Dash B with the new branch name after the Dash B.

Now that both teams have created their own branches and committed all their changes for each feature to their branches, it is time for them to merge these changes back in the master get makes it easy with the get merge Command get merged followed by the branch name that you want to merge will merge all of the changes from that branch into the branch you currently have checked out.

If there any conflicts between the two branches give will notify you of these conflicts and let you decide what to do with them before committing the changes, this is finally the end of all you need to know about it.

I know it can seem quite daunting, but I'm going to go over a live example of exactly how all these commands work to give you a more hands on experience with how get works.

Let's jump into that.

Hello, everybody.

What's first get started.

We're setting up a project on getting The easiest way to do this is to go to get hub, create a new repositories, give it any name you want.

We're just gonna call ours, get home test and then click to initialize.

This would have read me.

This will make us that you can call in the project down to your computer and then click create repositories.

And after that's done loaded.

No, bring you to your repositories.

Page.

Here's where you can clone the euro and make sure you use the shur O.

If this does clone with http, make sure you clip the button up here which will say, use SS age after you're done with that cooked the Earl, copy it and then go to the folder that you want to copy this into.

Once you're here, you can right click this and open the terminal here.

And then all you need to do is type Gibbs clone and then paste in the euro.

You just copied hitting.

Enter for this will copy All of the Cody is inside of that repositories, which includes that Read me we created and bring it into the folder that you are in currently with the terminal.

Now to open this just right, click it and open it with visual studio code and we can get started right away.

And we see we have a read me and it just says the project name.

The read me is important in version control systems such as get hub.

Because if you go to get have sight, you can see that inside of your repositories, everything in the read Me will show up on the main page of your depository.

There's a great place to put notes and information about what your code does, so that when people come to your depository, they have an easy way to understand it without having to read the actual code.

Now that we have that out of the way, let's get started by creating a file on this project.

We call it anything.

We want such a test on HTML and hit Enter after a little bit, you'll see that this fire will turn green with a little you next to it that stands for untracked.

This is because visual studio code integrates perfectly with git.

And this tells us that this file, which is green, means that it is new.

And since it has a you saying it's untracked, that means we haven't added this file to our get repositories yet.

In order to do that, let's open up the terminal by holding control and hitting the till Daiki and typing in get ad.

But we'll need to do is add the file name to the end of the get ad.

Can't still get what we want to add.

So we'll say test dot html.

This will add to get the test dot html file to the index of our get repositories.

When we hit enter, we'll see that this turns to a instead of you, which means it's been added to the index then.

Lastly, if we want to commit this change, we could take a gift commit and then we need to add a message to this.

So use Dash M to say that we're adding a message and in quotes put whatever message you want, such as added test file and then hit Enter.

And this will add this file to her.

Positive it, and you'll see that it is no longer green anymore because it is being tracked by get and is in an actual commit.

Now let's say that we want to edit this test file by adding some constant here.

Let's just say we're gonna add a paragraph tag and we're gonna put high inside of it.

If we say that, we'll see how this will turn yellow or orange, which means that the file has been modified.

As you can see by the end, this means that it is different than the current version in Get Hooker and get right now, in order to see what's different between these two files, we can run the get def command.

This command will tell us everything that is different in the files that we have in our repositories between the currently version that we have in our working directory and what is the most recent version in the head.

If we enter, we'll see that it tells us that this file the test dot HTM o.

The only difference is that we added this line high, which is what the Green stands for.

It means that has been added.

Now let's add that to our repositories.

And instead of using the file name, we're going to use a period which tells, Get that we want to add every single file that is in our project.

This is an easy way to add a bunch of files at one time, So when we do that, we'll see that our fire will get at it here.

And then.

If we want to commit that, we do get commit, give it a message, we'll just take a second to commit, hit, enter.

And now if I will be added with it.

We can make his many changes to his many files as we want in the project, and as soon as we add them, they will all be added into the index.