Git and GitHub Tutorial for Beginners

Summary

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

Q & A

What is Git and why would someone use it?

Git is an open source version control system that allows you to manage changes to your files over time. It lets you track changes, go back to previous versions, compare differences, see who made changes, and more. It's useful for source code management, tracking content changes on sites, collaborating on projects, and overall keeping a history of changes.

How do you get Git setup on your computer?

You need to first install Git by downloading it from the Git website or through a package manager. Once it's installed, you can interact with Git through the command line interface or GUI tools. You'll also want to configure your name and email to associate commits with.

What does it mean to commit changes in Git?

Committing in Git creates a snapshot of your repository at that point in time. It captures what all your files look like at that moment and adds an entry to the project history. Commits allow you to go back to previous versions of your code or content.

How can you collaborate with others using Git?

You can collaborate by using a hosted Git platform like GitHub. This gives you a centralized, cloud-based repository that your team can share. Members can fork repositories, create branches to work on features, then submit pull requests to merge their code. Issues and comments also facilitate collaboration.

What happens when you try to merge branches with conflicting changes?

When the same part of a file was edited on two different branches that are being merged, it creates a merge conflict. Git cannot automatically reconcile the conflicting changes. The conflicts must be manually resolved by editing the file to select which code to preserve before merging can happen.

How can you undo changes or go back to older versions of your files?

Git stores the entire history of a project, so you can use commands like git reset and git checkout to revert back to an older commit. This rolls back your code to look like it did at an earlier point. You can retrieve old versions without having to redo work.

What is a Git branch and why would you use branching?

A branch is essentially a copy of your main codebase that lets you develop features or test out changes without impacting the main/production version. Branching is useful for trying new ideas, fixing bugs, working on team tasks in parallel, or stabilizing production code while developing.

What is GitHub and how does it work with Git?

GitHub is a web-based platform for hosting and collaborating on Git repositories in the cloud. You push your local Git repo up to GitHub to create a centralized place for your team to access the project, track issues, review code, merge branches via pull requests, and more.

If I delete a tracked file locally, can I recover it with Git?

Yes, if you have previously committed a file in Git and then delete it locally, you can use the git restore command to recover the deleted file from the most recent commit. Git's version history keeps snapshots of all commits, enabling file recovery.

How can I ignore files like logs and temporary files from getting tracked in Git?

You can create a .gitignore file to specify intentionally untracked files that Git should ignore. Common examples are files containing sensitive data, system-generated files, compilation artifacts, and temporary files that can be reproduced.

Outlines

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

Mindmap

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

Keywords

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

Highlights

The video is abnormal, and we are working hard to fix it.
Please replace the link and try again.

Transcripts

Hi everyone, Kevin here.

Today we are going to learn how  to use both Git and also GitHub.

We'll start with what even is  Git and why would you use it.

Then we'll look at how you can  get Git running on your computer,  

and then we'll look at how you can use it.

After that, we'll look at GitHub.

GitHub is a hosting platform where you can  collaborate with others on your Git repositories.

By the end of this video, you'll be  proficient in using both Git and also GitHub.

If you'd like to follow along, I've included  some sample files down below in the description.

All right, let's check this out.

First off, what even is Git?

Git is open source and free source control  management or what's referred to as SCM.

With Git, you can manage  changes to files over time,  

and you can go back and see  what those changes were.

Here for example on the  KevinCookieCompany.com website,  

I say that our eggs come from chickens  that listen to classical music.

Did anyone ever really believe that? We  don't play classical music for our chickens.

So, I need to update this text on the website.

I can now create another version  of this website or another branch  

and then I can update the text there. Once  I'm confident that the changes look good,  

I can then merge that back into the  main branch and then I can commit that.

Basically, that means that my changes  will now show up on the website.

Now, let's say that maybe the operations  manager comes up to me and says, hey Kevin,  

we actually do play classical  music to all of our chickens.

Well, with Git, I can simply  revert back to a previous version.

That's the magic of using Git.

I could revert back to previous versions.

I can compare the differences between  different versions. I can see who changed what.

Basically, if I screw something up, well, I  could just jump back to a previous version.  

Now that we know what Git is, next, we need  to install it on our computer and to do that  

you can head to the website up above or you can  click on the link down below in the description.

Once you land on the website, click on downloads  

and then select your operating system and  then run through the installation process.

When I installed Git, it came  with a terminal called Git Bash.

To launch it, simply click on your Start menu and  then type in Git Bash and then you can launch it,  

but you could also use any other  terminal that you have on your computer.  

You could also use PowerShell or command  prompt. If you're on Mac, you could use  

the terminal that comes with your machine. You  could also download third party terminals like  

Hyper.is and that works across all different  platforms, so the choice is really yours.

