Working with Git
Hello folks!!! In this new post, I’ll talk a little bit about one the most famous CVS nowadays. We’ll learn some basics commands that will help you to get up and running in no time using this tool and start version all your changes in your source code. So without further ado, let’s get started and enjoy the reading 🙂
What is Git?
Git is one of the most used SCM tools these days. It allows managing source code easily an in a convenient way so developers can work more collaborative in any project. It was created by Linus Torvalds to help manage the code of Linux Operating System, but it’s been spread widely across multiple other projects. Currently, most of the software companies out there use it as its main Concurrent Versioning System or CVS. It’s main features are :
- It has a great performance.
- Branching a merging system.
- Has a middle staging area.
- Its distributed.
- Its Free and open source.
It provides a great shell to work with that support a set of commands that make work with git a great experience. Yes, you can use a GUI tool (if you’re on Mac or Windows) like Sourcetree, but come on, we always love the old trusty shell, isn’t? So for this post, we’re going to learn shell commands.
For every developer that works with any programming language either with a company or as an individual, learning this tool is a must. You can use free tools on the web like GitHub or Bitbucket that lets you version your code and work collaboratively with others developers.
For more info, you can visit Git page.
First things first, Install Git
To install Git is very simple. Depending on your OS you can do:
sudo apt install git
Windows or Mac
For these 2 OS, you just need to go to the specific Git page, download the installer and run it. Simple.
Basic commands to start working
After you install Git is time to start with some serious commands. These are the basic ones that you need to know to work fairly efficient with Git.
Init a local repository
To initialize a local Git repository, something like my-git-repo, run :
git init --bare my-git-repo.git
you’ll receive a message like
Initialized empty Git repository in /my-git-repo.git/.git/
You’ll see that a folder ./git has been created, and if you look inside, it will have a bunch of files and directories. Don’t worry about that for now.
drwxrwxr-x 7 4096 nov 8 20:42 ./ drwxrwxr-x 3 4096 nov 8 20:42 ../ drwxrwxr-x 2 4096 nov 8 20:42 branches/ -rw-rw-r-- 1 92 nov 8 20:42 config -rw-rw-r-- 1 73 nov 8 20:42 description -rw-rw-r-- 1 23 nov 8 20:42 HEAD drwxrwxr-x 2 4096 nov 8 20:42 hooks/ drwxrwxr-x 2 4096 nov 8 20:42 info/ drwxrwxr-x 4 4096 nov 8 20:42 objects/ drwxrwxr-x 4 4096 nov 8 20:42 refs/
The basic workflow for Git.
The most basic workflow to use Git is that you create a branch, make some changes, add them to the stage area, commit your changes, push them to the remote repo and then merge those into the main branch.
In Git you will have a main branch call master, where all the final code should exist. It’s not recommended that you work directly in this branch. The good way to do it is that you create your own working branch, make your changes an then merge that branch into master. There is also a complete workflow in Git called Git Flow, but we are not talking about it here, that’s a topic for another post. ;).
An overall view of the process may be like this
Clone the remote repo
To clone the repo just run
git clone my-git-repo.git/ my-git-local-repo
You’ll have a new my-git-local-repo folder. This is your local repo to work with. But this one will not have the master branch yet so let’s create it first. To do that we need to use steps 3, 4 and 5 listed in the diagram from before. Don’t worry we’ll cover all of the steps later on.
cd into my-git-local-repo and follow these steps, I’ll explain those after this.
git add .
git commit -m 'First Commit'
After this, you’ll have your master branch created. To confirm that run
Ok, that was a lot of fun, isn’t? Now let’s go step by step for the actual workflow.
Working with Git
So, now that you have your local repo all set up, we’re going through each of the steps listed before.
Create a working branch (Step 2).
To create the branch where you should make your changes run
git checkout -b my-branch
Now you’ll see that you’re on my-branch. Run git branch to confirm that.
master * my-branch
Make changes to your branch (Step 3).
Now, let’s make some changes. We can modify the file we already created, the README.md file. Just open it and add some text, maybe a title. In my case I’ll add “My first change in Git”. save those changes and then run:
This will show you the all the files that are modified. The output should be like this:
On branch my-branch Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git checkout -- <file>..." to discard changes in working directory) modified: README.md no changes added to commit (use "git add" and/or "git commit -a")
As you can see, file README.md show as modified. The next step is to add it in the Stage area to be able to commit those changes.
Add changes to the Staging area. (Step 4).
The Stage area is useful to arrange and group your commits to having some order or meaning. You can add all the files at once to make a unique commit with all the changes or you can select specific ones so you can be grouped as you like. To do so run these commands:
To add all at once:
git add .
To add specific files
git add README.md
After adding them, run git status again and you will see:
On branch my-branch Changes to be committed: (use "git reset HEAD <file>..." to unstage) modified: README.md
Your changes are ready to be committed. If you want to remove a file from the staging area just run:
git reset HEAD README.md
With this, the file is removed from stagging and can’t be committed.
Commit your changes. (Step 5).
Ok, now to commit your changes to your local repo just run this:
git commit -m 'Title added to the README file'
You should always put some meaningful message that describes the changes. The output of this command is:
[my-branch b1731a5] Title added to the README file 1 file changed, 1 insertion(+)
Merge your branch into master. (Step 6).
Now you need to merge those changes into the master branch. First, you need to be in master branch, so run:
git checkout master
Switched to branch 'master'
To merge the changes from your working branch into master run:
git merge my-branch master
Updating c258b24..bb45198 Fast-forward README.md | 1 + 1 file changed, 1 insertion(+)
Push changes to the remote repo. (Step 7).
The final step is to push all your changes to the remote repo, in this case, is my-git-repo.git. last las command to run is:
git push origin master
A confirmation output should be printed.
Counting objects: 6, done. Delta compression using up to 8 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (6/6), 462 bytes | 0 bytes/s, done. Total 6 (delta 0), reused 0 (delta 0) To /home/davidokun/Documents/Development/my-git-repo.git/ * [new branch] master -> master
To confirm that your changes are in the remote branch, just cd into my-git-repo.git and run:
This will show you all commits, the first one when we create the repo (git init) and the one from your local repo.
commit bb451984de9600c8d624ebd5f10938d0192b5762 Author: dark <firstname.lastname@example.org> Date: Fri Nov 10 21:12:16 2017 -0500 Title added to the README file commit c258b241153ad0bb25351c1c0ff214beb7e1754c Author: dark <email@example.com> Date: Fri Nov 10 21:11:06 2017 -0500 First Commit
In this post, we had a general view of what is Git and what is used for. We learn the basic workflow involved when versioning your code changes to have a trace of the work you do. And finally, we go step by step through this process learning each command to execute each step.
Hope this helps you with your everyday coding and I encourage you to open a GitHub account and start versioning your code. :). Until the next time.