Name: Learn Git in 20 Minutes
Uploaded: 2020-04-04T04:41:52.000Z
Duration: 23 min 30 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

Gerund

how everybody, whether you're a longtime programmer or just getting started, you've probably heard that get is one of the most important skills any developer can learn.

To-infinitive

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.

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.

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?

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 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.

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

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.

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 will make us that you can call in the project down to your computer and then click create repositories.

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.

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.

Subtitles ListPlay Video

Learn Git in 20 Minutes

content

multiple

period

conflict