Once you've installed Git, you can use any  terminal now to interact with Git. For this video,  

I'm going to use Git Bash simply because it  came with the Git installation on Windows.

Here I am in File Explorer, and I have these four  

different files that make up the  KevinCookieCompany.com website.

If you would like to follow along,  

you can download all of these files  in the description of this video.

I want to use Git for source control.

So how do we do that?

Well, let's open up Git Bash.

This is the terminal that we just installed.

Now again, you could also use any  other terminal that you would like.

Here I am in Git Bash and before we can get  started, we have to configure a few things.

First, we need to specify your  name and also your e-mail address.

The reason this is so important  is any time we commit something or  

write something to the history book,  we need to know, well, who's doing it.

First, let's specify the name.  Here type in git config --global  

user.name, then insert quotes and  here you can type in your name.

I'll type in Kevin Stratvert and then  close my quotes and then I'll press enter.

Next, we also need to specify your e-mail  address. In here let's type in git config  

--global user.email and then  type in your e-mail address.

I'll type in [email protected]  and then hit enter. Next, we also need to set  

the default branch name and that might  not make that much sense right now.  

Later on, we'll talk more about what branches  are and why you might want to use them.

But for now, let's once again  type in git config --global  

init or initialize.default branch and we're  going to call the default branch main.  

Once you type all of that in,  let's once again press enter.

So far, we've been using a  command called git config,  

and as we're going through this, if there's  ever a command and you're not quite sure  

what it does or what different  options you have for that command,  

you can very easily ask git for help. Here for  example, I could type in git config and then I can  

type in a - with an h. When I press enter, this  will show me help information about git config.

Now zoom out a little bit more  

and here you can see all the different  ways that you can configure things.

Down below as well if you want  more detailed help information,  

you could also type in git help  and then the command config.

Here I'll press enter.

This opens up a manual that's hosted on your  computer, so even if you're on the go or you  

don't have Internet access, you'll still be able  to access this file, and here it tells you more  

information about what that command does and here  you can see a full description of what it does,  

and you can see all of the different options  that you have when you run this command.

Back now in the terminal, to clear it out,  the easiest way to do that is you could  

simply type in clear, press enter, and  that gives you a fresh view once again.

Here once again I have the following  directory with all of the files that  

make up the Kevin Cookie Company website  and I want to use Git to track these files.

So, let's take a moment to look at this address  

here and just remember where  all of these files are stored.

It's likely in a different location on  your computer, so just make note of that.

Back here within Git Bash, we need to change the  directory to look at where we have those files.  

To change the directory, let's type in  CD, that stands for change directory,  

and then let's type in the location. I have it in  C:/users/Kevin and then Kevin Cookie Company.com

Now I can press on enter and here we see that  it's now looking at this location on my computer.  

To now turn this into a Git  repository, I simply type in git,  

initialize or init, and then  I could simply press enter.

And here we see that it's now  initialized this repository.

Look at that, we've now created our very  first repository. Back within File Explorer,  

it doesn't look like anything changed, but  here if I click on view and I'll go down to the  

option that says show and here I can show hidden  items, and here there's now a new folder called  

.git. I can now click on that, and this  contains all of the necessary repository files.  

Back within Git Bash, we're now going to  enter a command that you'll likely use often.

Type in git status and this will tell  us the status of our repository. When  

I press enter, here I can see that  I'm currently on the main branch.  

Remember at the very beginning,  we set main as our default branch.

Here I can see that there are currently no commits  yet, and don't worry, we'll get into what that is  

in a little bit. And down below, I see that  there are currently four untracked files.

These are all of the files  that we saw in File Explorer.

Currently all of my files are untracked.

That means if I make any changes to any of these  files, Git won't care because they are untracked.

Now if I track a file, Git will know  what changes I make to that file.

So, let's say I want to revert  back to a previous version.

I can do that.

So how do we track a file? To track a file,  I can simply type in git add and then I could  

specify the filename. So, let's say that  first I want to track the index.htm file.

Here I'll simply type in  index.htm and then hit enter.

So, this file is now being tracked.  To confirm that it's being tracked,  

once again, we could use the  command that we used earlier.

I can type in git status, hit  enter, and here I see that one  

file is currently being tracked and we  continue to have three untracked files.

Now let's say that for whatever reason,  I no longer want to track a file.

Right up here, I see the tracked file  and right up above that I see a command  

that I can use to unstage or  basically untrack this file.

I can type in git rm for remove  --cached and then the filename.

So, let's try this out.

I'll type in git rm --cached,  and here let's type in index.htm,  

then I'll hit enter. Now once again, let's  type in git status, hit enter and once again  

we're back to the original state where all  four of my files are currently untracked.

When I look at all of the different files that Git  

