How to Use Git on Linux

Edited 3 weeks ago by ExtremeHow Editorial Team

Version ControlGitDevelopmentCommand LineCollaborationSource Code ManagementProjectsSoftware DevelopmentOpen SourceUtilities

Git is a popular version control system used to track changes to source code during software development. It is used by millions of developers and companies worldwide. If you are developing software on Linux, it is important to understand how to use Git to manage your code effectively. In this guide, we will take a deep dive into using Git on Linux.

Introduction to Git

Git is a distributed version control system, which means that the entire codebase and its history is available on each developer's computer. This allows for seamless collaboration between multiple developers working on the same project.

Linus Torvalds, the creator of the Linux kernel, developed Git in 2005. Since then, it has become an essential tool in the software development arsenal due to its robustness, ease of splitting and merging branches, and amazing performance.

Key concepts in Git

• Repository (often abbreviated as repo): This is a directory or storage location where your projects live. It contains all the files in the project and a complete history of all changes made to those files.
• Working directory: The working directory is where you actually make changes to your project. This is your sandbox, which contains changes that have not yet been committed to the repository.
• Staging area: Also known as the index, this is a temporary storage area where you group or stage changes that you want to commit together.
• Commit: A commit is a snapshot of the changes made to the repository. It is like taking a photo of your work at a particular moment, allowing you to go back to that moment in the future.
• Branch: A branch is a pointer to a specific snapshot or commit in the repository. Each branch can track its own history and evolve independently of other branches.
• Merging: Merging is the process by which you take changes from one branch and merge them into another branch.
• Remote: A remote repository is a version of your project that is hosted on the Internet or another network. You can share your work with others by pushing your changes to a remote repository.

Installing Git on Linux

Before you can use Git, you need to make sure it is installed on your Linux machine. You can install Git using your Linux distribution's package manager.

Installing Git on Ubuntu/Debian

sudo apt update 
sudo apt install git

Confirm the installation by running the following:

git --version

This should revert the installed Git version.

Installing Git on CentOS

For CentOS, use the following command:

sudo yum update 
sudo yum install git

Again, confirm the installation:

git --version

Configuring Git

Before using Git, you should configure your username and email address, as these will be associated with your commits.

git config --global user.name "Your Name" 
git config --global user.email "youremail@example.com"

These settings are stored in the .gitconfig file in your home directory.

Check your configuration

To view all your Git configurations, use the command:

git config --list

You should see your username and email address in the output.

Creating a new Git repository

To start working with Git, you need to create a new Git repository. You can do this by running the following command in your project's directory:

git init

This command creates a hidden directory called .git, which contains all the necessary repository files.

Add file to repository

Create a new file using the text editor of your choice. Save the file in the project directory, then add it to the Git staging area using the following:

git add filename

Replace filename with the name of your file.

Be committed to change

Once the file is added to the staging area, you need to commit it. This is done like this:

git commit -m "Add initial file"

The -m flag allows you to write a commit message that describes the changes.

Working with branches

Branches in Git are a powerful way to isolate work in progress. Let's learn how to create and manage branches.

Create new branch

Use the following command to create a new branch:

git branch branchname

Replace branchname with the descriptive name of your branch.

Changing branches

Use the following to switch to your new branch:

git checkout branchname

checkout command changes the working directory to point to the desired branch.

Merging of branches

Once you are satisfied with the changes made to your branch, you can merge them into another branch, usually the main branch. Switch to the branch you want to merge into and then run:

git merge branchname

This command merges the specified branch into the current branch.

Working with remote repositories

Remote repositories allow you to share your code with others and contribute to others' projects. Let's see how to work with remote repositories.

Adding a remote repository

To add a remote repository, use the command:

git remote add origin https://github.com/yourusername/repository.git

Replace the URL with the URL of your repository. The word origin is an alias for the remote URL.

Pushing changes to a remote repository

After committing your changes, push them to the remote repository using the following:

git push origin branchname

This command commits your changes to the remote repository.

Cloning a remote repository

If you want to work on an existing remote repository, you can clone it using the following command:

git clone https://github.com/username/repo.git

This creates a new directory on your local machine containing all the files and history of the remote repository.

Pulling changes from a remote repository

To keep your local repository updated with changes in the remote repository, use:

git pull origin branchname

This fetches the changes from the remote branch and merges them into your current branch.

Resolving conflicts

Conflicts occur when changes in branches are not compatible with each other. You must resolve these conflicts before you can merge the branches.

Identify the conflict

Conflicts usually arise during a merge, and Git will notify you of any conflicts. Conflicting files will include conflict markers to indicate where changes conflict.

Resolve conflicts

To resolve a conflict, open the conflicting files in a text editor. Look for lines containing <<<<<<<, =======, and >>>>>>>>that indicate conflicting changes. Make the necessary changes to resolve these conflicts.

After you resolve the conflicts, add the resolved files to the staging area, then commit your changes:

git add resolved_file 
git commit -m "Resolve merge conflicts"

Git best practices

Following best practices ensures that Git will serve you well in managing your projects.

Write a meaningful commit message

Always use clear and descriptive commit messages that summarize the changes you made.

Make small changes frequently

Make changes as often as possible. Implement small, logical changes regularly for better project management.

Keep branch naming consistent

Adopt a consistent branch naming convention to help easily identify branches.

Sync with the remote regularly

Regularly pull changes from the remote repository to keep your local branch up to date.

Review the code regularly

Before merging branches, perform code reviews to catch potential problems and ensure code quality.

Conclusion

Version control is a fundamental skill for developers. Git on Linux provides an efficient way to manage and collaborate on code. With the knowledge and skills provided in this guide, you will be well-equipped to handle Git on Linux effectively. Get into the habit of using Git regularly, follow best practices, and gradually uncover more advanced topics like rebasing, cherry-picking, and bisecting to become proficient in Git.

  Share This Article

If you find anything wrong with the article content, you can request an update