Git: A Gentle Introduction - By SuperSimpleDev | SuperSimpleDev | Skillshare

Playback Speed


  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x

Git: A Gentle Introduction - By SuperSimpleDev

teacher avatar SuperSimpleDev, Hi I'm Simon from SuperSimpleDev YouTube

Watch this class and thousands more

Get unlimited access to every class
Taught by industry leaders & working professionals
Topics include illustration, design, photography, and more

Watch this class and thousands more

Get unlimited access to every class
Taught by industry leaders & working professionals
Topics include illustration, design, photography, and more

Lessons in This Class

10 Lessons (34m)
    • 1. Introduction

      1:19
    • 2. Install Git

      1:14
    • 3. Project Setup

      1:12
    • 4. Git Setup

      2:04
    • 5. Creating a Version / Commit

      6:55
    • 6. Visualizing Git & Git Concepts

      5:32
    • 7. Completing our Version History

      1:57
    • 8. Viewing Previous Versions of Our Code

      2:55
    • 9. Restoring a Previous Version of Our Code

      6:34
    • 10. Extra Git Features

      4:35
  • --
  • Beginner level
  • Intermediate level
  • Advanced level
  • All levels
  • Beg/Int level
  • Int/Adv level

Community Generated

The level is determined by a majority opinion of students who have reviewed this class. The teacher's recommendation is shown until at least 5 student responses are collected.

2

Students

--

Projects

About This Class

A gentle, easy-to-understanding introduction to Git for people with no experience. This course teaches Git through a real-world example: recreating the "Version History" feature of Google Docs and Microsoft Word.

What is Git?

Git is a tool developers use to create a version history for our code. For example, if we're working on a feature and changing 20 different files of code, what if we mess up and want to reverse all those changes? How do we remember what we changed in all 20 files?

Git solves this problem by providing a history for your code where you can look at previous versions of your code or go back to a previous version in case you mess up.

Why Should I Know Git?

If you want to be a professional developer, you'll need to know Git as all companies use it in their development workflows. Git is essential when you're working on a big project with thousands or even millions of lines of code to have track of which code is changing and who made the changes.

What do I Learn in this Course?

We will start off with the basics by learning how to install Git, how to set up Git to track your code for changes, how to create a version history for your code, and how to view previous versions of your code and how to go back to a previous version in case you mess up.

Topics Covered

  • How to install Git

  • Set up a Git repository

  • Create a version history of your code

  • Fundamental concepts:┬ácommit, staging, etc.

  • Viewing previous versions of your code

  • Restoring a previous version of your code

Meet Your Teacher

Teacher Profile Image

SuperSimpleDev

Hi I'm Simon from SuperSimpleDev YouTube

Teacher

Hey, I'm Simon! I run the SuperSimpleDev YouTube channel, and now teaching on Skillshare!

I hope to share what I've learned and I want to make a tech career possible for anyone.

See full profile

Class Ratings

Expectations Met?
  • Exceeded!
    0%
  • Yes
    0%
  • Somewhat
    0%
  • Not really
    0%
Reviews Archive

In October 2018, we updated our review system to improve the way we collect feedback. Below are the reviews written before that update.

Why Join Skillshare?

Take award-winning Skillshare Original Classes

Each class has short lessons, hands-on projects

Your membership supports Skillshare teachers

Learn From Anywhere

Take classes on the go with the Skillshare app. Stream or download to watch on the plane, the subway, or wherever you learn best.

Transcripts