knows about, here one of the files  is called Employee Salaries.txt.

And I definitely don't want to  risk having anyone see this file.

In fact, I would prefer to have Git  just completely ignore this file.

Let's open up File Explorer  to see how we can ignore it.

In File Explorer, we're going  to create a new file called  

.gitignore. This allows us to ignore certain  files, folders, or even just entire extentions.

Here I’ll right click and let's go to new and  I'll create a new text document. Right here,  

let's select the name and the extension and let's  re-title this .gitignore and then hit enter.

Here it tells me that it might become unstable  if I also change the filename extension.

Let's click on yes.

And here I have a new file called .gitignore.

I'll take Notepad here and let's  open this file in Notepad or  

you could use whatever text editor you want,  and currently there's nothing in this file,  

so I need to tell git what files  or folders that I want to ignore.

Here I'll add a comment by entering in the hash  symbol and I'll type in ignore all .txt files.

Remember, the employee salaries is a .txt file.  

Underneath that, here I could type in an asterisk,  so basically any filename .txt, I want to ignore.

Now I can go to file and save. To see a  comprehensive list of all of the different  

ways that you can ignore files, folders, or  even just entire extensions, you can go to  

the website down below. This is ideal for things  like log files or auto generated files that you  

don't want to include as part of your project,  or in this case, maybe you just don't want to  

show employee salaries. Back within Git Bash,  let's see if Git is in fact ignoring that file.

Once again, just like we've been doing  all along, we can type in git status  

and then hit enter, and here I  no longer see employee salaries.

I really dodged a bullet there.

To give us a little bit more  space, let's clear out this view.  

Now that we're ignoring one of the files,  I want git to track all of the other files.

Earlier we tracked that one file  index.htm, but then I also untracked it.

So how do I just rrack all of the files.

Here I could type in Git add –all,  and that'll track all the files.

Alternatively, I could also type in -A or I could  even simply type in . for the entire directory.

Those are all different ways that I can  track all of the files. Here I'll press enter  

and let's check what happened.

Once again, let's type in Git status, hit enter,  

and here I can see that all of these files  are currently being tracked except for that  

file that I ignored, and currently all  of these files are in an environment  

called staging. Now that I've added all of  these different files, I want to commit them.

So, what does it mean to commit?

To commit, you're taking a snapshot of  your repository at this point in time.

Basically, what all of your  files look like right now.

In a sense, it's like writing  an entry into a history book,  

and if you ever want to go back to this  point in the future, you could do that.

To commit them, we could use the commit command.

I'll type in Git commit -m,  

and then open quotes and here I can type  in a message to go along with this commit.

Now remember when we commit something that's  like writing the current state of all of these  

different files to the history books, and  this message will go along with that entry.  

Here, I'll say this is my first commit and let's  say committing all files to the repository.

Then I'll close my quotes  and here I can press enter.

Congratulations, you just  finished your first commit,  

and there's now a page in the history book.

That wasn't so bad, was it?

And just like that, I've now committed  all four of these files and they are now  

officially part of the Git record.

Here I could type in Git status once again and I  see that there are no longer any files to commit.

Let's say I now want to change one of my files.

I want to modify the index.htm file.

Here I'll click on this file,  and I'll drag it into Notepad,  

and here we see the contents of the file.

Now, if you remember, we say eggs from chickens  that listen to classical music, but I've recently  

found out that that's actually not true, so let me  remove this reference and maybe we just say that  

are, let's say, free range, and next I could go  up to file and I can now save this file. Back  

within Git, I can now type in Git status,  hit enter, and Git recognizes that one of  

these files has been modified. To see what's  been modified, Git has a command for this.

We could simply type in Git diff, and this  will show us what the differences are.

I'll hit enter and right here,  if I scroll up just a little bit,  

here we can see what the file name is, and  here I can see the original text in red  

and here I can see the changed text in green,  so once again the red text shows that listen  

to classical music and down here in the  green text, we see that are free range.

I'm satisfied with all of  these changes, and once again,  

I want to add this change to the history books.

Let's once again type in Git add index.htm.

The file is now currently sitting in staging.

Staging is a place where your files  sit until you're ready to commit them.

In a sense, it's kind of like a  holding pen until you're ready to  

add that entry to the history books. In  Git, you have three different environments.

You have your working files where  you can make edits to files.

Then you have staging, and once again, this is  that holding pen until you're ready to add it  

to the history books. And then you have your  third environment or where you commit things,  

and this has now been added as a log  or an entry into the history books.

Let's say I want to remove this file from staging.

Maybe I'm not ready to commit it.

I could type in the command, Git  restore --staged, and then index.htm.

Now, once I press that, this moves  that file back to my working files.

So, if I were to commit now, this file would  

not be included because this file was  currently in the working environment.

So, let's say that maybe you're working on 6  files and let's say that three of them you're  

ready to commit. You can move those three  to staging and then you could commit them  

and the files that are currently in the  working files, those would not be included.

The index.htm file is once again in my working  files, but I do actually want to commit it.

So once again, I could add it back to staging  and then I could commit it from staging.

But I could also just bypass or  skip over staging altogether.

To do that, let's simply type in Git commit –a -m,  and here I could say updated text to free range.

Then I can close my quotes and now when I  hit enter, this skips over the staging step  

and it's now committed this change. Here  within my git repository, I have one file  

called Secret Recipe and I definitely don't want  that falling into the wrong hands, so I should  

probably just delete the file, and I can do that  directly through Git. I could type in Git rm,  

rm for remove and then I could type in the file  name Secret Recipe.htm and then close my quotes.

But an even easier way to do that,  just directly in File Explorer,  

I could also delete the file right  here and now that file is gone.

Back within the terminal, let's type in Git status  and then hit enter, and here Git recognizes that  

this file has been deleted and the reason why is  this is one of the files that Git is tracking.

On second thought, maybe I should keep this file.

I personally haven't memorized  the secret recipe yet.

And right up here, I see a helpful  hint. If I want to restore this file,  

I could type in Git restore and then  the file name. So, let's test that out.

I'll type in Git restore, and here I'll insert  quotes and let's type in Secret Recipe.htm  

and then close quotes and hit enter.

If I go back to File Explorer,  look at that, the file is now back.

Now once again, this is one of the  advantages of working with Git.

If you've ever previously committed  a file, you can always go back to a  

previous version, or you can recover  that previous version if you need to.

Similar to deleting a file if you want  to rename a file, you can either do that  

directly in File Explorer, or you  could do that back in the terminal.

Let's try renaming a file in the terminal.

I’ll type in Git mv, and we're using mv, and that  stands for move, so we're basically moving from an  

old filename to a new filename. Here, I'll type in  the original filename and that's KCC logo.png and  

I want to move to the new name primary logo.png,  then I'll close my quotes and let's hit enter.

If we go back to File Explorer, here I can  see that the file name has been updated.

I want to add this change to the history books.

Basically, I want to add an entry that  says that this file name has been changed.

I'll type in Git commit -m and then  here I could type in the message.

So, let's say we changed  the file name of an image,  

and then I'll close my quotes and here I could  hit enter and that has now been committed.

So far, we've made a number of different commits,  

or basically entries to the  history book or the log.

What if we want to review all the  different commits that we've made?

We could type in the command  Git log and then press  

enter. And here we see all the different commits.

Every single commit has a unique identifier.

Here we also see the author and if you remember at  the very beginning, we defined who the author is.

So, I typed in Kevin Stratvert and then  we also typed in an e-mail address.

Then I could also see the  associated date with this commit.

So here at the top we go with the most  recent, all the way down to the oldest  

commits and right here I can also see the  text that I typed in as part of that commit.

If I want a more abbreviated version of this  view, I could type in Git log --oneline,  

and then I could hit enter and here we see an  abbreviated version of all the commit history.

Now looking at this commit history, I just  noticed that I typed in this text incorrectly,  

and I could go back and commit again  and then type in the text properly,  

but I actually just want to amend that text.

Luckily, with Git we can do that.

I'll type in Git commit –m and  here I'll say changed file name  

to primary logo.png and then close my quotes  and at the very end of this commit command,  

I could type in --amend and then press  enter and that's now amended that entry.

Now here I could press the arrow up icon  on my keyboard and I could go through  

all the different previous  commands that I've entered.

I could go up to Git log --oneline, hit enter,  and here you see that that text has now been  

corrected, so that's a really neat way that you  can just go back and quickly amend a previous  

commit without having to submit yet another  commit into the history books. I have all of these  

different commits, but let's say I want to see  what actually changed in these different commits.

I mean I have some text here, but what  if I want to dig into these specifics.

Here I could type in Git log –p,  

and then hit enter, and here I can look through  and see all of the different changes. Here for  

example, I can see in the most recent commit,  I changed the file name to primary logo.png.

And here I can see that I updated text to  free range and if I press my arrow key down,  

here I can see what the original text  was, and I can see what the new text was  

and if I press my arrow key down some  more, here I can see my very first commit  

where I added all of these different  files to the Git repository.  

To exit this view, I can press Q on my keyboard,  Q for quit and that exits out of this view.

Git log has all sorts of advanced capabilities.  You could search for specific text. You could  

look for changes that happen before a  certain date or even after a certain date.

Now once again, as we looked at earlier, if  you want to find out the full capabilities,  