1. Introduction: Get is a tool that's used in almost every software engineering job. If you want to get a job you're going to need to know get, and that's why we're learning it. So we're going to start with this tutorial right away with the most important question, what is good? So if you've ever used Google Docs or Microsoft Word, they have a really useful feature called the version history. So once in a while, Google Docs will save a copy of your document at that point in time. And then you can find all the copies of your document in a version history like this. And this makes it easy for you to go back to previous versions of your document or to restore your document back to a previous version in case you mess up. Get is basically the same thing. It's a version history for our code. So it allows us to save past versions of every fall over code. And then whenever we need to, we can view the code that we had in the past or we can restore all the recoded back to it has division. It's basically a safety net when we're developing software. But that's just the tip of the iceberg. Very histories is a small part of what it can do. And later on we're going to learn additional skills like GitHub and branching. That's going to take you to that professional level. But for now we're going to start off by learning how to use Git to recreate the Google Docs at Version History feature for our code. To follow along with this tutorial, you just need to have written some code for. You don't need any prior experience. I'm going to explain every step that we do with that said, let's get started with the tutorial. 2. Install Git: First, let's learn how to install Git. The installation process is pretty simple. You just have to go to this website, git dash SEM.com slash downloads. For Windows, the insulation is pretty simple. We just have to go to this Windows section and the installer will download automatically. If it doesn't, you can also click this link. After the installer finishes downloading, we're going to open it. And then we're just going to run the installer. So we can keep all the default options, just clicking Next until you're finished installing. For macOS users. We're going to go into this section and you see we have several options here. So the recommended option for installing Git is to install Xcode. So there are two ways to do that. The first way is to click this icon, which will open Spotlight. And then we're going to search for terminal. And we're going to open terminal. We're going to type in git. And then we're going to press Enter. Go ahead and press Install, and that will install Git for you. If that didn't work for you. You can also open the app store and search for Xcode and then install Xcode. 3. Project Setup: Now that we've installed Git, we're ready to learn how to use it to build this version history for our code. So I'm going to be doing this tutorial on a Mac. But the steps are the same, whether you're using a Mac or a Windows computer. So the first step that we need to do is to have some code to practice with. So if you have your own code or your own project that you want to use for your reading is that otherwise it, we're going to create some code quickly right now. So I'm gonna go to my desktop and create a new folder that's going to contain all of our code. I'm going to call it get tutorial. And then I'm going to open this folder in my code editor. Okay? So I'm just going to type out some example code that we can practice with. If you want to copy this code, feel free to pause the video if you need to. Okay, So this is our example code and we just have a console log statement with the filename. And then a console log with the version 1, just so that we can track which version that we're on since we are building a version history, it's pretty simple. We just need something to practice with. 4. Git Setup: So Git is mainly use from the command line, which is terminal on Mac or PowerShell on Windows. To open the command line on a Mac, we're going to click this icon, which will open Spotlight. And then we're going to search for terminal. And then we're going to open terminal. To open the command line on Windows. We're going to search in the Start menu for the programmer PowerShell. And then we're going to open Windows PowerShell. So let's go ahead and open that up. So you don't need to know a lot about the command line to use Git, but you do need to understand one concept. The command line is where we can give commands or instructions for the computer to follow. So for example, I can give this command ls, and when I press Enter, the computer will follow this command and list the files and folders that are in the current folder. So notice that I said current folder. So because I've yet to understand is that all of the commands run inside a specific folder. So when we first open up the command line, the commands are running inside a special folder called the Home folder. So in order to use Git, we need to change the folder that the commands are running inside of this folder, which contains all of our code. So to do that, we can give this command CD, which stands for change directory. Directory is the same thing as a folder. And we're going to change directory to Tilda slash desktop slash good tutorial. And let's verify that were in the right place by giving the ls command again to list the files and folders that are in the current folder. So as you can see, we have config dot js and source here, which matches what we have in our code editor. So we know we're in the right place. So one last thing you had to know about the command line is that if you ever close the command line and then you restart it, you're going to start inside the home folder again. So make sure that the first step you do is do change directory back into this folder which contains all our code. And that's it. Now we're ready to learn some good. 5. Creating a Version / Commit: Now let's create the first version of our code in the version history. So the first thing we need to do is to set up Git inside this folder that contains our code. And to do that, we're going to give this command git in it. And to run the command we're going to press Enter. So what this does is it sets up get inside this folder and get is now tracking all of the files in this folder for changes. So the next step we're gonna do is we're going to run another command called git status. And what this does is that it tells us what changes have been made since our previous version and since we don't have a version right now, we're just going to see that we have some new files. So let's go ahead and run this command. So there's a lot of texts that comes out. The most important part is here. So good, this is telling us that there is a new file called config dot JS and a new folder called source that are not being tracked in our version history. And that is correct because we actually don't have a word in history. So our next step is to create our first version. And we had to do two things to make this happen. The first thing we had to do is to pick which changes we want in our next version. And to do that, we're going to use this command, git. Add. Git actually allows us to pick which changes we want in our next version. So we actually don't have to have both of these in the next version. We actually just pick ab.js by adding it like this. We give this command. Git will only put this in the next version and this source folder will be left out. On the other hand, if I give a folder to get ad, it's going to add all of the files inside the folder, including any sub-folders. For our first example, let's just add both of these into the next version. And a shortcut for doing this is git add dot. So the dot in command line represents the current folder that the command line is running it. And if you remember at the beginning when we started up the command line, we change the folder. That command line is running in to this folder, which is this folder that contains all of our code. So if I say dot here, we're going to add everything in here, including any sub-folders. So that's a good shortcut you can use if you want to add everything into the next version. And we're going to press Enter to run this command. And now we're going to run git status again to verify that it worked. So now you can see we have two new files that are ready to be put in our version history. So remember that git add doesn't actually create a new version. It just lets us pick which changes we want in the next version. So to create a new version, we're going to use another GET command, which is git, commit, dash m. So a version in Git is known as a commit. As this tutorial progresses, I'm going to be using the words commit and commit history instead of version and version history, just to help you get familiar with the Git terminology. But for now I'm going to use version just because we're comparing with the Google Docs version history feature. Dash m here means we are attaching a message to this commit. So you always want to attach a message to a commit just to describe what you changed so that when you're looking at this commit down the road, you'll know exactly what happened. So since we're just practicing, I'm going to give a very simple commit message, version one. And to run this command, we're going to press Enter. Depending on your computer, you might actually get an error message that looks like this, fatal. So this means I get is requiring you to configure an email and a name to get that will be attached to your commit along with your commit message. So we're going to explain right after what this means. But to get passes error, you just had to run these two commands. So you're going to run git, config, dash, dash global, user.email. And then you're gonna give your e-mail. And we're also going to configure our name. So Git, config dash, dash global, user.name. And I'm going to put my name and you can put your name. And now we're going to run git commit again. And that should work successfully. So you can see this was a lot of text output here. We're gonna go through it one by one. So in this section where you basically saying that two files or modified and there were four lines of code added. And if you look at our code, we actually do have a four lines of code. So that's what this section describes. And in this section, get is basically just warning us that we haven't configured a username or an e-mail to get. So in addition to your message that you attach to each commit, you also want to attach your name and your email. That way in case one of your changes breaks the website, your teammates know who to blame. So that's what we're gonna do next. And all we had to do is actually just follow these commands. So Git config dash, dash global, user.name. So I'm going to put my name, you can put your name. And Git config dash, dash global, user.email assignment, that super simple, dot-dot-dot. So now that we've configured Git, let's take a look at our version history. So we can do that using this command git log. So this is our version history. You can see that we only have one version in here right now, which is the one we just created. And here is our commit message. Here is the author's name and e-mail. So notice that we configured the name and email after we created the commit. So that's why we have a default name and email based on my computer. And that's it. We just learned how to add a new versions too divergent history. Later on we'll learn how to go back and forth between previous versions of your code. But for now, I do want to show you one other thing. So let's say that while you're creating this commit, you make a mistake. So for example, you misspell the commit message or you forgot to add a change. So how do we deal with that? So let's set this up and let's just add in another change here. Change. Yes. And let's say that we actually wanted this file to be in our previous commit. What do we do? So in a way to fix this is just to create our new version as normal. So we're going to do git add again and git commit dash m version one. So here you can fix your spelling if you made a spelling mistake. And instead of just giving you this, we're also going to give dash, dash. Dash, dash amend means is that instead of creating a new commit, these changes are just going to go in the previous commit. So let's press Enter to run this command. And now we're going to run git log again. As you can see, we still only have a one version in our version history. And the extra file that we created has been added to that version. So that's how you can edit a commit in case you mess up. 6. Visualizing Git & Git Concepts: Now I want to show you how you can visualize the changes that get us tracking inside your code editor. So a lot of editors have Git integration is these days that allow you to see what the changes get is tracking inside your editor instead of just in the command line. So I'll show you how that works. So the editor I'm using is called Visual Studio Code. So you might be using a different code editor. So you have to check if your editor supports Git integration. So in VS code, we can actually visualize what changes we have made since the previous version. So let's go ahead and make some changes here. I'm just gonna change this to version two. And here as well, I'm going to change it to version two. So now if I go into this section, this is the section we have our changes that we made to get here. So this is the same thing as running git status in the command line, except we can actually visualize it in our code. So if I select one of these changes, we can actually see what code we have changed in this file and also for this file. So you can see that it can be really useful if you're working on a big feature. And instead of two files here you have like 20 different files and you can see exactly which code that you changed. So this editor also allows us to run some Git commands for us. So for example, if I want to git add this file, I can actually press this Plus button instead of going to the command line and running git add myself. If I want to add this file, I just have to click the Plus button here. And if I want to do git add dot, then the equivalent is just clicking this button here. So it makes it a little bit easier to run git commands just from your code editor. So you might have noticed that when we ran git add dot u changes replace in this area called the stage changes. So this is known as a staging area. This is basically where good puts all of the changes that we have picked using git add that we want to go into the next version, otherwise we might forget. And then under the staging area is all of the changes that we are currently working on, but we haven't used git add yet. So this area is called the working area. So all of your changes start off in the working area. So let's make a simple change right now just to visualize it. So now you can see that that change starts off any working area. And then when I run git add, it's going to add it to the staging area. So one other thing I want to show you about the staging area is that let's say that we go ahead and modify this file again. So let's go into config and let's have another simple modification. Save it, will go back. So you'll notice that convict ab.js is now both in the working area and in the staging area. So how does that work? So the way that it works is that they actually tracks changes, not files. Even though we get added the file config js to the staging area. The second change hasn't been added yet because it get fundamentally tracks changes. So that's why it can appear in both places. So let's go ahead and add these two files to the staging area. And you'll notice that it actually merges the two changes together. So that's just some foundational knowledge about how Git works. You're going to be using the staging area a lot. So it's pretty useful to know some of these facts about the staging area as well as the working area. So the last thing I wanna show you about these features is how to take changes out of our staging area and how to reset our working area. So let's start with staging first. So to take changes out of the staging area, our code editor might provide a convenient button in its Git integration. And my code editor has one right here. So all I have to do is click this button and it will take the change out of the staging area. So now let's also learn the get command for doing this. The command for doing this is git reset. Reset works the same way as ADH. If we give it a filename like reset, config dot js, it will only take convict ArcJS out of the staging area. If we give it a folder, it will take all of the files in the folder, including any sub-folders, and take all of that out of the staging area. So remember, a shortcut that we can use is git reset dot. So dot here represents our current folder, which is this folder that contains all of our code. So if we do get reset dot, it will take all of the changes out of the staging area. So let's go ahead and run this command. So now all of our changes are in the working area. And we can also reset the changes in our working area using another GET command. And that command is git, checkout dash, dash. And this works the same way as git add and git reset. We can give it a filename, which will undo all of the changes to this file in the working area. Or we can give it dot, which will remove all of these changes. So for this time, let's go back into our code editor and use the Git integration to do this. So if I click this button, this is the same thing as doing. So we reset, change that. Yes, this is the same thing as doing git, checkout dash, dash, change ab.js. And if I click the button up here, this is the same as doing git checkout, dash, dash, dot. So you can see how a Git integration in your code editor can really make your life easier when you're working with good. So now that we learned the fundamentals of good and how to create versions of Aboriginal history. We're going to move on and create the other features that we find in the Google Docs version history. 7. Completing our Version History: Now we're going to create a tumor versions and add them to our version history so that later we can learn how to go back to a previous version of our code. So if you want some practice, you can actually pause the video right now and try to create two versions on your own. So it's the same thing that we did when we created our first version. All right, So I'll do it right now for my code. So the first thing we're gonna do is just make some changes. And then we will pick the changes that we want in our next version. So git add dot. And then we're going to create the commit with a message. I'm just going to call this version too, just because we're practicing. Now I'm going to create another commit or another version. By first modifying the code. I'm going to add the changes that I made. And I'm going to pick these changes to put it in the next commit. Then just create another commit with git commit. And now if I run git log, you'll see that we now have three versions in our version history, and now we're ready to learn how to switch between different versions. So you might have noticed that one big difference between Google Docs and get is that Google Docs automatically creates versions of your document for you. So every once in awhile it'll save a version and you can go back to it later. But forget however we have to create our versions manually. So you might be wondering, why are we still creating our versions manually? Why can't we automate this? So the problem with code is that until you finish your code, it probably doesn't work. So we don't really want to be automatically creating versions of our code that don't work for Google Docs. It doesn't really matter the thing is finished or not. It's just a bunch of words and sentences, so you're not going to get errors from a half-finished document that's not the same with half-finished code. So that's why we always create versions manually with Git. You want to make sure that our code is good to go before we put it in our version history. 8. Viewing Previous Versions of Our Code: So now that we actually have a version history, we're going to learn how to go back and view a previous version of our code. So the get command for doing that is git checkout. And now we have to tell Git which version we want to go back to. So let's say that we want to go back to this version, version two. So in order to help get that, we want to go back to this version. We have to give it this big long string. So this is known as the commit hash. It's basically the ID of this commit or this version. So what we'll do is we're going to copy this commit hash and we're going to paste that to git checkout. And that's it. Now if we run this command, we are back to version two. So if we look at our code, you can see that we are back to version 2 of our code, and that's as simple as it gets. We just had to run git checkout and we'll go back to a previous version of our code. So the changes we made are really simple. But you can imagine that if we had a big feature where we changed 20 or 30 different files, this is really powerful for changing all of those files back to their previous version. Now let's go back to our command line and we're going to run git log to check the state of original history. So as you can see, we only have two commits here right now. And the reason for that is that git log only shows the current commit, as well as all the commits behind the current commit, but not any commits in front of it. So in order to show all of the commits in our version history, we're going to do git log, dash, dash o. And that will show you the three different versions that we had earlier. So you might notice that this word head is now beside version two. We scroll up to our previous version history. We see that head used to be beside version 3. So this word head here, this is telling us which version we are currently viewing. So in Google Docs, when you're viewing a previous version, diversion will usually just be highlighted. But in the command line we can't really highlight stuff. So that's why we use this word head to indicate which version we are currently viewing. So now let's get a little bit more practice. We're going to switch to the first version that we had in our version history. So pause the video if you want to do it yourself first, but now I'm gonna do it together. So the command that we need is git checkout. And remember we need to tell git the commit hash that we want to go to. So we're going to copy this and paste it here. And then we're going to run this command. So now we're on version one and we check our code. We can see that indeed our code is back to version one. And we can check the other file. Both of our files are back to version one. And if we go back and we run git log dash, dash, all, we see that head is now beside our first version. So that's how you go back and view previous versions of your code. 9. Restoring a Previous Version of Our Code: The last feature we're going to recreate from the Google Docs version history is the restore this version button which will restore the document that back to a previous version. Let's learn how to do that feature except using kid. So one thing that we might be tempted to try is that we'll look at our code and realize that we've already been restored back to what it was at Version 1. So we think, Oh, we had to do is start modifying it and creating new versions as usual. So let's give that a try and see what happens. So I'm gonna do a simple update here. And then I'm going to do the usual git add and then create a new commit on top of the version one commit, going to call this virgin one updated. And now if we run git log dash, dash all, we see that everything appears to be working fine. We have our old version 3 commit here, and we now have this new version one updated at the top. And this one was built off of this one. So we restored our code back to version one and then we restarted from version one. Unfortunately, this is not exactly what we want. So the way that it works is that if you go back to a previous version, start adding new versions on top of that previous version, you'll notice that the good histories going to start branching off of that previous version. And this is another way it works in Google Docs version history. Google Docs basically takes whatever your document was at that time and it just copies it over to the current document. So this is not exactly what we want. Now I do want to show you how you can view the branching effect in your command line and you do it with another command. So the first thing you notice is that we're no longer in the command line because the git log is way too long. And so if you try to type a command here, it won't work. So the exit out of this view, we're going to press Q for quit. And now we're going to get run git log again. Except this time we're going to add dash, dash graph. So if you add a dash, dash graph is going to start showing you the branching effect in your version history. So we're going to run this command. And now you can see we have two branches of commits. So the first branch is here, which is what we had earlier. And now we have the second branch, which is built off of our first version. So this is what happens when you simply go back to the previous version and then you start building off of that version. But for right now, since we're trying to recreate Google Docs written history, this isn't exactly what we want. So let's quit out of this view by pressing Q. And we're going to learn the actual command for doing the exact same thing that Google Docs does. The first thing we're gonna do is we're gonna go back to the previous branch or commits, which is here. So you'll notice that this commit also has a word beside it, minus called Master, depending on which version of Git you have, it might also be called main. So this is known as a branch name. And brand name helps us in two ways. The first way is that it makes it really easy to switch to another commit. So instead of doing git checkout and copy pasting this long commit hash and trying to remember it, we can just do git checkout master. And the second thing that a branch name helps us with is that it always points to the latest commit in the branch. So if I add another committed, this branch up here, Master will point to that commit. So this is an easy way to switch to the latest commit in any given branch. So we'll learn more about branches later as I said. But for now, just know that you can git checkout to a branch name instead of just git checkout the commit hash. So let's run this and go back to our previous branch. And now if we run git log dash, dash, dash, dash graph, you can see that we are now back to our main branch of commits that we had before. Now let's continue recreating that restore version feature from Google Docs. So there's actually a good command for doing this. And that command is git checkout. And we have to talk get two things. The first thing we had to tell kids is which version we want to restore from. So let's say that we want to restore from version 1. We're going to take this commit hash, copy it, and paste it here. And the second thing we are going to help get is which files we want to restore. So this works the same way as git add and git reset. We can give an individual file like this, config dot js. And it will restore the contents of config.xml back to what it was in version one. Without doing any sort of branching or moving the head back to Version 1. So that's how it works. So remember, forget ad. You can also give it a folder name. We can also do the same thing here. So if we do git checkout hash and then source, it will restore all the files in the source folder, including any sub-folders, back to their contents in this version. So remember that we can also do dot and this will restore all the code in this folder. So let's do that. We're going to press Enter to run this command. And now you see that config dot js is back to what it was in version 1 and index.js is back to what it was in version one. And if we run git log graph to see IR version history, you'll notice that head has not moved back to Version 1. So if we add another commit onto this, it's not going to start branching our version history like we had before. So this is how the Google Docs restore version feature works. We're just taking the contents of the previous version and then putting it and pasting it in the current version. And this is the equivalent GET command for doing that. Now let's complete this exercise by adding these changes to our version history. So first, let's run cleared status. And you notice that when we do git checkout to restore the contents of the file to the previous version. It actually automatically adds it in the staging area for us. So all we had to do is git commit, dash m and give our commit message as usual. So I'm going to call it version one restored. And now we're gonna do git log graph just to make sure that we don't have any branching happening. And there you go. This is how we recreate the restore virgin feature from the Google Docs history. 10. Extra Git Features: So I just want to say congratulations because we just recreated the version history feature of Google Docs and Microsoft Word using Git. And now that we're done comparing gets with Google Docs version history for the rest of this tutorial, I'm gonna be using the words commit and commit history just to help you get familiar with the Git terminology. So we finished the main project of recreating Google Docs version history using good. So now I'm going to show you some miscellaneous features are good that you'll find useful. So the first feature I'm going to show you is like shortcuts. So instead of typing git status, instead I can type git as an, IT will do the same thing. So this is called aliases and you set up an alias. Here is the get command, git, config, dash, dash, global, alias dot. And then you're gonna give the sort of shortcut and you want to use, so I'm going to use the shortcut S. And then I'm going to use the full command here to tell git what should stand for. So S is going to stand for status. So next time when I type Git, git is actually going to run git status. So that's just a way to save you some typing and to make things go faster when you're working with good. So I'll share with you some of the aliases and I use. One of them is Git, config dash, dash global, alias dot cm. And I use this to represent commit dash m. And another one is useful is Git config dash, dash global, alias adagio, and use that to stand for checkout. So now instead of doing git commit dash m, I can just do get cm. So if you ever need to use the aliases that I use or create your own. So the second extra feature I want to show you is how to ignore certain files from being added to your version history. So this usually happens if you have a file like secret dot EXE. And inside this file there's a bunch of sensitive information and maybe some passwords. And you don't really want to put this in your version history because it will be saved forever. So what you can do is you can actually add a new file called dot git ignore. And this is going to tell Git which files you want to ignore and not add into the version history. So we're gonna put secrets dot TXT into this file. And then when we run a git status, you can see that because we have a dot gitignore and inside we specified we want to ignore this file. Get is not tracking this file for changes. It's not going to add it to our version history. So this dot ignore file is actually a file that you should add it to your version history. So we're going to add it right now. Git, add git, commit, dash m, add git, ignore. And that's it. That's how you prevent certain files from being tracked by Git and being added to your version history. So the third and final extra feature I'm going to show you is how to completely removed get from your product. So first of all, let's create a copy of our project because we'll need it later. And we don't want to remove get right now. So we're going to paste that. And I'm just kinda call this good tutorial dash two. And now we're going to open a new command line and make sure that you change directory into this folder that contains a copy of all their code. Goryeo two. And let's run git log again just to make sure that I get is still in the copy of our folder. That's good. So to exit this, we're going to press Q for quit. And now to remove get from this project, all we have to do is give this command RM dash R, F dot. So all of the data in yet including all of our commands are changes in our version history is saved in a folder called dot get. And if we just delete this folder, then we will remove get from our project. And this RM RF command basically removes this folder and everything inside this folder. So let's go ahead and run this command. And now let's go ahead and run git log again. And you see that this is no longer a Git repository. So a repository just means a folder that is being tracked by Git. And that is how you removed yet completely from your project. Thanks for watching. We successfully recruited good oxy version history feature for our code using Git.