you could type in Git help log and then hit enter.  This once again opens up the manual for Git log,  

and here you can see the description and  here you could go through to see all the  

different capabilities of how you could  find specific changes in your commits.

One of the great things about having this commit  history is you can always jump back to previous  

commits. To do that you simply type in Git  reset and then you can type in the hashtag.

So here for instance, if I wanted to  jump to updated text to free range,  

I could simply type in this value  here and that would bring me back.

Now of course, I don't want to do  that, so I'm going to remove this.

You also have the option to modify what appears  in the history book and also the order in which  

all of these commits appear, and you can  do that using something called rebasing.

Here I could type in Git rebase  -i --root and then hit enter.

This brings me into an editor.

Here I see my three commits and  then I have all of these different  

options to modify the way things appear.

Once again, I can change the order.

I can even merge together  or squash two these commits.

Now this is beyond the scope of this video  today, but I wanted to let you know that this  

is possible. To exit this view, press the colon  key, then X, and hit enter and that brings us back  

into the main terminal view. So far,  we've been making all of our changes  

just directly to the main branch, but  you can also set up additional branches.

What is another branch?

Another branch is basically a copy of your  main branch, and it has all the same entries  

in that history book, but this allows you  to go off and work on let's say a feature  

or maybe you're fixing a bug and you can make all  your changes and it won't affect the main branch.  

Once you're satisfied with all of your changes,  you can then merge it back into the main branch.

This is also how software  development typically works.

You'll have developers and maybe one’s working  on a new feature. They'll create a new branch to  

work on that new feature. Maybe someone else  is working on a bug fix and they'll create  

another branch to work on that bug fix,  and once they finish all of their work and  

they're satisfied with how it looks, they can  merge that back into main. Here in File Explorer,  

there’s a file called Secret Recipe and this has  the Kevin Cookie Company secret recipe in it.

Now I probably shouldn't be showing you this,  

but we've been working a bit  together now and I trust you.

Let's click into this file.

Here within the secret recipe,  all of this looks pretty good,  

and this is a really good chocolate chip  cookie recipe. But right down here I see  

that it calls out heating the oven to 500  degrees Fahrenheit. That's extremely hot,  

and that would probably burn the cookies. I  need to change this to 375 degrees Fahrenheit.

Let's create another branch to make this change,  and once we're satisfied with the change,  

then we can merge it back onto the  main branch. To create a new branch,  

I’ll type in Git branch and now I can type in  a name for this new branch. I want to update or  

fix the temperature. I'll type in FixTemp and then  press enter, so now we should have two branches.

To confirm how many branches we have, I  can type in Git branch and then hit enter  

and here I can see that there's one branch called  

FixTemp and there's another branch  that we're currently in called main.

How do I know that we're currently in main,  right over here I see an asterisk next to main,  

indicating that this is the currently active  branch. To switch into the other branch,  

let's type in Git switch and then  I can type in FixTemp and hit  

enter and here it says that  we've switched to branch FixTemp.

Once again, I can type in Git branch and then  hit enter, and here I see that FixTemp is the  

currently active branch, and here I see the  asterisks indicating that. I've opened up File  

Explorer and all of the files that you see here in  the repository, these reflect the FixTemp branch.

Now I want to edit the secret recipe temperature.

I'll take this file and I'll drag it  over into Notepad and here I can see  

the contents of secret recipe. Now once again,  I want to change the temperature down here.

Currently it says 500. Let's change that to  375 and then click on save. Back now within  

Git Bash let's check the status of this branch.  I’ll type in git status and then hit enter.

And here I can see that there is  one modified file for secret recipe.

We just updated the temperature  so that makes sense.

Now I want to commit this change to this branch.  Just like we did before, let's type in Git commit  

–a -m, and then here I'll say updated temp for  baking instructions, then I'll close the quotes  

and hit enter, and that has now  committed the change to this branch.

Next, let's switch back to main.

Here I'll type in git switch main, then hit  enter. Here within File Explorer, because  

we switched back into main, all of these files  reflect the current state within the main branch.

So here if I click into secret recipe, here  we'll see that it still refers to 500 degrees  

Fahrenheit. We only changed it in the FixTemp  branch, so we now need to bring those changes  

from FixTemp back into main, or essentially, we  need to merge those changes in. To merge all of  

the changes back in, let's type in Git merge -m  and here we can type in a message for this merge.

I'll type in merge FixTemp back  to main and then close my quotes.

Then I also need to specify what  branch I want to merge back into main.

Here I'll type in FixTemp and then  hit enter and there I can see that the  

file has now been merged back into main.  Here in File Explorer, in the main view,  

I can now click on the secret recipe and here  I can see that the change has been merged in  

and here main is now referring to 375  degrees Fahrenheit for the oven temperature.

Now that we've merged all of the changes from  FixTemp back into main, we no longer have any  

need for that additional branch, and at this  point, we can simply delete that branch.  

To delete a branch, let's type in Git branch,  

then enter -d and then you can type in  the branch name that you want to delete.

I'll type in FixTemp and then hit enter  and that branch has now been deleted.

Let's type in Git branch and here I can  see that I only have one branch left and  

that's the main branch and that's also the  branch that we are currently in. Overall,  

this merge went pretty smoothly.

Nothing had changed in main so it was  really easy to bring our changes back in.

But what if you create a branch and  then you try to merge it back in  

but main has changed since  you created your branch.

In that case, you'll have a merge  conflict, so let's see how that works.

And first, let's create another branch.

Here I'm going to use a command that  not only switches me to the new branch,  

but it also creates the new branch.

I'll type in git switch –c, the c will  create the new branch and let's call this one  

UpdateText and then hit enter. Once  again, to confirm that we have in fact  

switched to a new branch, I could type in Git  branch and then hit enter and here once again  

I can see that we have two separate branches  and we're currently in the UpdateText branch.

Here in File Explorer, once again,  all of the files that you see here  

reflect the UpdateText branch.

I want to make some edits  to the index.htm file. Here,  

I'll take the file and I'll drag it into  Notepad so I can make some tweaks to it.

Here we refer to the finest ingredients, but I  think I'd prefer to say the best ingredients,  

and here I'll save the index.htm file, and back  within Git Bash, let's now commit these changes.

Here I'll type in Git commit  

and then I'll type in -a -m and here I'll  say update index text and then hit enter.

Let's now switch into main and  we'll make a change there as well.

Here I'll type in git switch main and  then hit enter. Here in File Explorer,  

this now represents the main view, and here I want  to make a similar change to the index.htm file.

Here I'll select the file and  I'll drag it over to Notepad,  

and here it refers to the finest ingredients.

Let's say maybe the most amazing ingredients  and then I'll save this file and close it.  

Back now in Git Bash, let's  commit these changes to main.

I'll type in Git commit –a and then  -m and here once again I'll say update  

index text and then I'll hit enter. So,  I've now committed this change to main.

Let's now try merging the changes  from UpdateText back to main to see  

what happens. To merge UpdateText to main,  let's type in Git merge and then UpdateText,  

and let's see what happens when we press enter.

When I press enter, here I get an error message  telling me that the merge failed and the reason  

why is that there are conflicts and right  down here in the bottom right-hand corner,  

I can see that I'm currently in  a branch called main merging.

Let's go back to File Explorer to see if  I could resolve these merge conflicts.  

Here in File Explorer, I can see all  of the files for the merging view,  

and if you remember, we had a merge  conflict with the index.htm file.  

Here, I'll drag that file into Notepad and  here I can see some text that says head.

Head refers to what's the current  reality or what's currently  

in main and down below I could see  the text that I'm trying to bring in  

from the branch UpdateText, and I  could decide which one I want to keep.

Now I want to keep the text from UpdateText, so  

here I'll delete the head and here I'll delete  this portion and then I'll save the file.

Let's go back to Git Bash.

Back in Git Bash, I can now commit the  change. Just like we've done before,  

I could type in Git commit –a  -m, and then update text on  

index and then I can close my quotes and hit  enter and that's now updated that merge conflict.

So that's one way you can  resolve your merge conflicts.

And now that I've resolved that conflict,  here I could see that I am now back in main.

This should give you an idea of the  typical flow that most people use in Git.

You have some feature or bug  that you need to work on.

So first you'll create another branch.

Then you'll go in and you'll  make all of your changes.

Then you can merge it back into the main branch.

And once you do that, then you'll delete  the branch that you were working on.

Now that you understand the fundamentals of  working with Git, you might be wondering, well,  

how do you work together  and collaborate with others?

So far, we've just been working with  a Git repository that's hosted on your  

local computer, but you can also host  your Git repository in the cloud,  

and one of the most popular cloud  repositories is called GitHub.

Not only do they offer a cloud repository,  but you could also manage your project.

You could set up Kanban boards.

You can track issues.

You could assign features  or bugs to different people.

In a sense, it's a social coding website. Let’s  check out how you can get started with GitHub?

First, we need to create a GitHub account.

You could head to the following website.

You can click on a link up above or  also down below in the description.

On the home page, type your e-mail address to  kick off the flow for creating a new account.

Once you finish setting up a new  account, we can now create a cloud repo.  

Over on the left-hand side, you should  see the option to create a new repo.

Alternatively, you can also head to the URL  

GitHub.new and that'll also  drop you on the new repo page.

Let's click on this.

You might be wondering, do I really need to  

create a cloud repo, especially if  you just plan on working by yourself?

Well, if you're planning on working with a team,  

it makes sense to set up a cloud  repo so you can all work together.

But even if you plan on just working by yourself,  by storing it in the cloud, if something happens  

to your local computer, you have a backup, and all  of your repo files are safe. To set up a new repo,  

over here I need to enter in a name for this  repo. I'll type in KevinCookieCompany.com.

Down below I could also type  in a description for this repo.

I'll leave it blank for now.

Here I could decide, do I want to  make this repo public so anyone  

can come in and access it or  do I want to make it private?

If I make it private, I could assign  different individuals access to my repo,  

so I could just work with  a smaller group of people

Down below I also have some other  options. Here I could add a readme file.

I could also add a gitignore file.

Remember earlier when we  were working with our repo,  

we manually created a gitignore file,  but here you could just create one  

as you create your repo and down below  you could also choose to add a license.

Now all this looks good, let's  click on create repository.

Now that we've finished creating our  repository, here I see a quick setup guide.  

Right here, I can see how to create  a new repository on the command line.  

Right here, I see the option to push an  existing repository from the command line.

We already have a repository on our local  computer that we've been working with  

for most of this video. We can take that  repository and we can push it into the cloud.

So, let's take this first command.

Git remote add origin and then this URL.

Your URL will be specific to your GitHub account.

Let's copy this and then go back to Git Bash.  Within Git Bash, here you can right-click and  

you can paste, or you can press shift and insert  to paste what we just copied. Right here, this  

is establishing a remote connection with GitHub  and we're calling this remote connection origin.

That's a common name that  most people end up using,  

and here we can see what the address  is that we're going to connect to.

Here I'll press enter.

Let's now go back to the website  to see what the next command is.

The next command will set  the target branch to main.

Let's copy this and then go back to  Git Bash and here I'll paste this in  

and then let's run that command as well.

Once again, let's go back to GitHub  

and here we can now push all the contents  from our local repository to the cloud.

I'll copy this and then let's paste this  in and once again, let's press enter.

And here I can see that my entire  local repository has now been pushed  

to GitHub into the cloud  repository. Back on GitHub,  

here I can click on the repository name  KevinCookieCompany.com and check that  

out. Here I can now see all the files from my  repository synced onto GitHub. That's pretty cool.

Right up here, I see that there's  currently only one branch,  

and I had another branch called UpdateText.

If we go back to you Git Bash, I could  also push through all of my branches.

Here I could type in Git push --all, and that'll  push through all of my branches to GitHub.

Let's press that. And here I can see that it  also passed through the UpdateText and branch.

Let's go back to GitHub. Here within GitHub, I  can see now that there are two separate branches.

I have my main branch and then I also  have the other branch titled UpdateText.

Now that we're on GitHub, let's take a  look around to see what we can do. Here,  

I can click on my different files, so  let's say I click on my primary logo.png.

Here I can preview what that  looks like. Here I'll go back.

Right here I could also see what the last  change or commit was for a specific file.

So right here with the secret recipe, here I could  see that we updated the temperature for the baking  

instructions. Here if I click on that, I could  review what it was and what it was changed to.

So here I could view that log or  the git log of all of the changes.

Back on the main screen, if I  want to add additional files here,  

I can simply drag and drop them onto GitHub  or I can click on add a file right up here.

Let's say I want to edit one of these files.

Here I can click on the file name secret  recipe and here I can click on this edit icon,  

and I can go through and make changes  directly in here and once I'm all done,  

I could also commit directly on GitHub.  Back on the main repository view over on  

the right-hand side, here I could  edit details about this project.

I could click on this settings gear, and I  could type in a description, the website.

I could enter various topics and here I could  decide whether I want to include releases,  

packages, or environments directly here on the  repository home screen. Up across the top of the  

page, we have all of these different tabs related  to the project and the first one is called issues.

Let's click into this one.

Issues is where you can enter in feature  requests or maybe someone finds a bug.

You could enter the details of  that directly into this page.

So, let's say that on the homepage, I notice  that we say that we get our sugar from India,  

but it turns out we also  get it from the Philippines.

So that's a bug on our homepage. Right over here,  let's click on new issue. On the issues page,  

over here, I can give this issue a title, and let  me type out we should call out that organic sugar  

comes from India and the Philippines. Over here I  could also type in additional details or comment.  

Over on the right-hand side, I  can assign this issue to someone.

Now currently there's no one else on my team,  so I’ll assign it to myself just so I can keep  

track of this issue. Down below, I could also  assign a label. I'll click on the settings gear  

and here I can add a bug, but you  have all these other labels as well.

I'll select bug. Right here I  could also assign it to a project.

I could also assign various milestones.

And I'm all done entering in the details  here, so let's click on submit new issue.  

This has now successfully created an issue  and the great thing in GitHub is, it's a  

social environment so other people could come in  here, they can leave a comment. We could discuss  

is this truly a bug that needs to be fixed  and maybe what priority should we give it?  

We can have that discussion all  right here within this page.

Now I have this issue assigned to  myself, so I should probably get  

to work and update our index page  to also call out the Philippines.  

In the top left-hand corner, let's click on the  code tab, and right here I have my index file.

I want to edit this. I’ll click on index.htm  and over here let's click on this edit icon.  

Within the edit view, right up here let's  change it so it wraps. So here I can see all  

the text on this page, and if I look right  here it calls out organic sugar only from  

India. And of course, we also  get it from the Philippines,  

so here I'll say and the Philippines.  Now I'm all done making my changes.

If I scroll down just a little bit here, I  could commit it directly to the main branch  

or I have the option to create a new branch  for this commit and to start a pull request.

So, what is a pull request?

Well, I can start a new pull request and  then this change has to be approved. So,  

especially if you're working with others, you can  have other people go in. They can make changes  

and then you can have them submit a pull request,  

so the change has to be reviewed by someone  before you push it through to the main branch.

I'll give this new branch a name.

I'll call it IncludePhilippinesSugar  and then click on propose changes.

This has now successfully created a new  branch called IncludePhilippinesSugar  

and now I want to submit a pull request.

This is basically a request for someone  to approve merging this back to main.

Right down below, I can see  the pull request details.

It says update index.htm, but I probably  want to be a little bit more explicit.

I'll insert a - and maybe include some text that  

says we should include Philippines as one  of the countries that we get sugar from.

All of this now looks good.

Let's click on create pull request.

This has now successfully created a pull request  so we could go through and have a discussion  

about the merits of this change and if everything  looks good, we can then merge the pull request.

Over on the right-hand side, there's a section  called development, and when I click on this  

settings gear, I can tie this change, or  this pull request back to the original issue.

So, here's the issue that I called out  where we missed calling out the Philippines.

I select that and this is  now tied back to that issue.  

Now if I merge this pull request, here  I'll confirm the merge. Not only will  

it merge this back into main, but it'll  also close out the corresponding issue.

Let's go up to the top of the page and click into  issues and here you'll see because I accepted that  

pull request or that change, it has automatically  closed that open issue. Here if I click into  

closed, here I could review that bug that came  in and look at that we're getting work done.

That one is all done. Up at the  very top, there are a few more tabs.

There's one called actions, and this is where you  

can run different tests. You can basically  write programs to manage your repository.

There’s another tab called projects, and  this is basically a project management view  

where you can view all of your  issues, view all your pull requests,  

you can filter the different views. It  makes it really easy to manage your project.

There’s another tab called Wiki, and  this is where you can document your code.

It's kind of like Wikipedia, but for your  project. There’s another tab called security,  

and this is where you could manage all  of your different policies. You can  

define what should happen when let's  say a vulnerability is discovered.

You could also set up scanning,  if that's what you want.

There’s another tab called  insights, and this is where you can  

see,well who's contributing to your  project. What does the traffic look like?  

How many issues have been closed? How many commits  have there been? How many people are contributing?

You can view all of that right here.

And lastly, there's another tab called settings,  and this is where you can configure various  

settings related to your project. Over on the  left-hand side, if you click on collaborators,  

here's where you can add additional  people to work with you on your project.

Let's go back to the main repository  view and over on the right-hand side,  

we can also create a release. Now this is V1  of our website. Let's click here on create.

And here I can choose a tag.

Why don't we call this release.

And here I'll select that.

And here I could give it a release title.

I'll title it V1.0.0. This is just the first  iteration. Over on the right-hand side,  

you can see some suggestions for  how you should name your release.  

Now this all looks pretty good,  let's click on publish release.

And look at this, we now have V1 available  and here anyone can now come in and they  

could download the source code for  the KevinCookieCompany.com website.

Now you might be wondering, we made  a few changes in GitHub on the cloud,  

but how do we get those changes  back onto our local computer?

Well, there are a few different  commands that we can use.

First, we could use Git  fetch, and this will download  

all the history from the remote tracking branches.

And to merge that in we could type in Git merge  

and that'll now merge it in with  what we have on our local machine.

But instead of typing in those two separate  commands, we could also type in git pull,  

and then I'll hit enter and this will download  all the files. So, it basically combines fetch  

and merge into just one command, git pull. All  right, well hopefully now you have a strong  

understanding of how you can get started with  both Git and also GitHub. To learn more, I've  

included some fantastic resources down below in  the description. To watch more videos like this,  

please consider subscribing and  I'll see you in the next video.